feat(chat): add plan fold for outputting the current state of plans

fix: update icons

fix: update as dump renderer

fix: .

fix: update api

fix: update api

Author: cenk1cenk2

lua/codecompanion/interactions/chat/acp/handler.lua

@@ -174,6 +174,9 @@ function ACPHandler:create_and_send_prompt(payload)
     :on_thought_chunk(function(content)
       self:handle_thought_chunk(content)
     end)
+    :on_plan(function(entries)
+      self:handle_plan(entries)
+    end)
     :on_tool_call(function(tool_call)
       self:process_tool_call(tool_call)
     end)
@@ -215,6 +218,20 @@ function ACPHandler:handle_thought_chunk(content)
   end
 end
 
+---Handle plan updates from the agent
+---@param entries table[] Array of plan entries with content, status, priority
+function ACPHandler:handle_plan(entries)
+  local lines = {}
+  for _, entry in ipairs(entries) do
+    table.insert(lines, entry.content or "Untitled")
+  end
+  local content = table.concat(lines, "\n")
+  self.chat:add_buf_message(
+    { role = config.constants.LLM_ROLE, content = content },
+    { type = self.chat.MESSAGE_TYPES.PLAN_MESSAGE, _plan_entries = entries }
+  )
+end
+
 ---Output tool call to the chat
 ---@param tool_call table
 ---@return nil

lua/codecompanion/interactions/chat/init.lua

