phyer/avante.nvim
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
yetone 2024-08-12 23:53:28 +08:00
commit 9edd4202af
No known key found for this signature in database
GPG Key ID: 222BA52B342D52AA
11 changed files with 1944 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
.editorconfig Normal file
View File

@ -0,0 +1,16 @@
; https://editorconfig.org/
root = true
[*]
insert_final_newline = true
charset = utf-8
trim_trailing_whitespace = true
indent_style = space
indent_size = 2
tab_width = 8
[{Makefile,**/Makefile}]
indent_style = tab
indent_size = 8

44
.gitignore vendored Normal file
View File

@ -0,0 +1,44 @@
# Lua compiled files
*.lua~
*.luac
# Neovim plugin specific files
plugin/packer_compiled.lua
# OS generated files
.DS_Store
Thumbs.db
# Editor/IDE generated files
*.swp
*.swo
*~
.vscode/
.idea/
# Dependency manager generated directories
/lua_modules/
/.luarocks/
# Log files
*.log
# Temporary files
tmp/
temp/
# Environment variable files (if you use .env file to store API keys)
.env
# If you use any build tools, you might need to ignore build output directories
/build/
/dist/
# If you use any test frameworks, you might need to ignore test coverage reports
/coverage/
# If you use documentation generation tools, you might need to ignore generated docs
/doc/
# If you have any personal configuration files, you should ignore them too
config.personal.lua

19
.luacheckrc Normal file
View File

@ -0,0 +1,19 @@
-- Rerun tests only if their modification time changed.
cache = true
-- Glorious list of warnings: https://luacheck.readthedocs.io/en/stable/warnings.html
ignore = {
'211',
'631',
'212', -- Unused argument, In the case of callback function, _arg_name is easier to understand than _, so this option is set to off.
'411', -- Redefining a local variable.
'412', -- Redefining an argument.
'422', -- Shadowing an argument
'431', -- Shadowing a variable
'122', -- Indirectly setting a readonly global
}
-- Global objects defined by the C code
read_globals = {
'vim',
}

9
.luarc.json Normal file
View File

@ -0,0 +1,9 @@
{
"workspace.library": [
"/Users/yetone/.local/share/nvim/lazy/neodev.nvim/types/stable",
"/opt/homebrew/Cellar/neovim/0.9.0/share/nvim/runtime/lua",
"/Users/yetone/.local/share/nvim/lazy/nvim-dap-ui/lua",
"/Users/yetone/.config/nvim/lua",
"${3rd}/luv/library"
]
}

201
LICENSE Normal file
View File

@ -0,0 +1,201 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

8
Makefile Normal file
View File

@ -0,0 +1,8 @@
luacheck:
luacheck `find -name "*.lua"` --codes
stylecheck:
stylua --check lua/
stylefix:
stylua lua/

78
README.md Normal file
View File

