fix(git): missing files in context module

Author: Danilo Verde Ribeiro

lua/opencode/context.lua

@@ -23,17 +23,17 @@ local function filter_path_privacy(path)
   if not path or path == '' then
     return path
   end
-  
+
   -- Check if privacy filtering is enabled in config
   if config.context and config.context.privacy_filter and config.context.privacy_filter.enabled == false then
     return path
   end
-  
+
   -- If path is within project, return as-is
   if is_in_cwd(path) then
     return path
   end
-  
+
   -- Redact paths outside project root
   local basename = vim.fn.fnamemodify(path, ':t')
   return '[EXTERNAL]/' .. basename
@@ -44,12 +44,12 @@ local function contains_secret(content)
   if not content or content == '' then
     return false
   end
-  
+
   -- Check if secret filtering is enabled in config
   if config.context and config.context.secret_filter and config.context.secret_filter.enabled == false then
     return false
   end
-  
+
   -- Common secret patterns
   local secret_patterns = {
     -- API keys and tokens (long alphanumeric strings)
@@ -65,13 +65,13 @@ local function contains_secret(content)
     -- Private keys
     '%-%-%-%-%-BEGIN [%w%s]+ PRIVATE KEY%-%-%-%-%-',
   }
-  
+
   for _, pattern in ipairs(secret_patterns) do
     if content:match(pattern) then
       return true
     end
   end
-  
+
   return false
 end
 
@@ -351,20 +351,20 @@ function M.get_current_file()
   if not file or file == '' or vim.fn.filereadable(file) ~= 1 then
     return nil
   end
-  
+
   local bufnr = vim.api.nvim_get_current_buf()
   local result = {
     path = filter_path_privacy(file),
     name = vim.fn.fnamemodify(file, ':t'),
     extension = vim.fn.fnamemodify(file, ':e'),
   }
-  
+
   -- Add filetype if available
   local filetype = vim.bo[bufnr].filetype
   if filetype and filetype ~= '' then
     result.filetype = filetype
   end
-  
+
   -- Add LSP client names if available
   local clients = vim.lsp.get_active_clients({ bufnr = bufnr })
   if #clients > 0 then
@@ -373,7 +373,7 @@ function M.get_current_file()
       table.insert(result.lsp_clients, client.name)
     end
   end
-  
+
   return result
 end
 
@@ -529,7 +529,7 @@ function M.get_undo_history()
   -- Check if current buffer has unsaved changes
   local bufnr = vim.api.nvim_get_current_buf()
   local has_unsaved_changes = vim.bo[bufnr].modified
-  
+
   -- Count total unsaved changes across all buffers
   local unsaved_buffers = {}
   for _, buf in ipairs(vim.api.nvim_list_bufs()) do
@@ -544,12 +544,14 @@ function M.get_undo_history()
     end
   end
 
-  return #result > 0 and {
-    entries = result,
-    seq_cur = undotree.seq_cur,
-    current_buffer_modified = has_unsaved_changes,
-    unsaved_buffers = #unsaved_buffers > 0 and unsaved_buffers or nil,
-  } or nil
+  return #result > 0
+      and {
+        entries = result,
+        seq_cur = undotree.seq_cur,
+        current_buffer_modified = has_unsaved_changes,
+        unsaved_buffers = #unsaved_buffers > 0 and unsaved_buffers or nil,
+      }
+    or nil
 end
 
 -- Get window and tab context
@@ -909,27 +911,27 @@ function M.get_git_info()
   local status_ok, status = pcall(vim.fn.systemlist, 'git status --porcelain 2>/dev/null')
   if status_ok and status then
     result.is_dirty = #status > 0
-    
+
     -- Count staged and unstaged changes
     local staged_count = 0
     local unstaged_count = 0
     for _, line in ipairs(status) do
       if line and line ~= '' then
         local index_status = line:sub(1, 1)
         local work_status = line:sub(2, 2)
-        
+
         -- Staged changes (index column not space or ?)
         if index_status ~= ' ' and index_status ~= '?' then
           staged_count = staged_count + 1
         end
-        
+
         -- Unstaged changes (work tree column not space)
         if work_status ~= ' ' then
           unstaged_count = unstaged_count + 1
         end
       end
     end
-    
+
     if staged_count > 0 then
       result.staged_changes = staged_count
     end
@@ -1616,37 +1618,37 @@ function M.get_recent_buffers(prompt, opts)
         lastused = buf.lastused,
         changed = buf.changed == 1,
       }
-      
+
       -- Add filetype if available (only for valid buffers)
       if vim.api.nvim_buf_is_valid(buf.bufnr) then
         local filetype = vim.bo[buf.bufnr].filetype
         if filetype and filetype ~= '' then
           buf_entry.filetype = filetype
         end
-        
+
         -- Add LSP client names if available
         local clients = vim.lsp.get_active_clients({ bufnr = buf.bufnr })
         if #clients > 0 then
           buf_entry.lsp_clients = {}
           for _, client in ipairs(clients) do
-          table.insert(buf_entry.lsp_clients, client.name)
+            table.insert(buf_entry.lsp_clients, client.name)
+          end
         end
       end
-      end
-      
+
       table.insert(result, buf_entry)
     end
 
     local recent_conf = config.context.recent_buffers
     if recent_conf and recent_conf.symbols_only then
       for _, buf_entry in ipairs(result) do
         local bufnr = buf_entry.bufnr
-        
+
         -- Skip if buffer is not valid
         if not vim.api.nvim_buf_is_valid(bufnr) then
           goto continue
         end
