1386 lines
47 KiB
Lua
1386 lines
47 KiB
Lua
local curl = require("plenary.curl")
|
|
local Utils = require("avante.utils")
|
|
local Path = require("plenary.path")
|
|
local Config = require("avante.config")
|
|
local RagService = require("avante.rag_service")
|
|
local Helpers = require("avante.llm_tools.helpers")
|
|
|
|
local M = {}
|
|
|
|
---@type AvanteLLMToolFunc<{ path: string }>
|
|
function M.read_file_toplevel_symbols(input, opts)
|
|
local on_log = opts.on_log
|
|
local RepoMap = require("avante.repo_map")
|
|
local abs_path = Helpers.get_abs_path(input.path)
|
|
if not Helpers.has_permission_to_access(abs_path) then return "", "No permission to access path: " .. abs_path end
|
|
if on_log then on_log("path: " .. abs_path) end
|
|
if not Path:new(abs_path):exists() then return "", "File does not exists: " .. abs_path end
|
|
local filetype = RepoMap.get_ts_lang(abs_path)
|
|
local repo_map_lib = RepoMap._init_repo_map_lib()
|
|
if not repo_map_lib then return "", "Failed to load avante_repo_map" end
|
|
local lines = Utils.read_file_from_buf_or_disk(abs_path)
|
|
local content = lines and table.concat(lines, "\n") or ""
|
|
local definitions = filetype and repo_map_lib.stringify_definitions(filetype, content) or ""
|
|
return definitions, nil
|
|
end
|
|
|
|
---@type AvanteLLMToolFunc<{ command: "view" | "str_replace" | "create" | "insert" | "undo_edit", path: string, old_str?: string, new_str?: string, file_text?: string, insert_line?: integer, new_str?: string, view_range?: integer[] }>
|
|
function M.str_replace_editor(input, opts)
|
|
if input.command == "undo_edit" then return require("avante.llm_tools.undo_edit").func(input, opts) end
|
|
---@cast input any
|
|
return M.str_replace_based_edit_tool(input, opts)
|
|
end
|
|
|
|
---@type AvanteLLMToolFunc<{ command: "view" | "str_replace" | "create" | "insert", path: string, old_str?: string, new_str?: string, file_text?: string, insert_line?: integer, new_str?: string, view_range?: integer[] }>
|
|
function M.str_replace_based_edit_tool(input, opts)
|
|
local on_log = opts.on_log
|
|
local on_complete = opts.on_complete
|
|
if not input.command then return false, "command not provided" end
|
|
if on_log then on_log("command: " .. input.command) end
|
|
if not on_complete then return false, "on_complete not provided" end
|
|
local abs_path = Helpers.get_abs_path(input.path)
|
|
if not Helpers.has_permission_to_access(abs_path) then return false, "No permission to access path: " .. abs_path end
|
|
if input.command == "view" then
|
|
local view = require("avante.llm_tools.view")
|
|
local input_ = { path = input.path }
|
|
if input.view_range then
|
|
local start_line, end_line = unpack(input.view_range)
|
|
input_.start_line = start_line
|
|
input_.end_line = end_line
|
|
end
|
|
return view(input_, opts)
|
|
end
|
|
if input.command == "str_replace" then
|
|
if input.new_str == nil and input.file_text ~= nil then
|
|
input.new_str = input.file_text
|
|
input.file_text = nil
|
|
end
|
|
return require("avante.llm_tools.str_replace").func(input, opts)
|
|
end
|
|
if input.command == "create" then return require("avante.llm_tools.create").func(input, opts) end
|
|
if input.command == "insert" then return require("avante.llm_tools.insert").func(input, opts) end
|
|
return false, "Unknown command: " .. input.command
|
|
end
|
|
|
|
---@type AvanteLLMToolFunc<{ abs_path: string }>
|
|
function M.read_global_file(input, opts)
|
|
local on_log = opts.on_log
|
|
local abs_path = Helpers.get_abs_path(input.abs_path)
|
|
if Helpers.is_ignored(abs_path) then return "", "This file is ignored: " .. abs_path end
|
|
if on_log then on_log("path: " .. abs_path) end
|
|
local file = io.open(abs_path, "r")
|
|
if not file then return "", "file not found: " .. abs_path end
|
|
local content = file:read("*a")
|
|
file:close()
|
|
return content, nil
|
|
end
|
|
|
|
---@type AvanteLLMToolFunc<{ abs_path: string, content: string }>
|
|
function M.write_global_file(input, opts)
|
|
local on_log = opts.on_log
|
|
local on_complete = opts.on_complete
|
|
local abs_path = Helpers.get_abs_path(input.abs_path)
|
|
if Helpers.is_ignored(abs_path) then return false, "This file is ignored: " .. abs_path end
|
|
if on_log then on_log("path: " .. abs_path) end
|
|
if on_log then on_log("content: " .. input.content) end
|
|
if not on_complete then return false, "on_complete not provided" end
|
|
Helpers.confirm("Are you sure you want to write to the file: " .. abs_path, function(ok)
|
|
if not ok then
|
|
on_complete(false, "User canceled")
|
|
return
|
|
end
|
|
local file = io.open(abs_path, "w")
|
|
if not file then
|
|
on_complete(false, "file not found: " .. abs_path)
|
|
return
|
|
end
|
|
file:write(input.content)
|
|
file:close()
|
|
on_complete(true, nil)
|
|
end, nil, opts.session_ctx, "write_global_file")
|
|
end
|
|
|
|
---@type AvanteLLMToolFunc<{ source_path: string, destination_path: string }>
|
|
function M.move_path(input, opts)
|
|
local on_log = opts.on_log
|
|
local on_complete = opts.on_complete
|
|
local abs_path = Helpers.get_abs_path(input.source_path)
|
|
if not Helpers.has_permission_to_access(abs_path) then return false, "No permission to access path: " .. abs_path end
|
|
if not Path:new(abs_path):exists() then return false, "The source path not found: " .. abs_path end
|
|
local new_abs_path = Helpers.get_abs_path(input.destination_path)
|
|
if on_log then on_log(abs_path .. " -> " .. new_abs_path) end
|
|
if not Helpers.has_permission_to_access(new_abs_path) then
|
|
return false, "No permission to access path: " .. new_abs_path
|
|
end
|
|
if Path:new(new_abs_path):exists() then return false, "The destination path already exists: " .. new_abs_path end
|
|
if not on_complete then return false, "on_complete not provided" end
|
|
Helpers.confirm(
|
|
"Are you sure you want to move the path: " .. abs_path .. " to: " .. new_abs_path,
|
|
function(ok, reason)
|
|
if not ok then
|
|
on_complete(false, "User declined, reason: " .. (reason or "unknown"))
|
|
return
|
|
end
|
|
os.rename(abs_path, new_abs_path)
|
|
on_complete(true, nil)
|
|
end,
|
|
nil,
|
|
opts.session_ctx,
|
|
"move_path"
|
|
)
|
|
end
|
|
|
|
---@type AvanteLLMToolFunc<{ source_path: string, destination_path: string }>
|
|
function M.copy_path(input, opts)
|
|
local on_log = opts.on_log
|
|
local on_complete = opts.on_complete
|
|
local abs_path = Helpers.get_abs_path(input.source_path)
|
|
if not Helpers.has_permission_to_access(abs_path) then return false, "No permission to access path: " .. abs_path end
|
|
if not Path:new(abs_path):exists() then return false, "The source path not found: " .. abs_path end
|
|
local new_abs_path = Helpers.get_abs_path(input.destination_path)
|
|
if not Helpers.has_permission_to_access(new_abs_path) then
|
|
return false, "No permission to access path: " .. new_abs_path
|
|
end
|
|
if Path:new(new_abs_path):exists() then return false, "The destination path already exists: " .. new_abs_path end
|
|
if not on_complete then return false, "on_complete not provided" end
|
|
Helpers.confirm(
|
|
"Are you sure you want to copy the path: " .. abs_path .. " to: " .. new_abs_path,
|
|
function(ok, reason)
|
|
if not ok then
|
|
on_complete(false, "User declined, reason: " .. (reason or "unknown"))
|
|
return
|
|
end
|
|
if on_log then on_log("Copying path: " .. abs_path .. " to " .. new_abs_path) end
|
|
if Path:new(abs_path):is_dir() then
|
|
Path:new(new_abs_path):mkdir({ parents = true })
|
|
for _, entry in ipairs(Path:new(abs_path):list()) do
|
|
local new_entry_path = Path:new(new_abs_path):joinpath(entry)
|
|
if entry:match("^%.") then goto continue end
|
|
if Path:new(new_entry_path):exists() then
|
|
if Path:new(new_entry_path):is_dir() then
|
|
Path:new(new_entry_path):rmdir()
|
|
else
|
|
Path:new(new_entry_path):unlink()
|
|
end
|
|
end
|
|
vim.fn.mkdir(new_entry_path, "p")
|
|
Path:new(new_entry_path):write(Path:new(abs_path):joinpath(entry):read(), "w")
|
|
::continue::
|
|
end
|
|
else
|
|
Path:new(new_abs_path):write(Path:new(abs_path):read(), "w")
|
|
end
|
|
on_complete(true, nil)
|
|
end,
|
|
nil,
|
|
opts.session_ctx,
|
|
"copy_path"
|
|
)
|
|
end
|
|
|
|
---@type AvanteLLMToolFunc<{ path: string }>
|
|
function M.delete_path(input, opts)
|
|
local on_log = opts.on_log
|
|
local on_complete = opts.on_complete
|
|
local abs_path = Helpers.get_abs_path(input.path)
|
|
if not Helpers.has_permission_to_access(abs_path) then return false, "No permission to access path: " .. abs_path end
|
|
if not Path:new(abs_path):exists() then return false, "Path not found: " .. abs_path end
|
|
if not on_complete then return false, "on_complete not provided" end
|
|
Helpers.confirm("Are you sure you want to delete the path: " .. abs_path, function(ok, reason)
|
|
if not ok then
|
|
on_complete(false, "User declined, reason: " .. (reason or "unknown"))
|
|
return
|
|
end
|
|
if on_log then on_log("Deleting path: " .. abs_path) end
|
|
os.remove(abs_path)
|
|
on_complete(true, nil)
|
|
end, nil, opts.session_ctx, "delete_path")
|
|
end
|
|
|
|
---@type AvanteLLMToolFunc<{ path: string }>
|
|
function M.create_dir(input, opts)
|
|
local on_log = opts.on_log
|
|
local on_complete = opts.on_complete
|
|
local abs_path = Helpers.get_abs_path(input.path)
|
|
if not Helpers.has_permission_to_access(abs_path) then return false, "No permission to access path: " .. abs_path end
|
|
if Path:new(abs_path):exists() then return false, "Directory already exists: " .. abs_path end
|
|
if not on_complete then return false, "on_complete not provided" end
|
|
Helpers.confirm("Are you sure you want to create the directory: " .. abs_path, function(ok, reason)
|
|
if not ok then
|
|
on_complete(false, "User declined, reason: " .. (reason or "unknown"))
|
|
return
|
|
end
|
|
if on_log then on_log("Creating directory: " .. abs_path) end
|
|
Path:new(abs_path):mkdir({ parents = true })
|
|
on_complete(true, nil)
|
|
end, nil, opts.session_ctx, "create_dir")
|
|
end
|
|
|
|
---@type AvanteLLMToolFunc<{ query: string }>
|
|
function M.web_search(input, opts)
|
|
local on_log = opts.on_log
|
|
local provider_type = Config.web_search_engine.provider
|
|
local proxy = Config.web_search_engine.proxy
|
|
if provider_type == nil then return nil, "Search engine provider is not set" end
|
|
if on_log then on_log("provider: " .. provider_type) end
|
|
if on_log then on_log("query: " .. input.query) end
|
|
local search_engine = Config.web_search_engine.providers[provider_type]
|
|
if search_engine == nil then return nil, "No search engine found: " .. provider_type end
|
|
if provider_type ~= "searxng" and search_engine.api_key_name == "" then return nil, "No API key provided" end
|
|
local api_key = provider_type ~= "searxng" and Utils.environment.parse(search_engine.api_key_name) or nil
|
|
if provider_type ~= "searxng" and api_key == nil or api_key == "" then
|
|
return nil, "Environment variable " .. search_engine.api_key_name .. " is not set"
|
|
end
|
|
if provider_type == "tavily" then
|
|
local curl_opts = {
|
|
headers = {
|
|
["Content-Type"] = "application/json",
|
|
["Authorization"] = "Bearer " .. api_key,
|
|
},
|
|
body = vim.json.encode(vim.tbl_deep_extend("force", {
|
|
query = input.query,
|
|
}, search_engine.extra_request_body)),
|
|
}
|
|
if proxy then curl_opts.proxy = proxy end
|
|
local resp = curl.post("https://api.tavily.com/search", curl_opts)
|
|
if resp.status ~= 200 then return nil, "Error: " .. resp.body end
|
|
local jsn = vim.json.decode(resp.body)
|
|
return search_engine.format_response_body(jsn)
|
|
elseif provider_type == "serpapi" then
|
|
local query_params = vim.tbl_deep_extend("force", {
|
|
api_key = api_key,
|
|
q = input.query,
|
|
}, search_engine.extra_request_body)
|
|
local query_string = ""
|
|
for key, value in pairs(query_params) do
|
|
query_string = query_string .. key .. "=" .. vim.uri_encode(value) .. "&"
|
|
end
|
|
local curl_opts = {
|
|
headers = {
|
|
["Content-Type"] = "application/json",
|
|
},
|
|
}
|
|
if proxy then curl_opts.proxy = proxy end
|
|
local resp = curl.get("https://serpapi.com/search?" .. query_string, curl_opts)
|
|
if resp.status ~= 200 then return nil, "Error: " .. resp.body end
|
|
local jsn = vim.json.decode(resp.body)
|
|
return search_engine.format_response_body(jsn)
|
|
elseif provider_type == "searchapi" then
|
|
local query_params = vim.tbl_deep_extend("force", {
|
|
api_key = api_key,
|
|
q = input.query,
|
|
}, search_engine.extra_request_body)
|
|
local query_string = ""
|
|
for key, value in pairs(query_params) do
|
|
query_string = query_string .. key .. "=" .. vim.uri_encode(value) .. "&"
|
|
end
|
|
local curl_opts = {
|
|
headers = {
|
|
["Content-Type"] = "application/json",
|
|
},
|
|
}
|
|
if proxy then curl_opts.proxy = proxy end
|
|
local resp = curl.get("https://searchapi.io/api/v1/search?" .. query_string, curl_opts)
|
|
if resp.status ~= 200 then return nil, "Error: " .. resp.body end
|
|
local jsn = vim.json.decode(resp.body)
|
|
return search_engine.format_response_body(jsn)
|
|
elseif provider_type == "google" then
|
|
local engine_id = Utils.environment.parse(search_engine.engine_id_name)
|
|
if engine_id == nil or engine_id == "" then
|
|
return nil, "Environment variable " .. search_engine.engine_id_name .. " is not set"
|
|
end
|
|
local query_params = vim.tbl_deep_extend("force", {
|
|
key = api_key,
|
|
cx = engine_id,
|
|
q = input.query,
|
|
}, search_engine.extra_request_body)
|
|
local query_string = ""
|
|
for key, value in pairs(query_params) do
|
|
query_string = query_string .. key .. "=" .. vim.uri_encode(value) .. "&"
|
|
end
|
|
local curl_opts = {
|
|
headers = {
|
|
["Content-Type"] = "application/json",
|
|
},
|
|
}
|
|
if proxy then curl_opts.proxy = proxy end
|
|
local resp = curl.get("https://www.googleapis.com/customsearch/v1?" .. query_string, curl_opts)
|
|
if resp.status ~= 200 then return nil, "Error: " .. resp.body end
|
|
local jsn = vim.json.decode(resp.body)
|
|
return search_engine.format_response_body(jsn)
|
|
elseif provider_type == "kagi" then
|
|
local query_params = vim.tbl_deep_extend("force", {
|
|
q = input.query,
|
|
}, search_engine.extra_request_body)
|
|
local query_string = ""
|
|
for key, value in pairs(query_params) do
|
|
query_string = query_string .. key .. "=" .. vim.uri_encode(value) .. "&"
|
|
end
|
|
local curl_opts = {
|
|
headers = {
|
|
["Authorization"] = "Bot " .. api_key,
|
|
["Content-Type"] = "application/json",
|
|
},
|
|
}
|
|
if proxy then curl_opts.proxy = proxy end
|
|
local resp = curl.get("https://kagi.com/api/v0/search?" .. query_string, curl_opts)
|
|
if resp.status ~= 200 then return nil, "Error: " .. resp.body end
|
|
local jsn = vim.json.decode(resp.body)
|
|
return search_engine.format_response_body(jsn)
|
|
elseif provider_type == "brave" then
|
|
local query_params = vim.tbl_deep_extend("force", {
|
|
q = input.query,
|
|
}, search_engine.extra_request_body)
|
|
local query_string = ""
|
|
for key, value in pairs(query_params) do
|
|
query_string = query_string .. key .. "=" .. vim.uri_encode(value) .. "&"
|
|
end
|
|
local curl_opts = {
|
|
headers = {
|
|
["Content-Type"] = "application/json",
|
|
["X-Subscription-Token"] = api_key,
|
|
},
|
|
}
|
|
if proxy then curl_opts.proxy = proxy end
|
|
local resp = curl.get("https://api.search.brave.com/res/v1/web/search?" .. query_string, curl_opts)
|
|
if resp.status ~= 200 then return nil, "Error: " .. resp.body end
|
|
local jsn = vim.json.decode(resp.body)
|
|
return search_engine.format_response_body(jsn)
|
|
elseif provider_type == "searxng" then
|
|
local searxng_api_url = Utils.environment.parse(search_engine.api_url_name)
|
|
if searxng_api_url == nil or searxng_api_url == "" then
|
|
return nil, "Environment variable " .. search_engine.api_url_name .. " is not set"
|
|
end
|
|
local query_params = vim.tbl_deep_extend("force", {
|
|
q = input.query,
|
|
}, search_engine.extra_request_body)
|
|
local query_string = ""
|
|
for key, value in pairs(query_params) do
|
|
query_string = query_string .. key .. "=" .. vim.uri_encode(value) .. "&"
|
|
end
|
|
local resp = curl.get(searxng_api_url .. "?" .. query_string, {
|
|
headers = {
|
|
["Content-Type"] = "application/json",
|
|
},
|
|
})
|
|
if resp.status ~= 200 then return nil, "Error: " .. resp.body end
|
|
local jsn = vim.json.decode(resp.body)
|
|
return search_engine.format_response_body(jsn)
|
|
end
|
|
return nil, "Error: No search engine found"
|
|
end
|
|
|
|
---@type AvanteLLMToolFunc<{ url: string }>
|
|
function M.fetch(input, opts)
|
|
local on_log = opts.on_log
|
|
if on_log then on_log("url: " .. input.url) end
|
|
local Html2Md = require("avante.html2md")
|
|
local res, err = Html2Md.fetch_md(input.url)
|
|
if err then return nil, err end
|
|
return res, nil
|
|
end
|
|
|
|
---@type AvanteLLMToolFunc<{ scope?: string }>
|
|
function M.git_diff(input, opts)
|
|
local on_log = opts.on_log
|
|
local git_cmd = vim.fn.exepath("git")
|
|
if git_cmd == "" then return nil, "Git command not found" end
|
|
local project_root = Utils.get_project_root()
|
|
if not project_root then return nil, "Not in a git repository" end
|
|
|
|
-- Check if we're in a git repository
|
|
local git_dir = vim.system({ "git", "rev-parse", "--git-dir" }, { text = true }):wait().stdout:gsub("\n", "")
|
|
if git_dir == "" then return nil, "Not a git repository" end
|
|
|
|
-- Get the diff
|
|
local scope = input.scope or ""
|
|
local cmd = { "git", "diff", "--cached", scope }
|
|
if on_log then on_log("Running command: " .. table.concat(cmd, " ")) end
|
|
local diff = vim.system(cmd, { text = true }):wait().stdout
|
|
|
|
if diff == "" then
|
|
-- If there's no staged changes, get unstaged changes
|
|
cmd = { "git", "diff", scope }
|
|
if on_log then on_log("No staged changes. Running command: " .. table.concat(cmd, " ")) end
|
|
diff = vim.system(cmd, { text = true }):wait().stdout
|
|
end
|
|
|
|
if diff == "" then return nil, "No changes detected" end
|
|
|
|
return diff, nil
|
|
end
|
|
|
|
---@type AvanteLLMToolFunc<{ message: string, scope?: string }>
|
|
function M.git_commit(input, opts)
|
|
local on_log = opts.on_log
|
|
local on_complete = opts.on_complete
|
|
|
|
local git_cmd = vim.fn.exepath("git")
|
|
if git_cmd == "" then return false, "Git command not found" end
|
|
local project_root = Utils.get_project_root()
|
|
if not project_root then return false, "Not in a git repository" end
|
|
|
|
-- Check if we're in a git repository
|
|
local git_dir = vim.system({ "git", "rev-parse", "--git-dir" }, { text = true }):wait().stdout:gsub("\n", "")
|
|
if git_dir == "" then return false, "Not a git repository" end
|
|
|
|
-- First check if there are any changes to commit
|
|
local status = vim.system({ "git", "status", "--porcelain" }, { text = true }):wait().stdout
|
|
if status == "" then return false, "No changes to commit" end
|
|
|
|
-- Get git user name and email
|
|
local git_user = vim.system({ "git", "config", "user.name" }, { text = true }):wait().stdout:gsub("\n", "")
|
|
local git_email = vim.system({ "git", "config", "user.email" }, { text = true }):wait().stdout:gsub("\n", "")
|
|
|
|
-- Check if GPG signing is available and configured
|
|
local has_gpg = false
|
|
local signing_key = vim
|
|
.system({ "git", "config", "--get", "user.signingkey" }, { text = true })
|
|
:wait().stdout
|
|
:gsub("\n", "")
|
|
|
|
if signing_key ~= "" then
|
|
-- Try to find gpg executable based on OS
|
|
local gpg_cmd
|
|
if vim.fn.has("win32") == 1 then
|
|
-- Check common Windows GPG paths
|
|
gpg_cmd = vim.fn.exepath("gpg.exe") ~= "" and vim.fn.exepath("gpg.exe") or vim.fn.exepath("gpg2.exe")
|
|
else
|
|
-- Unix-like systems (Linux/MacOS)
|
|
gpg_cmd = vim.fn.exepath("gpg") ~= "" and vim.fn.exepath("gpg") or vim.fn.exepath("gpg2")
|
|
end
|
|
|
|
if gpg_cmd ~= "" then
|
|
-- Verify GPG is working
|
|
has_gpg = vim.system({ gpg_cmd, "--version" }, { text = true }):wait().code == 0
|
|
end
|
|
end
|
|
|
|
if on_log then on_log(string.format("GPG signing %s", has_gpg and "enabled" or "disabled")) end
|
|
|
|
-- Prepare commit message
|
|
local commit_msg_lines = {}
|
|
for line in input.message:gmatch("[^\r\n]+") do
|
|
commit_msg_lines[#commit_msg_lines + 1] = line:gsub('"', '\\"')
|
|
end
|
|
commit_msg_lines[#commit_msg_lines + 1] = ""
|
|
-- add Generated-by line using provider and model name
|
|
if Config.behaviour and Config.behaviour.include_generated_by_commit_line then
|
|
local provider_name = Config.provider or "unknown"
|
|
local model_name = (Config.providers and Config.providers[provider_name] and Config.providers[provider_name].model)
|
|
or "unknown"
|
|
commit_msg_lines[#commit_msg_lines + 1] = string.format("Generated-by: %s/%s", provider_name, model_name)
|
|
end
|
|
if git_user ~= "" and git_email ~= "" then
|
|
commit_msg_lines[#commit_msg_lines + 1] = string.format("Signed-off-by: %s <%s>", git_user, git_email)
|
|
end
|
|
|
|
-- Construct full commit message for confirmation
|
|
local full_commit_msg = table.concat(commit_msg_lines, "\n")
|
|
|
|
if not on_complete then return false, "on_complete not provided" end
|
|
|
|
-- Confirm with user
|
|
Helpers.confirm("Are you sure you want to commit with message:\n" .. full_commit_msg, function(ok, reason)
|
|
if not ok then
|
|
on_complete(false, "User declined, reason: " .. (reason or "unknown"))
|
|
return
|
|
end
|
|
-- Stage changes if scope is provided
|
|
if input.scope then
|
|
local stage_cmd = { "git", "add", input.scope }
|
|
if on_log then on_log("Staging files: " .. table.concat(stage_cmd, " ")) end
|
|
local stage_result = vim.system(stage_cmd, { text = true }):wait()
|
|
if stage_result.code ~= 0 then
|
|
on_complete(false, "Failed to stage files: " .. stage_result.stderr)
|
|
return
|
|
end
|
|
end
|
|
|
|
-- Construct git commit command
|
|
local cmd_parts = { "git", "commit" }
|
|
-- Only add -S flag if GPG is available
|
|
if has_gpg then table.insert(cmd_parts, "-S") end
|
|
for _, line in ipairs(commit_msg_lines) do
|
|
table.insert(cmd_parts, "-m")
|
|
table.insert(cmd_parts, line)
|
|
end
|
|
local cmd = table.concat(cmd_parts, " ")
|
|
|
|
-- Execute git commit
|
|
if on_log then on_log("Running command: " .. cmd) end
|
|
local result = vim.system(cmd_parts, { text = true }):wait()
|
|
|
|
if result.code ~= 0 then
|
|
on_complete(false, "Failed to commit: " .. result.stderr)
|
|
return
|
|
end
|
|
|
|
on_complete(true, nil)
|
|
end, nil, opts.session_ctx, "git_commit")
|
|
end
|
|
|
|
---@type AvanteLLMToolFunc<{ query: string }>
|
|
function M.rag_search(input, opts)
|
|
local on_log = opts.on_log
|
|
local on_complete = opts.on_complete
|
|
if not on_complete then return nil, "on_complete not provided" end
|
|
if not Config.rag_service.enabled then return nil, "Rag service is not enabled" end
|
|
if not input.query then return nil, "No query provided" end
|
|
if on_log then on_log("query: " .. input.query) end
|
|
local root = Utils.get_project_root()
|
|
local uri = "file://" .. root
|
|
if uri:sub(-1) ~= "/" then uri = uri .. "/" end
|
|
RagService.retrieve(
|
|
uri,
|
|
input.query,
|
|
vim.schedule_wrap(function(resp, err)
|
|
if err then
|
|
on_complete(nil, err)
|
|
return
|
|
end
|
|
on_complete(vim.json.encode(resp), nil)
|
|
end)
|
|
)
|
|
end
|
|
|
|
---@type AvanteLLMToolFunc<{ code: string, path: string, container_image?: string }>
|
|
function M.python(input, opts)
|
|
local on_log = opts.on_log
|
|
local on_complete = opts.on_complete
|
|
local abs_path = Helpers.get_abs_path(input.path)
|
|
if not Helpers.has_permission_to_access(abs_path) then return nil, "No permission to access path: " .. abs_path end
|
|
if not Path:new(abs_path):exists() then return nil, "Path not found: " .. abs_path end
|
|
if on_log then on_log("cwd: " .. abs_path) end
|
|
if on_log then on_log("code:\n" .. input.code) end
|
|
local container_image = input.container_image or "python:3.11-slim-bookworm"
|
|
if not on_complete then return nil, "on_complete not provided" end
|
|
Helpers.confirm(
|
|
"Are you sure you want to run the following python code in the `"
|
|
.. container_image
|
|
.. "` container, in the directory: `"
|
|
.. abs_path
|
|
.. "`?\n"
|
|
.. input.code,
|
|
function(ok, reason)
|
|
if not ok then
|
|
on_complete(nil, "User declined, reason: " .. (reason or "unknown"))
|
|
return
|
|
end
|
|
if vim.fn.executable("docker") == 0 then
|
|
on_complete(nil, "Python tool is not available to execute any code")
|
|
return
|
|
end
|
|
|
|
local function handle_result(result) ---@param result vim.SystemCompleted
|
|
if result.code ~= 0 then return nil, "Error: " .. (result.stderr or "Unknown error") end
|
|
|
|
Utils.debug("output", result.stdout)
|
|
return result.stdout, nil
|
|
end
|
|
vim.system(
|
|
{
|
|
"docker",
|
|
"run",
|
|
"--rm",
|
|
"-v",
|
|
abs_path .. ":" .. abs_path,
|
|
"-w",
|
|
abs_path,
|
|
container_image,
|
|
"python",
|
|
"-c",
|
|
input.code,
|
|
},
|
|
{
|
|
text = true,
|
|
cwd = abs_path,
|
|
},
|
|
vim.schedule_wrap(function(result)
|
|
if not on_complete then return end
|
|
local output, err = handle_result(result)
|
|
on_complete(output, err)
|
|
end)
|
|
)
|
|
end,
|
|
nil,
|
|
opts.session_ctx,
|
|
"python"
|
|
)
|
|
end
|
|
|
|
---@param user_input string
|
|
---@param history_messages AvanteLLMMessage[]
|
|
---@return AvanteLLMTool[]
|
|
function M.get_tools(user_input, history_messages)
|
|
local custom_tools = Config.custom_tools
|
|
if type(custom_tools) == "function" then custom_tools = custom_tools() end
|
|
---@type AvanteLLMTool[]
|
|
local unfiltered_tools = vim.list_extend(vim.list_extend({}, M._tools), custom_tools)
|
|
return vim
|
|
.iter(unfiltered_tools)
|
|
:filter(function(tool) ---@param tool AvanteLLMTool
|
|
-- Always disable tools that are explicitly disabled
|
|
if vim.tbl_contains(Config.disabled_tools, tool.name) then return false end
|
|
if tool.enabled == nil then
|
|
return true
|
|
else
|
|
return tool.enabled({ user_input = user_input, history_messages = history_messages })
|
|
end
|
|
end)
|
|
:totable()
|
|
end
|
|
|
|
function M.get_tool_names()
|
|
local custom_tools = Config.custom_tools
|
|
if type(custom_tools) == "function" then custom_tools = custom_tools() end
|
|
---@type AvanteLLMTool[]
|
|
local unfiltered_tools = vim.list_extend(vim.list_extend({}, M._tools), custom_tools)
|
|
local tool_names = {}
|
|
for _, tool in ipairs(unfiltered_tools) do
|
|
table.insert(tool_names, tool.name)
|
|
end
|
|
return tool_names
|
|
end
|
|
|
|
---@type AvanteLLMTool[]
|
|
M._tools = {
|
|
require("avante.llm_tools.dispatch_agent"),
|
|
require("avante.llm_tools.glob"),
|
|
{
|
|
name = "rag_search",
|
|
enabled = function() return Config.rag_service.enabled and RagService.is_ready() end,
|
|
description = "Use Retrieval-Augmented Generation (RAG) to search for relevant information from an external knowledge base or documents. This tool retrieves relevant context from a large dataset and integrates it into the response generation process, improving accuracy and relevance. Use it when answering questions that require factual knowledge beyond what the model has been trained on.",
|
|
param = {
|
|
type = "table",
|
|
fields = {
|
|
{
|
|
name = "query",
|
|
description = "Query to search",
|
|
type = "string",
|
|
},
|
|
},
|
|
usage = {
|
|
query = "Query to search",
|
|
},
|
|
},
|
|
returns = {
|
|
{
|
|
name = "result",
|
|
description = "Result of the search",
|
|
type = "string",
|
|
},
|
|
{
|
|
name = "error",
|
|
description = "Error message if the search was not successful",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name = "run_python",
|
|
description = "Run python code in current project scope. Can't use it to read files or modify files.",
|
|
param = {
|
|
type = "table",
|
|
fields = {
|
|
{
|
|
name = "code",
|
|
description = "Python code to run",
|
|
type = "string",
|
|
},
|
|
{
|
|
name = "path",
|
|
description = "Relative path to the project directory, as cwd",
|
|
type = "string",
|
|
},
|
|
},
|
|
usage = {
|
|
code = "Python code to run",
|
|
path = "Relative path to the project directory, as cwd",
|
|
},
|
|
},
|
|
returns = {
|
|
{
|
|
name = "result",
|
|
description = "Python output",
|
|
type = "string",
|
|
},
|
|
{
|
|
name = "error",
|
|
description = "Error message if the python code failed",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name = "git_diff",
|
|
description = "Get git diff for generating commit message in current project scope",
|
|
param = {
|
|
type = "table",
|
|
fields = {
|
|
{
|
|
name = "scope",
|
|
description = "Scope for the git diff (e.g. specific files or directories)",
|
|
type = "string",
|
|
},
|
|
},
|
|
usage = {
|
|
scope = "Scope for the git diff (e.g. specific files or directories)",
|
|
},
|
|
},
|
|
returns = {
|
|
{
|
|
name = "result",
|
|
description = "Git diff output to be used for generating commit message",
|
|
type = "string",
|
|
},
|
|
{
|
|
name = "error",
|
|
description = "Error message if the diff generation failed",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name = "git_commit",
|
|
description = "Commit changes with the given commit message in current project scope",
|
|
param = {
|
|
type = "table",
|
|
fields = {
|
|
{
|
|
name = "message",
|
|
description = "Commit message to use",
|
|
type = "string",
|
|
},
|
|
{
|
|
name = "scope",
|
|
description = "Scope for staging files (e.g. specific files or directories)",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
usage = {
|
|
message = "Commit message to use",
|
|
scope = "Scope for staging files (e.g. specific files or directories)",
|
|
},
|
|
},
|
|
returns = {
|
|
{
|
|
name = "success",
|
|
description = "True if the commit was successful, false otherwise",
|
|
type = "boolean",
|
|
},
|
|
{
|
|
name = "error",
|
|
description = "Error message if the commit failed",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
},
|
|
require("avante.llm_tools.ls"),
|
|
require("avante.llm_tools.grep"),
|
|
require("avante.llm_tools.delete_tool_use_messages"),
|
|
require("avante.llm_tools.read_todos"),
|
|
require("avante.llm_tools.write_todos"),
|
|
{
|
|
name = "read_file_toplevel_symbols",
|
|
description = [[Read the top-level symbols of a file in current project scope.
|
|
|
|
This tool is useful for understanding the structure of a file and extracting information about its contents. It can be used to extract information about functions, types, constants, and other symbols that are defined at the top level of a file.
|
|
|
|
|
|
<example>
|
|
|
|
Given the following file:
|
|
a.py:
|
|
```python
|
|
a = 1
|
|
|
|
class A:
|
|
pass
|
|
|
|
def foo():
|
|
return "bar"
|
|
|
|
def baz():
|
|
return "qux"
|
|
```
|
|
|
|
The top-level symbols of "a.py":
|
|
[
|
|
"a",
|
|
"A",
|
|
"foo",
|
|
"baz"
|
|
]
|
|
|
|
Then you can use the "read_definitions" tool to retrieve the source code definitions of these symbols.
|
|
|
|
</example>]],
|
|
param = {
|
|
type = "table",
|
|
fields = {
|
|
{
|
|
name = "path",
|
|
description = "Relative path to the file in current project scope",
|
|
type = "string",
|
|
},
|
|
},
|
|
usage = {
|
|
path = "Relative path to the file in current project scope",
|
|
},
|
|
},
|
|
returns = {
|
|
{
|
|
name = "definitions",
|
|
description = "Top-level symbols of the file",
|
|
type = "string",
|
|
},
|
|
{
|
|
name = "error",
|
|
description = "Error message if the file was not read successfully",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
},
|
|
require("avante.llm_tools.str_replace"),
|
|
require("avante.llm_tools.view"),
|
|
require("avante.llm_tools.write_to_file"),
|
|
require("avante.llm_tools.insert"),
|
|
require("avante.llm_tools.undo_edit"),
|
|
{
|
|
name = "read_global_file",
|
|
description = "Read the contents of a file in the global scope. If the file content is already in the context, do not use this tool.",
|
|
enabled = function(opts)
|
|
if opts.user_input:match("@read_global_file") then return true end
|
|
for _, message in ipairs(opts.history_messages) do
|
|
if message.role == "user" then
|
|
local content = message.content
|
|
if type(content) == "string" and content:match("@read_global_file") then return true end
|
|
if type(content) == "table" then
|
|
for _, item in ipairs(content) do
|
|
if type(item) == "string" and item:match("@read_global_file") then return true end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end,
|
|
param = {
|
|
type = "table",
|
|
fields = {
|
|
{
|
|
name = "abs_path",
|
|
description = "Absolute path to the file in global scope",
|
|
type = "string",
|
|
},
|
|
},
|
|
usage = {
|
|
abs_path = "Absolute path to the file in global scope",
|
|
},
|
|
},
|
|
returns = {
|
|
{
|
|
name = "content",
|
|
description = "Contents of the file",
|
|
type = "string",
|
|
},
|
|
{
|
|
name = "error",
|
|
description = "Error message if the file was not read successfully",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name = "write_global_file",
|
|
description = "Write to a file in the global scope",
|
|
enabled = function(opts)
|
|
if opts.user_input:match("@write_global_file") then return true end
|
|
for _, message in ipairs(opts.history_messages) do
|
|
if message.role == "user" then
|
|
local content = message.content
|
|
if type(content) == "string" and content:match("@write_global_file") then return true end
|
|
if type(content) == "table" then
|
|
for _, item in ipairs(content) do
|
|
if type(item) == "string" and item:match("@write_global_file") then return true end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end,
|
|
param = {
|
|
type = "table",
|
|
fields = {
|
|
{
|
|
name = "abs_path",
|
|
description = "Absolute path to the file in global scope",
|
|
type = "string",
|
|
},
|
|
{
|
|
name = "content",
|
|
description = "Content to write to the file",
|
|
type = "string",
|
|
},
|
|
},
|
|
usage = {
|
|
abs_path = "The path to the file in the current project scope",
|
|
content = "The content to write to the file",
|
|
},
|
|
},
|
|
returns = {
|
|
{
|
|
name = "success",
|
|
description = "True if the file was written successfully, false otherwise",
|
|
type = "boolean",
|
|
},
|
|
{
|
|
name = "error",
|
|
description = "Error message if the file was not written successfully",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name = "move_path",
|
|
description = [[Moves or rename a file or directory in the project, and returns confirmation that the move succeeded.
|
|
If the source and destination directories are the same, but the filename is different, this performs a rename. Otherwise, it performs a move.
|
|
|
|
This tool should be used when it's desirable to move or rename a file or directory without changing its contents at all.]],
|
|
param = {
|
|
type = "table",
|
|
fields = {
|
|
{
|
|
name = "source_path",
|
|
description = [[The source path of the file or directory to move/rename.
|
|
|
|
<example>
|
|
If the project has the following files:
|
|
|
|
- directory1/a/something.txt
|
|
- directory2/a/things.txt
|
|
- directory3/a/other.txt
|
|
|
|
You can move the first file by providing a source_path of "directory1/a/something.txt"
|
|
</example>]],
|
|
type = "string",
|
|
},
|
|
{
|
|
name = "destination_path",
|
|
description = [[The destination path where the file or directory should be moved/renamed to. If the paths are the same except for the filename, then this will be a rename.
|
|
|
|
<example>
|
|
To move "directory1/a/something.txt" to "directory2/b/renamed.txt", provide a destination_path of "directory2/b/renamed.txt"
|
|
</example>]],
|
|
type = "string",
|
|
},
|
|
},
|
|
usage = {
|
|
source_path = "The source path of the file or directory to move/rename",
|
|
destination_path = "The destination path where the file or directory should be moved/renamed to",
|
|
},
|
|
},
|
|
returns = {
|
|
{
|
|
name = "success",
|
|
description = "True if the file was renamed successfully, false otherwise",
|
|
type = "boolean",
|
|
},
|
|
{
|
|
name = "error",
|
|
description = "Error message if the file was not renamed successfully",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name = "copy_path",
|
|
description = [[Copies a file or directory from the project to a new location, and returns confirmation that the copy succeeded.
|
|
|
|
This tool should be used when it's desirable to copy a file or directory without changing its contents at all.]],
|
|
param = {
|
|
type = "table",
|
|
fields = {
|
|
{
|
|
name = "source_path",
|
|
description = [[The source path of the file or directory to copy.
|
|
|
|
<example>
|
|
If the project has the following files:
|
|
|
|
- directory1/a/something.txt
|
|
- directory2/a/things.txt
|
|
- directory3/a/other.txt
|
|
|
|
You can copy the first file by providing a source_path of "directory1/a/something.txt"
|
|
</example>]],
|
|
type = "string",
|
|
},
|
|
{
|
|
name = "destination_path",
|
|
description = [[The destination path where the file or directory should be copied to.
|
|
|
|
<example>
|
|
To copy "directory1/a/something.txt" to "directory2/b/copied.txt", provide a destination_path of "directory2/b/copied.txt"
|
|
</example>]],
|
|
type = "string",
|
|
},
|
|
},
|
|
usage = {
|
|
source_path = "The source path of the file or directory to copy",
|
|
destination_path = "The destination path where the file or directory should be copied to",
|
|
},
|
|
},
|
|
returns = {
|
|
{
|
|
name = "success",
|
|
description = "True if the file was copied successfully, false otherwise",
|
|
type = "boolean",
|
|
},
|
|
{
|
|
name = "error",
|
|
description = "Error message if the file was not copied successfully",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name = "delete_path",
|
|
description = "Deletes the file or directory (and the directory's contents, recursively) at the specified path in the project, and returns confirmation of the deletion.",
|
|
param = {
|
|
type = "table",
|
|
fields = {
|
|
{
|
|
name = "path",
|
|
description = [[The path of the file or directory to delete.
|
|
<example>
|
|
If the project has the following files:
|
|
|
|
- directory1/a/something.txt
|
|
- directory2/a/things.txt
|
|
- directory3/a/other.txt
|
|
|
|
You can delete the first file by providing a path of "directory1/a/something.txt"
|
|
</example>
|
|
]],
|
|
type = "string",
|
|
},
|
|
},
|
|
usage = {
|
|
path = "Relative path to the file or directory in the current project scope",
|
|
},
|
|
},
|
|
returns = {
|
|
{
|
|
name = "success",
|
|
description = "True if the file was deleted successfully, false otherwise",
|
|
type = "boolean",
|
|
},
|
|
{
|
|
name = "error",
|
|
description = "Error message if the file was not deleted successfully",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name = "create_dir",
|
|
description = "Create a new directory in current project scope",
|
|
param = {
|
|
type = "table",
|
|
fields = {
|
|
{
|
|
name = "path",
|
|
description = "Relative path to the project directory",
|
|
type = "string",
|
|
},
|
|
},
|
|
usage = {
|
|
path = "Relative path to the project directory",
|
|
},
|
|
},
|
|
returns = {
|
|
{
|
|
name = "success",
|
|
description = "True if the directory was created successfully, false otherwise",
|
|
type = "boolean",
|
|
},
|
|
{
|
|
name = "error",
|
|
description = "Error message if the directory was not created successfully",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
},
|
|
require("avante.llm_tools.think"),
|
|
require("avante.llm_tools.get_diagnostics"),
|
|
require("avante.llm_tools.bash"),
|
|
require("avante.llm_tools.attempt_completion"),
|
|
require("avante.llm_tools.edit_file"),
|
|
{
|
|
name = "web_search",
|
|
description = "Search the web",
|
|
param = {
|
|
type = "table",
|
|
fields = {
|
|
{
|
|
name = "query",
|
|
description = "Query to search",
|
|
type = "string",
|
|
},
|
|
},
|
|
usage = {
|
|
query = "Query to search",
|
|
},
|
|
},
|
|
returns = {
|
|
{
|
|
name = "result",
|
|
description = "Result of the search",
|
|
type = "string",
|
|
},
|
|
{
|
|
name = "error",
|
|
description = "Error message if the search was not successful",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name = "fetch",
|
|
description = "Fetch markdown from a url",
|
|
param = {
|
|
type = "table",
|
|
fields = {
|
|
{
|
|
name = "url",
|
|
description = "Url to fetch markdown from",
|
|
type = "string",
|
|
},
|
|
},
|
|
usage = {
|
|
url = "Url to fetch markdown from",
|
|
},
|
|
},
|
|
returns = {
|
|
{
|
|
name = "result",
|
|
description = "Result of the fetch",
|
|
type = "string",
|
|
},
|
|
{
|
|
name = "error",
|
|
description = "Error message if the fetch was not successful",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name = "read_definitions",
|
|
description = "Retrieves the complete source code definitions of any symbol (function, type, constant, etc.) from your codebase.",
|
|
param = {
|
|
type = "table",
|
|
fields = {
|
|
{
|
|
name = "symbol_name",
|
|
description = "The name of the symbol to retrieve the definition for",
|
|
type = "string",
|
|
},
|
|
{
|
|
name = "show_line_numbers",
|
|
description = "Whether to show line numbers in the definitions",
|
|
type = "boolean",
|
|
default = false,
|
|
},
|
|
},
|
|
usage = {
|
|
symbol_name = "The name of the symbol to retrieve the definition for, example: fibonacci",
|
|
show_line_numbers = "true or false",
|
|
},
|
|
},
|
|
returns = {
|
|
{
|
|
name = "definitions",
|
|
description = "The source code definitions of the symbol",
|
|
type = "string[]",
|
|
},
|
|
{
|
|
name = "error",
|
|
description = "Error message if the definition retrieval failed",
|
|
type = "string",
|
|
optional = true,
|
|
},
|
|
},
|
|
func = function(input, opts)
|
|
local on_log = opts.on_log
|
|
local on_complete = opts.on_complete
|
|
local symbol_name = input.symbol_name
|
|
local show_line_numbers = input.show_line_numbers
|
|
if on_log then on_log("symbol_name: " .. vim.inspect(symbol_name)) end
|
|
if on_log then on_log("show_line_numbers: " .. vim.inspect(show_line_numbers)) end
|
|
if not symbol_name then return nil, "No symbol name provided" end
|
|
local sidebar = require("avante").get()
|
|
if not sidebar then return nil, "No sidebar" end
|
|
local bufnr = sidebar.code.bufnr
|
|
if not bufnr then return nil, "No bufnr" end
|
|
if not vim.api.nvim_buf_is_valid(bufnr) then return nil, "Invalid bufnr" end
|
|
if on_log then on_log("bufnr: " .. vim.inspect(bufnr)) end
|
|
Utils.lsp.read_definitions(bufnr, symbol_name, show_line_numbers, function(definitions, error)
|
|
local encoded_defs = vim.json.encode(definitions)
|
|
on_complete(encoded_defs, error)
|
|
end)
|
|
return nil, nil
|
|
end,
|
|
},
|
|
}
|
|
|
|
--- compatibility alias for old calls & tests
|
|
M.run_python = M.python
|
|
|
|
---@class avante.ProcessToolUseOpts
|
|
---@field session_ctx table
|
|
---@field on_log? fun(tool_id: string, tool_name: string, log: string, state: AvanteLLMToolUseState): nil
|
|
---@field set_tool_use_store? fun(tool_id: string, key: string, value: any): nil
|
|
---@field on_complete? fun(result: string | nil, error: string | nil): nil
|
|
|
|
---@param tools AvanteLLMTool[]
|
|
---@param tool_use AvanteLLMToolUse
|
|
---@return string | nil result
|
|
---@return string | nil error
|
|
function M.process_tool_use(tools, tool_use, opts)
|
|
local on_log = opts.on_log
|
|
local on_complete = opts.on_complete
|
|
-- Check if execution is already cancelled
|
|
if Helpers.is_cancelled then
|
|
Utils.debug("Tool execution cancelled before starting: " .. tool_use.name)
|
|
if on_complete then
|
|
on_complete(nil, Helpers.CANCEL_TOKEN)
|
|
return
|
|
end
|
|
return nil, Helpers.CANCEL_TOKEN
|
|
end
|
|
|
|
local func
|
|
if tool_use.name == "str_replace_editor" then
|
|
func = M.str_replace_editor
|
|
elseif tool_use.name == "str_replace_based_edit_tool" then
|
|
func = M.str_replace_based_edit_tool
|
|
else
|
|
---@type AvanteLLMTool?
|
|
local tool = vim.iter(tools):find(function(tool) return tool.name == tool_use.name end) ---@param tool AvanteLLMTool
|
|
if tool == nil then return nil, "This tool is not provided: " .. vim.inspect(tool_use.name) end
|
|
func = tool.func or M[tool.name]
|
|
end
|
|
local input_json = tool_use.input
|
|
if not func then return nil, "Tool not found: " .. tool_use.name end
|
|
if on_log then on_log(tool_use.id, tool_use.name, "running tool", "running") end
|
|
|
|
-- Set up a timer to periodically check for cancellation
|
|
local cancel_timer
|
|
if on_complete then
|
|
cancel_timer = vim.uv.new_timer()
|
|
if cancel_timer then
|
|
cancel_timer:start(
|
|
100,
|
|
100,
|
|
vim.schedule_wrap(function()
|
|
if Helpers.is_cancelled then
|
|
Utils.debug("Tool execution cancelled during execution: " .. tool_use.name)
|
|
if cancel_timer and not cancel_timer:is_closing() then
|
|
cancel_timer:stop()
|
|
cancel_timer:close()
|
|
end
|
|
Helpers.is_cancelled = false
|
|
on_complete(nil, Helpers.CANCEL_TOKEN)
|
|
end
|
|
end)
|
|
)
|
|
end
|
|
end
|
|
|
|
---@param result string | nil | boolean
|
|
---@param err string | nil
|
|
local function handle_result(result, err)
|
|
-- Stop the cancellation timer if it exists
|
|
if cancel_timer and not cancel_timer:is_closing() then
|
|
cancel_timer:stop()
|
|
cancel_timer:close()
|
|
end
|
|
|
|
-- Check for cancellation one more time before processing result
|
|
if Helpers.is_cancelled then
|
|
if on_log then on_log(tool_use.id, tool_use.name, "cancelled during result handling", "failed") end
|
|
return nil, Helpers.CANCEL_TOKEN
|
|
end
|
|
|
|
if err ~= nil then
|
|
if on_log then on_log(tool_use.id, tool_use.name, "Error: " .. err, "failed") end
|
|
else
|
|
if on_log then on_log(tool_use.id, tool_use.name, "tool finished", "succeeded") end
|
|
end
|
|
local result_str ---@type string?
|
|
if type(result) == "string" then
|
|
result_str = result
|
|
elseif result ~= nil then
|
|
result_str = vim.json.encode(result)
|
|
end
|
|
return result_str, err
|
|
end
|
|
|
|
local result, err = func(input_json, {
|
|
session_ctx = opts.session_ctx or {},
|
|
on_log = function(log)
|
|
-- Check for cancellation during logging
|
|
if Helpers.is_cancelled then return end
|
|
if on_log then on_log(tool_use.id, tool_use.name, log, "running") end
|
|
end,
|
|
set_store = function(key, value)
|
|
if opts.set_tool_use_store then opts.set_tool_use_store(tool_use.id, key, value) end
|
|
end,
|
|
on_complete = function(result, err)
|
|
-- Check for cancellation before completing
|
|
if Helpers.is_cancelled then
|
|
Helpers.is_cancelled = false
|
|
if on_complete then on_complete(nil, Helpers.CANCEL_TOKEN) end
|
|
return
|
|
end
|
|
|
|
result, err = handle_result(result, err)
|
|
if on_complete == nil then
|
|
Utils.error("asynchronous tool " .. tool_use.name .. " result not handled")
|
|
return
|
|
end
|
|
on_complete(result, err)
|
|
end,
|
|
streaming = opts.streaming,
|
|
tool_use_id = opts.tool_use_id,
|
|
})
|
|
|
|
-- Result and error being nil means that the tool was executed asynchronously
|
|
if result == nil and err == nil and on_complete then return end
|
|
return handle_result(result, err)
|
|
end
|
|
|
|
---@param tool_use AvanteLLMToolUse
|
|
---@return string
|
|
function M.stringify_tool_use(tool_use)
|
|
local s = string.format("`%s`", tool_use.name)
|
|
return s
|
|
end
|
|
|
|
return M
|