@ -0,0 +1,78 @@
# avante.nvim
**avante.nvim** is a Neovim plugin designed to emulate the behavior of the Cursor AI IDE, providing users with AI-driven code suggestions and the ability to apply these recommendations directly to their source files with minimal effort.
<div style="border-left: 4px solid red; padding: 10px; background-color: #f8d7da;">
<strong>Warning:</strong> This plugin is still in a very early stage of development, so please be aware that the current code is very messy and unstable, and problems are likely to occur.
</div>
## Features
- **AI-Powered Code Assistance**: Interact with AI to ask questions about your current code file and receive intelligent suggestions for improvement or modification.
- **One-Click Application**: Quickly apply the AI's suggested changes to your source code with a single command, streamlining the editing process and saving time.
## Installation
Install `avante.nvim` using [lazy.nvim](https://github.com/folke/lazy.nvim):
```lua
{
"yetone/avante.nvim",
event = "VeryLazy",
config = function()
require("avante").setup({})
end,
dependencies = {
"nvim-tree/nvim-web-devicons",
{
"grapp-dev/nui-components.nvim",
dependencies = {
"MunifTanjim/nui.nvim"
}
},
"nvim-lua/plenary.nvim",
"MeanderingProgrammer/render-markdown.nvim",
},
}
```
## Usage
Given its early stage, `avante.nvim` currently supports the following basic functionalities:
1. Set `ANTHROPIC_API_KEY` environment variable.
```sh
export ANTHROPIC_API=your-api-key
```
2. Open a code file in Neovim.
3. Use the `:AvanteAsk` command to query the AI about the code.
4. Review the AI's suggestions.
5. Apply the recommended changes directly to your code with a simple command or key binding.
**Note**: The plugin is still under active development, and both its functionality and interface are subject to significant changes. Expect some rough edges and instability as the project evolves.
## Key Bindings
The following key bindings are available for use with `avante.nvim`:
- <kbd>Leader</kbd><kbd>a</kbd><kbd>a</kbd> — show sidebar
- <kbd>c</kbd><kbd>o</kbd> — choose ours
- <kbd>c</kbd><kbd>t</kbd> — choose theirs
- <kbd>c</kbd><kbd>b</kbd> — choose both
- <kbd>c</kbd><kbd>0</kbd> — choose none
- <kbd>]</kbd><kbd>x</kbd> — move to previous conflict
- <kbd>[</kbd><kbd>x</kbd> — move to next conflict
## Roadmap
- **Enhanced AI Interactions**: Improve the depth of AI analysis and recommendations for more complex coding scenarios.
- **Stability Improvements**: Refactor and optimize the codebase to enhance the stability and reliability of the plugin.
- **Expanded Features**: Introduce additional customization options and new features to support a wider range of coding tasks.
## Contributing
Contributions to avante.nvim are welcome! If you're interested in helping out, please feel free to submit pull requests or open issues. Before contributing, ensure that your code has been thoroughly tested.
## License
avante.nvim is licensed under the MIT License. For more details, please refer to the [LICENSE](./LICENSE) file.

778
lua/avante/diff.lua Normal file
View File

@ -0,0 +1,778 @@
-- This file COPY and MODIFIED based on: https://github.com/akinsho/git-conflict.nvim/blob/main/lua/git-conflict.lua
local M = {}
local color = require("avante.diff.colors")
local utils = require("avante.diff.utils")
local fn = vim.fn
local api = vim.api
local fmt = string.format
local map = vim.keymap.set
local job = utils.job
-----------------------------------------------------------------------------//
-- REFERENCES:
-----------------------------------------------------------------------------//
-- Detecting the state of a git repository based on files in the .git directory.
-- https://stackoverflow.com/questions/49774200/how-to-tell-if-my-git-repo-is-in-a-conflict
-- git diff commands to git a list of conflicted files
-- https://stackoverflow.com/questions/3065650/whats-the-simplest-way-to-list-conflicted-files-in-git
-- how to show a full path for files in a git diff command
-- https://stackoverflow.com/questions/10459374/making-git-diff-stat-show-full-file-path
-- Advanced merging
-- https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging
-----------------------------------------------------------------------------//
-- Types
-----------------------------------------------------------------------------//
---@alias ConflictSide "'ours'"|"'theirs'"|"'both'"|"'base'"|"'none'"
--- @class ConflictHighlights
--- @field current string
--- @field incoming string
--- @field ancestor string?
---@class RangeMark
---@field label integer
---@field content string
--- @class PositionMarks
--- @field current RangeMark
--- @field incoming RangeMark
--- @field ancestor RangeMark
--- @class Range
--- @field range_start integer
--- @field range_end integer
--- @field content_start integer
--- @field content_end integer
--- @class ConflictPosition
--- @field incoming Range
--- @field middle Range
--- @field current Range
--- @field marks PositionMarks
--- @class ConflictBufferCache
--- @field lines table<integer, boolean> map of conflicted line numbers
--- @field positions ConflictPosition[]
--- @field tick integer
--- @field bufnr integer
--- @class AvanteConflictMappings
--- @field ours string
--- @field theirs string
--- @field none string
--- @field both string
--- @field next string
--- @field prev string
--- @class AvanteConflictConfig
--- @field default_mappings AvanteConflictMappings
--- @field disable_diagnostics boolean
--- @field list_opener string|function
--- @field highlights ConflictHighlights
--- @field debug boolean
--- @class AvanteConflictUserConfig
--- @field default_mappings boolean|AvanteConflictMappings
--- @field disable_diagnostics boolean
--- @field list_opener string|function
--- @field highlights ConflictHighlights
--- @field debug boolean
-----------------------------------------------------------------------------//
-- Constants
-----------------------------------------------------------------------------//
local SIDES = {
OURS = "ours",
THEIRS = "theirs",
BOTH = "both",
BASE = "base",
NONE = "none",
}
-- A mapping between the internal names and the display names
local name_map = {
ours = "current",
theirs = "incoming",
base = "ancestor",
both = "both",
none = "none",
}
local CURRENT_HL = "AvanteConflictCurrent"
local INCOMING_HL = "AvanteConflictIncoming"
local ANCESTOR_HL = "AvanteConflictAncestor"
local CURRENT_LABEL_HL = "AvanteConflictCurrentLabel"
local INCOMING_LABEL_HL = "AvanteConflictIncomingLabel"
local ANCESTOR_LABEL_HL = "AvanteConflictAncestorLabel"
local PRIORITY = vim.highlight.priorities.user
local NAMESPACE = api.nvim_create_namespace("avante-conflict")
local AUGROUP_NAME = "AvanteConflictCommands"
local sep = package.config:sub(1, 1)
local conflict_start = "^<<<<<<<"
local conflict_middle = "^======="
local conflict_end = "^>>>>>>>"
local conflict_ancestor = "^|||||||"
local DEFAULT_CURRENT_BG_COLOR = 4218238 -- #405d7e
local DEFAULT_INCOMING_BG_COLOR = 3229523 -- #314753
local DEFAULT_ANCESTOR_BG_COLOR = 6824314 -- #68217A
-----------------------------------------------------------------------------//
--- @type AvanteConflictMappings
local DEFAULT_MAPPINGS = {
ours = "co",
theirs = "ct",
none = "c0",
both = "cb",
next = "]x",
prev = "[x",
}
--- @type AvanteConflictConfig
local config = {
debug = false,
default_mappings = DEFAULT_MAPPINGS,
default_commands = true,
disable_diagnostics = false,
list_opener = "copen",
highlights = {
current = "DiffText",
incoming = "DiffAdd",
ancestor = nil,
},
}
--- @return table<string, ConflictBufferCache>
local function create_visited_buffers()
return setmetatable({}, {
__index = function(t, k)
if type(k) == "number" then
return t[api.nvim_buf_get_name(k)]
end
end,
})
end
--- A list of buffers that have conflicts in them. This is derived from
--- git using the diff command, and updated at intervals
local visited_buffers = create_visited_buffers()
-----------------------------------------------------------------------------//
---Get full path to the repository of the directory passed in
---@param dir any
---@param callback fun(data: string)
local function get_git_root(dir, callback)
job({ "git", "-C", dir, "rev-parse", "--show-toplevel" }, function(data)
callback(data[1])
end)
end
--- Get a list of the conflicted files within the specified directory
--- NOTE: only conflicted files within the git repository of the directory passed in are returned
--- also we add a line prefix to the git command so that the full path is returned
--- e.g. --line-prefix=`git rev-parse --show-toplevel`
---@reference: https://stackoverflow.com/a/10874862
---@param dir string?
---@param callback fun(files: table<string, integer[]>, string)
local function get_conflicted_files(dir, callback)
local cmd = { "git", "-C", dir, "diff", ("--line-prefix=%s%s"):format(dir, sep), "--name-only", "--diff-filter=U" }
job(cmd, function(data)
local files = {}
for _, filename in ipairs(data) do
if #filename > 0 then
files[filename] = files[filename] or {}
end
end
callback(files, dir)
end)
end
---Add the positions to the buffer in our in memory buffer list
---positions are keyed by a list of range start and end for each mark
---@param buf integer
---@param positions ConflictPosition[]
local function update_visited_buffers(buf, positions)
if not buf or not api.nvim_buf_is_valid(buf) then
return
end
local name = api.nvim_buf_get_name(buf)
-- If this buffer is not in the list
if not visited_buffers[name] then
return
end
visited_buffers[name].bufnr = buf
visited_buffers[name].tick = vim.b[buf].changedtick
visited_buffers[name].positions = positions
end
function M.add_visited_buffer(bufnr)
local name = api.nvim_buf_get_name(bufnr)
visited_buffers[name] = visited_buffers[name] or {}
end
---Set an extmark for each section of the git conflict
---@param bufnr integer
---@param hl string
---@param range_start integer
---@param range_end integer
---@return integer? extmark_id
local function hl_range(bufnr, hl, range_start, range_end)
if not range_start or not range_end then
return
end
return api.nvim_buf_set_extmark(bufnr, NAMESPACE, range_start, 0, {
hl_group = hl,
hl_eol = true,
hl_mode = "combine",
end_row = range_end,
priority = PRIORITY,
})
end
---Add highlights and additional data to each section heading of the conflict marker
---These works by covering the underlying text with an extmark that contains the same information
---with some extra detail appended.
---TODO: ideally this could be done by using virtual text at the EOL and highlighting the
---background but this doesn't work and currently this is done by filling the rest of the line with
---empty space and overlaying the line content
---@param bufnr integer
---@param hl_group string
---@param label string
---@param lnum integer
---@return integer extmark id
local function draw_section_label(bufnr, hl_group, label, lnum)
local remaining_space = api.nvim_win_get_width(0) - api.nvim_strwidth(label)
return api.nvim_buf_set_extmark(bufnr, NAMESPACE, lnum, 0, {
hl_group = hl_group,
virt_text = { { label .. string.rep(" ", remaining_space), hl_group } },
virt_text_pos = "overlay",
priority = PRIORITY,
})
end
---Highlight each part of a git conflict i.e. the incoming changes vs the current/HEAD changes
---TODO: should extmarks be ephemeral? or is it less expensive to save them and only re-apply
---them when a buffer changes since otherwise we have to reparse the whole buffer constantly
---@param positions table
---@param lines string[]
local function highlight_conflicts(positions, lines)
local bufnr = api.nvim_get_current_buf()
M.clear(bufnr)
for _, position in ipairs(positions) do
local current_start = position.current.range_start
local current_end = position.current.range_end
local incoming_start = position.incoming.range_start
local incoming_end = position.incoming.range_end
-- Add one since the index access in lines is 1 based
local current_label = lines[current_start + 1] .. " (Current changes)"
local incoming_label = lines[incoming_end + 1] .. " (Incoming changes)"
local curr_label_id = draw_section_label(bufnr, CURRENT_LABEL_HL, current_label, current_start)
local curr_id = hl_range(bufnr, CURRENT_HL, current_start, current_end + 1)
local inc_id = hl_range(bufnr, INCOMING_HL, incoming_start, incoming_end + 1)
local inc_label_id = draw_section_label(bufnr, INCOMING_LABEL_HL, incoming_label, incoming_end)
position.marks = {
current = { label = curr_label_id, content = curr_id },
incoming = { label = inc_label_id, content = inc_id },
ancestor = {},
}
if not vim.tbl_isempty(position.ancestor) then
local ancestor_start = position.ancestor.range_start
local ancestor_end = position.ancestor.range_end
local ancestor_label = lines[ancestor_start + 1] .. " (Base changes)"
local id = hl_range(bufnr, ANCESTOR_HL, ancestor_start + 1, ancestor_end + 1)
local label_id = draw_section_label(bufnr, ANCESTOR_LABEL_HL, ancestor_label, ancestor_start)
position.marks.ancestor = { label = label_id, content = id }
end
end
end
---Iterate through the buffer line by line checking there is a matching conflict marker
---when we find a starting mark we collect the position details and add it to a list of positions
---@param lines string[]
---@return boolean
---@return ConflictPosition[]
local function detect_conflicts(lines)
local positions = {}
local position, has_start, has_middle, has_ancestor = nil, false, false, false
for index, line in ipairs(lines) do
local lnum = index - 1
if line:match(conflict_start) then
has_start = true
position = {
current = { range_start = lnum, content_start = lnum + 1 },
middle = {},
incoming = {},
ancestor = {},
}
end
if has_start and line:match(conflict_ancestor) then
has_ancestor = true
position.ancestor.range_start = lnum
position.ancestor.content_start = lnum + 1
position.current.range_end = lnum - 1
position.current.content_end = lnum - 1
end
if has_start and line:match(conflict_middle) then
has_middle = true
if has_ancestor then
position.ancestor.content_end = lnum - 1
position.ancestor.range_end = lnum - 1
else
position.current.range_end = lnum - 1
position.current.content_end = lnum - 1
end
position.middle.range_start = lnum
position.middle.range_end = lnum + 1
position.incoming.range_start = lnum + 1
position.incoming.content_start = lnum + 1
end
if has_start and has_middle and line:match(conflict_end) then
position.incoming.range_end = lnum
position.incoming.content_end = lnum - 1
positions[#positions + 1] = position
position, has_start, has_middle, has_ancestor = nil, false, false, false
end
end
return #positions > 0, positions
end
---Helper function to find a conflict position based on a comparator function
---@param bufnr integer
---@param comparator fun(string, integer): boolean
---@param opts table?
---@return ConflictPosition?
local function find_position(bufnr, comparator, opts)
local match = visited_buffers[bufnr]
if not match then
return
end
local line = utils.get_cursor_pos()
line = line - 1 -- Convert to 0-based for position comparison
if opts and opts.reverse then
for i = #match.positions, 1, -1 do
local position = match.positions[i]
if comparator(line, position) then
return position
end
end
return nil
end
for _, position in ipairs(match.positions) do
if comparator(line, position) then
return position
end
end
return nil
end
---Retrieves a conflict marker position by checking the visited buffers for a supported range
---@param bufnr integer
---@return ConflictPosition?
local function get_current_position(bufnr)
return find_position(bufnr, function(line, position)
return position.current.range_start <= line and position.incoming.range_end >= line
end)
end
---@param position ConflictPosition?
---@param side ConflictSide
local function set_cursor(position, side)
if not position then
return
end
local target = side == SIDES.OURS and position.current or position.incoming
api.nvim_win_set_cursor(0, { target.range_start + 1, 0 })
end
---Get the conflict marker positions for a buffer if any and update the buffers state
---@param bufnr integer
---@param range_start integer
---@param range_end integer
local function parse_buffer(bufnr, range_start, range_end)
local lines = utils.get_buf_lines(range_start or 0, range_end or -1, bufnr)
local prev_conflicts = visited_buffers[bufnr].positions ~= nil and #visited_buffers[bufnr].positions > 0
local has_conflict, positions = detect_conflicts(lines)
update_visited_buffers(bufnr, positions)
if has_conflict then
highlight_conflicts(positions, lines)
else
M.clear(bufnr)
end
if prev_conflicts ~= has_conflict or not vim.b[bufnr].conflict_mappings_set then
local pattern = has_conflict and "AvanteConflictDetected" or "AvanteConflictResolved"
api.nvim_exec_autocmds("User", { pattern = pattern })
end
end
---Process a buffer if the changed tick has changed
---@param bufnr integer?
function M.process(bufnr, range_start, range_end)
bufnr = bufnr or api.nvim_get_current_buf()
if visited_buffers[bufnr] and visited_buffers[bufnr].tick == vim.b[bufnr].changedtick then
return
end
parse_buffer(bufnr, range_start, range_end)
end
-----------------------------------------------------------------------------//
-- Commands
-----------------------------------------------------------------------------//
local function set_commands()
local command = api.nvim_create_user_command
command("AvanteConflictListQf", function()
M.conflicts_to_qf_items(function(items)
if #items > 0 then
fn.setqflist(items, "r")
if type(config.list_opener) == "function" then
config.list_opener()
else
vim.cmd(config.list_opener)
end
end
end)
end, { nargs = 0 })
command("AvanteConflictChooseOurs", function()
M.choose("ours")
end, { nargs = 0 })
command("AvanteConflictChooseTheirs", function()
M.choose("theirs")
end, { nargs = 0 })
command("AvanteConflictChooseBoth", function()
M.choose("both")
end, { nargs = 0 })
command("AvanteConflictChooseBase", function()
M.choose("base")
end, { nargs = 0 })
command("AvanteConflictChooseNone", function()
M.choose("none")
end, { nargs = 0 })
command("AvanteConflictNextConflict", function()
M.find_next("ours")
end, { nargs = 0 })
command("AvanteConflictPrevConflict", function()
M.find_prev("ours")
end, { nargs = 0 })
end
-----------------------------------------------------------------------------//
-- Mappings
-----------------------------------------------------------------------------//
local function set_plug_mappings()
local function opts(desc)
return { silent = true, desc = "Git Conflict: " .. desc }
end
map({ "n", "v" }, "<Plug>(git-conflict-ours)", "<Cmd>AvanteConflictChooseOurs<CR>", opts("Choose Ours"))
map({ "n", "v" }, "<Plug>(git-conflict-both)", "<Cmd>AvanteConflictChooseBoth<CR>", opts("Choose Both"))
map({ "n", "v" }, "<Plug>(git-conflict-none)", "<Cmd>AvanteConflictChooseNone<CR>", opts("Choose None"))
map({ "n", "v" }, "<Plug>(git-conflict-theirs)", "<Cmd>AvanteConflictChooseTheirs<CR>", opts("Choose Theirs"))
map("n", "<Plug>(git-conflict-next-conflict)", "<Cmd>AvanteConflictNextConflict<CR>", opts("Next Conflict"))
map("n", "<Plug>(git-conflict-prev-conflict)", "<Cmd>AvanteConflictPrevConflict<CR>", opts("Previous Conflict"))
end
local function setup_buffer_mappings(bufnr)
local function opts(desc)
return { silent = true, buffer = bufnr, desc = "Git Conflict: " .. desc }
end
map({ "n", "v" }, config.default_mappings.ours, "<Plug>(git-conflict-ours)", opts("Choose Ours"))
map({ "n", "v" }, config.default_mappings.both, "<Plug>(git-conflict-both)", opts("Choose Both"))
map({ "n", "v" }, config.default_mappings.none, "<Plug>(git-conflict-none)", opts("Choose None"))
map({ "n", "v" }, config.default_mappings.theirs, "<Plug>(git-conflict-theirs)", opts("Choose Theirs"))
map({ "v", "v" }, config.default_mappings.ours, "<Plug>(git-conflict-ours)", opts("Choose Ours"))
-- map('V', config.default_mappings.ours, '<Plug>(git-conflict-ours)', opts('Choose Ours'))
map("n", config.default_mappings.prev, "<Plug>(git-conflict-prev-conflict)", opts("Previous Conflict"))
map("n", config.default_mappings.next, "<Plug>(git-conflict-next-conflict)", opts("Next Conflict"))
vim.b[bufnr].conflict_mappings_set = true
end
---@param key string
---@param mode "'n'|'v'|'o'|'nv'|'nvo'"?
---@return boolean
local function is_mapped(key, mode)
return fn.hasmapto(key, mode or "n") > 0
end
local function clear_buffer_mappings(bufnr)
if not bufnr or not vim.b[bufnr].conflict_mappings_set then
return
end
for _, mapping in pairs(config.default_mappings) do
if is_mapped(mapping) then
api.nvim_buf_del_keymap(bufnr, "n", mapping)
end
end
vim.b[bufnr].conflict_mappings_set = false
end
-----------------------------------------------------------------------------//
-- Highlights
-----------------------------------------------------------------------------//
---Derive the colour of the section label highlights based on each sections highlights
---@param highlights ConflictHighlights
local function set_highlights(highlights)
local current_color = utils.get_hl(highlights.current)
local incoming_color = utils.get_hl(highlights.incoming)
local ancestor_color = utils.get_hl(highlights.ancestor)
local current_bg = current_color.background or DEFAULT_CURRENT_BG_COLOR
local incoming_bg = incoming_color.background or DEFAULT_INCOMING_BG_COLOR
local ancestor_bg = ancestor_color.background or DEFAULT_ANCESTOR_BG_COLOR
local current_label_bg = color.shade_color(current_bg, 60)
local incoming_label_bg = color.shade_color(incoming_bg, 60)
local ancestor_label_bg = color.shade_color(ancestor_bg, 60)
api.nvim_set_hl(0, CURRENT_HL, { background = current_bg, bold = true, default = true })
api.nvim_set_hl(0, INCOMING_HL, { background = incoming_bg, bold = true, default = true })
api.nvim_set_hl(0, ANCESTOR_HL, { background = ancestor_bg, bold = true, default = true })
api.nvim_set_hl(0, CURRENT_LABEL_HL, { background = current_label_bg, default = true })
api.nvim_set_hl(0, INCOMING_LABEL_HL, { background = incoming_label_bg, default = true })
api.nvim_set_hl(0, ANCESTOR_LABEL_HL, { background = ancestor_label_bg, default = true })
end
---@param user_config AvanteConflictUserConfig
function M.setup(user_config)
local _user_config = user_config or {}
if _user_config.default_mappings == true then
_user_config.default_mappings = DEFAULT_MAPPINGS
end
config = vim.tbl_deep_extend("force", config, _user_config)
set_highlights(config.highlights)
if config.default_commands then
set_commands()
end
set_plug_mappings()
api.nvim_create_augroup(AUGROUP_NAME, { clear = true })
api.nvim_create_autocmd("ColorScheme", {
group = AUGROUP_NAME,
callback = function()
set_highlights(config.highlights)
end,
})
api.nvim_create_autocmd("User", {
group = AUGROUP_NAME,
pattern = "AvanteConflictDetected",
callback = function()
local bufnr = api.nvim_get_current_buf()
if config.disable_diagnostics then
vim.diagnostic.disable(bufnr)
end
if config.default_mappings then
setup_buffer_mappings(bufnr)
end
end,
})
api.nvim_create_autocmd("User", {
group = AUGROUP_NAME,
pattern = "AvanteConflictResolved",
callback = function()
local bufnr = api.nvim_get_current_buf()
if config.disable_diagnostics then
vim.diagnostic.enable(bufnr)
end
if config.default_mappings then
clear_buffer_mappings(bufnr)
end
end,
})
api.nvim_set_decoration_provider(NAMESPACE, {
on_buf = function(_, bufnr, _)
return utils.is_valid_buf(bufnr)
end,
on_win = function(_, _, bufnr, _, _)
if visited_buffers[bufnr] then
M.process(bufnr)
end
end,
})
end
--- Add additional metadata to a quickfix entry if we have already visited the buffer and have that
--- information
---@param item table<string, integer|string>
---@param items table<string, integer|string>[]
---@param visited_buf ConflictBufferCache
local function quickfix_items_from_positions(item, items, visited_buf)
if vim.tbl_isempty(visited_buf.positions) then
return
end
for _, pos in ipairs(visited_buf.positions) do
for key, value in pairs(pos) do
if vim.tbl_contains({ name_map.ours, name_map.theirs, name_map.base }, key) and not vim.tbl_isempty(value) then
local lnum = value.range_start + 1
local next_item = vim.deepcopy(item)
next_item.text = fmt("%s change", key, lnum)
next_item.lnum = lnum
next_item.col = 0
table.insert(items, next_item)
end
end
end
end
--- Convert the conflicts detected via get conflicted files into a list of quickfix entries.
---@param callback fun(files: table<string, integer[]>)
function M.conflicts_to_qf_items(callback)
local items = {}
for filename, visited_buf in pairs(visited_buffers) do
local item = {
filename = filename,
pattern = conflict_start,
text = "git conflict",
type = "E",
valid = 1,
}
if visited_buf and next(visited_buf) then
quickfix_items_from_positions(item, items, visited_buf)
else
table.insert(items, item)
end
end
callback(items)
end
---@param bufnr integer?
function M.clear(bufnr)
if bufnr and not api.nvim_buf_is_valid(bufnr) then
return
end
bufnr = bufnr or 0
api.nvim_buf_clear_namespace(bufnr, NAMESPACE, 0, -1)
end
---@param side ConflictSide
function M.find_next(side)
local pos = find_position(0, function(line, position)
return position.current.range_start >= line and position.incoming.range_end >= line
end)
set_cursor(pos, side)
end
---@param side ConflictSide
function M.find_prev(side)
local pos = find_position(0, function(line, position)
return position.current.range_start <= line and position.incoming.range_end <= line
end, { reverse = true })
set_cursor(pos, side)
end
---Select the changes to keep
---@param side ConflictSide
function M.choose(side)
local bufnr = api.nvim_get_current_buf()
if vim.fn.mode() == "v" or vim.fn.mode() == "V" or vim.fn.mode() == "" then
vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<Esc>", true, false, true), "n", true)
-- have to defer so that the < and > marks are set
vim.defer_fn(function()
local start = vim.api.nvim_buf_get_mark(0, "<")[1]
local finish = vim.api.nvim_buf_get_mark(0, ">")[1]
local position = find_position(bufnr, function(line, pos)
local left = pos.current.range_start >= start - 1
local right = pos.incoming.range_end <= finish + 1
return left and right
end)
while position ~= nil do
local lines = {}
if vim.tbl_contains({ SIDES.OURS, SIDES.THEIRS, SIDES.BASE }, side) then
local data = position[name_map[side]]
lines = utils.get_buf_lines(data.content_start, data.content_end + 1)
elseif side == SIDES.BOTH then
local first = utils.get_buf_lines(position.current.content_start, position.current.content_end + 1)
local second = utils.get_buf_lines(position.incoming.content_start, position.incoming.content_end + 1)
lines = vim.list_extend(first, second)
elseif side == SIDES.NONE then
lines = {}
else
return
end
local pos_start = position.current.range_start < 0 and 0 or position.current.range_start
local pos_end = position.incoming.range_end + 1
api.nvim_buf_set_lines(0, pos_start, pos_end, false, lines)
api.nvim_buf_del_extmark(0, NAMESPACE, position.marks.incoming.label)
api.nvim_buf_del_extmark(0, NAMESPACE, position.marks.current.label)
if position.marks.ancestor.label then
api.nvim_buf_del_extmark(0, NAMESPACE, position.marks.ancestor.label)
end
parse_buffer(bufnr)
position = find_position(bufnr, function(line, pos)
local left = pos.current.range_start >= start - 1
local right = pos.incoming.range_end <= finish + 1
return left and right
end)
end
end, 50)
return
end
local position = get_current_position(bufnr)
if not position then
return
end
local lines = {}
if vim.tbl_contains({ SIDES.OURS, SIDES.THEIRS, SIDES.BASE }, side) then
local data = position[name_map[side]]
lines = utils.get_buf_lines(data.content_start, data.content_end + 1)
elseif side == SIDES.BOTH then
local first = utils.get_buf_lines(position.current.content_start, position.current.content_end + 1)
local second = utils.get_buf_lines(position.incoming.content_start, position.incoming.content_end + 1)
lines = vim.list_extend(first, second)
elseif side == SIDES.NONE then
lines = {}
else
return
end
local pos_start = position.current.range_start < 0 and 0 or position.current.range_start
local pos_end = position.incoming.range_end + 1
api.nvim_buf_set_lines(0, pos_start, pos_end, false, lines)
api.nvim_buf_del_extmark(0, NAMESPACE, position.marks.incoming.label)
api.nvim_buf_del_extmark(0, NAMESPACE, position.marks.current.label)
if position.marks.ancestor.label then
api.nvim_buf_del_extmark(0, NAMESPACE, position.marks.ancestor.label)
end
parse_buffer(bufnr)
end
function M.conflict_count(bufnr)
if bufnr and not api.nvim_buf_is_valid(bufnr) then
return 0
end
bufnr = bufnr or 0
local name = api.nvim_buf_get_name(bufnr)
if not visited_buffers[name] then
return 0
end
return #visited_buffers[name].positions
end
return M

39
lua/avante/diff/colors.lua Normal file
View File

@ -0,0 +1,39 @@
local M = {}
local bit = require("bit")
local rshift, band = bit.rshift, bit.band
--- Returns a table containing the RGB values encoded inside 24 least
--- significant bits of the number @rgb_24bit
---
--@param rgb_24bit (number) 24-bit RGB value
--@returns (table) with keys 'r', 'g', 'b' in [0,255]
local function decode_24bit_rgb(rgb_24bit)
vim.validate({ rgb_24bit = { rgb_24bit, "n", true } })
local r = band(rshift(rgb_24bit, 16), 255)
local g = band(rshift(rgb_24bit, 8), 255)
local b = band(rgb_24bit, 255)
return { r = r, g = g, b = b }
end
local function alter(attr, percent)
return math.floor(attr * (100 + percent) / 100)
end
---@source https://stackoverflow.com/q/5560248
---@see: https://stackoverflow.com/a/37797380
---Darken a specified hex color
---@param color string
---@param percent number
---@return string
function M.shade_color(color, percent)
local rgb = decode_24bit_rgb(color)
if not rgb.r or not rgb.g or not rgb.b then
return "NONE"
end
local r, g, b = alter(rgb.r, percent), alter(rgb.g, percent), alter(rgb.b, percent)
r, g, b = math.min(r, 255), math.min(g, 255), math.min(b, 255)
return string.format("#%02x%02x%02x", r, g, b)
end
return M

88
lua/avante/diff/utils.lua Normal file
View File

@ -0,0 +1,88 @@
-----------------------------------------------------------------------------//
-- Utils
-----------------------------------------------------------------------------//
local M = {}
local api = vim.api
local fn = vim.fn
--- Wrapper for [vim.notify]
---@param msg string|string[]
---@param level "error" | "trace" | "debug" | "info" | "warn"
---@param once boolean?
function M.notify(msg, level, once)
if type(msg) == "table" then
msg = table.concat(msg, "\n")
end
local lvl = vim.log.levels[level:upper()] or vim.log.levels.INFO
local opts = { title = "Git conflict" }
if once then
return vim.notify_once(msg, lvl, opts)
end
vim.notify(msg, lvl, opts)
end
--- Start an async job
---@param cmd string
---@param callback fun(data: string[]): nil
function M.job(cmd, callback)
fn.jobstart(cmd, {
stdout_buffered = true,
on_stdout = function(_, data, _)
callback(data)
end,
})
end
---Only call the passed function once every timeout in ms
---@param timeout integer
---@param func function
---@return function
function M.throttle(timeout, func)
local timer = vim.loop.new_timer()
local running = false
return function(...)
if not running then
func(...)
running = true
timer:start(timeout, 0, function()
running = false
end)
end
end
end
---Wrapper around `api.nvim_buf_get_lines` which defaults to the current buffer
---@param start integer
---@param _end integer
---@param buf integer?
---@return string[]
function M.get_buf_lines(start, _end, buf)
return api.nvim_buf_get_lines(buf or 0, start, _end, false)
end
---Get cursor row and column as (1, 0) based
---@param win_id integer?
---@return integer, integer
function M.get_cursor_pos(win_id)
return unpack(api.nvim_win_get_cursor(win_id or 0))
end
---Check if the buffer is likely to have actionable conflict markers
---@param bufnr integer?
---@return boolean
function M.is_valid_buf(bufnr)
bufnr = bufnr or 0
return #vim.bo[bufnr].buftype == 0 and vim.bo[bufnr].modifiable
end
---@param name string?
---@return table<string, string>
function M.get_hl(name)
if not name then
return {}
end
return api.nvim_get_hl_by_name(name, true)
end
return M

664
lua/avante/init.lua Normal file
View File

@ -0,0 +1,664 @@
local M = {}
local curl = require("plenary.curl")
local Path = require("plenary.path")
local n = require("nui-components")
local diff = require("avante.diff")
local api = vim.api
local fn = vim.fn
local RESULT_BUF_NAME = "AVANTE_RESULT"
local CONFLICT_BUF_NAME = "AVANTE_CONFLICT"
local function create_result_buf()
local buf = api.nvim_create_buf(false, true)
api.nvim_set_option_value("filetype", "markdown", { buf = buf })
api.nvim_set_option_value("buftype", "nofile", { buf = buf })
api.nvim_set_option_value("swapfile", false, { buf = buf })
api.nvim_set_option_value("modifiable", false, { buf = buf })
api.nvim_buf_set_name(buf, RESULT_BUF_NAME)
return buf
end
local result_buf = create_result_buf()
local function is_code_buf(buf)
local ignored_filetypes = {
"dashboard",
"alpha",
"neo-tree",
"NvimTree",
"TelescopePrompt",
"Prompt",
"qf",
"help",
}
if api.nvim_buf_is_valid(buf) and api.nvim_get_option_value("buflisted", { buf = buf }) then
local buftype = api.nvim_get_option_value("buftype", { buf = buf })
local filetype = api.nvim_get_option_value("filetype", { buf = buf })
if buftype == "" and filetype ~= "" and not vim.tbl_contains(ignored_filetypes, filetype) then
local bufname = api.nvim_buf_get_name(buf)
if bufname ~= "" and bufname ~= RESULT_BUF_NAME and bufname ~= CONFLICT_BUF_NAME then
return true
end
end
end
return false
end
local signal = n.create_signal({
is_loading = false,
text = "",
})
local _cur_code_buf = nil
local function get_cur_code_buf()
return _cur_code_buf
end
local function get_cur_code_buf_name()
local code_buf = get_cur_code_buf()
if code_buf == nil then
print("Error: cannot get code buffer")
return
end
return api.nvim_buf_get_name(code_buf)
end
local function get_cur_code_win()
local code_buf = get_cur_code_buf()
if code_buf == nil then
print("Error: cannot get code buffer")
return
end
return fn.bufwinid(code_buf)
end
local function get_cur_code_buf_content()
local code_buf = get_cur_code_buf()
if code_buf == nil then
print("Error: cannot get code buffer")
return {}
end
return api.nvim_buf_get_lines(code_buf, 0, -1, false)
end
local function prepend_line_number(content)
local lines = vim.split(content, "\n")
local result = {}
for i, line in ipairs(lines) do
table.insert(result, "L" .. i .. ": " .. line)
end
return table.concat(result, "\n")
end
local function extract_code_snippets(content)
local snippets = {}
local current_snippet = {}
local in_code_block = false
local lang, start_line, end_line
local explanation = ""
for line in content:gmatch("[^\r\n]+") do
local start_line_str, end_line_str = line:match("^Replace lines: (%d+)-(%d+)")
if start_line_str ~= nil and end_line_str ~= nil then
start_line = tonumber(start_line_str)
end_line = tonumber(end_line_str)
end
if line:match("^```") then
if in_code_block then
if start_line ~= nil and end_line ~= nil then
table.insert(snippets, {
range = { start_line, end_line },
content = table.concat(current_snippet, "\n"),
lang = lang,
explanation = explanation,
})
end
current_snippet = {}
start_line, end_line = nil, nil
explanation = ""
in_code_block = false
else
lang = line:match("^```(%w+)")
if not lang or lang == "" then
lang = "text"
end
in_code_block = true
end
elseif in_code_block then
table.insert(current_snippet, line)
else
explanation = explanation .. line .. "\n"
end
end
return snippets
end
local system_prompt = [[
You are an excellent programming expert.
]]
local user_prompt_tpl = [[
Your primary task is to suggest code modifications with precise line number ranges. Follow these instructions meticulously:
1. Carefully analyze the original code, paying close attention to its structure and line numbers. Line numbers start from 1 and include ALL lines, even empty ones.
2. When suggesting modifications:
a. Explain why the change is necessary or beneficial.
b. Provide the exact code snippet to be replaced using this format:
Replace lines: {{start_line}}-{{end_line}}
```{{language}}
{{suggested_code}}
```
3. Crucial guidelines for line numbers:
- L1:, L2:, L3:, ... in the prefix of each line represent line numbers in the original code, you must use these exact numbers, but you must NOT include them in your response.
- The range {{start_line}}-{{end_line}} is INCLUSIVE. Both start_line and end_line are included in the replacement.
- Count EVERY line, including empty lines, comments, and the LAST line of the file.
- For single-line changes, use the same number for start and end lines.
- For multi-line changes, ensure the range covers ALL affected lines, from the very first to the very last.
- Include the entire block (e.g., complete function) when modifying structured code.
- Pay special attention to the start_line, ensuring it's not omitted or incorrectly set.
- Double-check that your start_line is correct, especially for changes at the beginning of the file.
- Also, be careful with the end_line, especially when it's the last line of the file.
- Double-check that your line numbers align perfectly with the original code structure.
4. Context and verification:
- Show 1-2 unchanged lines before and after each modification as context.
- These context lines are NOT included in the replacement range.
- After each suggestion, recount the lines to verify the accuracy of your line numbers.
- Double-check that both the start_line and end_line are correct for each modification.
- Verify that your suggested changes align perfectly with the original code structure.
5. Final check:
- Review all suggestions, ensuring each line number is correct, especially the start_line and end_line.
- Pay extra attention to the start_line of each modification, ensuring it hasn't shifted down.
- Confirm that no unrelated code is accidentally modified or deleted.
- Verify that the start_line and end_line correctly include all intended lines for replacement.
- If a modification involves the first or last line of the file, explicitly state this in your explanation.
- Perform a final alignment check to ensure your line numbers haven't shifted, especially the start_line.
- Double-check that your line numbers align perfectly with the original code structure.
- Do not show the content after these modifications.
Remember: Accurate line numbers are CRITICAL. The range start_line to end_line must include ALL lines to be replaced, from the very first to the very last. Double-check every range before finalizing your response, paying special attention to the start_line to ensure it hasn't shifted down. Ensure that your line numbers perfectly match the original code structure without any overall shift.
QUESTION: ${{question}}
CODE:
```
${{code}}
```
]]
local function call_claude_api_stream(prompt, original_content, on_chunk, on_complete)
local api_key = os.getenv("ANTHROPIC_API_KEY")
if not api_key then
error("ANTHROPIC_API_KEY environment variable is not set")
end
local user_prompt = user_prompt_tpl:gsub("${{question}}", prompt):gsub("${{code}}", original_content)
print("Sending request to Claude API...")
local tokens = M.config.claude.model == "claude-3-5-sonnet-20240620" and 8192 or 4096
local headers = {
["Content-Type"] = "application/json",
["x-api-key"] = api_key,
["anthropic-version"] = "2023-06-01",
["anthropic-beta"] = "messages-2023-12-15",
}
if M.config.claude.model == "claude-3-5-sonnet-20240620" then
headers["anthropic-beta"] = "max-tokens-3-5-sonnet-2024-07-15"
end
local url = "https://api.anthropic.com/v1/messages"
curl.post(url, {
---@diagnostic disable-next-line: unused-local
stream = function(err, data, job)
if err then
error("Error: " .. vim.inspect(err))
return
end
if data then
for line in data:gmatch("[^\r\n]+") do
if line:sub(1, 6) == "data: " then
vim.schedule(function()
local success, parsed = pcall(fn.json_decode, line:sub(7))
if success and parsed and parsed.type == "content_block_delta" then
on_chunk(parsed.delta.text)
elseif success and parsed and parsed.type == "message_stop" then
-- Stream request completed
on_complete()
elseif success and parsed and parsed.type == "error" then
print("Error: " .. vim.inspect(parsed))
-- Stream request completed
on_complete()
end
end)
end
end
end
end,
headers = headers,
body = fn.json_encode({
model = M.config.claude.model,
system = system_prompt,
messages = {
{ role = "user", content = user_prompt },
},
stream = true,
temperature = M.config.claude.temperature,
max_tokens = tokens,
}),
})
end
local function call_openai_api_stream(prompt, original_content, on_chunk, on_complete)
local api_key = os.getenv("OPENAI_API_KEY")
if not api_key then
error("OPENAI_API_KEY environment variable is not set")
end
local user_prompt = user_prompt_tpl:gsub("${{question}}", prompt):gsub("${{code}}", original_content)
print("Sending request to OpenAI API...")
curl.post("https://api.openai.com/v1/chat/completions", {
---@diagnostic disable-next-line: unused-local
stream = function(err, data, job)
if err then
error("Error: " .. vim.inspect(err))
return
end
if data then
for line in data:gmatch("[^\r\n]+") do
if line:sub(1, 6) == "data: " then
vim.schedule(function()
local success, parsed = pcall(fn.json_decode, line:sub(7))
if success and parsed and parsed.choices and parsed.choices[1].delta.content then
on_chunk(parsed.choices[1].delta.content)
elseif success and parsed and parsed.choices and parsed.choices[1].finish_reason == "stop" then
-- Stream request completed
on_complete()
end
end)
end
end
end
end,
headers = {
["Content-Type"] = "application/json",
["Authorization"] = "Bearer " .. api_key,
},
body = fn.json_encode({
model = M.config.openai.model,
messages = {
{ role = "system", content = system_prompt },
{ role = "user", content = user_prompt },
},
temperature = M.config.openai.temperature,
max_tokens = M.config.openai.max_tokens,
stream = true,
}),
})
end
local function call_ai_api_stream(prompt, original_content, on_chunk, on_complete)
if M.config.provider == "openai" then
call_openai_api_stream(prompt, original_content, on_chunk, on_complete)
elseif M.config.provider == "claude" then
call_claude_api_stream(prompt, original_content, on_chunk, on_complete)
end
end
local function update_result_buf_content(content)
local current_win = api.nvim_get_current_win()
local result_win = fn.bufwinid(result_buf)
vim.defer_fn(function()
api.nvim_set_option_value("modifiable", true, { buf = result_buf })
api.nvim_buf_set_lines(result_buf, 0, -1, false, vim.split(content, "\n"))
api.nvim_set_option_value("filetype", "markdown", { buf = result_buf })
if result_win ~= -1 then
-- Move to the bottom
api.nvim_win_set_cursor(result_win, { api.nvim_buf_line_count(result_buf), 0 })
api.nvim_set_option_value("modifiable", false, { buf = result_buf })
api.nvim_set_current_win(current_win)
end
end, 0)
end
-- Add a new function to display notifications
local function show_notification(message)
vim.notify(message, vim.log.levels.INFO, {
title = "AI Assistant",
timeout = 3000,
})
end
-- Function to get the current project root directory
local function get_project_root()
local current_file = fn.expand("%:p")
local current_dir = fn.fnamemodify(current_file, ":h")
local git_root = fn.systemlist("git -C " .. fn.shellescape(current_dir) .. " rev-parse --show-toplevel")[1]
return git_root or current_dir
end
local function get_chat_history_filename()
local code_buf_name = get_cur_code_buf_name()
if code_buf_name == nil then
print("Error: cannot get code buffer name")
return
end
local relative_path = fn.fnamemodify(code_buf_name, ":~:.")
-- Replace path separators with double underscores
local path_with_separators = fn.substitute(relative_path, "/", "__", "g")
-- Replace other non-alphanumeric characters with single underscores
return fn.substitute(path_with_separators, "[^A-Za-z0-9._]", "_", "g")
end
-- Function to get the chat history file path
local function get_chat_history_file()
local project_root = get_project_root()
local filename = get_chat_history_filename()
local history_dir = Path:new(project_root, ".avante_chat_history")
return history_dir:joinpath(filename .. ".json")
end
-- Function to get current timestamp
local function get_timestamp()
return os.date("%Y-%m-%d %H:%M:%S")
end
-- Function to load chat history
local function load_chat_history()
local history_file = get_chat_history_file()
if history_file:exists() then
local content = history_file:read()
return fn.json_decode(content)
end
return {}
end
-- Function to save chat history
local function save_chat_history(history)
local history_file = get_chat_history_file()
local history_dir = history_file:parent()
-- Create the directory if it doesn't exist
if not history_dir:exists() then
history_dir:mkdir({ parents = true })
end
history_file:write(fn.json_encode(history), "w")
end
local function update_result_buf_with_history(history)
local content = ""
for _, entry in ipairs(history) do
content = content .. "## " .. entry.timestamp .. "\n\n"
content = content .. "> " .. entry.requirement:gsub("\n", "\n> ") .. "\n\n"
content = content .. entry.response .. "\n\n"
content = content .. "---\n\n"
end
update_result_buf_content(content)
end
local function get_conflict_content(content, snippets)
-- sort snippets by start_line
table.sort(snippets, function(a, b)
return a.range[1] < b.range[1]
end)
local lines = vim.split(content, "\n")
local result = {}
local current_line = 1
for _, snippet in ipairs(snippets) do
local start_line, end_line = unpack(snippet.range)
while current_line < start_line do
table.insert(result, lines[current_line])
current_line = current_line + 1
end
table.insert(result, "<<<<<<< HEAD")
for i = start_line, end_line do
table.insert(result, lines[i])
end
table.insert(result, "=======")
for _, line in ipairs(vim.split(snippet.content, "\n")) do
table.insert(result, line)
end
table.insert(result, ">>>>>>> Snippet")
current_line = end_line + 1
end
while current_line <= #lines do
table.insert(result, lines[current_line])
current_line = current_line + 1
end
return result
end
local renderer_width = math.ceil(vim.o.columns * 0.3)
local renderer = n.create_renderer({
width = renderer_width,
height = vim.o.lines,
position = vim.o.columns - renderer_width,
relative = "editor",
})
function M.render_sidebar()
local chat_history = load_chat_history()
update_result_buf_with_history(chat_history)
local function handle_submit()
local state = signal:get_value()
local user_input = state.text
local timestamp = get_timestamp()
update_result_buf_content(
"\n\n## " .. timestamp .. "\n\n> " .. user_input:gsub("\n", "\n> ") .. "\n\nGenerating response...\n"
)
local code_buf = get_cur_code_buf()
if code_buf == nil then
error("Error: cannot get code buffer")
return
end
local content = table.concat(get_cur_code_buf_content(), "\n")
local content_with_line_numbers = prepend_line_number(content)
local full_response = ""
signal.is_loading = true
call_ai_api_stream(user_input, content_with_line_numbers, function(chunk)
full_response = full_response .. chunk
update_result_buf_content(
"## " .. timestamp .. "\n\n> " .. user_input:gsub("\n", "\n> ") .. "\n\n" .. full_response
)
vim.schedule(function()
vim.cmd("redraw")
end)
end, function()
signal.is_loading = false
-- Execute when the stream request is actually completed
update_result_buf_content(
"## "
.. timestamp
.. "\n\n> "
.. user_input:gsub("\n", "\n> ")
.. "\n\n"
.. full_response
.. "\n\n**Generation complete!** Please review the code suggestions above.\n\n\n\n"
)
-- Display notification
show_notification("Content generation complete!")
-- Save chat history
table.insert(chat_history or {}, { timestamp = timestamp, requirement = user_input, response = full_response })
save_chat_history(chat_history)
local snippets = extract_code_snippets(full_response)
local conflict_content = get_conflict_content(content, snippets)
vim.defer_fn(function()
api.nvim_buf_set_lines(code_buf, 0, -1, false, conflict_content)
local code_win = get_cur_code_win()
if code_win == nil then
error("Error: cannot get code window")
return
end
api.nvim_set_current_win(code_win)
api.nvim_feedkeys(api.nvim_replace_termcodes("<Esc>", true, false, true), "n", true)
diff.add_visited_buffer(code_buf)
diff.process(code_buf)
api.nvim_feedkeys("gg", "n", false)
vim.defer_fn(function()
vim.cmd("AvanteConflictNextConflict")
api.nvim_feedkeys("zz", "n", false)
end, 1000)
end, 10)
end)
end
local body = function()
local code_buf = get_cur_code_buf()
if code_buf == nil then
error("Error: cannot get code buffer")
return
end
local filetype = api.nvim_get_option_value("filetype", { buf = code_buf })
local icon = require("nvim-web-devicons").get_icon_by_filetype(filetype, {})
local code_file_fullpath = api.nvim_buf_get_name(code_buf)
local code_filename = fn.fnamemodify(code_file_fullpath, ":t")
return n.rows(
{ flex = 0 },
n.box(
{
direction = "column",
size = vim.o.lines - 3,
},
n.buffer({
id = "response",
flex = 1,
buf = result_buf,
autoscroll = true,
border_label = {
text = "💬 Avante Chat",
align = "center",
},
})
),
n.gap(1),
n.columns(
{ flex = 0 },
n.text_input({
id = "text-input",
border_label = {
text = string.format(" 🙋 Your question (with %s %s): ", icon, code_filename),
},
autofocus = true,
wrap = true,
flex = 1,
on_change = function(value)
local state = signal:get_value()
local is_enter = value:sub(-1) == "\n" and #state.text < #value
if is_enter then
value = value:sub(1, -2)
end
signal.text = value
if is_enter and #value > 0 then
handle_submit()
end
end,
}),
n.gap(1),
n.spinner({
is_loading = signal.is_loading,
padding = { top = 1, left = 1 },
---@diagnostic disable-next-line: undefined-field
hidden = signal.is_loading:negate(),
})
)
)
end
renderer:render(body)
end
M.config = {
provider = "claude",
openai = {
model = "gpt-4o",
temperature = 0,
max_tokens = 4096,
},
claude = {
model = "claude-3-5-sonnet-20240620",
temperature = 0,
max_tokens = 4096,
},
mappings = {
show_sidebar = "<leader>aa",
apply = "co",
reject = "ct",
next = "]x",
prev = "[x",
},
}
function M.setup(opts)
local bufnr = vim.api.nvim_get_current_buf()
if is_code_buf(bufnr) then
_cur_code_buf = bufnr
end
diff.setup({
debug = false, -- log output to console
default_mappings = true, -- disable buffer local mapping created by this plugin
default_commands = true, -- disable commands created by this plugin
disable_diagnostics = true, -- This will disable the diagnostics in a buffer whilst it is conflicted
list_opener = "copen",
highlights = {
incoming = "DiffAdded",
current = "DiffRemoved",
},
})
M.config = vim.tbl_deep_extend("force", M.config, opts or {})
local function on_buf_enter()
bufnr = vim.api.nvim_get_current_buf()
if is_code_buf(bufnr) then
_cur_code_buf = bufnr
end
end
api.nvim_create_autocmd("BufEnter", {
callback = on_buf_enter,
})
api.nvim_create_user_command("AvanteAsk", function()
M.render_sidebar()
end, {
nargs = 0,
})
api.nvim_set_keymap("n", M.config.mappings.show_sidebar, "<cmd>AvanteAsk<CR>", { noremap = true, silent = true })
end
return M