commit 9edd4202affec2e5705f478bd1269d3a1e70dac7 Author: yetone Date: Mon Aug 12 23:53:28 2024 +0800 first commit diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..16907cb --- /dev/null +++ b/.editorconfig @@ -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 + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b015473 --- /dev/null +++ b/.gitignore @@ -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 \ No newline at end of file diff --git a/.luacheckrc b/.luacheckrc new file mode 100644 index 0000000..9aac06e --- /dev/null +++ b/.luacheckrc @@ -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', +} diff --git a/.luarc.json b/.luarc.json new file mode 100644 index 0000000..8b2003a --- /dev/null +++ b/.luarc.json @@ -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" + ] +} \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..f49a4e1 --- /dev/null +++ b/LICENSE @@ -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. \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..6ff648f --- /dev/null +++ b/Makefile @@ -0,0 +1,8 @@ +luacheck: + luacheck `find -name "*.lua"` --codes + +stylecheck: + stylua --check lua/ + +stylefix: + stylua lua/ diff --git a/README.md b/README.md new file mode 100644 index 0000000..d00f9c0 --- /dev/null +++ b/README.md @@ -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. + +
+Warning: 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. +
+ +## 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`: + +- Leaderaa — show sidebar +- co — choose ours +- ct — choose theirs +- cb — choose both +- c0 — choose none +- ]x — move to previous conflict +- [x — 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. diff --git a/lua/avante/diff.lua b/lua/avante/diff.lua new file mode 100644 index 0000000..309f807 --- /dev/null +++ b/lua/avante/diff.lua @@ -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 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 +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) +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" }, "(git-conflict-ours)", "AvanteConflictChooseOurs", opts("Choose Ours")) + map({ "n", "v" }, "(git-conflict-both)", "AvanteConflictChooseBoth", opts("Choose Both")) + map({ "n", "v" }, "(git-conflict-none)", "AvanteConflictChooseNone", opts("Choose None")) + map({ "n", "v" }, "(git-conflict-theirs)", "AvanteConflictChooseTheirs", opts("Choose Theirs")) + map("n", "(git-conflict-next-conflict)", "AvanteConflictNextConflict", opts("Next Conflict")) + map("n", "(git-conflict-prev-conflict)", "AvanteConflictPrevConflict", 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, "(git-conflict-ours)", opts("Choose Ours")) + map({ "n", "v" }, config.default_mappings.both, "(git-conflict-both)", opts("Choose Both")) + map({ "n", "v" }, config.default_mappings.none, "(git-conflict-none)", opts("Choose None")) + map({ "n", "v" }, config.default_mappings.theirs, "(git-conflict-theirs)", opts("Choose Theirs")) + map({ "v", "v" }, config.default_mappings.ours, "(git-conflict-ours)", opts("Choose Ours")) + -- map('V', config.default_mappings.ours, '(git-conflict-ours)', opts('Choose Ours')) + map("n", config.default_mappings.prev, "(git-conflict-prev-conflict)", opts("Previous Conflict")) + map("n", config.default_mappings.next, "(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 +---@param items table[] +---@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) +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("", 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 diff --git a/lua/avante/diff/colors.lua b/lua/avante/diff/colors.lua new file mode 100644 index 0000000..5005519 --- /dev/null +++ b/lua/avante/diff/colors.lua @@ -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 diff --git a/lua/avante/diff/utils.lua b/lua/avante/diff/utils.lua new file mode 100644 index 0000000..d6cc6ad --- /dev/null +++ b/lua/avante/diff/utils.lua @@ -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 +function M.get_hl(name) + if not name then + return {} + end + return api.nvim_get_hl_by_name(name, true) +end + +return M diff --git a/lua/avante/init.lua b/lua/avante/init.lua new file mode 100644 index 0000000..4205fc0 --- /dev/null +++ b/lua/avante/init.lua @@ -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("", 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 = "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, "AvanteAsk", { noremap = true, silent = true }) +end + +return M