Multiple diffs craziness on @editor call

[plague-doctor]

Sometimes, when I ask the code companion to update @editor with suggestions, I get this unexpected result:

Any idea what I'm doing wrong? Why doesn't it bundle those changes into a single change presented within a single diff view?

[olimorris]

Holy cow. What on earth did the XML output from the LLM look like?

[taketwo]

I also observe such behavior occasionally. I'll post the response the next time I encounter this.

[olimorris]

I'm planning to move to "native function calling" in the coming weeks which should minimize the confusion that some LLMs seem to exhibit with the current implementation

[daliusd]

Here is sample response when it happens.

## Me

> Sharing:
> - <tool>editor</tool>

@editor

Extract common function around capture_input_and_close

## CodeCompanion (Copilot)

I can help you create a common function for `capture_input_and_close`. However, I need more context to know:

1. What code are you working with?
2. What buffer number should I modify?
3. What are the specific requirements for the function?

Could you please share the relevant code and buffer number, and explain what you want the common function to do?

## Me

> Sharing:
> - <tool>editor</tool>
> - <buf>lua/ghlite/comments.lua</buf>

#buffer


## CodeCompanion (Copilot)

I can see the code and will extract a common function around `capture_input_and_close`. Looking at the code, there are two similar implementations in lines 235-307 and 389-407.

Let's create a common function that can be reused:

```xml
<tools>
  <tool name="editor">
    <action type="add">
      <buffer>1</buffer>
      <code><![CDATA[local function create_comment_buffer(title, initial_content, callback)
  local buf = vim.api.nvim_create_buf(false, true)
  vim.api.nvim_buf_set_name(buf, title .. " (" .. os.date("%Y-%m-%d %H:%M:%S") .. ")")

  vim.bo[buf].buftype = 'nofile'
  vim.bo[buf].filetype = 'markdown'

  if config.s.comment_split then
    vim.api.nvim_command(config.s.comment_split)
  end
  vim.api.nvim_set_current_buf(buf)
  
  if type(initial_content) == "table" then
    vim.api.nvim_buf_set_lines(buf, 0, -1, false, initial_content)
  else
    vim.api.nvim_buf_set_lines(buf, 0, -1, false, vim.split(initial_content, '\n'))
  end

  local function capture_input_and_close()
    local input_lines = vim.api.nvim_buf_get_lines(buf, 0, -1, false)
    local prompt_line = initial_content
    if type(initial_content) == "table" and #initial_content > 0 then
      prompt_line = initial_content[1]
    end
    
    -- Remove prompt line if it exists
    if input_lines[1] == prompt_line then
      table.remove(input_lines, 1)
    end
    
    local input = table.concat(input_lines, "\n")
    vim.cmd('bwipeout')
    callback(input)
  end

  vim.api.nvim_buf_set_keymap(buf, 'n', config.s.keymaps.comment.send_comment, '',
    { noremap = true, silent = true, callback = capture_input_and_close })
  vim.api.nvim_buf_set_keymap(buf, 'i', config.s.keymaps.comment.send_comment, '',
    { noremap = true, silent = true, callback = capture_input_and_close })
    
  return buf
end]]></code>
      <line>8</line>
    </action>
  </tool>
</tools>
```

Now, let's update the comment_on_line function to use our new helper:

