Update plugin code to work with Lazy.nvim and on nvim 0.10.0

README.md

@@ -24,66 +24,96 @@ Using [dein](https://github.com/Shougo/dein.vim)
 call dein#add('joshuavial/aider.nvim')
 ```
 
+Using [lazy.nvim](https://github.com/folke/lazy.nvim)
+
+```lua
+{
+  "joshuavial/aider.nvim",
+  config = function()
+    require("aider").setup({
+      -- your configuration comes here
+      -- if you don't want to use the default settings
+      auto_manage_context = true,
+      default_bindings = true,
+      debug = false, -- Set to true to enable debug logging
+    })
+  end,
+}
+```
+
 ## Usage
 
-The Aider Plugin for Neovim provides the `AiderOpen` and `AiderBackground` lua functions. 
+The Aider Plugin for Neovim provides several functions and commands:
 
-The `AiderOpen` function opens a terminal window with the Aider command. It accepts the following arguments:
-- `args`: The command line arguments to pass to `aider` - defaults to ""
-- `window_type`: The window style to use 'vsplit' (default), 'hsplit' or 'editor'
+1. `AiderOpen`: Opens a terminal window with the Aider command.
 
-NOTE: if an Aider job is already running calling AiderOpen will reattach to it, even if it is called with different flags
+   - Arguments:
+     - `args`: Command line arguments to pass to `aider` (default: "")
+     - `window_type`: Window style to use ('vsplit' (default), 'hsplit', or 'editor')
+   - Note: If an Aider job is already running, calling AiderOpen will reattach to it, even with different flags.
 
-The `AiderBackground` function runs the Aider command in the background. It accepts the following arguments:
-- `args`: The command line arguments to pass to `aider` - defaults to ""
-- `message`: The message to pass to the Aider command - defaults to "Complete as many todo items as you can and remove the comment for any item you complete."
+2. `AiderBackground`: Runs the Aider command in the background.
 
-When Aider opens (through either function), it will automatically add all open buffers to both commands. If you are going to use this plugin you will want to actively manage open buffers with commands like `:ls` and `:bd`.
+   - Arguments:
+     - `args`: Command line arguments to pass to `aider` (default: "")
+     - `message`: Message to pass to the Aider command (default: "Complete as many todo items as you can and remove the comment for any item you complete.")
 
-Here are some examples of how to use the `AiderOpen` and `AiderBackground` functions:
+3. `AiderAddModifiedFiles`: Adds all git-modified files to the Aider chat.
+   - This function can be called directly or through the user command `:AiderAddModifiedFiles`
+
+When Aider opens (through either function), it automatically adds all open buffers to both commands. It's recommended to actively manage open buffers with commands like `:ls` and `:bd`.
+
+Examples of using these commands:
 
 ```vim
-:lua AiderOpen() 
-:lua AiderOpen("-3", "hsplit") 
-:lua AiderOpen("AIDER_NO_AUTO_COMMITS=1 aider -3", "editor")
-:lua AiderBackground()
-:lua AiderBackground("-3")
-:lua AiderBackground("AIDER_NO_AUTO_COMMITS=1 aider -3")
+:AiderOpen
+:AiderOpen -3 hsplit
+:AiderOpen "AIDER_NO_AUTO_COMMITS=1 aider -3" editor
+:AiderBackground
+:AiderBackground -3
+:AiderBackground "AIDER_NO_AUTO_COMMITS=1 aider -3"
+:AiderAddModifiedFiles
 ```
 
-You can also set keybindings for the `AiderOpen` and `AiderBackground` functions in Lua. Here's an example:
+You can set custom keybindings for these commands in your Neovim configuration. For example:
 
 ```lua
--- set a keybinding for the AiderOpen function
-vim.api.nvim_set_keymap('n', '<leader>oa', '<cmd>lua AiderOpen()<cr>', {noremap = true, silent = true})
--- set a keybinding for the AiderBackground function
-vim.api.nvim_set_keymap('n', '<leader>ob', '<cmd>lua AiderBackground()<cr>', {noremap = true, silent = true})
+vim.api.nvim_set_keymap('n', '<leader>ao', ':AiderOpen<CR>', {noremap = true, silent = true})
+vim.api.nvim_set_keymap('n', '<leader>ab', ':AiderBackground<CR>', {noremap = true, silent = true})
+vim.api.nvim_set_keymap('n', '<leader>am', ':AiderAddModifiedFiles<CR>', {noremap = true, silent = true})
 ```
 
-In this example, pressing `<leader>oa` in normal mode will call the `AiderOpen` function, and `<leader>ob` will call the `AiderBackground` function.
-
-Run `aider --help` to see all the options you can pass to the cli.
+Run `aider --help` to see all the options you can pass to the CLI.
 
 The plugin provides the following default keybindings:
 
-- `<leader><Space><Space>` to open a terminal window with the Aider defaults (gpt-4).
-- `<leader><Space>3` to open a terminal window with the Aider command using the gpt-3.5-turbo-16k model for chat.
-- `<leader><space>b` to run the Aider command in the background with the defaults.
-- `<leader><space>b3` to run the Aider command in the background using the gpt-3.5-turbo-16k model for chat.
+- `<leader>Ao`: Open a terminal window with the Aider defaults (gpt-4).
+- `<leader>AO`: Open a terminal window with the Aider command using the gpt-3.5-turbo-16k model for chat.
+- `<leader>Ab`: Run the Aider command in the background with the defaults.
+- `<leader>AB`: Run the Aider command in the background using the gpt-3.5-turbo-16k model for chat.
+- `<leader>Am`: Add all git-modified files to the Aider chat.
+
+These keybindings are set up using which-key, providing a descriptive popup menu when you press `<leader>A`.
 
 ## Setup
 
 The Aider Plugin for Neovim provides a `setup` function that you can use to configure the plugin. This function accepts a table with the following keys:
 
 - `auto_manage_context`: A boolean value that determines whether the plugin should automatically manage the context. If set to `true`, the plugin will automatically add and remove buffers from the context as they are opened and closed. Defaults to `true`.
 - `default_bindings`: A boolean value that determines whether the plugin should use the default keybindings. If set to `true`, the plugin will require the keybindings file and set the default keybindings. Defaults to `true`.
+- `debug`: A boolean value that determines whether the plugin should enable debug logging. When set to true, it will print debug information to help troubleshoot issues. Defaults to false.
 
 Here is an example of how to use the `setup` function:
 
 ```lua
 require('aider').setup({
   auto_manage_context = false,
-  default_bindings = false
+  default_bindings = false,
+  debug = true,
+  vim = true, -- Pass the `--vim` flag to Aider when opening a new chat
+
+  -- only necessary if you want to change the default keybindings. <Leader>C is not a particularly good choice. It's just shown as an example.
+  vim.api.nvim_set_keymap('n', '<leader>C', ':AiderOpen<CR>', {noremap = true, silent = true})
 })
 ```
 
@@ -95,40 +125,29 @@ The plugin exposes a global variable called `aider_background_status` that you c
 
 ```lua
 lualine_x = {{
-    function() 
+    function()
       return 'A'
     end,
     color = { fg = '#8FBCBB' }, -- green
-    cond = function() 
+    cond = function()
       return _G.aider_background_status == 'idle'
     end
   },
   {
-    function() 
+    function()
       return 'A'
     end,
     color = { fg = '#BF616A' }, -- red
-    cond = function() 
+    cond = function()
       return _G.aider_background_status == 'working'
     end
   }
 }
 ```
 
-## Reloading buffers
+## Reloading buffers after Aider updates the underlying code
 
-Because the AiderOnBufferOpen command is bound to BufReadPost it will fire whenever a buffer is reloaded if you just use a `:e!`. The ReloadBuffer function below will prevent a file from being added to aider every time it's openeed.
-
-```lua
-function ReloadBuffer()
-  local temp_sync_value = vim.g.aider_buffer_sync                            
-  vim.g.aider_buffer_sync = 0                                                
-  vim.api.nvim_exec2('e!', {output = false})
-  vim.g.aider_buffer_sync = temp_sync_value
-end
-```
-
-To use this function, simply call `:lua ReloadBuffer()` (or bind it to your favourite shortcut). This will refresh the current buffer and display any changes made by Aider.
+Run the `:e` command to re-edit the current buffer updating its contents with any changes made since initially loading it.
 
 ## Tips for Working with Buffers in Vim
 
@@ -140,24 +159,6 @@ If you're not familiar with buffers in Vim, here are some tips:
 - Use `:bd <number>` or `:bdelete <number>` to close a specific buffer. Replace `<number>` with the buffer number.
 - Use `:bufdo bd` to close all buffers.
 
-This helper function may be useful for closing all buffers that are hidden
-
-```lua
-_G.close_hidden_buffers = function()
-  local curr_buf_num = vim.api.nvim_get_current_buf()
-  local all_buf_nums = vim.api.nvim_list_bufs()
-
-  for _, buf_num in ipairs(all_buf_nums) do
-    if buf_num ~= curr_buf_num and vim.api.nvim_buf_is_valid(buf_num) and vim.api.nvim_buf_is_loaded(buf_num) and vim.fn.bufwinnr(buf_num) == -1 then
-      if vim.fn.getbufvar(buf_num, '&buftype') ~= 'terminal' then
-        vim.api.nvim_buf_delete(buf_num, { force = true })
-      end
-    end
-  end
-end
-```
-
 ## NOTE
 
 if you resize a split the nvim buffer can truncate the text output, chatGPT tells me there isn't an easy work around for this. Feel free to make a PR if you think it's easy to solve without rearchitecting and using tmux or something similar.
-