737 lines
31 KiB
Lua
737 lines
31 KiB
Lua
|
|
vim.keymap.set({'n', 'v'}, '<leader>mct', '<cmd>CodeCompanionChat Toggle<cr>', { noremap = true, silent = true, desc = "CC Toggle" })
|
|
vim.keymap.set({'n', 'v'}, '<leader>mca', '<cmd>CodeCompanionActions<cr>', { noremap = true, silent = true, desc = "CC Action" })
|
|
vim.keymap.set({'n', 'v'}, '<leader>mce', '<cmd>CodeCompanion Explain<cr>', { desc = "CC Explain" })
|
|
vim.keymap.set({'n'}, '<leader>mcf', '<cmd>CodeCompanion Fix code<cr>', { desc = "CC fix" })
|
|
vim.keymap.set({'v'}, '<leader>mcc', '<cmd>CodeCompanionChat Add<cr>', { noremap = true, silent = true, desc = "CC Add" })
|
|
vim.keymap.set({'v'}, '<leader>mcr', '<cmd>CodeCompanion Code Review<cr>', { desc = 'Code Review' })
|
|
vim.keymap.set({'v'}, '<leader>mco', '<cmd>CodeCompanion Optimize Performance<cr>', { desc = 'Optimize Code' })
|
|
vim.keymap.set({'v'}, '<leader>mcg', '<cmd>CodeCompanion Generate Tests<cr>', { desc = 'Generate Tests' })
|
|
vim.keymap.set({'v'}, '<leader>mcd', '<cmd>CodeCompanion Debug Analysis<cr>', { desc = 'Debug Analysis' })
|
|
|
|
-- TODO: run this command
|
|
-- build = "uv tool upgrade vectorcode", -- This helps keeping the CLI up-to-date
|
|
vim.api.nvim_create_autocmd('PackChanged', {
|
|
callback = function()
|
|
vim.fn.jobstart({ "uv", "tool", "upgrade", "vectorcode" }, {
|
|
on_exit = function(_, exit_code, _)
|
|
if exit_code == 0 then
|
|
vim.notify("vectorcode upgraded", vim.log.levels.INFO, { title = "CodeCompanion" })
|
|
else
|
|
vim.notify("vectorcode upgrade failed (exit " .. exit_code .. ")", vim.log.levels.WARN, { title = "CodeCompanion" })
|
|
end
|
|
end,
|
|
})
|
|
end
|
|
})
|
|
|
|
local function get_abacus_key()
|
|
local ok, res = pcall(vim.fn.systemlist, "pass show abacus.ai-api")
|
|
if not ok or not res or vim.tbl_isempty(res) then
|
|
return ""
|
|
end
|
|
-- systemlist returns lines; join and trim whitespace
|
|
local key = table.concat(res, "\n")
|
|
key = key:gsub("^%s+", ""):gsub("%s+$", "")
|
|
return key
|
|
end
|
|
|
|
local function copilot_supports_sampling(self)
|
|
local model = self.schema.model.default
|
|
if type(model) == "function" then
|
|
model = model(self)
|
|
end
|
|
|
|
model = type(model) == "string" and model:lower() or ""
|
|
return not model:find("gpt%-5", 1, false) and not model:find("codex", 1, false)
|
|
end
|
|
|
|
|
|
local ok, codecompanion = pcall(require, "codecompanion")
|
|
if not ok or not codecompanion then
|
|
vim.notify("codecompanion not available", vim.log.levels.ERROR)
|
|
return
|
|
end
|
|
codecompanion.setup({
|
|
adapters = {
|
|
http = {
|
|
opts = {
|
|
show_presets = true,
|
|
show_model_choices = true,
|
|
},
|
|
-- openai = function()
|
|
-- return require("codecompanion.adapters").extend("openai", {
|
|
-- env = { api_key = "cmd:pass show api.openai.com" }
|
|
-- })
|
|
-- end,
|
|
openrouter = function()
|
|
return require("codecompanion.adapters").extend("openai_compatible", {
|
|
env = {
|
|
url = "https://openrouter.ai/api",
|
|
api_key = "OPENROUTER_API_KEY",
|
|
chat_url = "/v1/chat/completions",
|
|
},
|
|
schema = {
|
|
model = {
|
|
default = "anthropic/claude-3.7-sonnet",
|
|
},
|
|
},
|
|
})
|
|
end,
|
|
abacus = function()
|
|
return require("codecompanion.adapters").extend("openai_compatible", {
|
|
name = "abacus",
|
|
formatted_name = "Abacus.AI",
|
|
env = {
|
|
url = "https://routellm.abacus.ai/v1",
|
|
-- IMPORTANT: include /v1 in the base url
|
|
api_key = get_abacus_key(),
|
|
chat_url = "/chat/completions"
|
|
},
|
|
headers = {
|
|
["Content-Type"] = "application/json",
|
|
["Authorization"] = "Bearer ${api_key}",
|
|
},
|
|
schema = {
|
|
model = {
|
|
order = 1,
|
|
mapping = "parameters",
|
|
type = "enum",
|
|
desc = "The model to use for chat completions.",
|
|
default = "route-llm",
|
|
choices = {
|
|
-- Routing Model
|
|
["route-llm"] = { opts = { desc = "Intelligent routing to best model" } },
|
|
|
|
-- OpenAI Models
|
|
["gpt-5.2"] = { opts = { has_vision = true } },
|
|
["gpt-5.1"] = { opts = { has_vision = true } },
|
|
["gpt-5.1-chat-latest"] = { opts = { has_vision = true } },
|
|
["gpt-5"] = { opts = { has_vision = true } },
|
|
["gpt-5-mini"] = { opts = { has_vision = true } },
|
|
["gpt-5-nano"] = { opts = { has_vision = true } },
|
|
["gpt-4o"] = { opts = { has_vision = true } },
|
|
["gpt-4o-mini"] = { opts = { has_vision = true } },
|
|
["o4-mini"] = { opts = { can_reason = true } },
|
|
["o3"] = { opts = { can_reason = true } },
|
|
["o3-pro"] = { opts = { can_reason = true } },
|
|
|
|
-- Anthropic Models
|
|
["claude-4-5-sonnet"] = { opts = { has_vision = true } },
|
|
["claude-4-5-haiku"] = { opts = { has_vision = true } },
|
|
["claude-4-5-opus"] = { opts = { has_vision = true } },
|
|
["claude-3-opus"] = { opts = { has_vision = true } },
|
|
|
|
-- Google Models
|
|
["gemini-3-pro"] = { opts = { has_vision = true } },
|
|
["gemini-3-flash"] = { opts = { has_vision = true } },
|
|
["gemini-2.5-pro"] = { opts = { has_vision = true } },
|
|
["gemini-2.5-flash"] = { opts = { has_vision = true } },
|
|
|
|
-- xAI Models
|
|
["grok-4-1-fast"] = {},
|
|
["grok-4"] = {},
|
|
["grok-code-fast-1"] = {},
|
|
|
|
-- Meta Models
|
|
["llama-4-Maverick-17B"] = {},
|
|
["llama-3.1-405B"] = {},
|
|
["llama-3.1-70B"] = {},
|
|
|
|
-- DeepSeek Models
|
|
["deepseek-v3.2"] = {},
|
|
["deepseek-v3.1-Terminus"] = {},
|
|
["deepseek-R1"] = { opts = { can_reason = true } },
|
|
|
|
-- Qwen Models
|
|
["qwen-3-Max"] = {},
|
|
["qwen3-coder-480b-a35b-instruct"] = {},
|
|
["qwen-3-32B"] = {},
|
|
["qwq-32B"] = { opts = { can_reason = true } },
|
|
},
|
|
},
|
|
temperature = {
|
|
order = 2,
|
|
mapping = "parameters",
|
|
type = "number",
|
|
optional = true,
|
|
default = 1.0,
|
|
desc = "Controls randomness of output (0-2).",
|
|
validate = function(n)
|
|
return n >= 0 and n <= 2, "Must be between 0 and 2"
|
|
end,
|
|
},
|
|
max_tokens = {
|
|
order = 3,
|
|
mapping = "parameters",
|
|
type = "integer",
|
|
optional = true,
|
|
default = nil,
|
|
desc = "Maximum tokens to generate.",
|
|
validate = function(n)
|
|
return n > 0, "Must be greater than 0"
|
|
end,
|
|
},
|
|
top_p = {
|
|
order = 4,
|
|
mapping = "parameters",
|
|
type = "number",
|
|
optional = true,
|
|
default = 1.0,
|
|
desc = "Nucleus sampling parameter (0-1).",
|
|
validate = function(n)
|
|
return n >= 0 and n <= 1, "Must be between 0 and 1"
|
|
end,
|
|
},
|
|
},
|
|
})
|
|
end,
|
|
ollama = function()
|
|
local ollama_url = os.getenv("OLLAMA_URL") or "http://localhost:11434"
|
|
return require("codecompanion.adapters").extend("ollama", {
|
|
env = {
|
|
url = ollama_url,
|
|
},
|
|
schema = {
|
|
model = {
|
|
default = "qwen3.5",
|
|
},
|
|
},
|
|
})
|
|
end,
|
|
copilot = function()
|
|
return require("codecompanion.adapters").extend("copilot", {
|
|
schema = {
|
|
model = {
|
|
default = "gpt-5-mini", -- Consistent model choice
|
|
},
|
|
-- CodeCompanion only skips schema fields when `enabled` is a
|
|
-- function that returns false.
|
|
temperature = {
|
|
enabled = copilot_supports_sampling,
|
|
},
|
|
top_p = {
|
|
enabled = copilot_supports_sampling,
|
|
},
|
|
n = {
|
|
enabled = copilot_supports_sampling,
|
|
},
|
|
max_tokens = {
|
|
default = 16284,
|
|
}
|
|
}
|
|
})
|
|
end,
|
|
},
|
|
acp = {
|
|
opts = {
|
|
show_presets = true,
|
|
},
|
|
copilot_cli = function()
|
|
return require("codecompanion.adapters").extend("copilot_cli", {})
|
|
end,
|
|
codex = function()
|
|
return require("codecompanion.adapters").extend("codex", {
|
|
-- commands = {
|
|
-- default = { "codex-acp" },
|
|
-- },
|
|
-- schema = {
|
|
-- model = {
|
|
-- default = "github-copilot/gpt-5.2-codex",
|
|
-- },
|
|
-- },
|
|
defaults = {
|
|
timeout = 20000,
|
|
auth_method = "chatgpt", -- "openai-api-key"|"codex-api-key"|"chatgpt"
|
|
},
|
|
})
|
|
end,
|
|
-- opencode = function()
|
|
-- return require("codecompanion.adapters").extend("codex", {
|
|
-- commands = {
|
|
-- default = { "opencode", "acp" },
|
|
-- },
|
|
-- schema = {
|
|
-- model = {
|
|
-- default = "github-copilot/gpt-5.2-codex",
|
|
-- },
|
|
-- },
|
|
-- defaults = {
|
|
-- timeout = 20000,
|
|
-- auth_method = "chatgpt", -- "openai-api-key"|"codex-api-key"|"chatgpt"
|
|
-- },
|
|
-- })
|
|
-- end,
|
|
},
|
|
},
|
|
rules = {
|
|
opts = {
|
|
chat = {
|
|
enabled = true,
|
|
autoload = { "default" }
|
|
},
|
|
},
|
|
},
|
|
opts = {
|
|
send_code = true,
|
|
log_level = "WARN", -- Change to DEBUG for troubleshooting
|
|
language = "English",
|
|
-- NEW: Performance improvements
|
|
job_start_delay = 500, -- Reduced from default 1500ms
|
|
submit_delay = 1000, -- Reduced from default 2000ms
|
|
},
|
|
extensions = {
|
|
spinner = {},
|
|
-- ddgr_search = {
|
|
-- opts = {
|
|
-- require_approval_before = false,
|
|
-- },
|
|
-- },
|
|
agentskills = {
|
|
opts = {
|
|
paths = {
|
|
{ vim.fn.expand("~/.agents/skills"), recursive = true },
|
|
},
|
|
},
|
|
},
|
|
-- vectorcode = { lazy = true },
|
|
history = {
|
|
lazy = true,
|
|
enabled = true,
|
|
opts = {
|
|
keymap = "ghf",
|
|
save_chat_keymap = "ghs",
|
|
picker = "snacks",
|
|
dir_to_save = vim.env.HOME .. "/Documents/ai-history",
|
|
title_generation_opts = {
|
|
adapter = "copilot",
|
|
model = "gpt-5-mini",
|
|
},
|
|
summary = {
|
|
create_summary_keymap = "ghc",
|
|
browse_summaries_keymap = "ghb",
|
|
},
|
|
},
|
|
},
|
|
-- mcphub = {
|
|
-- callback = "mcphub.extensions.codecompanion",
|
|
-- opts = {
|
|
-- make_vars = true,
|
|
-- make_slash_commands = true,
|
|
-- show_result_in_chat = true,
|
|
-- },
|
|
-- },
|
|
},
|
|
interactions = {
|
|
chat = {
|
|
variables = {
|
|
project = {
|
|
callback = function()
|
|
-- Get project files structure
|
|
local files = vim.fn.systemlist("fd . -type f")
|
|
return table.concat(files, "\n")
|
|
end,
|
|
description = "Share project structure"
|
|
}
|
|
},
|
|
tools = {
|
|
opts = {
|
|
auto_submit_errors = false, -- Send any errors to the LLM automatically?
|
|
auto_submit_success = false, -- Send any successful output to the LLM automatically?
|
|
system_prompt = {
|
|
enabled = true,
|
|
replace_main_system_prompt = false,
|
|
},
|
|
default_tools = {
|
|
"ask_questions",
|
|
"file_search",
|
|
"read_file",
|
|
"cmd_runner",
|
|
"fetch",
|
|
"grep_search",
|
|
"memory",
|
|
"agent_skills",
|
|
-- "ddgr_search",
|
|
},
|
|
},
|
|
["fetch_enhanced"] = {
|
|
description = "Fetch a data from the web",
|
|
callback = function(url, options)
|
|
options = options or {}
|
|
local max_length = options.max_length or 200000 -- 200KB default
|
|
local timeout = options.timeout or 60
|
|
|
|
local res = vim.system({
|
|
"curl", "-L", "-s", "--max-time", tostring(timeout), "--user-agent", "CodeCompanion-Neovim", url
|
|
}, { timeout = (timeout + 5) * 1000 }):wait()
|
|
|
|
if not res or res.code ~= 0 then
|
|
return nil, "Failed to fetch URL: " .. tostring(res and res.code or "unknown")
|
|
end
|
|
|
|
local result = res.output or ""
|
|
if #result > max_length then
|
|
result = result:sub(1, max_length) .. "\n[... truncated at " .. max_length .. " characters ...]"
|
|
end
|
|
|
|
return result
|
|
end,
|
|
opts = {
|
|
requires_approval = false,
|
|
}
|
|
},
|
|
["fetch_unlimited"] = {
|
|
description = "Fetch a data from the web",
|
|
callback = function(url, options)
|
|
options = options or {}
|
|
|
|
-- Use a local proxy service or direct system calls
|
|
local temp_file = vim.fn.tempname()
|
|
local cmd = string.format(
|
|
'wget --timeout=60 --tries=3 --output-document="%s" "%s" 2>/dev/null && cat "%s" && rm "%s"',
|
|
temp_file, url, temp_file, temp_file
|
|
)
|
|
|
|
local handle = io.popen(cmd)
|
|
if not handle then
|
|
return nil, "Failed to fetch URL"
|
|
end
|
|
|
|
local result = handle:read("*a")
|
|
handle:close()
|
|
|
|
-- Optional: Process and clean the content
|
|
-- Remove excessive whitespace, clean HTML if needed
|
|
-- result = result:gsub("%s+", " "):gsub("^\s+", ""):gsub("%s+$", "")
|
|
|
|
return result
|
|
end,
|
|
opts = {
|
|
requires_approval = false,
|
|
description = "Fetch web content with unlimited size"
|
|
}
|
|
},
|
|
["fetch"] = {
|
|
description = "Fetch a webpage in a markdown format",
|
|
callback = function(url, options)
|
|
local cmd = string.format(
|
|
'reader -o -i none %s 2>/dev/null',
|
|
url
|
|
)
|
|
local handle = io.popen(cmd)
|
|
if not handle then
|
|
return nil, "Failed to fetch URL"
|
|
end
|
|
|
|
local result = handle:read("*a")
|
|
handle:close()
|
|
|
|
return result
|
|
end,
|
|
},
|
|
-- ["mcp"] = { -- Name this tool whatever you like
|
|
-- -- Callback provides the necessary functions to CodeCompanion
|
|
-- callback = function()
|
|
-- return require("mcphub.extensions.codecompanion")
|
|
-- end,
|
|
-- opts = {
|
|
-- -- If true, CodeCompanion will ask for approval before executing the MCP tool call
|
|
-- requires_approval = true,
|
|
-- -- Optional: Pass parameters like temperature to the underlying LLM if the chat strategy supports it
|
|
-- temperature = 0.7
|
|
-- }
|
|
-- },
|
|
groups = {
|
|
['plan'] = {
|
|
description = "Planning my project and codes with enhanced web access",
|
|
prompt = "Using all the ${tools} at your disposal including enhanced web fetching. Analyze the codes and use it to help me with my query. You have access to unlimited web content fetching.",
|
|
tools = {
|
|
"ask_questions",
|
|
"fetch", -- Backup unlimited fetch
|
|
"file_search",
|
|
"grep_search",
|
|
"list_code_usages",
|
|
"next_edit_suggestion",
|
|
"read_file",
|
|
"cmd_runner",
|
|
},
|
|
opts = {
|
|
collapse_tools = true,
|
|
-- Override default fetch behavior for this group
|
|
tool_config = {
|
|
fetch_enhanced = {
|
|
max_length = 500000, -- 500KB for planning tasks
|
|
chunk_processing = true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
['research'] = {
|
|
description = "Deep research with unlimited web access",
|
|
prompt = "You are a research assistant with unlimited web access. Using the ${tools} fetch and analyze large documents, research papers, and comprehensive web content.",
|
|
tools = {
|
|
"ask_questions",
|
|
"fetch",
|
|
"fetch_enhanced",
|
|
"file_search",
|
|
"read_file",
|
|
},
|
|
opts = {
|
|
collapse_tools = false,
|
|
},
|
|
},
|
|
-- NEW: Add development group for coding tasks
|
|
['dev'] = {
|
|
description = "Full-stack development with all necessary tools",
|
|
prompt = "You are an expert full-stack developer. Use ${tools} to understand, modify, and test code. Always gather context before making changes.",
|
|
tools = {
|
|
"agents",
|
|
},
|
|
opts = {
|
|
collapse_tools = true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
slash_commands = {
|
|
["buffer"] = { opts = { provider = "snacks" } }, -- snacks
|
|
["file"] = { opts = { provider = "snacks" } }, -- snackes
|
|
['git_files'] = {
|
|
description = 'List git files',
|
|
---@param chat CodeCompanion.Chat
|
|
callback = function(chat)
|
|
local handle = io.popen 'git ls-files'
|
|
if handle ~= nil then
|
|
local result = handle:read '*a'
|
|
handle:close()
|
|
chat:add_reference({ content = result }, 'git', '<git_files>')
|
|
return vim.notify('Git files added to the chat.')
|
|
else
|
|
return vim.notify('No git files available', vim.log.levels.INFO, { title = 'CodeCompanion' })
|
|
end
|
|
end,
|
|
opts = {
|
|
contains_code = false,
|
|
},
|
|
},
|
|
-- NEW: Add helpful workspace command
|
|
["workspace"] = {
|
|
description = "Add workspace context",
|
|
callback = function(chat)
|
|
local cwd = vim.fn.getcwd()
|
|
local workspace_info = string.format("Working directory: %s", cwd)
|
|
|
|
-- Get project type
|
|
local files = vim.fn.glob(cwd .. "/*", false, true)
|
|
for _, file in ipairs(files) do
|
|
local basename = vim.fn.fnamemodify(file, ":t")
|
|
if basename == "package.json" then
|
|
workspace_info = workspace_info .. "\nProject type: Node.js/JavaScript"
|
|
break
|
|
elseif basename == "Cargo.toml" then
|
|
workspace_info = workspace_info .. "\nProject type: Rust"
|
|
break
|
|
elseif basename == "go.mod" then
|
|
workspace_info = workspace_info .. "\nProject type: Go"
|
|
break
|
|
end
|
|
end
|
|
|
|
chat:add_reference({ content = workspace_info }, 'workspace', '<workspace>')
|
|
return vim.notify('Workspace context added.')
|
|
end,
|
|
opts = {
|
|
contains_code = false,
|
|
},
|
|
},
|
|
},
|
|
-- adapter = { name = "abacus", model = "route-llm" },
|
|
-- adapter = { name = "opencode", model = "github-copilot/gpt-5.2-codex" },
|
|
-- adapter = { name = "copilot", model = "gpt-5-mini" },
|
|
adapter = { name = "goose" },
|
|
},
|
|
inline = {
|
|
-- adapter = { name = "abacus", model = "route-llm" },
|
|
adapter = { name = "copilot", model = "gpt-5.1-codex-mini" },
|
|
},
|
|
cmd = {
|
|
adapter = { name = "copilot", model = "gpt-5-mini" },
|
|
},
|
|
background = {
|
|
adapter = { name = "copilot", model = "gpt-5-mini" },
|
|
},
|
|
},
|
|
prompt_library = {
|
|
markdown = {
|
|
dirs = {
|
|
vim.fn.getcwd() .. "/.prompts",
|
|
"~/.agents/prompts",
|
|
},
|
|
},
|
|
["Code Review"] = {
|
|
interaction = "chat",
|
|
description = "Review the selected code for improvements",
|
|
opts = {
|
|
mapping = "<LocalLeader>rpc",
|
|
modes = { "v" },
|
|
adapter = {
|
|
name = "copilot",
|
|
model = "chatgpt-5.3-codex",
|
|
},
|
|
},
|
|
prompts = {
|
|
{
|
|
role = "system",
|
|
content = "You are an expert code reviewer. Analyze the code for: 1) Logic errors 2) Performance issues 3) Security vulnerabilities 4) Best practices 5) Code clarity and maintainability. Provide specific, actionable feedback.",
|
|
},
|
|
{
|
|
role = "user",
|
|
content = function(context)
|
|
local code = require("codecompanion.helpers.actions").get_code(context.start_line, context.end_line)
|
|
return "Please review this code:\n\n```" .. context.filetype .. "\n" .. code .. "\n```"
|
|
end,
|
|
},
|
|
},
|
|
cc_keywords = { "review", "critique", "smell", "security", "vulnerability", "best practice", "maintainab" },
|
|
cc_threshold = 2,
|
|
},
|
|
["Optimize Performance"] = {
|
|
interaction = "chat",
|
|
description = "Get performance optimization suggestions",
|
|
opts = {
|
|
mapping = "<LocalLeader>rpo",
|
|
modes = { "v" },
|
|
adapter = {
|
|
name = "copilot",
|
|
model = "chatgpt-5.3-codex",
|
|
},
|
|
},
|
|
prompts = {
|
|
{
|
|
role = "system",
|
|
content = "You are a performance optimization expert. Focus on: 1) Time complexity improvements 2) Space efficiency 3) Algorithm optimization 4) Framework-specific optimizations 5) Caching strategies.",
|
|
},
|
|
{
|
|
role = "user",
|
|
content = function(context)
|
|
local code = require("codecompanion.helpers.actions").get_code(context.start_line, context.end_line)
|
|
return "How can I optimize the performance of this code?\n\n```" .. context.filetype .. "\n" .. code .. "\n```"
|
|
end,
|
|
},
|
|
},
|
|
cc_keywords = { "optimize", "performance", "slow", "latency", "throughput", "memory", "alloc" },
|
|
},
|
|
["Debug Analysis"] = {
|
|
interaction = "chat",
|
|
description = "Analyze and debug problematic code",
|
|
opts = {
|
|
mapping = "<LocalLeader>rpd",
|
|
modes = { "v" },
|
|
|
|
adapter = {
|
|
name = "copilot",
|
|
model = "chatgpt-5.3-codex",
|
|
},
|
|
},
|
|
prompts = {
|
|
{
|
|
role = "system",
|
|
content = [[You are a debugging expert. Analyze code for:
|
|
1. Potential bugs and issues
|
|
2. Logic errors
|
|
3. Runtime errors
|
|
4. Common pitfalls
|
|
5. Debugging strategies.
|
|
6. Provide specific solutions.]],
|
|
},
|
|
{
|
|
role = "user",
|
|
content = function(context)
|
|
local code = require("codecompanion.helpers.actions").get_code(context.start_line, context.end_line)
|
|
return string.format(
|
|
[[Help me debug this code from buffer %d and identify potential issues:
|
|
|
|
```%s
|
|
%s
|
|
```]],
|
|
context.bufnr,
|
|
context.filetype,
|
|
code
|
|
)
|
|
end,
|
|
opts = {
|
|
contains_code = true,
|
|
}
|
|
},
|
|
},
|
|
cc_keywords = { "bug", "debug", "error", "exception", "crash", "stacktrace", "broken", "issue" },
|
|
},
|
|
["Architecture Review"] = {
|
|
interaction = "chat",
|
|
description = "Review architectural patterns and design",
|
|
opts = {
|
|
mapping = "<LocalLeader>rpa",
|
|
modes = { "v" },
|
|
|
|
adapter = {
|
|
name = "copilot",
|
|
model = "chatgpt-5.4",
|
|
},
|
|
},
|
|
prompts = {
|
|
{
|
|
role = "system",
|
|
content = "You are a software architect. Review code for: 1) Design patterns usage 2) SOLID principles 3) Separation of concerns 4) Scalability considerations 5) Maintainability. Suggest architectural improvements.",
|
|
},
|
|
{
|
|
role = "user",
|
|
content = function(context)
|
|
|
|
local code = require("codecompanion.helpers.actions").get_code(context.start_line, context.end_line)
|
|
return string.format(
|
|
[[Please review the architecture and design of this code from buffer %d:
|
|
|
|
```%s
|
|
%s
|
|
```]],
|
|
context.bufnr,
|
|
context.filetype,
|
|
code
|
|
)
|
|
end,
|
|
opts = {
|
|
contains_code = true,
|
|
}
|
|
},
|
|
},
|
|
cc_keywords = { "architecture", "design", "pattern", "solid", "scalab", "maintainab", "refactor" },
|
|
},
|
|
},
|
|
display = {
|
|
action_palette = {
|
|
provider = "snacks",
|
|
opts = {
|
|
show_default_actions = true,
|
|
show_default_prompt_library = true,
|
|
}
|
|
},
|
|
chat = {
|
|
show_settings = false,
|
|
render_headers = false,
|
|
icons = {
|
|
chat_context = "📎️",
|
|
},
|
|
fold_context = true,
|
|
-- NEW: Better chat window configuration
|
|
window = {
|
|
layout = "vertical",
|
|
width = 0.45,
|
|
height = 0.8,
|
|
border = "rounded", -- Better visual
|
|
},
|
|
auto_scroll = false,
|
|
start_in_insert_mode = false, -- More convenient
|
|
}
|
|
}
|
|
})
|