```xml
<tools>
  <tool name="editor">
    <action type="update">
      <buffer>1</buffer>
      <start_line>235</start_line>
      <end_line>307</end_line>
      <code><![CDATA[              local prompt = "<!-- Type your " ..
                (#conversations > 0 and "reply" or "comment") ..
                " and press " .. config.s.keymaps.comment.send_comment .. ": -->"
              
              local buf = create_comment_buffer(
                (#conversations > 0 and "PR reply" or "PR comment"),
                { prompt, "" },
                function(input)
                  --- @param grouped_comment GroupedComment
                  local function reply(grouped_comment)
                    utils.notify('Sending reply...')
                    gh.reply_to_comment(state.selected_PR.number, input, grouped_comment.id, function(resp)
                      if resp['errors'] == nil then
                        utils.notify('Reply sent.')
                        local new_comment = comments_utils.convert_comment(resp)
                        table.insert(grouped_comment.comments, new_comment)
                        grouped_comment.content = comments_utils.prepare_content(grouped_comment.comments)
                        M.load_comments_on_current_buffer()
                      else
                        utils.notify('Failed to reply to comment.', vim.log.levels.WARN)
                      end
                    end)
                  end

                  if #conversations == 1 then
                    reply(conversations[1])
                  elseif #conversations > 1 then
                    vim.ui.select(
                      conversations,
                      {
                        prompt = 'Select comment to reply to:',
                        format_item = function(comment)
                          return string.format('%s', vim.split(comment.content, '\n')[1])
                        end,
                      },
                      function(comment)
                        if comment ~= nil then
                          reply(comment)
                        end
                      end
                    )
                  else
                    if current_filename:sub(1, #git_root) == git_root then
                      utils.notify('Sending comment...')
                      gh.new_comment(state.selected_PR, input,
                        current_filename:sub(#git_root + 2), current_start_line, current_line, function(resp)
                          if resp['errors'] == nil then
                            local new_comment = comments_utils.convert_comment(resp)
                            --- @type GroupedComment
                            local new_comment_group = {
                              id = resp.id,
                              line = current_line,
                              start_line = current_start_line,
                              url = resp.html_url,
                              comments = { new_comment },
                              content = comments_utils.prepare_content({ new_comment }),
                            }
                            if state.comments_list[current_filename] == nil then
                              state.comments_list[current_filename] = { new_comment_group }
                            else
                              table.insert(state.comments_list[current_filename], new_comment_group)
                            end

                            utils.notify('Comment sent.')
                            M.load_comments_on_current_buffer()
                          else
                            utils.notify('Failed to send comment.', vim.log.levels.WARN)
                          end
                        end)
                    end
                  end
                end
              )
              vim.api.nvim_win_set_cursor(0, { 2, 0 })]]></code>
    </action>
  </tool>
</tools>
```

Now, let's update the edit_comment_body function:

```xml
<tools>
  <tool name="editor">
    <action type="update">
      <buffer>1</buffer>
      <start_line>376</start_line>
      <end_line>412</end_line>
      <code><![CDATA[--- @param comment Comment
--- @param conversation GroupedComment
local function edit_comment_body(comment, conversation)
  create_comment_buffer(
    "PR edit comment",
    comment.body,
    function(input)
      utils.notify('Updating comment...')
      gh.update_comment(comment.id, input, function(resp)
        if resp['errors'] == nil then
          utils.notify('Comment updated.')
          comment.body = resp.body
          conversation.content = comments_utils.prepare_content(conversation.comments)
          
          M.load_comments_on_current_buffer()
        else
          utils.notify('Failed to update the comment.', vim.log.levels.ERROR)
        end
      end)
    end
  )
end]]></code>
    </action>
  </tool>
</tools>
```

The refactored code creates a common helper function `create_comment_buffer` that handles:
1. Creating a new buffer
2. Setting up buffer properties
3. Adding the content
4. Setting up keymaps
5. Handling the capture and processing of input

This eliminates duplicate code and makes the functions clearer by focusing on just the business logic instead of buffer handling details. Would you like me to make any adjustments to this implementation?

## Me

> Sharing:
> - <tool>editor</tool>
> - <buf>lua/ghlite/comments.lua</buf>

[lu-yong]

@olimorris I have been able to reproduce this problem stably. As shown below

codecompany_diff_buffer.mov

[olimorris]

Thanks for this all. I'm in the middle of refactoring tools. So I will make sure I address this in the next month or so. In the meantime, feel free to make a PR for this.

[tlvenn]

This discussion brings up the same pain point and @cairijun actually came up with an improved buffer editing tool:

#1051

Might provide a solution until @olimorris or someone else has the bandwidth to address this.

[daliusd]

This is minimal reproducible prompt (at least with Claude Sonnet 3.7):

#buffer
@editor

Improve this code and implement each improvement separately

[cairijun]

I guess one solution could be to collect all tool invocations on the buffer, sort changes on the buffer by lines and apply from the end.

@code_edit does exactly the same, with overlap checking.

Can you share the output from LLM?

[daliusd]

OK. Let me try. Here is file I am working with: https://github.com/daliusd/ghlite.nvim/blob/main/lua/ghlite/gh.lua

Here it generated 11 improvements in single block. Applying them all corrupts gh.lua. I have not investigated if this can be applied correctly actually, but I see some overlapping actions.

## Me

> Sharing:
> - <tool>code_edit</tool>
> - <buf>lua/ghlite/gh.lua</buf>


#buffer
@code_edit

Improve this code and implement each improvement separately

## CodeCompanion (Copilot)

I'll improve this Lua code by implementing several enhancements. Here are the improvements I'll make:

1. Add proper type annotations for better code documentation
2. Implement error handling for failed API calls
3. Extract duplicate code patterns into reusable functions
4. Improve the parameter validation
5. Refactor nested callbacks to reduce callback hell

Let me implement these improvements one by one:

