Fidget.nvim integration

[jessevdp]

CodeCompanion is AWESOME!

I'm working on a cool fidget.nvim integration to show signs of life when CodeCompanion is waiting.

It's pretty cool!

Tip

See the finalized demo & code here.

Demo 👀

Screen.Recording.2025-02-01.at.10.47.21.mov

See the source code 😎

Notes:

• This might not handle concurrent requests too well?

local M = {}

local progress = require("fidget.progress")
local handle = nil

function M:init()
  local group = vim.api.nvim_create_augroup("CodeCompanionFidgetHooks", {})

  vim.api.nvim_create_autocmd({ "User" }, {
    pattern = "CodeCompanionRequest*",
    group = group,
    callback = function(request)
      if request.match == "CodeCompanionRequestStarted" then
        local adapter_name = "TODO"
        local model_name = "TODO"
        handle = progress.handle.create({
          title = " Requesting assistance",
          lsp_client = {
            name = string.format("CodeCompanion (%s - %s)", adapter_name, model_name),
          },
        })
      elseif request.match == "CodeCompanionRequestFinished" then
        if handle then
          handle:finish()
        end
      end
    end,
  })
end

return M

Anyway... I wanted to improve my experience a bit and show what adapter (and underlying model) are being used to make the request. I think this could improve the experience of :CodeCompanion* commands where (unlike in the chat) you don't really know what the current adapter and model are?

I don't have a code-companion model selection in my status line or anything (since I use lualine with a unique status line on each buffer... indicating the current adapter and model on every single one seems a bit excessive.)

Perhaps my use-case isn't the best.. Nevertheless...

I figured providing data should be pretty easy! I traced the CodeCompanionRequestStarted event here:

codecompanion.nvim/lua/codecompanion/http.lua

Line 174 in d75641e

util.fire("RequestStarted" .. (self.user_args.event or ""), opts)

codecompanion.nvim/lua/codecompanion/utils/init.lua

Lines 8 to 11 in d75641e

	function M.fire(event, opts)
	opts = opts or {}
	api.nvim_exec_autocmds("User", { pattern = "CodeCompanion" .. event, data = opts })
	end

I printed event.data and it seems pretty minimal for me:

local group = vim.api.nvim_create_augroup("CodeCompanionFidgetHooks", {})

vim.api.nvim_create_autocmd({ "User" }, {
  pattern = "CodeCompanionRequest*",
  group = group,
  callback = function(request)
    if request.match == "CodeCompanionRequestStarted" then
      print(vim.inspect(request.data))
    end
  end,
})

Output:

{
  bufnr = 5
}

---

• Are you open to adding data.adapter
• What else could be useful to add?
• Am I on the right track? Or should I be looking elsewhere?

[olimorris]

This is fantastic and such a clean implementation. To get additional information regarding the chat buffer you could do:

local chat = require("codecompanion").buf_get_chat(request.data.bufnr)

That gives you access to everything in the chat buffer so you could then access chat.adapter.formatted_name and chat.adapter.schema.model.default. Regarding the latter, default actually refers to the currently selected model (I should probably change that at some point).

My reason for only emitting the bufnr was because for some, sending the whole chat buffer could be overkill and I was never convinced that there wouldn't be performance issues.

I would very much love to add this to the docs pages. I've purposefully never added anything that resembles aesthetics because it's so subjective. But it would be great to showcase what others have done.

[olimorris]

I've pushed some updates in v11.24.0. The output would be something like:

{
  buf = 3,
  data = {
    adapter = {
      formatted_name = "Copilot",
      model = "o3-mini-2025-01-31",
      name = "copilot"
    },
    bufnr = 3,
    strategy = "chat" -- "inline" | "cmd"
  },
  event = "User",
  file = "CodeCompanionRequestStarted",
  group = 13,
  id = 29,
  match = "CodeCompanionRequestStarted"
}

I played around a bit and (given a slow model) when firing away :CodeCompanion inline commands it is possible to get two requests going at the same time for the same bufnr.

The reality of this happening will be super low so not worth worrying about.

