WIP: remove path/project info from session

Author: sudo-tee

lua/opencode/config_file.lua

@@ -23,21 +23,33 @@ function M.get_opencode_config()
 end
 
 ---@return OpencodeProject|nil
-function M.get_opencode_project()
+M.get_opencode_project = Promise.async_wrap(function()
   if not M.project_promise then
     local state = require('opencode.state')
     M.project_promise = state.api_client:get_current_project()
   end
   local ok, result = pcall(function()
-    return M.project_promise:wait()
+    return M.project_promise:await()
   end)
   if not ok then
     vim.notify('Error fetching Opencode project: ' .. vim.inspect(result), vim.log.levels.ERROR)
     return nil
   end
 
   return result --[[@as OpencodeProject|nil]]
-end
+end)
+
+---Get the snapshot storage path for the current workspace
+---@return string
+M.get_workspace_snapshot_path = Promise.async_wrap(function()
+  local project = M.get_opencode_project():await()
+  if not project then
+    vim.notify('No OpenCode project found in the current directory', vim.log.levels.ERROR)
+    return ''
+  end
+  local home = vim.uv.os_homedir()
+  return home .. '/.local/share/opencode/snapshot/' .. project_id
+end)
 
 ---@return OpencodeProvidersResponse|nil
 function M.get_opencode_providers()

lua/opencode/core.lua

@@ -14,19 +14,21 @@ M._abort_count = 0
 
 ---@param parent_id string?
 function M.select_session(parent_id)
-  local all_sessions = session.get_all_workspace_sessions() or {}
-  local filtered_sessions = vim.tbl_filter(function(s)
-    return s.title ~= '' and s ~= nil and s.parentID == parent_id
-  end, all_sessions)
+  session.get_all_workspace_sessions():and_then(function(all_sessions)
+    all_sessions = all_sessions or {}
+    local filtered_sessions = vim.tbl_filter(function(s)
+      return s.title ~= '' and s ~= nil and s.parentID == parent_id
+    end, all_sessions)
 
-  ui.select_session(filtered_sessions, function(selected_session)
-    if not selected_session then
-      if state.windows then
-        ui.focus_input()
+    ui.select_session(filtered_sessions, function(selected_session)
+      if not selected_session then
+        if state.windows then
+          ui.focus_input()
+        end
+        return
       end
-      return
-    end
-    M.switch_session(selected_session.id)
+      M.switch_session(selected_session.id)
+    end)
   end)
 end
 
@@ -94,10 +96,12 @@ function M.open(opts)
           state.active_session = M.create_new_session()
         else
           if not state.active_session then
-            state.active_session = session.get_last_workspace_session()
-            if not state.active_session then
-              state.active_session = M.create_new_session()
-            end
+            session.get_last_workspace_session():and_then(function(last_session)
+              state.active_session = last_session
+              if not state.active_session then
+                state.active_session = M.create_new_session()
+              end
+            end)
           else
             if not state.display_route and are_windows_closed then
               -- We're not displaying /help or something like that but we have an active session
@@ -408,16 +412,18 @@ end
 
 function M._on_user_message_count_change(_, new, old)
   if config.hooks and config.hooks.on_done_thinking then
-    local all_sessions = session.get_all_workspace_sessions() or {}
-    local done_sessions = vim.tbl_filter(function(s)
-      local msg_count = new[s.id] or 0
-      local old_msg_count = (old and old[s.id]) or 0
-      return msg_count == 0 and old_msg_count > 0
-    end, all_sessions)
-
-    for _, done_session in ipairs(done_sessions) do
-      pcall(config.hooks.on_done_thinking, done_session)
-    end
+    session.get_all_workspace_sessions():and_then(function(all_sessions)
+      all_sessions = all_sessions or {}
+      local done_sessions = vim.tbl_filter(function(s)
+        local msg_count = new[s.id] or 0
+        local old_msg_count = (old and old[s.id]) or 0
+        return msg_count == 0 and old_msg_count > 0
+      end, all_sessions)
+
+      for _, done_session in ipairs(done_sessions) do
+        pcall(config.hooks.on_done_thinking, done_session)
+      end
+    end)
   end
 end
 

lua/opencode/git_review.lua

@@ -4,19 +4,19 @@ local snapshot = require('opencode.snapshot')
 local diff_tab = require('opencode.ui.diff_tab')
 local utils = require('opencode.util')
 local session = require('opencode.session')
+local config_file = require('opencode.config_file')
 
 local M = {}
 
 ---@param cmd_args string[]
 ---@param opts? vim.SystemOpts
 ---@return string|nil, string|nil
 local function snapshot_git(cmd_args, opts)
-  local snapshot_dir = state.active_session and state.active_session.snapshot_path
-  if not snapshot_dir then
+  if not M.__snapshot_path then
     vim.notify('No snapshot path for the active session.')
     return nil, nil
   end
-  local args = { 'git', '-C', snapshot_dir }
+  local args = { 'git', '-C', M.__snapshot_path }
   vim.list_extend(args, cmd_args)
   local result = vim.system(args, opts or {}):wait()
   if result and result.code == 0 then
@@ -26,6 +26,7 @@ local function snapshot_git(cmd_args, opts)
   end
 end
 
+M.__snapshot_path = nil
 M.__changed_files = nil
 M.__current_file_index = nil
 M.__diff_tab = nil
@@ -76,11 +77,13 @@ local function require_git_project(fn, silent)
       end
       return
     end
-    if not state.active_session.snapshot_path or vim.fn.isdirectory(state.active_session.snapshot_path) == 0 then
-      if not silent then
+    if not M.__snapshot_path then
+      M.__snapshot_path = config_file.get_workspace_snapshot_path():wait()
+      if vim.fn.isdirectory(M.__snapshot_path) == 0 and not silent then
         vim.notify('Error: No snapshot path for the active session.')
+      else
+        return
       end
-      return
     end
     return fn(...)
   end

lua/opencode/promise.lua

@@ -7,14 +7,30 @@
 ---@field wait fun(self: self, timeout?: integer, interval?: integer): any
 ---@field is_resolved fun(self: self): boolean
 ---@field is_rejected fun(self: self): boolean
+---@field await fun(self: self): any
 ---@field _resolved boolean
 ---@field _value any
 ---@field _error any
 ---@field _then_callbacks fun(value: any)[]
 ---@field _catch_callbacks fun(err: any)[]
+---@field _coroutines thread[]
 local Promise = {}
 Promise.__index = Promise
 
+---Resume waiting coroutines with result
+---@param coroutines thread[]
+---@param value any
+---@param err any
+local function resume_coroutines(coroutines, value, err)
+  for _, co in ipairs(coroutines) do
+    vim.schedule(function()
+      if coroutine.status(co) == 'suspended' then
+        coroutine.resume(co, value, err)
+      end
+    end)
+  end
+end
+
 ---Create a waitable promise that can be resolved or rejected later
 ---@generic T
 ---@return Promise<T>
@@ -25,6 +41,7 @@ function Promise.new()
     _error = nil,
     _then_callbacks = {},
     _catch_callbacks = {},
+    _coroutines = {},
   }, Promise)
   return self
 end