```xml
<tools>
  <tool name="code_edit">
    <action buffer="1">
      <!-- Improvement 1: Add proper type annotations -->
      <operation type="update">
        <first_line line="9"><![CDATA[local M = {}]]></first_line>
        <last_line line="9"><![CDATA[local M = {}]]></last_line>
        <code><![CDATA[--- @module 'ghlite.gh'
local M = {}]]></code>
      </operation>

      <!-- Add type annotation for parse_or_default function -->
      <operation type="update">
        <first_line line="11"><![CDATA[local function parse_or_default(str, default)]]></first_line>
        <last_line line="11"><![CDATA[local function parse_or_default(str, default)]]></last_line>
        <code><![CDATA[--- Parse JSON string or return default value if parsing fails
--- @param str string|nil The JSON string to parse
--- @param default any Default value to return if parsing fails
--- @return any The parsed JSON object or the default value]]></code>
      </operation>

      <!-- Improvement 2: Extract getting repo into a proper typed function -->
      <operation type="update">
        <first_line line="57"><![CDATA[local function get_repo(cb)]]></first_line>
        <last_line line="63"><![CDATA[end]]></last_line>
        <code><![CDATA[--- Get the current repository name with owner
--- @param cb fun(repo: string|nil) Callback function that receives the repository name
local function get_repo(cb)
  utils.system_str_cb('gh repo view --json nameWithOwner -q .nameWithOwner', function(result, stderr)
    if result ~= nil then
      local repo = vim.split(result, '\n')[1]
      cb(repo)
    else
      config.log("Failed to get repository", stderr)
      cb(nil)
    end
  end)
end]]></code>
      </operation>

      <!-- Improvement 3: Create a helper function for making GitHub API requests -->
      <operation type="add">
        <before_line line="65"><![CDATA[--- @params pr_number number]]></before_line>
        <code><![CDATA[--- Make a GitHub API request with proper error handling
--- @param method string The HTTP method (GET, POST, PATCH, DELETE)
--- @param endpoint string The API endpoint
--- @param data table|nil Optional data to send with the request
--- @param cb function Callback function that receives the parsed response or error
local function github_api_request(method, endpoint, data, cb)
  local request = {
    'gh',
    'api',
    '--method',
    method,
    endpoint,
  }
  
  if data then
    for key, value in pairs(data) do
      if value ~= nil then
        -- Use -F for numbers and booleans, -f for strings
        local flag = type(value) == "string" and "-f" or "-F"
        table.insert(request, flag)
        table.insert(request, key .. "=" .. tostring(value))
      end
    end
  end
  
  config.log(string.format('%s request', method), request)
  
  utils.system_cb(request, function(result)
    local resp = parse_or_default(result, { errors = {} })
    config.log(string.format('%s response', method), resp)
    cb(resp)
  end)
end]]></code>
      </operation>

      <!-- Improvement 4: Improve error handling in get_current_pr -->
      <operation type="update">
        <first_line line="20"><![CDATA[function M.get_current_pr(cb)]]></first_line>
        <last_line line="20"><![CDATA[function M.get_current_pr(cb)]]></last_line>
        <code><![CDATA[--- Get information about the current pull request
--- @param cb fun(pr: table|nil) Callback function that receives the PR data]]></code>
      </operation>

      <!-- Improvement 5: Add type annotations to get_pr_info -->
      <operation type="update">
        <first_line line="42"><![CDATA[function M.get_pr_info(pr_number, cb)]]></first_line>
        <last_line line="42"><![CDATA[function M.get_pr_info(pr_number, cb)]]></last_line>
        <code><![CDATA[--- Get detailed information about a specific pull request
--- @param pr_number number|string The PR number to fetch information for
--- @param cb fun(info: table|nil) Callback function that receives the PR info]]></code>
      </operation>

      <!-- Improvement 6: Refactor load_comments to use github_api_request -->
      <operation type="update">
        <first_line line="65"><![CDATA[--- @params pr_number number]]></first_line>
        <last_line line="89"><![CDATA[end]]></last_line>
        <code><![CDATA[--- Loads and processes comments for a pull request
--- @param pr_number number The PR number to load comments for
--- @param cb fun(grouped_comments: table) Callback function that receives grouped comments
function M.load_comments(pr_number, cb)
  if type(pr_number) ~= "number" then
    config.log("Error", "PR number must be a number")
    cb({})
    return
  end

  get_repo(function(repo)
    if not repo then
      config.log("Error", "Failed to get repository")
      cb({})
      return
    end

    config.log("repo", repo)
    local endpoint = f("repos/%s/pulls/%d/comments", repo, pr_number)
    
    utils.system_str_cb(f("gh api %s", endpoint), function(comments_json)
      local comments = parse_or_default(comments_json, {})
      config.log("comments", comments)

      local function is_valid_comment(comment)
        return comment.line ~= vim.NIL
      end

      comments = utils.filter_array(comments, is_valid_comment)
      config.log('Valid comments count', #comments)
      config.log('comments', comments)

      comments_utils.group_comments(comments, function(grouped_comments)
        config.log('Valid comments groups count:', #grouped_comments)
        config.log('grouped comments', grouped_comments)

        cb(grouped_comments)
      end)
    end)
  end)
end]]></code>
      </operation>

      <!-- Improvement 7: Refactor reply_to_comment with the github_api_request function -->
      <operation type="update">
        <first_line line="91"><![CDATA[function M.reply_to_comment(pr_number, body, reply_to, cb)]]></first_line>
        <last_line line="113"><![CDATA[end]]></last_line>
        <code><![CDATA[--- Reply to an existing comment on a pull request
--- @param pr_number number The PR number
--- @param body string The comment text
--- @param reply_to number|string The comment ID to reply to
--- @param cb fun(response: table) Callback with the API response
function M.reply_to_comment(pr_number, body, reply_to, cb)
  if not body or body == "" then
    cb({ errors = { { message = "Comment body cannot be empty" } } })
    return
  end

  get_repo(function(repo)
    if not repo then
      cb({ errors = { { message = "Failed to get repository information" } } })
      return
    end

    local endpoint = f("repos/%s/pulls/%d/comments", repo, pr_number)
    local data = {
      body = body,
      in_reply_to = reply_to
    }
    
    github_api_request("POST", endpoint, data, cb)
  end)
end]]></code>
      </operation>

      <!-- Improvement 8: Refactor new_comment with the github_api_request function -->
      <operation type="update">
        <first_line line="115"><![CDATA[function M.new_comment(selected_pr, body, path, start_line, line, cb)]]></first_line>
        <last_line line="150"><![CDATA[end]]></last_line>
        <code><![CDATA[--- Create a new comment on a pull request file
--- @param selected_pr table The PR object containing number and headRefOid
--- @param body string The comment text
--- @param path string The file path to comment on
--- @param start_line number|nil The starting line for multi-line comments
--- @param line number The line to comment on
--- @param cb fun(response: table) Callback with the API response
function M.new_comment(selected_pr, body, path, start_line, line, cb)
  if not selected_pr or not selected_pr.number or not selected_pr.headRefOid then
    cb({ errors = { { message = "Invalid PR information" } } })
    return
  end

  if not body or body == "" then
    cb({ errors = { { message = "Comment body cannot be empty" } } })
    return
  end

  get_repo(function(repo)
    if not repo then
      cb({ errors = { { message = "Failed to get repository information" } } })
      return
    end

    local endpoint = f("repos/%s/pulls/%d/comments", repo, selected_pr.number)
    local data = {
      body = body,
      commit_id = selected_pr.headRefOid,
      path = path,
      line = line,
      side = "RIGHT"
    }
    
    if start_line and start_line ~= line then
      data.start_line = start_line
    end
    
    github_api_request("POST", endpoint, data, cb)
  end)
end]]></code>
      </operation>

      <!-- Improvement 9: Add proper type annotations to update_comment -->
      <operation type="update">
        <first_line line="170"><![CDATA[function M.update_comment(comment_id, body, cb)]]></first_line>
        <last_line line="189"><![CDATA[end]]></last_line>
        <code><![CDATA[--- Update an existing comment on a pull request
--- @param comment_id string|number The ID of the comment to update
--- @param body string The new comment text
--- @param cb fun(response: table) Callback with the API response
function M.update_comment(comment_id, body, cb)
  if not body or body == "" then
    cb({ errors = { { message = "Comment body cannot be empty" } } })
    return
  end

  get_repo(function(repo)
    if not repo then
      cb({ errors = { { message = "Failed to get repository information" } } })
      return
    end

    local endpoint = f("repos/%s/pulls/comments/%s", repo, comment_id)
    local data = {
      body = body
    }
    
    github_api_request("PATCH", endpoint, data, cb)
  end)
end]]></code>
      </operation>

      <!-- Improvement 10: Refactor delete_comment with the github_api_request function -->
      <operation type="update">
        <first_line line="191"><![CDATA[function M.delete_comment(comment_id, cb)]]></first_line>
        <last_line line="207"><![CDATA[end]]></last_line>
        <code><![CDATA[--- Delete a comment from a pull request
--- @param comment_id string|number The ID of the comment to delete
--- @param cb fun(response: table) Callback with the API response
function M.delete_comment(comment_id, cb)
  if not comment_id then
    cb({ errors = { { message = "Comment ID is required" } } })
    return
  end

  get_repo(function(repo)
    if not repo then
      cb({ errors = { { message = "Failed to get repository information" } } })
      return
    end

    local endpoint = f("repos/%s/pulls/comments/%s", repo, comment_id)
    github_api_request("DELETE", endpoint, nil, cb)
  end)
end]]></code>
      </operation>

      <!-- Improvement 11: Add type annotations to remaining functions -->
      <operation type="update">
        <first_line line="229"><![CDATA[--- @param number number]]></first_line>
        <last_line line="232"><![CDATA[end]]></last_line>
        <code><![CDATA[--- Check out a specific pull request
--- @param number number The PR number to check out
--- @param cb fun(result: string|nil) Callback with the command result
function M.checkout_pr(number, cb)
  utils.system_str_cb(f('gh pr checkout %d', number), cb)
end]]></code>
      </operation>
    </action>
  </tool>
</tools>
```

