opencode-pilot 0.18.2 → 0.19.0

package/AGENTS.md

@@ -61,13 +61,14 @@ npx opencode-pilot status
 
 ## Configuration
 
-Config file: `~/.config/opencode-pilot/config.yaml`
+Config file: `~/.config/opencode/pilot/config.yaml`
 
 Configuration has these sections:
-- `tools` - field mappings for MCP servers
-- `sources` - polling sources with generic MCP tool references
-- `repos` - per-repository settings (use YAML anchors to share config)
+- `defaults` - default values applied to all sources
+- `repos_dir` - directory to auto-discover repos via git remotes
+- `sources` - polling sources with presets, shorthand, or full MCP tool config
+- `tools` - field mappings to normalize different MCP APIs
 
-Template files: `~/.config/opencode-pilot/templates/*.md`
+Template files: `~/.config/opencode/pilot/templates/*.md`
 
 See [examples/config.yaml](examples/config.yaml) for a complete example.

package/README.md

@@ -74,6 +74,23 @@ Session names for `my-prs-attention` indicate the condition: "Conflicts: {title}
 
 Create prompt templates as markdown files in `~/.config/opencode/pilot/templates/`. Templates support placeholders like `{title}`, `{body}`, `{number}`, `{html_url}`, etc.
 
+### Session and Sandbox Reuse
+
+By default, pilot reuses existing sessions and sandboxes to avoid duplicates:
+
+- **Session reuse**: If a non-archived session already exists for the target directory, pilot appends to it instead of creating a new session. Archived sessions are never reused.
+- **Sandbox reuse**: When `worktree: "new"` with a `worktree_name`, pilot first checks if a sandbox with that name already exists and reuses it.
+
+```yaml
+defaults:
+  # Disable session reuse (always create new sessions)
+  reuse_active_session: false
+  # Disable sandbox reuse (always create new worktrees)
+  prefer_existing_sandbox: false
+```
+
+When multiple sessions exist for the same directory, pilot prefers idle sessions over busy ones, then selects the most recently updated.
+
 ### Worktree Support
 
 Run sessions in isolated git worktrees instead of the main project directory. This uses OpenCode's built-in worktree management API to create and manage worktrees.
@@ -81,7 +98,7 @@ Run sessions in isolated git worktrees instead of the main project directory. Th
 ```yaml
 sources:
   - preset: github/my-issues
-    # Create a fresh worktree for each session
+    # Create a fresh worktree for each session (or reuse if name matches)
     worktree: "new"
     worktree_name: "issue-{number}"  # Optional: name template
     
@@ -91,9 +108,10 @@ sources:
 ```
 
 **Options:**
-- `worktree: "new"` - Create a new worktree via OpenCode's API
+- `worktree: "new"` - Create a new worktree via OpenCode's API (or reuse existing if name matches)
 - `worktree: "name"` - Look up existing worktree by name from project sandboxes
 - `worktree_name` - Template for naming new worktrees (only with `worktree: "new"`)
+- `prefer_existing_sandbox: false` - Disable sandbox reuse for this source
 
 ## CLI Commands
 

package/examples/config.yaml

@@ -1,5 +1,5 @@
 # Example config.yaml for opencode-pilot
-# Copy to ~/.config/opencode-pilot/config.yaml
+# Copy to ~/.config/opencode/pilot/config.yaml
 
 # Preferred OpenCode server port for attaching sessions
 # When multiple OpenCode instances are running, pilot will attach new sessions
@@ -19,6 +19,12 @@ repos_dir: ~/code
 defaults:
   agent: plan
   prompt: default
+  # Session reuse: append to existing non-archived session instead of creating new
+  # Default: true. Set to false to always create new sessions.
+  # reuse_active_session: true
+  # Sandbox reuse: reuse existing worktree/sandbox with matching name
+  # Default: true. Set to false to always create new sandboxes.
+  # prefer_existing_sandbox: true
 
 sources:
   # Presets - common patterns with sensible defaults

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-pilot",
-  "version": "0.18.2",
+  "version": "0.19.0",
   "type": "module",
   "main": "plugin/index.js",
   "description": "Automation daemon for OpenCode - polls for work and spawns sessions",