[jessevdp]

Amazing! 😁

[olimorris]

Was thinking about this last night and potential request clashes so was actually pretty trivial to just put an id on the http.lua file. So request will look something like:

Started:

{
  buf = 10,
  data = {
    adapter = {
      formatted_name = "Copilot",
      model = "o3-mini-2025-01-31",
      name = "copilot"
    },
    bufnr = 10,
    id = 6107753,
    strategy = "chat"
  },
  event = "User",
  file = "CodeCompanionRequestStarted",
  group = 14,
  id = 30,
  match = "CodeCompanionRequestStarted"
}

Finished:

{
  buf = 10,
  data = {
    adapter = {
      formatted_name = "Copilot",
      model = "o3-mini-2025-01-31",
      name = "copilot"
    },
    bufnr = 10,
    id = 6107753,
    status = "success",
    strategy = "chat"
  },
  event = "User",
  file = "CodeCompanionRequestFinished",
  group = 14,
  id = 30,
  match = "CodeCompanionRequestFinished"
}

So you can link a Started and Finished request together.

[jessevdp]

That’s awesome! With the status addition too!

I’ve got some time on my hands this afternoon so I’ll hack on my fidget.nvim integration and polish it up.

In case you want to add the example to the docs.. Do you want me to publish the final result here? Anything I can do to help? Would you like a video showcase? Etc.

[olimorris]

A video and your code would be epic. I'll create a new section in the docs later today and will add them there.

[jessevdp]

@olimorris here's the final demo + code. Thanks for all of the input, quick responses, and CodeCompanion in general. I had a lot of fun hacking on this small integration this weekend. 😆

codecompanion-fidget-demo.mp4

Here's what I came up with in terms of code:

-- lua/plugins/codecompanion.lua

return {
  {
    "olimorris/codecompanion.nvim",
    dependencies = {
      -- ...
      "j-hui/fidget.nvim"
    },
    opts = {
      strategies = {
        -- ...
      },
    },
    init = function()
      require("plugins.codecompanion.fidget-spinner"):init()
    end,
  },
}

-- lua/plugins/codecompanion/fidget-spinner.lua

local progress = require("fidget.progress")

local M = {}

function M:init()
  local group = vim.api.nvim_create_augroup("CodeCompanionFidgetHooks", {})

  vim.api.nvim_create_autocmd({ "User" }, {
    pattern = "CodeCompanionRequestStarted",
    group = group,
    callback = function(request)
      local handle = M:create_progress_handle(request)
      M:store_progress_handle(request.data.id, handle)
    end,
  })

  vim.api.nvim_create_autocmd({ "User" }, {
    pattern = "CodeCompanionRequestFinished",
    group = group,
    callback = function(request)
      local handle = M:pop_progress_handle(request.data.id)
      if handle then
        M:report_exit_status(handle, request)
        handle:finish()
      end
    end,
  })
end

M.handles = {}

function M:store_progress_handle(id, handle)
  M.handles[id] = handle
end

function M:pop_progress_handle(id)
  local handle = M.handles[id]
  M.handles[id] = nil
  return handle
end

function M:create_progress_handle(request)
  return progress.handle.create({
    title = " Requesting assistance (" .. request.data.strategy .. ")",
    message = "In progress...",
    lsp_client = {
      name = M:llm_role_title(request.data.adapter),
    },
  })
end

function M:llm_role_title(adapter)
  local parts = {}
  table.insert(parts, adapter.formatted_name)
  if adapter.model and adapter.model ~= "" then
    table.insert(parts, "(" .. adapter.model .. ")")
  end
  return table.concat(parts, " ")
end

function M:report_exit_status(handle, request)
  if request.data.status == "success" then
    handle.message = "Completed"
  elseif request.data.status == "error" then
    handle.message = " Error"
  else
    handle.message = "󰜺 Cancelled"
  end
end

return M

[olimorris]

This is amazing. Thank you so much for sharing and I can't wait to use it myself 😀

[jessevdp]

Update: I added the "j-hui/fidget.nvim" dependency to the lazy spec in the snippets above.