I've implemented several key improvements to the code:

1. Added proper type annotations to functions for better documentation and IDE support
2. Created a `github_api_request` helper function to centralize API calls and error handling
3. Improved the `get_repo` function with better error handling
4. Added parameter validation to prevent errors with invalid inputs
5. Refactored several methods to use the new `github_api_request` helper
6. Made the code more consistent with clear documentation for each function

These changes make the code more maintainable, better documented, and more robust with improved error handling.

Would you like me to implement more improvements, such as refactoring other functions or adding more documentation to additional methods?

## Me

> Sharing:
> - <tool>code_edit</tool>
> - <buf>lua/ghlite/gh.lua</buf>

[daliusd]

The problem is that with prompt above 50% times code actions are returned in separate blocks anyway. In that case codecompanion code is running each tool one-by-one. E.g.

## Me

> Sharing:
> - <tool>code_edit</tool>
> - <buf>lua/ghlite/gh.lua</buf>


#buffer
@code_edit

Improve this code and implement each improvement separately


## CodeCompanion (Copilot)

I'll improve this Lua code by focusing on several key areas. Let me implement each improvement separately.

### 1. Add proper documentation to functions

```xml
<tools>
  <tool name="code_edit">
    <action buffer="1">
      <operation type="update">
        <first_line line="20"><![CDATA[function M.get_current_pr(cb)]]></first_line>
        <last_line line="20"><![CDATA[function M.get_current_pr(cb)]]></last_line>
        <code><![CDATA[--- Gets information about the current pull request
--- @param cb function Callback function that receives PR data or nil if not found]]></code>
      </operation>
    </action>
  </tool>
</tools>
```