@@ -344,6 +344,7 @@ local Chat = {}
 
 Chat.MESSAGE_TYPES = {
   LLM_MESSAGE = "llm_message",
+  PLAN_MESSAGE = "plan_message",
   REASONING_MESSAGE = "reasoning_message",
   SYSTEM_MESSAGE = "system_message",
   TOOL_MESSAGE = "tool_message",

lua/codecompanion/interactions/chat/ui/builder.lua

@@ -17,12 +17,74 @@
 local config = require("codecompanion.config")
 
 local Icons = require("codecompanion.interactions.chat.ui.icons")
+local Plan = require("codecompanion.interactions.chat.ui.formatters.plan")
 local Reasoning = require("codecompanion.interactions.chat.ui.formatters.reasoning")
 local Standard = require("codecompanion.interactions.chat.ui.formatters.standard")
 local Tools = require("codecompanion.interactions.chat.ui.formatters.tools")
 
 local api = vim.api
 
+---Resolve a tool status to its icon and highlight groups
+---Resolve a tool status to IconOpts
+---@param status string
+---@return CodeCompanion.Chat.UI.IconOpts
+local function resolve_tool_icon(status)
+  local icons = config.display.chat.icons
+  local map = {
+    pending = {
+      icon = icons.tool_pending,
+      icon_hl_group = "CodeCompanionChatToolPending",
+      line_hl_group = "CodeCompanionChatToolText",
+    },
+    in_progress = {
+      icon = icons.tool_in_progress,
+      icon_hl_group = "CodeCompanionChatToolInProgress",
+      line_hl_group = "CodeCompanionChatToolText",
+    },
+    completed = {
+      icon = icons.tool_success,
+      icon_hl_group = "CodeCompanionChatToolSuccessIcon",
+      line_hl_group = "CodeCompanionChatToolText",
+    },
+    failed = {
+      icon = icons.tool_failure,
+      icon_hl_group = "CodeCompanionChatToolFailureIcon",
+      line_hl_group = "CodeCompanionChatToolText",
+    },
+  }
+  return map[status] or map.pending
+end
+
+---Resolve a plan status to IconOpts
+---@param status string
+---@return CodeCompanion.Chat.UI.IconOpts
+local function resolve_plan_icon(status)
+  local icons = config.display.chat.icons
+  local map = {
+    pending = {
+      icon = icons.tool_pending,
+      icon_hl_group = "CodeCompanionChatToolPending",
+      line_hl_group = "CodeCompanionChatPlanPending",
+    },
+    in_progress = {
+      icon = icons.tool_in_progress,
+      icon_hl_group = "CodeCompanionChatToolInProgress",
+      line_hl_group = "CodeCompanionChatPlanInProgress",
+    },
+    completed = {
+      icon = icons.tool_success,
+      icon_hl_group = "CodeCompanionChatToolSuccessIcon",
+      line_hl_group = "CodeCompanionChatPlanCompleted",
+    },
+    failed = {
+      icon = icons.tool_failure,
+      icon_hl_group = "CodeCompanionChatToolFailureIcon",
+      line_hl_group = "CodeCompanionChatPlanFailed",
+    },
+  }
+  return map[status] or map.pending
+end
+
 local EPHEMERAL_STATE = {
   __index = {
     update_role = function(self, role)
@@ -32,9 +94,15 @@ local EPHEMERAL_STATE = {
     mark_reasoning_complete = function(self)
       self.has_reasoning_output = false
     end,
+    mark_plan_complete = function(self)
+      self.has_plan_output = false
+    end,
     mark_reasoning_started = function(self)
       self.has_reasoning_output = true
     end,
+    mark_plan_started = function(self)
+      self.has_plan_output = true
+    end,
     update_type = function(self, type)
       self.last_type = type
     end,
@@ -76,6 +144,7 @@ function Builder.new(args)
     state = {
       last_role = args.chat._last_role,
       last_type = nil,
+      has_plan_output = false,
       has_reasoning_output = false,
 
       -- Block tracking
@@ -99,6 +168,7 @@ function Builder.new(args)
     _formatters = {
       Tools:new(args.chat),
       Reasoning:new(args.chat),
+      Plan:new(args.chat),
       Standard:new(args.chat),
     },
     _fmt_state = setmetatable({}, EPHEMERAL_STATE),
@@ -114,6 +184,7 @@ local function create_state(out, base_state)
 
   state.last_role = base_state.last_role
   state.last_type = base_state.last_type
+  state.has_plan_output = base_state.has_plan_output
   state.has_reasoning_output = base_state.has_reasoning_output
 
   -- Block tracking
@@ -194,6 +265,11 @@ function Builder:add_message(data, opts)
   if opts._icon_info and opts._icon_info.has_icon and pre_content_lines > 0 then
     opts._icon_info.line_offset = (opts._icon_info.line_offset or 0) + pre_content_lines
   end
+  if opts._plan_icons and pre_content_lines > 0 then
+    for _, entry in ipairs(opts._plan_icons) do
+      entry.line_offset = (entry.line_offset or 0) + pre_content_lines
+    end
+  end
 
   local insert_line, icon_id
   if not vim.tbl_isempty(lines) then
@@ -288,9 +364,19 @@ function Builder:_write_to_buffer(lines, opts)
   local icon_id
   if opts._icon_info and opts._icon_info.has_icon then
     local target_line = insert_line + (opts._icon_info.line_offset or 0)
-    icon_id = Icons.apply(self.chat.bufnr, target_line, opts._icon_info.status, {
-      virt_text_pos = opts.virt_text_pos,
-    })
+    local icon_opts = resolve_tool_icon(opts._icon_info.status)
+    icon_opts.virt_text_pos = opts.virt_text_pos
+    icon_id = Icons.apply(self.chat.bufnr, target_line, icon_opts)
+  end
+
+  -- Plan entry icons
+  if opts._plan_icons then
+    for _, entry in ipairs(opts._plan_icons) do
+      local target_line = insert_line + (entry.line_offset or 0)
+      local icon_opts = resolve_plan_icon(entry.status)
+      icon_opts.virt_text_pos = "inline"
+      Icons.apply(self.chat.bufnr, target_line, icon_opts)
+    end
   end
 
   -- Record write bounds
@@ -323,6 +409,15 @@ function Builder:_write_to_buffer(lines, opts)
     end)
   end
 
+  -- Plan folds
+  if self.state.has_plan_output and not state.has_plan_output and config.display.chat.fold_reasoning then
+    local range_start = self.state.current_section_start or 0
+    local range_end = insert_line
+    vim.schedule(function()
+      self.chat.ui.folds:create_plan_fold(self.chat, range_start, range_end)
+    end)
+  end
+
   if state.last_role ~= config.constants.USER_ROLE then
     self.chat.ui:lock_buf()
   end
@@ -335,6 +430,7 @@ end
 ---Sync formatting state back to builder's persistent state
 ---@param state table
 function Builder:_sync_state_from_formatting_state(state)
+  self.state.has_plan_output = state.has_plan_output
   self.state.has_reasoning_output = state.has_reasoning_output
   self.state.last_role = state.last_role
   self.state.last_type = state.last_type
@@ -382,7 +478,10 @@ function Builder:update_line(line_number, content, opts)
     end
     -- Also clear by line range as a safety net
     Icons.clear_line(self.chat.bufnr, start_line)
-    new_icon_id = Icons.apply(self.chat.bufnr, start_line, opts.status, opts)
+    local icon_opts = resolve_tool_icon(opts.status)
+    icon_opts.priority = opts.priority
+    icon_opts.virt_text_pos = opts.virt_text_pos
+    new_icon_id = Icons.apply(self.chat.bufnr, start_line, icon_opts)
   end
 
   if self.state.last_role ~= config.constants.USER_ROLE then

lua/codecompanion/interactions/chat/ui/folds.lua

@@ -9,15 +9,16 @@ local Folds = {}
 local CONSTANTS = {
   NS_FOLD_TOOLS = api.nvim_create_namespace("CodeCompanion-tool_fold_marks"),
   NS_FOLD_CONTEXT = api.nvim_create_namespace("CodeCompanion-context_fold_marks"),
+  NS_FOLD_PLAN = api.nvim_create_namespace("CodeCompanion-plan_fold_marks"),
   NS_FOLD_REASONING = api.nvim_create_namespace("CodeCompanion-reasoning_fold_marks"),
 }
 
 -- Unified fold summaries storage
----@type table<number, table<number, { content: string, type: "tool"|"context"|"reasoning" }>>
+---@type table<number, table<number, { content: string, type: "tool"|"context"|"plan"|"reasoning" }>>
 Folds.fold_summaries = {}
 
 ---@class CodeCompanion.Chat.UI.FoldConfig
----@field type "tool"|"context"|"reasoning"
+---@field type "tool"|"context"|"plan"|"reasoning"
 ---@field content string
 ---@field success_keywords? string[]
 ---@field failure_keywords? string[]
@@ -57,7 +58,7 @@ end
 
 ---Format fold text based on type
 ---@param content string
----@param fold_type "tool"|"context"|"reasoning"
+---@param fold_type "tool"|"context"|"reasoning"|"plan"
 ---@param opts? table
 ---@return table[]
 function Folds._format_fold_text(content, fold_type, opts)
@@ -88,7 +89,7 @@ function Folds._format_fold_text(content, fold_type, opts)
     if not opts.show_icon_only then
       table.insert(chunks, { content, "CodeCompanionChatContext" })
     end
-  elseif fold_type == "reasoning" then
+  elseif fold_type == "reasoning" or fold_type == "plan" then
     table.insert(chunks, { content, "CodeCompanionChatFold" })
   end
 
@@ -184,6 +185,8 @@ function Folds:recreate(bufnr, start_row, end_row, fold_config)
     ns = CONSTANTS.NS_FOLD_TOOLS
   elseif fold_config.type == "context" then
     ns = CONSTANTS.NS_FOLD_CONTEXT
+  elseif fold_config.type == "plan" then
+    ns = CONSTANTS.NS_FOLD_PLAN
   elseif fold_config.type == "reasoning" then
     ns = CONSTANTS.NS_FOLD_REASONING
   end
@@ -311,6 +314,74 @@ function Folds:create_reasoning_fold(chat, start_row, end_row)
   })
 end
 
+---Fold the most recent plan section in the chat buffer
+---@param chat CodeCompanion.Chat
+---@param start_row number (0-based)
+---@param end_row number (0-based)
+---@return nil
+function Folds:create_plan_fold(chat, start_row, end_row)
+  if not config.display.chat.fold_reasoning then
+    return
+  end
+
+  local summary_text = "  " .. config.display.chat.icons.chat_fold .. " ..."
+
+  local bufnr = chat.bufnr
+  local parser = chat.chat_parser
+  if not (bufnr and parser) then
+    return
+  end
+
+  local ok, query = pcall(
+    vim.treesitter.query.parse,
+    "markdown",
+    [[
+    (section
+      (atx_heading
+        (atx_h3_marker)
+        heading_content: (_) @block_name
+      )
+      (#eq? @block_name "Plan")
+    ) @plan
+  ]]
+  )
+  if not ok or not query then
+    return
+  end
+
+  local tree = parser:parse({ start_row, end_row })[1]
+  if not tree then
+    return
+  end
+  local root = tree:root()
+
+  local latest_node, latest_range = nil, -1
+  for id, node in query:iter_captures(root, bufnr, start_row, end_row) do
+    if query.captures[id] == "plan" then
+      local range = node:range()
+      if range >= latest_range then
+        latest_node, latest_range = node, range
+      end
+    end
+  end
+  if not latest_node then
+    return
+  end
+
+  local range, _, er = latest_node:range()
+  local fold_start = range + 1
+  local fold_end = math.max(fold_start, er - 1)
+
+  if fold_start >= fold_end then
+    return
+  end
+
+  self:recreate(bufnr, fold_start, fold_end, {
+    type = "plan",
+    content = summary_text,
+  })
+end
+
 ---Clean up fold data for a buffer
 ---@param bufnr number
 function Folds:cleanup(bufnr)

lua/codecompanion/interactions/chat/ui/formatters/plan.lua

@@ -0,0 +1,48 @@
+local BaseFormatter = require("codecompanion.interactions.chat.ui.formatters.base")
+
+---@class CodeCompanion.Chat.UI.Formatters.Plan : CodeCompanion.Chat.UI.Formatters.Base
+local Plan = setmetatable({}, { __index = BaseFormatter })
+Plan.__class = "Plan"
+
+function Plan:can_handle(message, opts, tags)
+  return opts and opts.type == tags.PLAN_MESSAGE
+end
+
+function Plan:get_type()
+  return self.chat.MESSAGE_TYPES.PLAN_MESSAGE
+end
+
+function Plan:format(message, opts, state)
+  local lines = {}
+
+  if state.is_new_block and state.block_index > 0 then
+    table.insert(lines, "")
+    table.insert(lines, "")
+  end
+
+  if not state.has_plan_output then
+    table.insert(lines, "### Plan")
+    table.insert(lines, "")
+    state:mark_plan_started()
+  end
+
+  local content_start = #lines
+  for _, line in ipairs(vim.split(message.content, "\n", { plain = true, trimempty = false })) do
+    table.insert(lines, line)
+  end
+
+  if opts._plan_entries then
+    local plan_icons = {}
+    for i, entry in ipairs(opts._plan_entries) do
+      table.insert(plan_icons, {
+        line_offset = content_start + (i - 1),
+        status = entry.status or "pending",
+      })
+    end
+    opts._plan_icons = plan_icons
+  end
+
+  return lines, nil
+end
+
+return Plan