[paulodiovani]

The only problem I see is that, when the chat window is full, the code companion text stays behind the notification.
Did you find any way to avoid that?

[RobertoMaurizzi]

Having immediate feedback is extremely handy, especially while experimenting with local models. Thanks @jessevdp

[haus20xx]

I adapted your integration to work with Noice.nvim in particular to work with the out of box behavior that comes with LazyVim.

-- plugins/ai/companion.lua
return {
  "olimorris/codecompanion.nvim",
  init = function()
    require("plugins.ai.extensions.companion-notification").init()
  end,

  dependencies = {
    "nvim-lua/plenary.nvim",
    "nvim-treesitter/nvim-treesitter",
    "folke/noice.nvim",
  }
}

-- plugins/ai/extensions/companion-notification.lua

local Format = require("noice.text.format")
local Message = require("noice.message")
local Manager = require("noice.message.manager")
local Router = require("noice.message.router")

local ThrottleTime = 200
local M = {}

M.handles = {}
function M.init()
  local group = vim.api.nvim_create_augroup("NoiceCompanionRequests", {})

  vim.api.nvim_create_autocmd({ "User" }, {
    pattern = "CodeCompanionRequestStarted",
    group = group,
    callback = function(request)
      local handle = M.create_progress_message(request)
      M.store_progress_handle(request.data.id, handle)
      M.update(handle)
    end,
  })

  vim.api.nvim_create_autocmd({ "User" }, {
    pattern = "CodeCompanionRequestFinished",
    group = group,
    callback = function(request)
      local message = M.pop_progress_message(request.data.id)
      if message then
        message.opts.progress.message = M.report_exit_status(request)
        M.finish_progress_message(message)
      end
    end,
  })
end

function M.store_progress_handle(id, handle)
  M.handles[id] = handle
end

function M.pop_progress_message(id)
  local handle = M.handles[id]
  M.handles[id] = nil
  return handle
end

function M.create_progress_message(request)
  local msg = Message("lsp", "progress")
  local id = request.data.id
  msg.opts.progress = {
    client_id = "client " .. id,
    client = M.llm_role_title(request.data.adapter),
    id = id,
    message = "Awaiting Response: ",
  }
  return msg
end

function M.update(message)
  if M.handles[message.opts.progress.id] then
    Manager.add(Format.format(message, "lsp_progress"))
    vim.defer_fn(function()
      M.update(message)
    end, ThrottleTime)
  end
end

function M.finish_progress_message(message)
  Manager.add(Format.format(message, "lsp_progress"))
  Router.update()
  Manager.remove(message)
end

function M.llm_role_title(adapter)
  local parts = {}
  table.insert(parts, adapter.formatted_name)
  if adapter.model and adapter.model ~= "" then
    table.insert(parts, "(" .. adapter.model .. ")")
  end
  return table.concat(parts, " ")
end

function M.report_exit_status(request)
  if request.data.status == "success" then
    return "Completed"
  elseif request.data.status == "error" then
    return " Error"
  else
    return "󰜺 Cancelled"
  end
end

return M