### 2. Fix type annotation for parameter in load_comments

```xml
<tools>
  <tool name="code_edit">
    <action buffer="1">
      <operation type="update">
        <first_line line="65"><![CDATA[--- @params pr_number number]]></first_line>
        <last_line line="65"><![CDATA[--- @params pr_number number]]></last_line>
        <code><![CDATA[--- @param pr_number number PR number to load comments for]]></code>
      </operation>
    </action>
  </tool>
</tools>
```

### 3. Add error handling for get_repo function

```xml
<tools>
  <tool name="code_edit">
    <action buffer="1">
      <operation type="update">
        <first_line line="57"><![CDATA[local function get_repo(cb)]]></first_line>
        <last_line line="63"><![CDATA[end]]></last_line>
        <code><![CDATA[--- Gets the repository name with owner
--- @param cb function Callback function that receives the repo name
local function get_repo(cb)
  utils.system_str_cb('gh repo view --json nameWithOwner -q .nameWithOwner', function(result, stderr)
    if result ~= nil then
      cb(vim.split(result, '\n')[1])
    else
      config.log("Error getting repository information", stderr)
      cb(nil)
    end
  end)
end]]></code>
      </operation>
    </action>
  </tool>
</tools>
```

### 4. Refactor duplicate error handling pattern in get_current_pr and get_pr_list

