Fidget/status updates

[schilkp]

Here is a simple integration with fidget.nvim[1] for progress reporting:

example.mp4

Currently this uses fidget's API directly. I did not look into this but there may also be a nvim-level API for LSP progress reporting, which potentially would allow for support for other status/notification plugins.

Please let me know if you want this somewhere (As an example, or integrated) - happy to PR.

local M = {}


function M.start_fidget()
    local has_fidget, fidget = pcall(require, "fidget")
    if not has_fidget then
        return
    end

    if M.fidget_progress_handle then
        M.fidget_progress_handle.message = "Abort."
        M.fidget_progress_handle:cancel()
        M.fidget_progress_handle = nil
    end

    M.fidget_progress_handle = fidget.progress.handle.create({
        title = "",
        message = "Thinking...",
        lsp_client = { name = "CodeCompanion" },
    })
end

function M.stop_fidget()
    local has_fidget, _ = pcall(require, "fidget")
    if not has_fidget then
        return
    end

    if M.fidget_progress_handle then
        M.fidget_progress_handle.message = "Done."
        M.fidget_progress_handle:finish()
        M.fidget_progress_handle = nil
    end
end

function M.setup_fidget()
    local has_fidget, _ = pcall(require, "fidget")
    if has_fidget then
        -- New AU group:
        local group = vim.api.nvim_create_augroup("CodeCompanionHooks", {})

        -- Attach:
        vim.api.nvim_create_autocmd({ "User" }, {
            pattern = "CodeCompanionRequest*",
            group = group,
            callback = function(request)
                if request.match == "CodeCompanionRequestStarted" then
                    M.start_req_fidget()
                elseif request.match == "CodeCompanionRequestFinished" then
                    M.stop_req_fidget()
                end
            end,
        })
    end
end

return M

[1] https://github.com/j-hui/fidget.nvim

[olimorris]

Awesome and thanks for sharing. That looks so clean.

I'm going to start labelling discussions so others can find them more easily.

[schilkp]

Would this make sense here?
https://codecompanion.olimorris.dev/usage/events.html

[olimorris]

I think I'm going to have a Community section in the docs site where one of the options is a UI page and I'll probably link to discussions such as these. That way people can interact with the OP's yet it gets the visibility of the doc site. What are your thoughts?

[schilkp]

Sure! Whatever you think makes sense :)

[S1M0N38]

A spinner indicating request status is a great addition, especially for non-streaming functionality. If you're considering adding this to codecompletion.nvim, I recommend checking out spinner.nvim

It's a single-file utility designed for easy integration into plugin codebases.

[petobens]

Hi! Sorry for chiming in but I do have a similar question request: in https://github.com/jackMort/ChatGPT.nvim there is a visual indicator that the LLM is "Loading...". Can a similar thing be added (is already present?) in code companion? In the following GIF you can see how ChatGPT.nvim does this loading reporting and then how CodeCompanion works (with no indicator):

I can open a separate issue @olimorris if this is not the place to discuss this.

[olimorris]

I probably need to do a PSA on the CodeCompanion UI at some point, like I did for adapters, yesterday.

The Neovim UI and what constitutes good or great or poor, from an aesthetic perspective, is purely subjective. That's why I never force that on the users. Instead, I've built a fairly flexible event/hook system that you're welcome to do what you like with. There's some great examples of integrations with Heirline and Lualine in the statusline and I urge users to get the plugin working how they like.

[olimorris]

And what I should say, if there are any events that are missing / stopping you from getting a good setup, let me know and I can add them in.

[petobens]

We now have events for when a request has started or finished, is it possible to create an event that signals when output starts streaming?

[petobens]

@olimorris something like CodeCompanionRequestOutput or similar. Basically I want to show a Loading ... message/spinner that disappears once the output starts streaming/showing up.

[bassamsdata]

Well, I’ve created something different for this: (focus on the cursor): it can be implemented as an opt-in feature for codecompanion.

Screen.Recording.2025-02-03.at.11.46.08.PM.mov

[olimorris]

Now @bassamsdata you can't show off a vid like that and not share all the code 😂. This looks unreal.

[bassamsdata]

Thank you, and my bad. I forgot to share the code because it was midnight :)

so here we go:

local M = {}

local ns_id = vim.api.nvim_create_namespace("spinner")

M.config = {
  spinner = {
    text = "",
    -- text = "",
    hl_positions = { 
      { 0, 3 }, -- First circle
      { 3, 6 }, -- Second circle
      { 6, 9 }, -- Third circle
    },
    interval = 100,
    hl_group = "Title",
    hl_dim_group = "NonText",
  },
}