Which does have load wheel that will cycle(sorry I don't have a workflow for screencasts lmao)

It's probably a bit messier than it needs to be since I basically copy pasted your work as a starting point and then chipped away to get it to match Noice's implementation for lsp progress events, but it gets the job done!

[MushiTheMoshi]

hey, is it possible to move the notifications box to the top right corner?

[MushiTheMoshi]

After cancelling chat it's not possible to continue sending messages it gives: No messages to submit

[ktunprasert]

Here's a version for fellow snacks.nvim enjoyer

        local group = vim.api.nvim_create_augroup("CodeCompanionFidgetHooks", { clear = true })
        vim.api.nvim_create_autocmd({ "User" }, {
            pattern = "CodeCompanionRequest*",
            group = group,
            callback = function(request)
                local msg

                if request.match == "CodeCompanionRequestStarted" then
                    msg = "[CodeCompanion] starting..."
                elseif request.match == "CodeCompanionRequestStreaming" then
                    msg = "[CodeCompanion] streaming..."
                else
                    msg = "[CodeCompanion] finished"
                end

                vim.notify(msg, "info", {
                    id = "code_companion_status",
                    title = "Code Companion Status",
                    opts = function(notif)
                        notif.icon = request.match == "CodeCompanionRequestFinished" and " "
                            ---@diagnostic disable-next-line: undefined-field
                            or spinner[math.floor(vim.uv.hrtime() / (1e6 * 80)) % #spinner + 1]
                    end,
                })
            end,
        })

NVIDIA_Overlay_2025-05-08_21-12-08.webm

[ktunprasert]

refined a bit more to keep some notifications persistent and some ignored

local spinner = { "⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏" }
local group = vim.api.nvim_create_augroup("CodeCompanionFidgetHooks", { clear = true })
vim.api.nvim_create_autocmd({ "User" }, {
    pattern = "CodeCompanion*",
    group = group,
    callback = function(request)
        if request.match == "CodeCompanionChatSubmitted" then
            return
        end

        local msg

        msg = "[CodeCompanion] " .. request.match:gsub("CodeCompanion", "")

        vim.notify(msg, "info", {
            timeout = 1000,
            keep = function()
                return not vim.iter({ "Finished", "Opened", "Hidden", "Closed", "Cleared", "Created", }):fold(
                    false,
                    function(acc, cond)
                        return acc or vim.endswith(request.match, cond)
                    end)
            end,
            id = "code_companion_status",
            title = "Code Companion Status",
            opts = function(notif)
                notif.icon = ""
                if vim.endswith(request.match, "Started") then
                    ---@diagnostic disable-next-line: undefined-field
                    notif.icon = spinner[math.floor(vim.uv.hrtime() / (1e6 * 80)) % #spinner + 1]
                elseif vim.endswith(request.match, "Finished") then
                    notif.icon = " "
                end
            end,
        })
    end,
})

[stuckinsnow]

I was inspired by this thread and made something similar for lualine; I have requested this here -- nvim-lualine/lualine.nvim#1419 -- but I will leave the code below:

2025-05-22.23-45-16.mp4

local M = {}

local state = {
  last_status = "Idle",
  animation = { "...", ".. ", ".  " },
  completed_time = nil,
}

function M.update_status(event)
  if event == "CodeCompanionRequestStarted" then
    state.last_status = "Awaiting Response"
    state.completed_time = nil
  elseif event == "CodeCompanionRequestStreaming" then
    state.last_status = "Streaming"
    state.completed_time = nil
  elseif event == "CodeCompanionRequestFinished" then
    state.last_status = "Completed"
    state.completed_time = vim.uv and vim.uv.hrtime() or nil
  elseif event == "CodeCompanionRequestError" then
    state.last_status = " Error"
    state.completed_time = nil
  elseif event == "CodeCompanionRequestCancelled" then
    state.last_status = "󰜺 Cancelled"
    state.completed_time = nil
  else
    state.last_status = "Idle"
    state.completed_time = nil
  end
end

function M.component()
  if state.last_status == "Awaiting Response" or state.last_status == "Streaming" then
    if vim.uv and vim.uv.hrtime then
      local animation_index = math.floor(vim.uv.hrtime() / (1e6 * 80)) % #state.animation + 1
      return state.last_status .. state.animation[animation_index]
    end
    return state.last_status
  elseif state.last_status == "Completed" then
    if state.completed_time and vim.uv and vim.uv.hrtime and (vim.uv.hrtime() - state.completed_time) > 2e9 then
      state.last_status = "Idle"
      return ""
    end
    return state.last_status
  end
  return state.last_status ~= "Idle" and state.last_status or ""
end

vim.api.nvim_create_autocmd("User", {
  pattern = {
    "CodeCompanionRequestStarted",
    "CodeCompanionRequestStreaming",
    "CodeCompanionRequestFinished",
    "CodeCompanionRequestError",
    "CodeCompanionRequestCancelled",
  },
  callback = function(args)
    if args.match then
      M.update_status(args.match)
    end
  end,
})

return M.component