```xml
<tools>
  <tool name="code_edit">
    <action buffer="1">
      <operation type="add">
        <before_line line="11"><![CDATA[local f = string.format]]></before_line>
        <code><![CDATA[--- Handles GitHub CLI fallback for backwards compatibility with older versions
--- @param command string The primary command to execute
--- @param fallback_command string The fallback command without unsupported fields
--- @param cb function Callback to receive the result
local function gh_command_with_fallback(command, fallback_command, cb)
  utils.system_str_cb(command, function(result, stderr)
    local prefix = 'Unknown JSON field'
    if result == nil then
      cb(nil)
      return
    elseif stderr and string.sub(stderr, 1, #prefix) == prefix then
      utils.system_str_cb(fallback_command, function(fallback_result)
        if fallback_result == nil then
          cb(nil)
          return
        end
        cb(parse_or_default(fallback_result, nil))
      end)
    else
      cb(parse_or_default(result, nil))
    end
  end)
end]]></code>
      </operation>
    </action>
  </tool>
</tools>
```

### 5. Simplify get_current_pr using the new helper function

```xml
<tools>
  <tool name="code_edit">
    <action buffer="1">
      <operation type="update">
        <first_line line="20"><![CDATA[--- Gets information about the current pull request
--- @param cb function Callback function that receives PR data or nil if not found
function M.get_current_pr(cb)]]></first_line>
        <last_line line="40"><![CDATA[end]]></last_line>
        <code><![CDATA[--- Gets information about the current pull request
--- @param cb function Callback function that receives PR data or nil if not found
function M.get_current_pr(cb)
  local primary = 'gh pr view --json headRefName,headRefOid,number,baseRefName,baseRefOid,reviewDecision'
  local fallback = 'gh pr view --json headRefName,headRefOid,number,baseRefName,reviewDecision'
  
  gh_command_with_fallback(primary, fallback, cb)
end]]></code>
      </operation>
    </action>
  </tool>
</tools>
```

### 6. Simplify get_pr_list using the new helper function

```xml
<tools>
  <tool name="code_edit">
    <action buffer="1">
      <operation type="update">
        <first_line line="209"><![CDATA[function M.get_pr_list(cb)]]></first_line>
        <last_line line="227"><![CDATA[end]]></last_line>
        <code><![CDATA[--- Gets a list of pull requests
--- @param cb function Callback function that receives the list of PRs
function M.get_pr_list(cb)
  local primary = 'gh pr list --json number,title,author,createdAt,isDraft,reviewDecision,headRefName,headRefOid,baseRefName,baseRefOid,labels'
  local fallback = 'gh pr list --json number,title,author,createdAt,isDraft,reviewDecision,headRefName,headRefOid,baseRefName,labels'
  
  gh_command_with_fallback(primary, fallback, function(result)
    cb(result or {})
  end)
end]]></code>
      </operation>
    </action>
  </tool>
</tools>
```

### 7. Improve error handling in delete_comment

```xml
<tools>
  <tool name="code_edit">
    <action buffer="1">
      <operation type="update">
        <first_line line="191"><![CDATA[function M.delete_comment(comment_id, cb)]]></first_line>
        <last_line line="207"><![CDATA[end]]></last_line>
        <code><![CDATA[--- Deletes a comment from a PR
--- @param comment_id string|number The ID of the comment to delete
--- @param cb function Callback function that receives the response
function M.delete_comment(comment_id, cb)
  if not comment_id then
    config.log("Error: No comment_id provided for deletion")
    cb({ error = "No comment_id provided" })
    return
  end
  
  get_repo(function(repo)
    if not repo then
      config.log("Error: Could not determine repository")
      cb({ error = "Repository not found" })
      return
    end
    
    local request = {
      'gh',
      'api',
      '--method',
      'DELETE',
      f("repos/%s/pulls/comments/%s", repo, comment_id),
    }
    config.log('delete_comment request', request)

    utils.system_cb(request, function(resp)
      config.log("delete_comment resp", resp)
      cb(resp)
    end)
  end)
end]]></code>
      </operation>
    </action>
  </tool>
</tools>
```

### 8. Clean up unused variable in new_pr_comment

```xml
<tools>
  <tool name="code_edit">
    <action buffer="1">
      <operation type="update">
        <first_line line="164"><![CDATA[    local result = utils.system_cb(request, function(result)]]></first_line>
        <last_line line="164"><![CDATA[    local result = utils.system_cb(request, function(result)]]></last_line>
        <code><![CDATA[    utils.system_cb(request, function(result)]]></code>
      </operation>
    </action>
  </tool>
</tools>
```

### 9. Fix similar unused variable in request_changes_pr

```xml
<tools>
  <tool name="code_edit">
    <action buffer="1">
      <operation type="update">
        <first_line line="251"><![CDATA[    local result = utils.system_cb(request, function(result)]]></first_line>
        <last_line line="251"><![CDATA[    local result = utils.system_cb(request, function(result)]]></last_line>
        <code><![CDATA[    utils.system_cb(request, function(result)]]></code>
      </operation>
    </action>
  </tool>
</tools>
```

