621 lines
21 KiB
Lua
621 lines
21 KiB
Lua
local Helpers = require("avante.history.helpers")
|
|
local Line = require("avante.ui.line")
|
|
local Utils = require("avante.utils")
|
|
local Highlights = require("avante.highlights")
|
|
|
|
local M = {}
|
|
|
|
---@diagnostic disable-next-line: deprecated
|
|
local islist = vim.islist or vim.tbl_islist
|
|
|
|
---Converts text into format suitable for UI
|
|
---@param text string
|
|
---@param decoration string | nil
|
|
---@param filter? fun(text_line: string, idx: integer, len: integer): boolean
|
|
---@return avante.ui.Line[]
|
|
local function text_to_lines(text, decoration, filter)
|
|
local text_lines = vim.split(text, "\n")
|
|
local lines = {}
|
|
for idx, text_line in ipairs(text_lines) do
|
|
if filter and not filter(text_line, idx, #text_lines) then goto continue end
|
|
if decoration then
|
|
table.insert(lines, Line:new({ { decoration }, { text_line } }))
|
|
else
|
|
table.insert(lines, Line:new({ { text_line } }))
|
|
end
|
|
::continue::
|
|
end
|
|
return lines
|
|
end
|
|
|
|
---Converts text into format suitable for UI
|
|
---@param text string
|
|
---@param decoration string | nil
|
|
---@param truncate boolean | nil
|
|
---@return avante.ui.Line[]
|
|
local function text_to_truncated_lines(text, decoration, truncate)
|
|
local text_lines = vim.split(text, "\n")
|
|
local lines = {}
|
|
for _, text_line in ipairs(text_lines) do
|
|
if truncate and #lines > 3 then
|
|
table.insert(
|
|
lines,
|
|
Line:new({
|
|
{ decoration },
|
|
{
|
|
string.format("... (Result truncated, remaining %d lines not shown)", #text_lines - #lines + 1),
|
|
Highlights.AVANTE_COMMENT_FG,
|
|
},
|
|
})
|
|
)
|
|
break
|
|
end
|
|
table.insert(lines, Line:new({ { decoration }, { text_line } }))
|
|
end
|
|
return lines
|
|
end
|
|
|
|
---@param lines avante.ui.Line[]
|
|
---@param decoration string | nil
|
|
---@param truncate boolean | nil
|
|
---@return avante.ui.Line[]
|
|
local function lines_to_truncated_lines(lines, decoration, truncate)
|
|
local truncated_lines = {}
|
|
for idx, line in ipairs(lines) do
|
|
if truncate and #truncated_lines > 3 then
|
|
table.insert(
|
|
truncated_lines,
|
|
Line:new({
|
|
{ decoration },
|
|
{
|
|
string.format("... (Result truncated, remaining %d lines not shown)", #lines - idx + 1),
|
|
Highlights.AVANTE_COMMENT_FG,
|
|
},
|
|
})
|
|
)
|
|
break
|
|
end
|
|
table.insert(truncated_lines, line)
|
|
end
|
|
return truncated_lines
|
|
end
|
|
|
|
---Converts "thinking" item into format suitable for UI
|
|
---@param item AvanteLLMMessageContentItem
|
|
---@return avante.ui.Line[]
|
|
local function thinking_to_lines(item)
|
|
local text = item.thinking or item.data or ""
|
|
local text_lines = vim.split(text, "\n")
|
|
--- trim prefix empty lines
|
|
while #text_lines > 0 and text_lines[1] == "" do
|
|
table.remove(text_lines, 1)
|
|
end
|
|
--- trim suffix empty lines
|
|
while #text_lines > 0 and text_lines[#text_lines] == "" do
|
|
table.remove(text_lines, #text_lines)
|
|
end
|
|
local ui_lines = {}
|
|
table.insert(ui_lines, Line:new({ { Utils.icon("🤔 ") .. "Thought content:" } }))
|
|
table.insert(ui_lines, Line:new({ { "" } }))
|
|
for _, text_line in ipairs(text_lines) do
|
|
table.insert(ui_lines, Line:new({ { "> " .. text_line } }))
|
|
end
|
|
return ui_lines
|
|
end
|
|
|
|
---Converts logs generated by a tool during execution into format suitable for UI
|
|
---@param tool_name string
|
|
---@param logs string[]
|
|
---@return avante.ui.Line[]
|
|
function M.tool_logs_to_lines(tool_name, logs)
|
|
local ui_lines = {}
|
|
local num_logs = #logs
|
|
|
|
for log_idx = 1, num_logs do
|
|
local log_lines = vim.split(logs[log_idx]:gsub("^%[" .. tool_name .. "%]: ", "", 1), "\n")
|
|
local num_lines = #log_lines
|
|
|
|
for line_idx = 1, num_lines do
|
|
local decoration = "│ "
|
|
table.insert(ui_lines, Line:new({ { decoration }, { " " .. log_lines[line_idx] } }))
|
|
end
|
|
end
|
|
return ui_lines
|
|
end
|
|
|
|
local STATE_TO_HL = {
|
|
generating = "AvanteStateSpinnerToolCalling",
|
|
failed = "AvanteStateSpinnerFailed",
|
|
succeeded = "AvanteStateSpinnerSucceeded",
|
|
}
|
|
|
|
function M.get_diff_lines(old_str, new_str, decoration, truncate)
|
|
local lines = {}
|
|
local line_count = 0
|
|
local old_lines = vim.split(old_str, "\n")
|
|
local new_lines = vim.split(new_str, "\n")
|
|
---@diagnostic disable-next-line: assign-type-mismatch, missing-fields
|
|
local patch = vim.diff(old_str, new_str, { ---@type integer[][]
|
|
algorithm = "histogram",
|
|
result_type = "indices",
|
|
ctxlen = vim.o.scrolloff,
|
|
})
|
|
local prev_start_a = 0
|
|
local truncated_lines = 0
|
|
for _, hunk in ipairs(patch) do
|
|
local start_a, count_a, start_b, count_b = unpack(hunk)
|
|
local no_change_lines = vim.list_slice(old_lines, prev_start_a, start_a - 1)
|
|
if truncate then
|
|
local last_three_no_change_lines = vim.list_slice(no_change_lines, #no_change_lines - 3)
|
|
truncated_lines = truncated_lines + #no_change_lines - #last_three_no_change_lines
|
|
if #no_change_lines > 4 then
|
|
table.insert(lines, Line:new({ { decoration }, { "...", Highlights.AVANTE_COMMENT_FG } }))
|
|
end
|
|
no_change_lines = last_three_no_change_lines
|
|
end
|
|
for idx, line in ipairs(no_change_lines) do
|
|
if truncate and line_count > 10 then
|
|
truncated_lines = truncated_lines + #no_change_lines - idx
|
|
break
|
|
end
|
|
line_count = line_count + 1
|
|
table.insert(lines, Line:new({ { decoration }, { line } }))
|
|
end
|
|
prev_start_a = start_a + count_a
|
|
if count_a > 0 then
|
|
local delete_lines = vim.list_slice(old_lines, start_a, start_a + count_a - 1)
|
|
for idx, line in ipairs(delete_lines) do
|
|
if truncate and line_count > 10 then
|
|
truncated_lines = truncated_lines + #delete_lines - idx
|
|
break
|
|
end
|
|
line_count = line_count + 1
|
|
table.insert(lines, Line:new({ { decoration }, { line, Highlights.TO_BE_DELETED_WITHOUT_STRIKETHROUGH } }))
|
|
end
|
|
end
|
|
if count_b > 0 then
|
|
local create_lines = vim.list_slice(new_lines, start_b, start_b + count_b - 1)
|
|
for idx, line in ipairs(create_lines) do
|
|
if truncate and line_count > 10 then
|
|
truncated_lines = truncated_lines + #create_lines - idx
|
|
break
|
|
end
|
|
line_count = line_count + 1
|
|
table.insert(lines, Line:new({ { decoration }, { line, Highlights.INCOMING } }))
|
|
end
|
|
end
|
|
end
|
|
if prev_start_a < #old_lines then
|
|
-- Append remaining old_lines
|
|
local no_change_lines = vim.list_slice(old_lines, prev_start_a, #old_lines)
|
|
local first_three_no_change_lines = vim.list_slice(no_change_lines, 1, 3)
|
|
for idx, line in ipairs(first_three_no_change_lines) do
|
|
if truncate and line_count > 10 then
|
|
truncated_lines = truncated_lines + #first_three_no_change_lines - idx
|
|
break
|
|
end
|
|
line_count = line_count + 1
|
|
table.insert(lines, Line:new({ { decoration }, { line } }))
|
|
end
|
|
end
|
|
if truncate and truncated_lines > 0 then
|
|
table.insert(
|
|
lines,
|
|
Line:new({
|
|
{ decoration },
|
|
{
|
|
string.format("... (Result truncated, remaining %d lines not shown)", truncated_lines),
|
|
Highlights.AVANTE_COMMENT_FG,
|
|
},
|
|
})
|
|
)
|
|
end
|
|
return lines
|
|
end
|
|
|
|
---@param content any
|
|
---@param decoration string | nil
|
|
---@param truncate boolean | nil
|
|
function M.get_content_lines(content, decoration, truncate)
|
|
local lines = {}
|
|
local content_obj = content
|
|
if type(content) == "string" then
|
|
local ok, content_obj_ = pcall(vim.json.decode, content)
|
|
if ok then content_obj = content_obj_ end
|
|
end
|
|
if type(content_obj) == "table" then
|
|
if islist(content_obj) then
|
|
local all_lines = {}
|
|
for _, content_item in ipairs(content_obj) do
|
|
if type(content_item) == "string" then
|
|
local lines_ = text_to_lines(content_item, decoration)
|
|
all_lines = vim.list_extend(all_lines, lines_)
|
|
end
|
|
end
|
|
local lines_ = lines_to_truncated_lines(all_lines, decoration, truncate)
|
|
lines = vim.list_extend(lines, lines_)
|
|
end
|
|
if type(content_obj.content) == "string" then
|
|
local lines_ = text_to_truncated_lines(content_obj.content, decoration, truncate)
|
|
lines = vim.list_extend(lines, lines_)
|
|
end
|
|
if islist(content_obj.content) then
|
|
local all_lines = {}
|
|
for _, content_item in ipairs(content_obj.content) do
|
|
if type(content_item) == "string" then
|
|
local lines_ = text_to_lines(content_item, decoration)
|
|
all_lines = vim.list_extend(all_lines, lines_)
|
|
end
|
|
end
|
|
local lines_ = lines_to_truncated_lines(all_lines, decoration, truncate)
|
|
lines = vim.list_extend(lines, lines_)
|
|
end
|
|
if islist(content_obj.matches) then
|
|
local all_lines = {}
|
|
for _, content_item in ipairs(content_obj.matches) do
|
|
if type(content_item) == "string" then
|
|
local lines_ = text_to_lines(content_item, decoration)
|
|
all_lines = vim.list_extend(all_lines, lines_)
|
|
end
|
|
end
|
|
local lines_ = lines_to_truncated_lines(all_lines, decoration, truncate)
|
|
lines = vim.list_extend(lines, lines_)
|
|
end
|
|
end
|
|
if type(content_obj) == "string" then
|
|
local lines_ = text_to_lines(content_obj, decoration)
|
|
local line_count = 0
|
|
for idx, line in ipairs(lines_) do
|
|
if truncate and line_count > 3 then
|
|
table.insert(
|
|
lines,
|
|
Line:new({
|
|
{ decoration },
|
|
{
|
|
string.format("... (Result truncated, remaining %d lines not shown)", #lines_ - idx + 1),
|
|
Highlights.AVANTE_COMMENT_FG,
|
|
},
|
|
})
|
|
)
|
|
break
|
|
end
|
|
line_count = line_count + 1
|
|
table.insert(lines, line)
|
|
end
|
|
end
|
|
if type(content_obj) == "number" then
|
|
table.insert(lines, Line:new({ { decoration }, { tostring(content_obj) } }))
|
|
end
|
|
if islist(content) then
|
|
for _, content_item in ipairs(content) do
|
|
local line_count = 0
|
|
if content_item.type == "content" then
|
|
if content_item.content.type == "text" then
|
|
local lines_ = text_to_lines(content_item.content.text, decoration, function(text_line, idx, len)
|
|
if idx == 1 and text_line:match("^%s*```%s*$") then return false end
|
|
if idx == len and text_line:match("^%s*```%s*$") then return false end
|
|
return true
|
|
end)
|
|
for idx, line in ipairs(lines_) do
|
|
if truncate and line_count > 3 then
|
|
table.insert(
|
|
lines,
|
|
Line:new({
|
|
{ decoration },
|
|
{
|
|
string.format("... (Result truncated, remaining %d lines not shown)", #lines_ - idx + 1),
|
|
Highlights.AVANTE_COMMENT_FG,
|
|
},
|
|
})
|
|
)
|
|
break
|
|
end
|
|
line_count = line_count + 1
|
|
table.insert(lines, line)
|
|
end
|
|
end
|
|
elseif
|
|
content_item.type == "diff"
|
|
and content_item.oldText ~= nil
|
|
and content_item.newText ~= nil
|
|
and content_item.oldText ~= vim.NIL
|
|
and content_item.newText ~= vim.NIL
|
|
then
|
|
local relative_path = Utils.relative_path(content_item.path)
|
|
table.insert(lines, Line:new({ { decoration }, { "Path: " .. relative_path } }))
|
|
local lines_ = M.get_diff_lines(content_item.oldText, content_item.newText, decoration, truncate)
|
|
lines = vim.list_extend(lines, lines_)
|
|
end
|
|
end
|
|
end
|
|
return lines
|
|
end
|
|
|
|
---@param message avante.HistoryMessage
|
|
---@return string tool_name
|
|
---@return string | nil error
|
|
function M.get_tool_display_name(message)
|
|
local content = message.message.content
|
|
if type(content) ~= "table" then return "", "expected message content to be a table" end
|
|
|
|
---@cast content AvanteLLMMessageContentItem[]
|
|
|
|
if not islist(content) then return "", "expected message content to be a list" end
|
|
|
|
local item = message.message.content[1]
|
|
|
|
local native_tool_name = item.name
|
|
if native_tool_name == "other" and message.acp_tool_call then
|
|
native_tool_name = message.acp_tool_call.title or "Other"
|
|
end
|
|
if message.acp_tool_call and message.acp_tool_call.title then native_tool_name = message.acp_tool_call.title end
|
|
local tool_name = native_tool_name
|
|
if message.displayed_tool_name then
|
|
tool_name = message.displayed_tool_name
|
|
else
|
|
local param
|
|
if item.input and type(item.input) == "table" then
|
|
local path
|
|
if type(item.input.path) == "string" then path = item.input.path end
|
|
if type(item.input.rel_path) == "string" then path = item.input.rel_path end
|
|
if type(item.input.filepath) == "string" then path = item.input.filepath end
|
|
if type(item.input.file_path) == "string" then path = item.input.file_path end
|
|
if type(item.input.query) == "string" then param = item.input.query end
|
|
if type(item.input.pattern) == "string" then param = item.input.pattern end
|
|
if type(item.input.command) == "string" then
|
|
param = item.input.command
|
|
local pieces = vim.split(param, "\n")
|
|
if #pieces > 1 then param = pieces[1] .. "..." end
|
|
end
|
|
if native_tool_name == "execute" and not param then
|
|
if message.acp_tool_call and message.acp_tool_call.title then param = message.acp_tool_call.title end
|
|
end
|
|
if not param and path then
|
|
local relative_path = Utils.relative_path(path)
|
|
param = relative_path
|
|
end
|
|
end
|
|
if not param and message.acp_tool_call then
|
|
if message.acp_tool_call.locations then
|
|
for _, location in ipairs(message.acp_tool_call.locations) do
|
|
if location.path then
|
|
local relative_path = Utils.relative_path(location.path)
|
|
param = relative_path
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if
|
|
not param
|
|
and message.acp_tool_call
|
|
and message.acp_tool_call.rawInput
|
|
and message.acp_tool_call.rawInput.command
|
|
then
|
|
param = message.acp_tool_call.rawInput.command
|
|
pcall(function()
|
|
local project_root = Utils.root.get()
|
|
param = param:gsub(project_root .. "/?", "")
|
|
end)
|
|
end
|
|
if param then tool_name = native_tool_name .. "(" .. vim.inspect(param) .. ")" end
|
|
end
|
|
|
|
---@cast tool_name string
|
|
|
|
return tool_name, nil
|
|
end
|
|
|
|
---Converts a tool invocation into format suitable for UI
|
|
---@param item AvanteLLMMessageContentItem
|
|
---@param message avante.HistoryMessage
|
|
---@param messages avante.HistoryMessage[]
|
|
---@param expanded boolean | nil
|
|
---@return avante.ui.Line[]
|
|
local function tool_to_lines(item, message, messages, expanded)
|
|
-- local logs = message.tool_use_logs
|
|
local lines = {}
|
|
|
|
local tool_name, error = M.get_tool_display_name(message)
|
|
if error then
|
|
table.insert(lines, Line:new({ { "❌ " }, { error } }))
|
|
return lines
|
|
end
|
|
|
|
local rest_input_text_lines = {}
|
|
|
|
local result = Helpers.get_tool_result(item.id, messages)
|
|
local state
|
|
if not result then
|
|
state = "generating"
|
|
elseif result.is_error then
|
|
state = "failed"
|
|
else
|
|
state = "succeeded"
|
|
end
|
|
table.insert(
|
|
lines,
|
|
Line:new({
|
|
{ "╭─ " },
|
|
{ " " .. tool_name .. " ", STATE_TO_HL[state] },
|
|
{ " " .. state },
|
|
})
|
|
)
|
|
-- if logs then vim.list_extend(lines, tool_logs_to_lines(item.name, logs)) end
|
|
local decoration = "│ "
|
|
if rest_input_text_lines and #rest_input_text_lines > 0 then
|
|
local lines_ = text_to_lines(table.concat(rest_input_text_lines, "\n"), decoration)
|
|
local line_count = 0
|
|
for idx, line in ipairs(lines_) do
|
|
if not expanded and line_count > 3 then
|
|
table.insert(
|
|
lines,
|
|
Line:new({
|
|
{ decoration },
|
|
{
|
|
string.format("... (Input truncated, remaining %d lines not shown)", #lines_ - idx + 1),
|
|
Highlights.AVANTE_COMMENT_FG,
|
|
},
|
|
})
|
|
)
|
|
break
|
|
end
|
|
line_count = line_count + 1
|
|
table.insert(lines, line)
|
|
end
|
|
table.insert(lines, Line:new({ { decoration }, { "" } }))
|
|
end
|
|
local add_diff_lines = false
|
|
if item.input and type(item.input) == "table" then
|
|
if type(item.input.old_str) == "string" and type(item.input.new_str) == "string" then
|
|
local diff_lines = M.get_diff_lines(item.input.old_str, item.input.new_str, decoration, not expanded)
|
|
add_diff_lines = true
|
|
vim.list_extend(lines, diff_lines)
|
|
end
|
|
end
|
|
if
|
|
not add_diff_lines
|
|
and message.acp_tool_call
|
|
and message.acp_tool_call.rawInput
|
|
and message.acp_tool_call.rawInput.oldString
|
|
then
|
|
local diff_lines = M.get_diff_lines(
|
|
message.acp_tool_call.rawInput.oldString,
|
|
message.acp_tool_call.rawInput.newString,
|
|
decoration,
|
|
not expanded
|
|
)
|
|
vim.list_extend(lines, diff_lines)
|
|
end
|
|
if
|
|
message.acp_tool_call
|
|
and message.acp_tool_call.rawOutput
|
|
and message.acp_tool_call.rawOutput.metadata
|
|
and message.acp_tool_call.rawOutput.metadata.preview
|
|
then
|
|
local preview = message.acp_tool_call.rawOutput.metadata.preview
|
|
if preview then
|
|
local content_lines = M.get_content_lines(preview, decoration, not expanded)
|
|
vim.list_extend(lines, content_lines)
|
|
end
|
|
else
|
|
if message.acp_tool_call and message.acp_tool_call.content then
|
|
local content = message.acp_tool_call.content
|
|
if content then
|
|
local content_lines = M.get_content_lines(content, decoration, not expanded)
|
|
vim.list_extend(lines, content_lines)
|
|
end
|
|
else
|
|
if result and result.content then
|
|
local result_content = result.content
|
|
if result_content then
|
|
local content_lines = M.get_content_lines(result_content, decoration, not expanded)
|
|
vim.list_extend(lines, content_lines)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if #lines <= 1 then
|
|
if state == "generating" then
|
|
table.insert(lines, Line:new({ { decoration }, { "...", Highlights.AVANTE_COMMENT_FG } }))
|
|
else
|
|
table.insert(lines, Line:new({ { decoration }, { "completed" } }))
|
|
end
|
|
end
|
|
--- remove last empty lines
|
|
while #lines > 0 and lines[#lines].sections[2] and lines[#lines].sections[2][1] == "" do
|
|
table.remove(lines, #lines)
|
|
end
|
|
local last_line = lines[#lines]
|
|
last_line.sections[1][1] = "╰─ "
|
|
return lines
|
|
end
|
|
|
|
---Converts a message item into representation suitable for UI
|
|
---@param item AvanteLLMMessageContentItem
|
|
---@param message avante.HistoryMessage
|
|
---@param messages avante.HistoryMessage[]
|
|
---@param expanded boolean | nil
|
|
---@return avante.ui.Line[]
|
|
local function message_content_item_to_lines(item, message, messages, expanded)
|
|
if type(item) == "string" then
|
|
return text_to_lines(item)
|
|
elseif type(item) == "table" then
|
|
if item.type == "thinking" or item.type == "redacted_thinking" then
|
|
return thinking_to_lines(item)
|
|
elseif item.type == "text" then
|
|
return text_to_lines(item.text)
|
|
elseif item.type == "image" then
|
|
return { Line:new({ { "![image](" .. item.source.media_type .. ": " .. item.source.data .. ")" } }) }
|
|
elseif item.type == "tool_use" and item.name then
|
|
local ok, llm_tool = pcall(require, "avante.llm_tools." .. item.name)
|
|
if ok then
|
|
local tool_result_message = Helpers.get_tool_result_message(item.id, messages)
|
|
---@cast llm_tool AvanteLLMTool
|
|
if llm_tool.on_render then
|
|
return llm_tool.on_render(item.input, {
|
|
logs = message.tool_use_logs,
|
|
state = message.state,
|
|
store = message.tool_use_store,
|
|
result_message = tool_result_message,
|
|
})
|
|
end
|
|
end
|
|
|
|
local lines = tool_to_lines(item, message, messages, expanded)
|
|
if message.tool_use_log_lines then lines = vim.list_extend(lines, message.tool_use_log_lines) end
|
|
return lines
|
|
end
|
|
end
|
|
return {}
|
|
end
|
|
|
|
---Converts a message into representation suitable for UI
|
|
---@param message avante.HistoryMessage
|
|
---@param messages avante.HistoryMessage[]
|
|
---@param expanded boolean | nil
|
|
---@return avante.ui.Line[]
|
|
function M.message_to_lines(message, messages, expanded)
|
|
if message.displayed_content then return text_to_lines(message.displayed_content) end
|
|
local content = message.message.content
|
|
if type(content) == "string" then return text_to_lines(content) end
|
|
if islist(content) then
|
|
local lines = {}
|
|
for _, item in ipairs(content) do
|
|
local item_lines = message_content_item_to_lines(item, message, messages, expanded)
|
|
lines = vim.list_extend(lines, item_lines)
|
|
end
|
|
return lines
|
|
end
|
|
return {}
|
|
end
|
|
|
|
---Converts a message item into text representation
|
|
---@param item AvanteLLMMessageContentItem
|
|
---@param message avante.HistoryMessage
|
|
---@param messages avante.HistoryMessage[]
|
|
---@return string
|
|
local function message_content_item_to_text(item, message, messages)
|
|
local lines = message_content_item_to_lines(item, message, messages)
|
|
return vim.iter(lines):map(function(line) return tostring(line) end):join("\n")
|
|
end
|
|
|
|
---Converts a message into text representation
|
|
---@param message avante.HistoryMessage
|
|
---@param messages avante.HistoryMessage[]
|
|
---@return string
|
|
function M.message_to_text(message, messages)
|
|
local content = message.message.content
|
|
if type(content) == "string" then return content end
|
|
if islist(content) then
|
|
return vim
|
|
.iter(content)
|
|
:map(function(item) return message_content_item_to_text(item, message, messages) end)
|
|
:filter(function(text) return text ~= "" end)
|
|
:join("\n")
|
|
end
|
|
return ""
|
|
end
|
|
|
|
return M
|