-
|
Hello, Thanks a lot for this great plugin! It looks amazing. I'm looking for a bit more convenient way of sharing files with LLM to ask questions. Instead of |
Beta Was this translation helpful? Give feedback.
Replies: 7 comments 12 replies
-
|
That's a really awesome idea. To enable tighter integration between plugins, I've implemented events which are fired throughout the plugin's lifecycle. Lazy.nvim does the same too. It essentially pushes the focus of integration onto the user rather than us, the plugin maintainers. I'd advise investigating whether nvim-tree has a similar event system which you could create an autocmd around. You could then programmatically add references to a CodeCompanion chat buffer based on those events. |
Beta Was this translation helpful? Give feedback.
-
|
Thanks a lot. I'm only confused about how to add references to a CodeCompanion chat buffer. I would love to define some function like: local function add_file_to_context(file_path)
local codecompanion = require('codecompanion')
codecompanion.chat_buffer().add_to_context(file_path
endWhich I could call when reacting to some event (or actually I would initally use it in my custom command). The problem is - I'm not sure how to implement this function. I will try to dig deeper into the source code. |
Beta Was this translation helpful? Give feedback.
-
|
The |
Beta Was this translation helpful? Give feedback.
-
|
Amazing! Thanks, I will play with it. |
Beta Was this translation helpful? Give feedback.
-
|
Thanks to your suggestions @olimorris I've implemented following custom command: vim.api.nvim_create_user_command('Cga', function(opts)
require("codecompanion").last_chat().References:add({
id = opts.args,
path = opts.args,
source = "codecompanion.strategies.chat.slash_commands.file",
opts = {
pinned = true
}
})
end, { nargs = 1 });Now this is extremely useful for me, because I can just navigate on nvim tree and press |
Beta Was this translation helpful? Give feedback.
-
|
Dang you guys are making me super jealous. I need to workout how I can do this with oil.nvim |
Beta Was this translation helpful? Give feedback.
-
|
Amazing. You've nailed it @ravitemer! In my case though, I need to keep local function nvim_tree_on_attach(bufnr)
local api = require("nvim-tree.api")
local luv = vim.loop
-- Function to recursively add files in a directory to chat references
local function traverse_directory(path, chat)
local handle, err = luv.fs_scandir(path)
if not handle then return print("Error scanning directory: " .. err) end
while true do
local name, type = luv.fs_scandir_next(handle)
if not name then break end
local item_path = path .. "/" .. name
if type == "file" then
-- add the file to references
chat.References:add({
id = '<file>' .. item_path .. '</file>',
path = item_path,
source = "codecompanion.strategies.chat.slash_commands.file",
opts = {
pinned = true
}
})
elseif type == "directory" then
-- recursive call for a subdirectory
traverse_directory(item_path, chat)
end
end
end
-- Attach default mappings
api.config.mappings.default_on_attach(bufnr)
vim.keymap.set('n', 'ca', function()
local node = api.tree.get_node_under_cursor()
local path = node.absolute_path
local codecompanion = require("codecompanion")
local chat = codecompanion.last_chat()
-- create chat if none exists
if (chat == nil) then
chat = codecompanion.chat()
end
local attr = luv.fs_stat(path)
if attr and attr.type == "directory" then
-- Recursively traverse the directory
traverse_directory(path, chat)
else
-- if already added, ignore
for _, ref in ipairs(chat.refs) do
if ref.path == path then
return print("Already added")
end
end
chat.References:add({
id = '<file>' .. path .. '</file>',
path = path,
source = "codecompanion.strategies.chat.slash_commands.file",
opts = {
pinned = true
}
})
end
end, { buffer = bufnr, desc = "Add or Pin file to Chat" })
end
I'm not sure about |
Beta Was this translation helpful? Give feedback.
-
|
That's even better! Thanks @sobanieca. This will be handy. Regarding token limits, I can't say I experience this partly because I don't use adding files or pinning them that much during my workflow. I have the following workflow setup such that I rarely have to reference anything explicitly. It has been super helpful and has been working flawlessly. First I'll explain how and later give the details. My workflow for a project:
1. custom-instructions.mdusually at .github/copilot-instructions.md (inspired from vscode's copilot custom instructions) ## Project Overview
This is a SvelteKit 5 project using runes ($state, $props, $derived) that .... The app is fully client-rendered (SSR disabled).
Key technical details:
- SvelteKit (with Svelte 5 runes)
- Client-side only (SSR disabled)
- TailwindCSS with shadcn-svelte components
- Firebase/Firestore for user data
## Code Conventions
### 1. Svelte Component Structure
- Use Svelte 5 runes syntax ($state, $derived, $props, $effect)
- Event handlers use `onclick` instead of `on:click`
- Components are feature-based grouped
- All UI components are in `$ui/` directory
- Import paths use aliases:
```js
import { Button } from '$ui/button';
import { toast } from '$utils';
```
### 2. Component Styling
- Use Tailwind classes with shadcn-svelte patterns
- Support dark mode using `dark:` prefix
- Use CSS variables from app.css for theming
- Follow the color token system:
### 3. State Management and Utils
- Use Firestore for persistent storage
- Use svelte-sonner for toasts
```js
import { toast } from '$utils';
toast.success('Operation successful');
```
### 4. Common Component Pattern
```svelte
<script>
import { Button } from '$ui/button';
let { prop1, prop2 } = $props();
let someState = $state(initial);
let derived = $derived(computation);
function handleAction() {
// Action logic
}
</script>
<div class="flex items-center bg-background dark:bg-background-dark">
<Button variant="ghost" onclick={handleAction}>Action</Button>
</div>
```
### 5. Error Handling
- Use toast.error for error feedback
- Implement proper error boundaries
- Handle Telegram API errors gracefully
When suggesting code, ensure it adheres to these patterns and conventions.
---Any other project related details like file structure---2. Let LLM see what I seeWhen I am working on a particular feature in my app let's say I want to implement progress tracking for upload and download operations. I have to first open any related files to see how I should do it anyway e.g 3. Let LLM control the editorNow with In this entire flow,
I have been using this for over a month and I have no complaints. If in case at some point you don't want to add them automatically I have setup a SetupI initially opened a discussion here #420 (comment) explaining this setup. All I did was to build on the currently existing default adapter. In form messages I insert or replace the custom-instructions as well as the buffers.
local utils = require("user.codecompanion.adapters.utils")
return {
features = {
text = true,
tokens = true,
vision = false,
},
handlers = {
form_messages = function(adapter, messages)
if not vim.g.enable_codecompanion_custom_messages then
return {
messages = utils.remove_custom_messages(messages),
}
end
local obj = require("codecompanion.adapters.copilot").handlers.form_messages(adapter, messages)
local _messages = utils.add_custom_instructions_message(obj.messages)
_messages = utils.add_buffers_message(_messages, adapter)
return {
messages = _messages,
}
end,
},
schema = {
model = {
default = "claude-3.5-sonnet",
},
max_tokens = {
default = 8192,
},
},
}
local utils = require("user.utils")
local BufVariable = require("user.codecompanion.variables.bufs")
local function get_buffers_message(chat)
local var = BufVariable.new({ layers = 2, chat = chat })
local buf_message = var:execute()
local prompt =
"The following buffers are currently active for the user. This list will always be up-to-date and any response that requires line numbers and file content should depend on this.\n\n"
return {
role = "system",
content = prompt .. "\n" .. buf_message,
opts = {
tag = "custom_buffers_message",
visible = false,
}
}
end
local remove_custom_messages = function(messages)
vim.notify("Removing custom messages")
return vim.tbl_filter(function(message)
return not (message.opts and message.opts.tag and message.opts.tag:find("custom_"))
end, messages)
end
local add_buffers_message = function(messages, chat)
local bufs_message_index = utils.find_index(messages, function(message)
return message.opts and message.opts.tag == "custom_buffers_message"
end)
local msg = get_buffers_message(chat)
if bufs_message_index == -1 then
table.insert(messages, 3, msg)
else
--replace with new message
messages[bufs_message_index] = msg
end
return messages
end
local function get_custom_instructions()
local path = vim.fn.getcwd()
while path ~= "/" do
local instructions_path = path .. "/.github/copilot-instructions.md"
if vim.fn.filereadable(instructions_path) == 1 then
vim.notify("Found custom instructions at " .. instructions_path)
return vim.fn.readfile(instructions_path)
end
path = vim.fn.fnamemodify(path, ":h")
end
return nil
end
local function get_custom_instructions_message()
local instructions = get_custom_instructions()
if instructions then
local prompt = "User's Custom instructions for the current repository:\n\n"
return {
role = "system",
content = prompt .. table.concat(instructions, "\n"),
opts = {
tag = "custom_instructions_message",
visible = false,
}
}
end
return nil
end
local function add_custom_instructions_message(messages)
local instructions_message_index = utils.find_index(messages, function(message)
return message.opts and message.opts.tag == "custom_instructions_message"
end)
local msg = get_custom_instructions_message()
if msg then
if instructions_message_index == -1 then
table.insert(messages, 2, msg)
else
messages[instructions_message_index] = msg
end
end
return messages
end
return {
add_buffers_message = add_buffers_message,
get_buffers_message = get_buffers_message,
add_custom_instructions_message = add_custom_instructions_message,
get_custom_instructions_message = get_custom_instructions_message,
remove_custom_messages = remove_custom_messages,
}
local buf_utils = require("codecompanion.utils.buffers")
local file_utils = reload("user.utils.file_utils")
local editor_utils = reload("user.utils.editor")
local Variable = {}
local function get_active_buf()
local bufs = editor_utils.get_buffers_info()
local active_buf = vim.tbl_filter(function(buf)
return buf.is_visible
end
, bufs)[1]
return active_buf
end
function Variable.new(args)
local self = setmetatable({
chat = args.chat,
params = args.params,
layers = args.layers or 1,
}, { __index = Variable })
return self
end
---Return the contents of all listed and loaded buffers
---@return string
function Variable:execute()
local buffers_info = editor_utils.get_buffers_info()
local output = {}
-- First add visible buffers
for _, buf_info in ipairs(buffers_info) do
if buf_info.is_visible and vim.api.nvim_buf_is_loaded(buf_info.bufnr) then
local buffer_content = buf_utils.format_with_line_numbers(buf_info.bufnr)
buffer_content = "Visible Buffer:\n" .. buffer_content
table.insert(output, buffer_content)
end
end
-- Then add non-visible buffers
for _, buf_info in ipairs(buffers_info) do
if not buf_info.is_visible and vim.api.nvim_buf_is_loaded(buf_info.bufnr) then
local buffer_content = buf_utils.format_with_line_numbers(buf_info.bufnr)
table.insert(output, buffer_content)
end
end
local active_buffers = table.concat(output, "\n\n")
local file_structure = self:get_file_structure()
return [[
=== Active Buffers ===
]] .. active_buffers .. [[
=== File Structure ]] .. self.layers .. [[ layers up ===
]] .. file_structure .. [[
]]
end
---Generate the file structure up to the specified number of layers
---@return string
function Variable:get_file_structure()
local current_file_path = get_active_buf().filename
local layers_up = self.layers
local layers_deep = 3 -- Adjust as needed
if self.params then
local layersup, layersdown = self.params:match("(%d+)-(%d+)")
if layersup and layersdown then
layers_up = tonumber(layersup) or layers_up
layers_deep = tonumber(layersdown) or layers_deep
end
end
local ignore_dirs = { "^%.git$", "^node_modules$", "^.DS_Store$", "^__pycache__$" }
local root_dir = file_utils.get_root_dir(current_file_path, layers_up)
local file_structure = file_utils.generate_file_structure(root_dir, layers_deep, ignore_dirs)
return [[
]] .. root_dir .. [[
]] .. file_structure .. [[
]]
end
return Variable
local M = {}
--- Get the root directory based on the current file path and the specified number of layers
--- @param current_file_path string
--- @param layers number
--- @return string
function M.get_root_dir(current_file_path, layers)
if not layers or layers == 0 then
return current_file_path
end
local root_dir = current_file_path
for _ = 1, layers do
root_dir = vim.fn.fnamemodify(root_dir, ":h")
end
return root_dir
end
--- Generate the file structure up to the specified number of layers
--- @param root_dir string
--- @param layers number
--- @param ignore_dirs table
--- @return string
function M.generate_file_structure(root_dir, layers, ignore_dirs)
local function is_ignored(name)
for _, ignore in ipairs(ignore_dirs) do
if name:match(ignore) then
return true
end
end
return false
end
local function get_sorted_entries(dir)
local dirs = {}
local files = {}
local entries = vim.fn.readdir(dir)
for _, entry in ipairs(entries) do
if entry ~= "." and entry ~= ".." and not is_ignored(entry) then
local full_path = dir .. "/" .. entry
if vim.fn.isdirectory(full_path) == 1 then
table.insert(dirs, entry)
else
table.insert(files, entry)
end
end
end
table.sort(dirs)
table.sort(files)
return dirs, files
end
local function scan_dir(dir, depth, prefix)
if depth > layers then
return ""
end
local result = {}
local dirs, files = get_sorted_entries(dir)
local total_entries = #dirs + #files
local count = 0
-- Process directories
for index, directory in ipairs(dirs) do
count = count + 1
local is_last = (count == total_entries) and (#files == 0)
local full_path = dir .. "/" .. directory
local current_prefix = is_last and "└── " or "├── "
local next_prefix = is_last and " " or "│ "
table.insert(result, prefix .. current_prefix .. directory)
local sub_content = scan_dir(full_path, depth + 1, prefix .. next_prefix)
if sub_content ~= "" then
table.insert(result, sub_content)
end
end
-- Process files
for i, file in ipairs(files) do
count = count + 1
local is_last = (count == total_entries)
local current_prefix = is_last and "└── " or "├── "
table.insert(result, prefix .. current_prefix .. file)
end
return table.concat(result, "\n")
end
return scan_dir(root_dir, 1, "")
end
--- Check if a file exists and is readable
--- @param file_path string
--- @return boolean
function M.file_exists(file_path)
local f = io.open(file_path, "r")
if f then
io.close(f)
return true
end
return false
end
--- Get file size in bytes
--- @param file_path string
--- @return number|nil, string|nil
function M.get_file_size(file_path)
if not M.file_exists(file_path) then
return nil, "File does not exist"
end
local f = io.open(file_path, "r")
if not f then return nil, "Cannot open file" end
local size = f:seek("end")
f:close()
return size
end
--- Read file contents
--- @param file_path string
--- @return string|nil, string|nil
function M.read_file(file_path)
if not M.file_exists(file_path) then
return nil, "File does not exist"
end
local f = io.open(file_path, "r")
if not f then return nil, "Cannot open file" end
local content = f:read("*all")
f:close()
return content
end
--- List files in directory
--- @param dir_path string
--- @param pattern string|nil
--- @return table|nil, string|nil
function M.list_files(dir_path, pattern)
pattern = pattern or ""
local files = {}
local handle = vim.loop.fs_scandir(dir_path)
if not handle then
return nil, "Cannot open directory"
end
while true do
local name, type = vim.loop.fs_scandir_next(handle)
if not name then break end
if type == "file" and (pattern == "" or name:match(pattern)) then
table.insert(files, name)
end
end
return files
end
return M
-- Define the module table
local M = {}
-- Function to get buffer information
function M.get_buffers_info()
local buffers_info = {}
local buffers = vim.api.nvim_list_bufs()
for _, bufnr in ipairs(buffers) do
if vim.fn.buflisted(bufnr) == 1 then
local filename = vim.api.nvim_buf_get_name(bufnr)
local is_loaded = vim.api.nvim_buf_is_loaded(bufnr)
local is_visible = false
local winnr = nil
if filename ~= "" and filename ~= nil then
for _, win in ipairs(vim.api.nvim_list_wins()) do
if vim.api.nvim_win_get_buf(win) == bufnr then
is_visible = true
winnr = vim.fn.win_id2win(win)
break
end
end
table.insert(buffers_info, {
bufnr = bufnr,
filename = filename,
is_loaded = is_loaded,
is_visible = is_visible,
winnr = winnr
})
end
end
end
return buffers_info
end
-- Function to generate system prompt for AI assistant
function M.generate_system_prompt()
local buffers_info = M.get_buffers_info()
local visible_buffers = {}
local loaded_buffers = {}
local unlisted_buffers = {}
local unnamed_buffers = {}
-- Categorize buffers
for _, buf_info in ipairs(buffers_info) do
if buf_info.is_visible then
table.insert(visible_buffers, buf_info)
elseif buf_info.is_loaded then
table.insert(loaded_buffers, buf_info)
end
end
-- Return nil if no buffers are found
if #visible_buffers == 0 and #loaded_buffers == 0 then
return nil
end
-- Initialize prompt
local prompt =
"The following buffers are currently active for the user. This list will always be up-to-date and any response that requires a reference to the active files should depend on this.\n\n"
-- Add visible buffers section
if #visible_buffers > 0 then
prompt = prompt .. "### Visible Buffers:\n\nThese buffers are currently visible to the user:\n\n"
for _, buf_info in ipairs(visible_buffers) do
prompt = prompt ..
string.format("Buffer ID: %d\nName: %s\nFiletype: %s\nPath: %s\nWinnr: %d\n\n", buf_info.bufnr,
vim.fn.fnamemodify(buf_info.filename, ":t"), vim.bo[buf_info.bufnr].filetype, buf_info.filename,
buf_info.winnr)
end
end
-- Add loaded buffers section
if #loaded_buffers > 0 then
prompt = prompt .. "### Loaded Buffers:\n\nThese buffers are currently loaded but not visible:\n\n"
for _, buf_info in ipairs(loaded_buffers) do
prompt = prompt ..
string.format("Buffer ID: %d\nName: %s\nFiletype: %s\nPath: %s\n\n", buf_info.bufnr,
vim.fn.fnamemodify(buf_info.filename, ":t"), vim.bo[buf_info.bufnr].filetype, buf_info.filename)
end
end
return prompt
end
-- Function to get lines with line numbers
function M.get_lines_with_numbers(bufnr, range)
local start_line = range[1] or 0
local end_line = range[2] or -1
local lines = vim.api.nvim_buf_get_lines(bufnr, start_line, end_line, false)
local numbered_lines = {}
for i, line in ipairs(lines) do
table.insert(numbered_lines, string.format("%d: %s", start_line + i - 1, line))
end
local filetype = vim.bo[bufnr].filetype
return string.format("```%s\n%s\n```", filetype, table.concat(numbered_lines, "\n"))
end
-- print(M.get_lines_with_numbers(0, { 1, -1 }))
-- print(M.generate_system_prompt())
-- Return the module table
return MI love my current workflow and hope it might help someone. @olimorris I feel this would be useful for many users and feel makes codecompanion even more fun to use. Happy to hear you thoughts on providing this in any form by default. |
Beta Was this translation helpful? Give feedback.
-
|
Wow... This is something! I've bookmarked it and will need more time to try it out, but looks extremely promising. I guess I will have to switch to Claude at some point (currently I'm sticking with ChatGPT). Many thanks for sharing! 🎉 |
Beta Was this translation helpful? Give feedback.
-
|
This whole conversation is amazing!! Thank you all for the time you have spent sharing and helping! As an aside, I agree 100% claude is the way! And I too use copilot (since I already pay for copilot autocomplete) and use claude as my model and it is all "free" (just my $10 a month regular copilot autocomplete subscription). It is quite amazing if you have not tried it @sobanieca ! |
Beta Was this translation helpful? Give feedback.
-
|
It looks like this project is changing fast and now you should use What I wanted is to add opened buffer other than {
'<leader>aa',
function()
local bufnr = vim.api.nvim_get_current_buf();
local name = require("codecompanion").last_chat().references:make_id_from_buf(bufnr)
if name == "" then
name = "Buffer " .. bufnr
end
local id = "<buf>" .. name .. "</buf>"
require("codecompanion").last_chat().references:add({
bufnr = bufnr,
id = id,
source = "codecompanion.strategies.chat.variables.buffer",
opts = {
watched = true
}
})
vim.print('buffer added to chat')
end,
silent = true,
desc = 'buffer to CodeCompanion chat'
}, |
Beta Was this translation helpful? Give feedback.
-
|
OK. I was wrong. Code above does not work and something like this is required: {
'<leader>aa',
function()
local bufnr = vim.api.nvim_get_current_buf();
local content = require("codecompanion.utils.buffers").format_with_line_numbers(bufnr)
local name = require("codecompanion").last_chat().references:make_id_from_buf(bufnr)
if name == "" then
name = "Buffer " .. bufnr
end
local id = "<buf>" .. name .. "</buf>"
local path = vim.api.nvim_buf_get_name(bufnr)
local message = "Here is the content from"
require("codecompanion").last_chat():add_message({
role = 'user',
content = string.format(
[[%s `%s` (which has a buffer number of _%d_ and a filepath of `%s`):
%s]],
message,
vim.fn.fnamemodify(path, ":t"),
bufnr,
path,
content
),
}, { reference = id, visible = false })
require("codecompanion").last_chat().references:add({
bufnr = bufnr,
id = id,
path = path,
source = "codecompanion.strategies.chat.slash_commands.buffer",
opts = {}
})
vim.print('buffer added to chat')
end,
silent = true,
desc = 'buffer to CodeCompanion chat'
}, |
Beta Was this translation helpful? Give feedback.
-
|
I use It is a keymap that executes a command for the entry under the cursor. Note: I purposely decided not to add files from dirs under dirs recursively. -- plugins/utils/ai-assistant.lua
local M = {}
M.add_file_path_to_chat = function(file_path, chat)
for _, ref in ipairs(chat.refs) do
if ref.path == file_path then return print("Already added") end
end
local ref = {
id = "<file>" .. file_path .. "</file>",
path = file_path,
source = "codecompanion.strategies.chat.slash_commands.file",
opts = { pinned = true },
}
chat.references:add(ref)
end
M.list_file_paths = function(path)
local stat = vim.uv.fs_stat(path)
if stat == nil then return print("Path does not exist") end
if stat.type == "directory" then
local paths = {}
for item in vim.fs.dir(path, { depth = 1 }) do
local item_path = vim.fs.joinpath(path, item)
local item_stat = vim.uv.fs_stat(item_path)
if item_stat ~= nil and item_stat.type == "file" then paths[#paths + 1] = item_path end
end
return paths
end
if stat.type == "file" then return { path } end
return {}
end
return Mand then on my local add_path_to_codecompanion_chat = function()
local path = MiniFiles.get_fs_entry().path
if path == nil then return vim.notify("Cursor is not on valid entry") end
local utils = require("plugins.utils.ai-assistant")
local file_paths = utils.list_file_paths(path)
if #file_paths == 0 then return print("No files found") end
local codecompanion = require("codecompanion")
local chat = codecompanion.last_chat()
if chat == nil then --if no chat, create one
chat = codecompanion.chat()
end
for _, file_path in ipairs(file_paths) do
utils.add_file_path_to_chat(file_path, chat)
end
end
vim.api.nvim_create_autocmd("User", {
pattern = "MiniFilesBufferCreate",
callback = function(args)
local b = args.data.buf_id
vim.keymap.set("n", "ga", add_path_to_codecompanion_chat, { buffer = b, desc = "Add to CodeCompanion" })
end,
})I'm not a pro lua dev so I'm open to any feedback :D |
Beta Was this translation helpful? Give feedback.
-
Looks pretty good to me! Nice work! |
Beta Was this translation helpful? Give feedback.
-
|
I use oil.nvim and able to make it work. I able to come up with this thanks to the example code in /file slash command, as usual great work making that readable @olimorris here is my oil config, it is not very clean because I am not experienced with lua and just trying out things now oil.setup({
default_file_explorer = true,
keymaps = {
["a"] = {
desc = "share file with code companion",
callback = function()
local Path = require("plenary.path")
local oil = require("oil")
local cc = require("codecompanion")
local fmt = string.format
local cur_dir = oil.get_current_dir()
local fullpath = cur_dir .. oil.get_cursor_entry().name
local path = Path:new(fullpath)
local ok, content = pcall(function()
return Path.new(fullpath):read()
end)
local relpath = path:make_relative()
local ft = vim.filetype.match({ filename = fullpath })
local description = fmt(
[[%s %s:
```%s
%s
```]],
"Here is the content of the file",
"located at `" .. relpath .. "`",
ft,
content
)
local id = "<file>" .. relpath .. "</file>"
cc.last_chat():add_message({
role = require("codecompanion.config").config.constants.USER_ROLE,
content = description,
}, { reference = id, visible = false })
cc.last_chat().references:add({
id = id,
path = relpath,
source = "codecompanion.strategies.chat.slash_commands.file",
})
vim.notify(relpath .. " added to codecompanion")
end,
},
},
})
|
Beta Was this translation helpful? Give feedback.
-
|
here is my mapping for the Telescope, with this I can add files from the telescope picker to the chat mappings = {
n = {
["a"] = function()
local Path = require("plenary.path")
local cc = require("codecompanion")
local action_state = require("telescope.actions.state")
local fmt = string.format
local selection = action_state.get_selected_entry()[1]
local cwd = vim.fn.getcwd()
local fullpath = cwd .. "/" .. selection
local ok, content = pcall(function()
return Path.new(fullpath):read()
end)
local ft = vim.filetype.match({ filename = fullpath })
local description = fmt(
[[%s %s:
```%s
%s
```]],
"Here is the content of the file",
"located at `" .. selection .. "`",
ft,
content
)
local id = "<file>" .. selection .. "</file>"
local chat = cc.last_chat()
if not chat then
vim.notify("No active chat session", vim.log.levels.WARN)
return
end
chat:add_message({
role = require("codecompanion.config").config.constants.USER_ROLE,
content = description,
}, { reference = id, visible = false })
chat.references:add({
id = id,
path = selection,
source = "codecompanion.strategies.chat.slash_commands.file",
})
vim.notify(selection .. " added to chat")
end,
},
},
|
Beta Was this translation helpful? Give feedback.
-
|
refactored to a separate reusable helper local M = {}
local Path = require("plenary.path")
local cc = require("codecompanion")
local fmt = string.format
local constants = require("codecompanion.config").config.constants
function M.share(fullpath, relpath)
local path = Path:new(fullpath)
local ok, content = pcall(function()
return path:read()
end)
if not ok then
vim.notify("Failed to read file: " .. fullpath, vim.log.levels.ERROR)
return
end
local ft = vim.filetype.match({ filename = fullpath })
local description = fmt(
[[%s %s:
```%s
%s
```]],
"Here is the content of the file",
"located at `" .. relpath .. "`",
ft,
content
)
local id = "<file>" .. relpath .. "</file>"
local chat = cc.last_chat()
if not chat then
vim.notify("No active chat session", vim.log.levels.WARN)
return
end
chat:add_message({
role = constants.USER_ROLE,
content = description,
}, { reference = id, visible = false })
chat.references:add({
id = id,
path = relpath,
source = "codecompanion.strategies.chat.slash_commands.file",
})
vim.notify(relpath .. " added to chat")
end
return M
|
Beta Was this translation helpful? Give feedback.
Thanks to your suggestions @olimorris I've implemented following custom command:
Now this is extremely useful for me, because I can just navigate on nvim tree and press
.which is a shortcut for providing command with file path already provided and I can just typeCga(ChatGPT add :P) and I'm there. Many thanks for help!