### 10. Add proper documentation to key functions

```xml
<tools>
  <tool name="code_edit">
    <action buffer="1">
      <operation type="update">
        <first_line line="42"><![CDATA[function M.get_pr_info(pr_number, cb)]]></first_line>
        <last_line line="42"><![CDATA[function M.get_pr_info(pr_number, cb)]]></last_line>
        <code><![CDATA[--- Gets detailed information about a specific pull request
--- @param pr_number number|string The PR number to get information for
--- @param cb function Callback function that receives the PR information]]></code>
      </operation>
      
      <operation type="update">
        <first_line line="91"><![CDATA[function M.reply_to_comment(pr_number, body, reply_to, cb)]]></first_line>
        <last_line line="91"><![

## Me

> Sharing:
> - <tool>code_edit</tool>
> - <buf>lua/ghlite/gh.lua</buf>

Please correct for the error message I've shared

[cairijun]

I guess "separately" in your prompt confuses the LLM.

Besides, doing complex code edits in a single step might not be a good idea. Try spliting it into at least two (planning + edit). See https://aider.chat/2024/09/26/architect.html
Example:

User -> LLM:
#buffer
Improve this code. Output only your plan briefly, along with all code snippets that need to be changed and their exactly positions.

LLM -> User:
...

User -> LLM / LLM -> User: (Optional: Discuss the changes with LLM)

User -> LLM:
Use @code_edit to implement all the changes.

I also updated the gist to fix a potential false positive in overlap checking.

[daliusd]

I guess "separately" in your prompt confuses the LLM.

That's intentional here to reproduce issue consistently with @editor. The problem in general that sometimes this happens even without doing complex edits and you get what is reported in this discussion.

[olimorris]

Hi All. Opening this up to the Community for help. Now I've merged function calling into the plugin and we have awesome tools like MCP Hub and VectorCode, I'm hoping this is an enhancement someone would want to pick up.

In speaking to people over the past few months, a common ask has been for users to be able to "step-through" any buffer edits, individually. Currently the editor tool just shows multiple edits as one big change. It's possible the queue system I built for agents and tools could be used for this purpose.

[taketwo]

Could it be possible to co-opt Diffview.nvim? It provides a single tabpage interface for easily cycling through diffs for all modified files for any git rev. I understand that changes output by a tool are not a git rev, but perhaps the plugin has an API that is agnostic to the source of the diffs.

[jinzhongjia]

Perhaps you can divide the modification into multiple ones from top to bottom and then apply it

[daviareias]

I also have this, I thought it was because I did something wrong.

Not only it opens 2-5 buffers but the output also seems to have repeated lines?

[pratyushmittal]

@daviareias can you please share the output of gd. Pressing gd in chat window will show full raw message history. That will help me investigate this.

The above thread is an old one before the code used function_tools. The current version is a highly refactored version.

[daviareias]

It seems this happens when the AI adds more than one line, I'm also getting an error message if I try to use the @editor with claude. Here is what I see

Here is the debug:

-- Adapter: "Gemini"
-- Buffer: 7
-- Context: "+page.svelte" (3)

local settings = {
  model = "gemini-2.5-flash-preview-05-20",  -- "gemini-2.5-pro-preview-05-06", "gemini-2.0-flash", "gemini-2.0-flash-lite", "gemini-1.5-pro", "gemini-1.5-flash", 
  max_tokens = nil,
  temperature = nil,
  top_p = nil,
  reasoning_effort = "medium",
}

local messages = 
{ {
    content = "when asked to write code:\n-talk as less as possible\n do not add comments unless strictly necessary",
    cycle = 1,
    id = 900020486,
    opts = {
      tag = "from_config",
      visible = false
    },
    role = "system"
  }, {
    content = "editor\nHello can you add some comments in this buffer just to see if you're working buffer 3 (`+page.svelte`)\n\nplease add more than one comment",
    cycle = 1,
    id = 144552754,
    opts = {
      visible = true
    },
    role = "user"
  }, {
    content = "# Editor Tool (`editor`)\n\n## CONTEXT\n- You have access to an editor tool running within CodeCompanion, in Neovim.\n- You can use it to add, edit or delete code in a Neovim buffer, via a buffer number that the user has provided to you.\n- You can specify line numbers to add, edit or delete code and CodeCompanion will carry out the action in the buffer, on your behalf.\n\n## OBJECTIVE\n- To implement code changes in a Neovim buffer.\n\n## RESPONSE\n- Only invoke this tool when the user specifically asks.\n- Use this tool strictly for code editing.\n- If the user asks you to write specific code, do so to the letter, paying great attention.\n- This tool can be called multiple times to make multiple changes to the same buffer.\n- If the user has not provided you with a buffer number, you must ask them for one.\n- Ensure that the code you write is syntactically correct and valid and that indentations are correct.\n\n## POINTS TO NOTE\n- This tool can be used alongside other tools within CodeCompanion\n",
    cycle = 1,
    id = 295007336,
    opts = {
      reference = "<tool>editor</tool>",
      tag = "tool",
      visible = false
    },
    role = "system"
  }, {
    content = "Here is the content from the buffer.\n\nBuffer Number: 3\nName: +page.svelte\nPath: /parcelamento_landing_page/src/routes/+page.svelte\nFiletype: svelte\nContent:\n```svelte\n1:  <!-- Main script section -->\n2:  \n3:  <script>\n4:  \timport IndexFaq from '../components/IndexFaq.svelte';\n5:  \timport Graph from '../components/sections/Graph.svelte';\n6:  \timport SecondarySections from '../components/sections/SecondarySections.svelte';\n7:  \timport schema from './schema.json';\n8:  \timport metaTags from './metatags.js';\n9:  \n10:  \tconst applink = 'https://example.com';\n11:  </script>\n12:  \n13:  <svelte:head>\n```\n",
    cycle = 1,
    id = 1989320703,
    opts = {
      reference = "<buf>src/routes/+page.svelte</buf>",
      tag = "variable",
      visible = false
    },
    role = "user"
  }, {
    cycle = 1,
    id = 1823482581,
    opts = {
      visible = true
    },
    role = "llm",
    tool_calls = { {
        _index = 1,
        ["function"] = {
          arguments = '{"buffer":3,"code":"\\u003c!-- This is a new comment added by the AI. --\\u003e","start_line":2,"action":"add"}',
          name = "editor"
        },
        id = "call_1749142871_1",
        type = "function"
      } }
  }, {
    content = "**Editor Tool:** Added 1 line(s) in buffer 3:\n```svelte\n<!-- This is a new comment added by the AI. -->\n```",
    cycle = 1,
    id = 1679955124,
    opts = {
      tag = "tool_output",
      visible = true
    },
    role = "tool",
    tool_call_id = "call_1749142871_1"
  }, {
    content = "I've shared the output from the tool/function call with you.",
    cycle = 1,
    id = 1761236678,
    opts = {
      visible = false
    },
    role = "user"
  }, {
    cycle = 1,
    id = 103306562,
    opts = {
      visible = true
    },
    role = "llm",
    tool_calls = { {
        _index = 1,
        ["function"] = {
          arguments = '{"action":"add","start_line":4,"buffer":3,"code":"\\u003c!-- Another comment added to the script section. --\\u003e"}',
          name = "editor"
        },
        id = "call_1749142873_1",
        type = "function"
      } }
  }, {
    content = "**Editor Tool:** Added 1 line(s) in buffer 3:\n```svelte\n<!-- Another comment added to the script section. -->\n```",
    cycle = 1,
    id = 1751636025,
    opts = {
      tag = "tool_output",
      visible = true
    },
    role = "tool",
    tool_call_id = "call_1749142873_1"
  }, {
    content = "I've shared the output from the tool/function call with you.",
    cycle = 1,
    id = 1761236678,
    opts = {
      visible = false
    },
    role = "user"
  }, {
    content = "Great, I've added two comments to your `+page.svelte` file in buffer 3.\n\nThe first comment `<!-- This is a new comment added by the AI. -->` was added on line 2.\nThe second comment `<!-- Another comment added to the script section. -->` was added on line 4.\n\nPlease let me know if you need any further modifications or assistance!",
    cycle = 1,
    id = 505215208,
    opts = {
      visible = true
    },
    role = "llm"
  } }```

[olimorris]

Bear with me on this. Will be pushing some updates in the next couple of weeks to improve the editing of buffers

[duggthangs]

@olimorris What do you think about this editor tool?

code_editor.mp4

For every edit, we queue it up and user can tab through (or ga) through the edits a hunk at a time. The idea of queuing up and processing one at a time in a loop I think can be a good solution to this problem.

For the tool I showcased, it's not perfect, but almost ready to publish :)

[olimorris]

I'm part way through a refactor in #1586 which will handle this.

My planned solution is that all tool calls will wait for the user to reject or accept the code change.

But please share what you've done as would be very interested in seeing your solution.

[olimorris]

Release v16.2.0 will partly address this, principally because we're processing a single edit at a time and asking users to approve them. It's not a fix per se, but a change in plugin behaviour which should prevent this from happening by default.