@@ -25,7 +25,9 @@
     "opencode-pilot": "./bin/opencode-pilot"
   },
   "scripts": {
-    "test": "node --test test/unit/*.test.js"
+    "test": "node --test test/unit/*.test.js",
+    "test:integration": "node --test test/integration/*.test.js",
+    "test:all": "node --test test/unit/*.test.js test/integration/*.test.js"
   },
   "devDependencies": {
     "@semantic-release/git": "^10.0.1",

package/service/actions.js

@@ -306,6 +306,258 @@ export function buildCommand(item, config) {
   return `[API] POST /session?directory=${cwd} (title: "${sessionName}")`;
 }
 
+/**
+ * List sessions from the OpenCode server
+ * 
+ * @param {string} serverUrl - Server URL (e.g., "http://localhost:4096")
+ * @param {object} [options] - Options
+ * @param {string} [options.directory] - Filter by directory
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<Array>} Array of session objects
+ */
+export async function listSessions(serverUrl, options = {}) {
+  const fetchFn = options.fetch || fetch;
+  
+  try {
+    const url = new URL('/session', serverUrl);
+    if (options.directory) {
+      url.searchParams.set('directory', options.directory);
+    }
+    // Only get root sessions (not child/forked sessions)
+    url.searchParams.set('roots', 'true');
+    
+    const response = await fetchFn(url.toString());
+    
+    if (!response.ok) {
+      debug(`listSessions: ${serverUrl} returned ${response.status}`);
+      return [];
+    }
+    
+    const sessions = await response.json();
+    return Array.isArray(sessions) ? sessions : [];
+  } catch (err) {
+    debug(`listSessions: error - ${err.message}`);
+    return [];
+  }
+}
+
+/**
+ * Check if a session is archived
+ * A session is archived if time.archived is set (it's a timestamp)
+ * 
+ * @param {object} session - Session object from API
+ * @returns {boolean} True if session is archived
+ */
+export function isSessionArchived(session) {
+  return session?.time?.archived !== undefined;
+}
+
+/**
+ * Get session statuses from the OpenCode server
+ * Returns a map of sessionId -> status (idle, busy, retry)
+ * Sessions not in the map are considered idle
+ * 
+ * @param {string} serverUrl - Server URL
+ * @param {object} [options] - Options
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<object>} Map of sessionId -> status object
+ */
+export async function getSessionStatuses(serverUrl, options = {}) {
+  const fetchFn = options.fetch || fetch;
+  
+  try {
+    const response = await fetchFn(`${serverUrl}/session/status`);
+    
+    if (!response.ok) {
+      debug(`getSessionStatuses: ${serverUrl} returned ${response.status}`);
+      return {};
+    }
+    
+    return await response.json();
+  } catch (err) {
+    debug(`getSessionStatuses: error - ${err.message}`);
+    return {};
+  }
+}
+
+/**
+ * Find the best session to reuse from a list of candidates
+ * Prefers idle sessions, then most recently updated
+ * 
+ * @param {Array} sessions - Array of non-archived sessions
+ * @param {object} statuses - Map of sessionId -> status from /session/status
+ * @returns {object|null} Best session to reuse, or null if none
+ */
+export function selectBestSession(sessions, statuses) {
+  if (!sessions || sessions.length === 0) {
+    return null;
+  }
+  
+  // Separate idle vs busy/retry sessions
+  const idle = [];
+  const other = [];
+  
+  for (const session of sessions) {
+    const status = statuses[session.id];
+    // Sessions not in statuses map are idle (per OpenCode behavior)
+    if (!status || status.type === 'idle') {
+      idle.push(session);
+    } else {
+      other.push(session);
+    }
+  }
+  
+  // Sort by most recently updated (highest time.updated first)
+  const sortByUpdated = (a, b) => (b.time?.updated || 0) - (a.time?.updated || 0);
+  
+  // Prefer idle sessions
+  if (idle.length > 0) {
+    idle.sort(sortByUpdated);
+    return idle[0];
+  }
+  
+  // Fall back to busy/retry sessions (sorted by most recent)
+  if (other.length > 0) {
+    other.sort(sortByUpdated);
+    return other[0];
+  }
+  
+  return null;
+}
+
+/**
+ * Send a message to an existing session
+ * 
+ * @param {string} serverUrl - Server URL
+ * @param {string} sessionId - Session ID to send message to
+ * @param {string} directory - Working directory
+ * @param {string} prompt - The prompt/message to send
+ * @param {object} [options] - Options
+ * @param {string} [options.title] - Update session title (optional)
+ * @param {string} [options.agent] - Agent to use
+ * @param {string} [options.model] - Model to use
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<object>} Result with sessionId, success, error
+ */
+export async function sendMessageToSession(serverUrl, sessionId, directory, prompt, options = {}) {
+  const fetchFn = options.fetch || fetch;
+  
+  try {
+    // Step 1: Update session title if provided
+    if (options.title) {
+      const updateUrl = new URL(`/session/${sessionId}`, serverUrl);
+      updateUrl.searchParams.set('directory', directory);
+      await fetchFn(updateUrl.toString(), {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ title: options.title }),
+      });
+      debug(`sendMessageToSession: updated title for session ${sessionId}`);
+    }
+    
+    // Step 2: Send the message
+    const messageUrl = new URL(`/session/${sessionId}/message`, serverUrl);
+    messageUrl.searchParams.set('directory', directory);
+    
+    const messageBody = {
+      parts: [{ type: 'text', text: prompt }],
+    };
+    
+    if (options.agent) {
+      messageBody.agent = options.agent;
+    }
+    
+    if (options.model) {
+      const [providerID, modelID] = options.model.includes('/') 
+        ? options.model.split('/', 2) 
+        : ['anthropic', options.model];
+      messageBody.providerID = providerID;
+      messageBody.modelID = modelID;
+    }
+    
+    // Use AbortController with timeout (same pattern as createSessionViaApi)
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    
+    try {
+      const messageResponse = await fetchFn(messageUrl.toString(), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(messageBody),
+        signal: controller.signal,
+      });
+      
+      clearTimeout(timeoutId);
+      
+      if (!messageResponse.ok) {
+        const errorText = await messageResponse.text();
+        throw new Error(`Failed to send message: ${messageResponse.status} ${errorText}`);
+      }
+      
+      debug(`sendMessageToSession: sent message to session ${sessionId}`);
+    } catch (abortErr) {
+      clearTimeout(timeoutId);
+      if (abortErr.name === 'AbortError') {
+        debug(`sendMessageToSession: message request started for session ${sessionId} (response aborted as expected)`);
+      } else {
+        throw abortErr;
+      }
+    }
+    
+    return {
+      success: true,
+      sessionId,
+      directory,
+      reused: true,
+    };
+  } catch (err) {
+    debug(`sendMessageToSession: error - ${err.message}`);
+    return {
+      success: false,
+      error: err.message,
+    };
+  }
+}
+
+/**
+ * Find an existing session to reuse for the given directory
+ * Returns null if no suitable session found (archived sessions are excluded)
+ * 
+ * @param {string} serverUrl - Server URL
+ * @param {string} directory - Working directory to match
+ * @param {object} [options] - Options
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<object|null>} Session to reuse, or null
+ */
+export async function findReusableSession(serverUrl, directory, options = {}) {
+  // Get sessions for this directory
+  const sessions = await listSessions(serverUrl, { 
+    directory, 
+    fetch: options.fetch 
+  });
+  
+  if (sessions.length === 0) {
+    debug(`findReusableSession: no sessions found for ${directory}`);
+    return null;
+  }
+  
+  // Filter out archived sessions
+  const activeSessions = sessions.filter(s => !isSessionArchived(s));
+  
+  if (activeSessions.length === 0) {
+    debug(`findReusableSession: all ${sessions.length} sessions are archived for ${directory}`);
+    return null;
+  }
+  
+  debug(`findReusableSession: found ${activeSessions.length} active sessions for ${directory}`);
+  
+  // Get statuses to prefer idle sessions
+  const statuses = await getSessionStatuses(serverUrl, { fetch: options.fetch });
+  
+  // Select the best session
+  return selectBestSession(activeSessions, statuses);
+}
+
 /**
  * Create a session via the OpenCode HTTP API
  * 
@@ -500,6 +752,8 @@ export async function executeAction(item, config, options = {}) {
     worktree: worktreeMode,
     // Expand worktree_name template with item fields (e.g., "issue-{number}")
     worktreeName: config.worktree_name ? expandTemplate(config.worktree_name, item) : undefined,
+    // Config flag to control sandbox reuse (default true)
+    preferExistingSandbox: config.prefer_existing_sandbox,
   };
   
   const worktreeResult = await resolveWorktreeDirectory(
@@ -513,6 +767,8 @@ export async function executeAction(item, config, options = {}) {
   
   if (worktreeResult.worktreeCreated) {
     debug(`executeAction: created new worktree at ${cwd}`);
+  } else if (worktreeResult.worktreeReused) {
+    debug(`executeAction: reusing existing sandbox at ${cwd}`);
   } else if (worktreeResult.error) {
     debug(`executeAction: worktree resolution warning - ${worktreeResult.error}`);
   }
@@ -527,6 +783,34 @@ export async function executeAction(item, config, options = {}) {
     ? buildSessionName(config.session.name, item)
     : (item.title || `session-${Date.now()}`);
   
+  // Check if we should try to reuse an existing session
+  const reuseActiveSession = config.reuse_active_session !== false; // default true
+  
+  if (reuseActiveSession && !options.dryRun) {
+    const existingSession = await findReusableSession(serverUrl, cwd, { fetch: options.fetch });
+    
+    if (existingSession) {
+      debug(`executeAction: found reusable session ${existingSession.id} for ${cwd}`);
+      
+      const reuseCommand = `[API] POST ${serverUrl}/session/${existingSession.id}/message (reusing session)`;
+      
+      const result = await sendMessageToSession(serverUrl, existingSession.id, cwd, prompt, {
+        title: sessionTitle,
+        agent: config.agent,
+        model: config.model,
+        fetch: options.fetch,
+      });
+      
+      return {
+        command: reuseCommand,
+        success: result.success,
+        sessionId: result.sessionId,
+        sessionReused: true,
+        error: result.error,
+      };
+    }
+  }
+  
   const apiCommand = `[API] POST ${serverUrl}/session?directory=${cwd}`;
   debug(`executeAction: using HTTP API - ${apiCommand}`);
   

package/service/poller.js

@@ -379,9 +379,7 @@ export async function pollGenericSource(source, options = {}) {
 /**
  * Fetch issue comments using gh CLI
  * 
- * The GitHub MCP server doesn't have a tool to list issue comments,
- * so we use gh CLI directly. This fetches the conversation thread
- * where bots like Linear post their comments.
+ * Fetches the conversation thread where bots like Linear post their comments.
  * 
  * @param {string} owner - Repository owner
  * @param {string} repo - Repository name
@@ -409,19 +407,50 @@ async function fetchIssueCommentsViaCli(owner, repo, number, timeout) {
   }
 }
 
+/**
+ * Fetch PR review comments using gh CLI
+ * 
+ * Fetches inline code review comments on a PR.
+ * 
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} number - PR number
+ * @param {number} timeout - Timeout in ms
+ * @returns {Promise<Array>} Array of comment objects
+ */
+async function fetchPrReviewCommentsViaCli(owner, repo, number, timeout) {
+  const { exec } = await import('child_process');
+  const { promisify } = await import('util');
+  const execAsync = promisify(exec);
+  
+  try {
+    const { stdout } = await Promise.race([
+      execAsync(`gh api repos/${owner}/${repo}/pulls/${number}/comments`),
+      createTimeout(timeout, "gh api call for PR comments"),
+    ]);
+    
+    const comments = JSON.parse(stdout);
+    return Array.isArray(comments) ? comments : [];
+  } catch (err) {
+    console.error(`[poller] Error fetching PR review comments via gh: ${err.message}`);
+    return [];
+  }
+}
+
 /**
  * Fetch comments for a GitHub issue/PR and enrich the item
  * 
- * Fetches BOTH types of comments:
- * 1. PR review comments (inline code comments) via MCP github_get_pull_request_comments
- * 2. Issue comments (conversation thread) via gh CLI
+ * Fetches BOTH types of comments using gh CLI:
+ * 1. PR review comments (inline code comments) via gh api pulls/{number}/comments
+ * 2. Issue comments (conversation thread) via gh api issues/{number}/comments
  * 
- * This is necessary because bots like Linear post to issue comments, not PR review comments.
+ * This is necessary because:
+ * - Bots like Linear post to issue comments, not PR review comments
+ * - Human reviewers post inline feedback as PR review comments
  * 
- * @param {object} item - Item with owner, repo_short, and number fields
+ * @param {object} item - Item with repository_full_name and number fields
  * @param {object} [options] - Options
  * @param {number} [options.timeout] - Timeout in ms (default: 30000)
- * @param {string} [options.opencodeConfigPath] - Path to opencode.json for MCP config
  * @returns {Promise<Array>} Array of comment objects (merged from both endpoints)
  */
 export async function fetchGitHubComments(item, options = {}) {
@@ -443,61 +472,20 @@ export async function fetchGitHubComments(item, options = {}) {
     return [];
   }
   
-  let mcpConfig;
   try {
-    mcpConfig = getMcpConfig("github", options.opencodeConfigPath);
-  } catch {
-    console.error("[poller] GitHub MCP not configured, cannot fetch comments");
-    return [];
-  }
-  
-  const client = new Client({ name: "opencode-pilot", version: "1.0.0" });
-  
-  try {
-    const transport = await createTransport(mcpConfig);
-    
-    await Promise.race([
-      client.connect(transport),
-      createTimeout(timeout, "MCP connection for comments"),
-    ]);
-    
-    // Fetch both PR review comments (via MCP) AND issue comments (via gh CLI) in parallel
-    const [prCommentsResult, issueComments] = await Promise.all([
-      // PR review comments via MCP (may not be available on all MCP servers)
-      client.callTool({ 
-        name: "github_get_pull_request_comments", 
-        arguments: { owner, repo, pull_number: number } 
-      }).catch(() => null), // Gracefully handle if tool doesn't exist
-      // Issue comments via gh CLI (conversation thread where Linear bot posts)
+    // Fetch both PR review comments AND issue comments in parallel via gh CLI
+    const [prComments, issueComments] = await Promise.all([
+      // PR review comments (inline code comments from reviewers)
+      fetchPrReviewCommentsViaCli(owner, repo, number, timeout),
+      // Issue comments (conversation thread where Linear bot posts)
       fetchIssueCommentsViaCli(owner, repo, number, timeout),
     ]);
     
-    // Parse PR review comments
-    let prComments = [];
-    const prText = prCommentsResult?.content?.[0]?.text;
-    if (prText) {
-      try {
-        const parsed = JSON.parse(prText);
-        prComments = Array.isArray(parsed) ? parsed : [];
-      } catch {
-        // Ignore parse errors
-      }
-    }
-    
     // Return merged comments from both sources
     return [...prComments, ...issueComments];
   } catch (err) {
     console.error(`[poller] Error fetching comments: ${err.message}`);
     return [];
-  } finally {
-    try {
-      await Promise.race([
-        client.close(),
-        new Promise(resolve => setTimeout(resolve, 3000)),
-      ]);
-    } catch {
-      // Ignore close errors
-    }
   }
 }
 

package/service/worktree.js

@@ -8,18 +8,26 @@
 import { debug } from "./logger.js";
 
 /**
- * List available worktrees/sandboxes for a project
+ * List existing worktrees from the OpenCode server
  * 
  * @param {string} serverUrl - OpenCode server URL (e.g., "http://localhost:4096")
  * @param {object} [options] - Options
+ * @param {string} [options.directory] - Project directory (required for global server)
  * @param {function} [options.fetch] - Custom fetch function (for testing)
- * @returns {Promise<string[]>} Array of worktree directory paths
+ * @returns {Promise<string[]>} Array of worktree paths
  */
 export async function listWorktrees(serverUrl, options = {}) {
   const fetchFn = options.fetch || fetch;
   
   try {
-    const response = await fetchFn(`${serverUrl}/experimental/worktree`);
+    // Build URL with directory parameter if provided
+    // This tells the global server which project to list worktrees for
+    let url = `${serverUrl}/experimental/worktree`;
+    if (options.directory) {
+      url += `?directory=${encodeURIComponent(options.directory)}`;
+    }
+    
+    const response = await fetchFn(url);
     
     if (!response.ok) {
       debug(`listWorktrees: ${serverUrl} returned ${response.status}`);
@@ -162,6 +170,25 @@ export async function getProjectInfoForDirectory(serverUrl, directory, options =
   }
 }
 
+/**
+ * Find an existing worktree by exact name match
+ * 
+ * @param {string[]} worktrees - List of worktree paths
+ * @param {string} name - Name to match (final path component)
+ * @returns {string|null} Matching worktree path or null
+ */
+function findWorktreeByName(worktrees, name) {
+  for (const wt of worktrees) {
+    // Match exact final path component
+    const parts = wt.split('/');
+    const finalComponent = parts[parts.length - 1];
+    if (finalComponent === name) {
+      return wt;
+    }
+  }
+  return null;
+}
+
 /**
  * Resolve the working directory based on worktree configuration
  * 
@@ -174,9 +201,10 @@ export async function getProjectInfoForDirectory(serverUrl, directory, options =
  * @param {object} worktreeConfig - Worktree configuration
  * @param {string} [worktreeConfig.worktree] - Worktree mode: "new" or worktree name
  * @param {string} [worktreeConfig.worktreeName] - Name for new worktree (only with "new")
+ * @param {boolean} [worktreeConfig.preferExistingSandbox] - If true (default), reuse existing sandbox with matching name
  * @param {object} [options] - Options
  * @param {function} [options.fetch] - Custom fetch function (for testing)
- * @returns {Promise<object>} Result with { directory, worktreeCreated?, error? }
+ * @returns {Promise<object>} Result with { directory, worktreeCreated?, worktreeReused?, error? }
  */
 export async function resolveWorktreeDirectory(serverUrl, baseDir, worktreeConfig, options = {}) {
   // No worktree config - use base directory
@@ -193,9 +221,25 @@ export async function resolveWorktreeDirectory(serverUrl, baseDir, worktreeConfi
   }
   
   const worktreeValue = worktreeConfig.worktree;
+  const preferExisting = worktreeConfig.preferExistingSandbox !== false; // default true
   
-  // "new" - create a fresh worktree via OpenCode API
+  // "new" - create a fresh worktree via OpenCode API (or reuse if matching name exists)
   if (worktreeValue === "new") {
+    // If worktreeName is provided and preferExisting is true, try to reuse existing
+    if (worktreeConfig.worktreeName && preferExisting) {
+      const worktrees = await listWorktrees(serverUrl, { ...options, directory: baseDir });
+      const existingMatch = findWorktreeByName(worktrees, worktreeConfig.worktreeName);
+      
+      if (existingMatch) {
+        debug(`resolveWorktreeDirectory: reusing existing sandbox "${worktreeConfig.worktreeName}" at ${existingMatch}`);
+        return {
+          directory: existingMatch,
+          worktreeReused: true,
+        };
+      }
+    }
+    
+    // No existing match found (or not looking), create new
     const result = await createWorktree(serverUrl, {
       directory: baseDir,
       name: worktreeConfig.worktreeName,
@@ -217,7 +261,7 @@ export async function resolveWorktreeDirectory(serverUrl, baseDir, worktreeConfi
   }
   
   // Named worktree - look it up from available sandboxes via OpenCode API
-  const worktrees = await listWorktrees(serverUrl, options);
+  const worktrees = await listWorktrees(serverUrl, { ...options, directory: baseDir });
   const match = worktrees.find(w => w.includes(worktreeValue));
   if (match) {
     return { directory: match };