-        
+
         local line_count = vim.api.nvim_buf_line_count(bufnr)
         if line_count <= 100 then
           goto continue

lua/opencode/context_cache.lua

@@ -0,0 +1,200 @@
+-- TTL-based cache for context sections
+-- Provides per-section caching with configurable TTL and async job management
+--
+
+local M = {}
+
+-- Cache structure: { [section_name] = { timestamp = number, data = any, job_id = number|nil } }
+M.cache = {}
+
+-- Default TTL in milliseconds (5 seconds)
+M.DEFAULT_TTL = 5000
+
+-- Async job tracking
+M.jobs = {}
+
+---Check if cached data is still valid
+---@param section_name string
+---@param ttl? number TTL in milliseconds (defaults to DEFAULT_TTL)
+---@return boolean
+function M.is_valid(section_name, ttl)
+  ttl = ttl or M.DEFAULT_TTL
+  local cached = M.cache[section_name]
+  if not cached then
+    return false
+  end
+
+  local now = vim.loop.hrtime() / 1e6 -- Convert to milliseconds
+  return (now - cached.timestamp) < ttl
+end
+
+---Get cached data if valid
+---@param section_name string
+---@param ttl? number TTL in milliseconds
+---@return any|nil
+function M.get(section_name, ttl)
+  if M.is_valid(section_name, ttl) then
+    return M.cache[section_name].data
+  end
+  return nil
+end
+
+---Set cached data
+---@param section_name string
+---@param data any
+function M.set(section_name, data)
+  local now = vim.loop.hrtime() / 1e6
+  M.cache[section_name] = {
+    timestamp = now,
+    data = data,
+    job_id = nil,
+  }
+end
+
+---Clear specific cache entry
+---@param section_name string
+function M.clear(section_name)
+  M.cache[section_name] = nil
+end
+
+---Clear all cache
+function M.clear_all()
+  M.cache = {}
+  M.jobs = {}
+end
+
+---Start async job for expensive operation
+---@param section_name string
+---@param cmd string|table Command to execute
+---@param callback function(data: any) Called with result
+---@param opts? table Options: { timeout: number, on_error: function }
+function M.start_job(section_name, cmd, callback, opts)
+  opts = opts or {}
+  local timeout = opts.timeout or 5000
+
+  -- Cancel existing job if any
+  if M.jobs[section_name] then
+    vim.fn.jobstop(M.jobs[section_name])
+  end
+
+  local output = {}
+  local job_id = vim.fn.jobstart(cmd, {
+    stdout_buffered = true,
+    stderr_buffered = true,
+    on_stdout = function(_, data)
+      if data then
+        vim.list_extend(output, data)
+      end
+    end,
+    on_stderr = function(_, data)
+      if opts.on_error and data and #data > 0 then
+        opts.on_error(data)
+      end
+    end,
+    on_exit = function(_, exit_code)
+      M.jobs[section_name] = nil
+      if exit_code == 0 then
+        local result = table.concat(output, '\n')
+        callback(result)
+      elseif opts.on_error then
+        opts.on_error({ 'Job failed with exit code: ' .. exit_code })
+      end
+    end,
+  })
+
+  M.jobs[section_name] = job_id
+
+  -- Set timeout
+  vim.defer_fn(function()
+    if M.jobs[section_name] == job_id then
+      vim.fn.jobstop(job_id)
+      M.jobs[section_name] = nil
+      if opts.on_error then
+        opts.on_error({ 'Job timeout after ' .. timeout .. 'ms' })
+      end
+    end
+  end, timeout)
+
+  return job_id
+end
+
+---Execute multiple jobs in parallel and call callback when all complete
+---@param tasks table[] Array of { name: string, cmd: string|table, ttl?: number }
+---@param callback function(results: table) Called with { [name] = data }
+---@param opts? table Options: { timeout: number }
+function M.parallel(tasks, callback, opts)
+  opts = opts or {}
+  local results = {}
+  local pending = #tasks
+  local completed = false
+
+  if pending == 0 then
+    callback(results)
+    return
+  end
+
+  for _, task in ipairs(tasks) do
+    local name = task.name
+
+    -- Check cache first
+    local cached = M.get(name, task.ttl)
+    if cached then
+      results[name] = cached
+      pending = pending - 1
+      if pending == 0 and not completed then
+        completed = true
+        vim.schedule(function()
+          callback(results)
+        end)
+      end
+    else
+      -- Start async job
+      M.start_job(name, task.cmd, function(data)
+        results[name] = data
+        M.set(name, data)
+        pending = pending - 1
+
+        if pending == 0 and not completed then
+          completed = true
+          vim.schedule(function()
+            callback(results)
+          end)
+        end
+      end, {
+        timeout = opts.timeout or 3000,
+        on_error = function(err)
+          results[name] = nil
+          pending = pending - 1
+
+          if pending == 0 and not completed then
+            completed = true
+            vim.schedule(function()
+              callback(results)
+            end)
+          end
+        end,
+      })
+    end
+  end
+end
+
+---Get cache statistics
+---@return table { total: number, by_section: table }
+function M.stats()
+  local stats = { total = 0, by_section = {} }
+  local now = vim.loop.hrtime() / 1e6
+
+  for section, cached in pairs(M.cache) do
+    local age = now - cached.timestamp
+    stats.by_section[section] = {
+      age_ms = age,
+      valid = age < M.DEFAULT_TTL,
+      has_data = cached.data ~= nil,
+    }
+    stats.total = stats.total + 1
+  end
+
+  return stats
+end
+
+return M