local spinner_state = {
  timer = nil,
  win = nil,
  buf = nil,
  frame = 1,
}

local function create_spinner_window()
  local buf = vim.api.nvim_create_buf(false, true)
  vim.api.nvim_set_option_value("bufhidden", "wipe", { buf = buf })

  local win = vim.api.nvim_open_win(buf, false, {
    relative = "cursor",
    row = -1,
    col = 0,
    width = 3,
    height = 1,
    style = "minimal",
    focusable = false,
  })

  vim.api.nvim_buf_set_lines(buf, 0, -1, false, { M.config.spinner.text })

  -- Set the dim highlight for the entire text
  vim.api.nvim_buf_set_extmark(buf, ns_id, 0, 0, {
    end_col = 9,
    hl_group = M.config.spinner.hl_dim_group,
    priority = vim.highlight.priorities.user - 1,
  })

  return buf, win, ns_id
end

function M.start_spinner()
  if spinner_state.timer then
    return
  end

  local buf, win = create_spinner_window()
  spinner_state.buf = buf
  spinner_state.win = win

  spinner_state.timer = vim.loop.new_timer()
  spinner_state.timer:start(
    0,
    M.config.spinner.interval,
    vim.schedule_wrap(function()
      if
        spinner_state.win == nil
        or spinner_state.buf == nil
        or not (
          vim.api.nvim_win_is_valid(spinner_state.win)
          and vim.api.nvim_buf_is_valid(spinner_state.buf)
        )
      then
        M.stop_spinner()
        return
      end

      -- Update window position relative to cursor
      local ok = pcall(vim.api.nvim_win_set_config, spinner_state.win, {
        relative = "cursor",
        row = -1,
        col = 0,
      })

      -- If window update failed, stop the spinner
      if not ok then
        M.stop_spinner()
        return
      end
      vim.api.nvim_buf_clear_namespace(spinner_state.buf, ns_id, 0, -1)

      vim.api.nvim_buf_set_extmark(spinner_state.buf, ns_id, 0, 0, {
        end_col = 9,
        hl_group = M.config.spinner.hl_dim_group,
        priority = vim.highlight.priorities.user - 1,
      })

      -- Set animation highlight
      local hl_pos = M.config.spinner.hl_positions[spinner_state.frame]
      vim.api.nvim_buf_set_extmark(spinner_state.buf, ns_id, 0, hl_pos[1], {
        end_col = hl_pos[2],
        hl_group = M.config.spinner.hl_group,
        priority = vim.highlight.priorities.user + 1,
      })

      spinner_state.frame = (spinner_state.frame % #M.config.spinner.hl_positions) + 1
    end)
  )
end

function M.stop_spinner()
  if spinner_state.timer then
    spinner_state.timer:stop()
    spinner_state.timer:close()
    spinner_state.timer = nil
  end

  -- safely close the window if it exists and is valid
  if spinner_state.win then
    pcall(vim.api.nvim_win_close, spinner_state.win, true)
    spinner_state.win = nil
  end

  if spinner_state.buf then
    pcall(vim.api.nvim_buf_delete, spinner_state.buf, { force = true })
    spinner_state.buf = nil
  end
  spinner_state.frame = 1
end

vim.api.nvim_create_autocmd("User", {
  pattern = {
    "CodeCompanionRequestStarted",
    "CodeCompanionRequestFinished",
  },
  callback = function(args)
    if args.match == "CodeCompanionRequestStarted" then
      M.start_spinner()
    elseif args.match == "CodeCompanionRequestFinished" then
      M.stop_spinner()
    end
  end,
})

return M

[olimorris]

Damn that's clean! I'll add that to the docs later

[jessevdp]

Damn that looks sick!!

[schilkp]

Hi All!

In case you have not seen this @olimorris, there is now a tracking issue in neovim for implementing primitives used by plugins such as this one: neovim/neovim#32084

It specifically mentions an nvim api for status/progress notifications, hence it might be relevant here. Also if you have anything that you might find useful, that might be a good place to chime in :)

[yuhua99]

Hi everyone,
I’ve put together a new style of status update that leverages Vim’s built‑in virt_lines—no extra plugins required—and I’d love to share it with you all.

6/9 Update
Thanks to @carried-away for pointing out that the incorrect order of chat:add_buf_message and chat:submit could cause #ref breaking.
I've updated the code below.

spinner.lua

local M = {
  processing = false,
  spinner_index = 1,
  namespace_id = nil,
  timer = nil,
  spinner_symbols = {
    "⠋",
    "⠙",
    "⠹",
    "⠸",
    "⠼",
    "⠴",
    "⠦",
    "⠧",
    "⠇",
    "⠏",
  },
  filetype = "codecompanion",
}