@@ -45,6 +62,9 @@ function Promise:resolve(value)
   for _, callback in ipairs(self._then_callbacks) do
     schedule_then(callback, value)
   end
+
+  resume_coroutines(self._coroutines, value, nil)
+
   return self
 end
 
@@ -64,6 +84,9 @@ function Promise:reject(err)
   for _, callback in ipairs(self._catch_callbacks) do
     schedule_catch(callback, err)
   end
+
+  resume_coroutines(self._coroutines, nil, err)
+
   return self
 end
 
@@ -193,6 +216,39 @@ function Promise:is_rejected()
   return self._resolved and self._error ~= nil
 end
 
+---Await the promise from within a coroutine
+---This will yield the coroutine until the promise resolves or rejects
+---@generic T
+---@return T
+function Promise:await()
+  -- If already resolved, return immediately
+  if self._resolved then
+    if self._error then
+      error(self._error)
+    end
+    return self._value
+  end
+
+  -- Get the current coroutine
+  local co = coroutine.running()
+  if not co then
+    error('await() can only be called from within a coroutine')
+  end
+
+  -- Register the coroutine to be resumed when promise settles
+  table.insert(self._coroutines, co)
+
+  -- Yield and wait for resume
+  ---@diagnostic disable-next-line: await-in-sync
+  local value, err = coroutine.yield()
+
+  if err then
+    error(err)
+  end
+
+  return value
+end
+
 ---@generic T
 ---@param obj T
 ---@return_cast obj Promise<T>
@@ -211,4 +267,54 @@ function Promise.wrap(obj)
   end
 end
 
+---Run an async function in a coroutine
+---The function can use promise:await() to wait for promises
+---@generic T
+---@param fn fun(): T
+---@return Promise<T>
+---@return_cast T Promise<T>
+function Promise.async(fn)
+  local promise = Promise.new()
+
+  local co = coroutine.create(function()
+    local ok, result = pcall(fn)
+    if not ok then
+      promise:reject(result)
+    else
+      if Promise.is_promise(result) then
+        result
+          :and_then(function(val)
+            promise:resolve(val)
+          end)
+          :catch(function(err)
+            promise:reject(err)
+          end)
+      else
+        promise:resolve(result)
+      end
+    end
+  end)
+
+  local ok, err = coroutine.resume(co)
+  if not ok then
+    promise:reject(err)
+  end
+
+  return promise
+end
+
+---Wrap a function to run asynchronously
+---Takes a function and returns a wrapped version that returns a Promise
+---@generic T
+---@param fn fun(...): T
+---@return fun(...): Promise<T>
+function Promise.async_wrap(fn)
+  return function(...)
+    local args = { ... }
+    return Promise.async(function()
+      return fn(unpack(args))
+    end)
+  end
+end
+
 return Promise