function M:get_buf(filetype)
  for _, buf in ipairs(vim.api.nvim_list_bufs()) do
    if vim.api.nvim_buf_is_valid(buf) and vim.bo[buf].filetype == filetype then
      return buf
    end
  end
  return nil
end

function M:update_spinner()
  if not self.processing then
    self:stop_spinner()
    return
  end

  self.spinner_index = (self.spinner_index % #self.spinner_symbols) + 1

  local buf = self:get_buf(self.filetype)
  if buf == nil then
    return
  end

  -- Clear previous virtual text
  vim.api.nvim_buf_clear_namespace(buf, self.namespace_id, 0, -1)

  local last_line = vim.api.nvim_buf_line_count(buf) - 1
  vim.api.nvim_buf_set_extmark(buf, self.namespace_id, last_line, 0, {
    virt_lines = { { { self.spinner_symbols[self.spinner_index] .. " Processing...", "Comment" } } },
    virt_lines_above = true, -- false means below the line
  })
end

function M:start_spinner()
  self.processing = true
  self.spinner_index = 0

  if self.timer then
    self.timer:stop()
    self.timer:close()
    self.timer = nil
  end

  self.timer = vim.loop.new_timer()
  self.timer:start(
    0,
    100,
    vim.schedule_wrap(function()
      self:update_spinner()
    end)
  )
end

function M:stop_spinner()
  self.processing = false

  if self.timer then
    self.timer:stop()
    self.timer:close()
    self.timer = nil
  end

  local buf = self:get_buf(self.filetype)
  if buf == nil then
    return
  end

  vim.api.nvim_buf_clear_namespace(buf, self.namespace_id, 0, -1)
end

function M:init()
  -- Create namespace for virtual text
  self.namespace_id = vim.api.nvim_create_namespace("CodeCompanionSpinner")

  vim.api.nvim_create_augroup("CodeCompanionHooks", { clear = true })
  local group = vim.api.nvim_create_augroup("CodeCompanionHooks", {})

  vim.api.nvim_create_autocmd({ "User" }, {
    pattern = "CodeCompanionRequest*",
    group = group,
    callback = function(request)
      if request.match == "CodeCompanionRequestStarted" then
        self:start_spinner()
      elseif request.match == "CodeCompanionRequestFinished" then
        self:stop_spinner()
      end
    end,
  })
end

return M

and modify the send commend

            send = {
              callback = function(chat)
                vim.cmd("stopinsert")
                chat:submit()
                chat:add_buf_message({ role = "llm", content = "" })
              end,
              index = 1,
              description = "Send",
            },

init the spinner in config

    config = function(_, opts)
      local spinner = require("plugins.code-companion.spinner")
      spinner:init()

      -- Setup the entire opts table
      require("codecompanion").setup(opts)
    end,

[olimorris]

That is beautiful! Thanks for sharing. I'll be sure to include that in the docs 👏🏼

[kuznetsss]

This looks great! Maybe it could be included in the codecompanion under option? Currently it is a bit unclear when request is sent and model is processing it.

[carried-away]

just a heads up, i had to switch the order to

chat:submit()
chat:add_buf_message({ role = "llm", content = "" })

or else # references like #buffer wouldn't get picked up. I assume its because the llm is returning a blank line prior to submit, so all that gets skipped

Thank you @yuhua99 for the inline function and thank you @olimorris for the plugin!

[taketwo]

I've used this for a while, but came to the conclusion that a spinner in statusline is more convenient. But anyhow, what I decided to keep from the above snippet is the send command customization that does stopinsert. I've realized that it always bothered me that CodeCompanion lets the LLM output be streamed while keeping buffer in insert mode. This resulted e.g. in nvim-cmp displaying autocompletion popups all the time. With automatic stopinsert on send, this does not happen anymore.

I'd prefer if I did not need to override the callback, though. @olimorris would you be open to adding an option to control this behavior? Or maybe even go for unconditional stopinsert, always?

[franco-ruggeri]

Hi all, I extended the code above from @yuhua99 to handle parallel requests in multiple chats and wrapped it into a plugin called codecompanion-spinner to simplify the usage for other users. I hope it is useful for someone!

[franco-ruggeri]

Update: now codecompanion-spinner can be used as an extension.

{
    "olimorris/codecompanion.nvim",
    dependencies = {
        { "nvim-lua/plenary.nvim", version = false },
        "franco-ruggeri/codecompanion-spinner.nvim",
    },
    opts = {
        extensions = {
            spinner = {},
        },
    },
}