opencode-pilot 0.18.3 → 0.19.1

package/.github/dependabot.yml

@@ -0,0 +1,33 @@
+version: 2
+updates:
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    # Group updates to reduce PR noise
+    groups:
+      # Group all dev dependencies together
+      dev-dependencies:
+        dependency-type: "development"
+        update-types:
+          - "minor"
+          - "patch"
+      # Group production dependencies together
+      production-dependencies:
+        dependency-type: "production"
+        update-types:
+          - "minor"
+          - "patch"
+    # Keep major updates separate for careful review
+    open-pull-requests-limit: 10
+    commit-message:
+      prefix: "chore(deps)"
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    commit-message:
+      prefix: "chore(deps)"

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.3",
+  "version": "0.19.1",
   "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

@@ -437,21 +437,54 @@ async function fetchPrReviewCommentsViaCli(owner, repo, number, timeout) {
   }
 }
 
+/**
+ * Fetch PR reviews using gh CLI
+ * 
+ * Fetches formal PR reviews (APPROVED, CHANGES_REQUESTED, COMMENTED state).
+ * These are separate from inline comments and issue comments.
+ * 
+ * @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 review objects with user, state, body
+ */
+async function fetchPrReviewsViaCli(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}/reviews`),
+      createTimeout(timeout, "gh api call for PR reviews"),
+    ]);
+    
+    const reviews = JSON.parse(stdout);
+    return Array.isArray(reviews) ? reviews : [];
+  } catch (err) {
+    console.error(`[poller] Error fetching PR reviews via gh: ${err.message}`);
+    return [];
+  }
+}
+
 /**
  * Fetch comments for a GitHub issue/PR and enrich the item
  * 
- * Fetches BOTH types of comments using gh CLI:
+ * Fetches THREE types of feedback 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
+ * 3. PR reviews (formal reviews) via gh api pulls/{number}/reviews
  * 
  * This is necessary because:
  * - Bots like Linear post to issue comments, not PR review comments
  * - Human reviewers post inline feedback as PR review comments
+ * - Formal PR reviews (APPROVED, CHANGES_REQUESTED, COMMENTED) are stored separately
  * 
  * @param {object} item - Item with repository_full_name and number fields
  * @param {object} [options] - Options
  * @param {number} [options.timeout] - Timeout in ms (default: 30000)
- * @returns {Promise<Array>} Array of comment objects (merged from both endpoints)
+ * @returns {Promise<Array>} Array of comment/review objects (merged from all endpoints)
  */
 export async function fetchGitHubComments(item, options = {}) {
   const timeout = options.timeout || DEFAULT_MCP_TIMEOUT;
@@ -473,16 +506,18 @@ export async function fetchGitHubComments(item, options = {}) {
   }
   
   try {
-    // Fetch both PR review comments AND issue comments in parallel via gh CLI
-    const [prComments, issueComments] = await Promise.all([
+    // Fetch PR review comments, issue comments, AND PR reviews in parallel via gh CLI
+    const [prComments, issueComments, prReviews] = 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),
+      // PR reviews (formal reviews: APPROVED, CHANGES_REQUESTED, COMMENTED)
+      fetchPrReviewsViaCli(owner, repo, number, timeout),
     ]);
     
-    // Return merged comments from both sources
-    return [...prComments, ...issueComments];
+    // Return merged feedback from all sources
+    return [...prComments, ...issueComments, ...prReviews];
   } catch (err) {
     console.error(`[poller] Error fetching comments: ${err.message}`);
     return [];

package/service/utils.js

@@ -70,17 +70,64 @@ export function isBot(username, type) {
 }
 
 /**
- * Check if a PR/issue has non-bot feedback (comments from humans other than the author)
+ * Check if feedback is a PR review (has state field from /pulls/{number}/reviews)
+ * 
+ * PR reviews have a state field: APPROVED, CHANGES_REQUESTED, COMMENTED, PENDING, DISMISSED
+ * Regular comments (from /issues/{number}/comments or /pulls/{number}/comments) don't have state.
+ * 
+ * @param {object} feedback - Comment or review object
+ * @returns {boolean} True if this is a PR review (not a regular comment)
+ */
+export function isPrReview(feedback) {
+  return feedback && typeof feedback.state === 'string';
+}
+
+/**
+ * Check if feedback is an inline PR comment (from /pulls/{number}/comments)
+ * 
+ * Inline comments have path, position, or diff_hunk fields that top-level comments don't have.
+ * They may also have in_reply_to_id if they're replies to other inline comments.
+ * 
+ * @param {object} feedback - Comment or review object
+ * @returns {boolean} True if this is an inline PR comment
+ */
+export function isInlineComment(feedback) {
+  if (!feedback) return false;
+  // Inline comments have path (file path) and usually diff_hunk or position
+  return typeof feedback.path === 'string' || typeof feedback.diff_hunk === 'string';
+}
+
+/**
+ * Check if feedback is a reply to another comment
+ * 
+ * @param {object} feedback - Comment or review object
+ * @returns {boolean} True if this is a reply
+ */
+export function isReply(feedback) {
+  if (!feedback) return false;
+  // PR review comments use in_reply_to_id for replies
+  return feedback.in_reply_to_id !== undefined && feedback.in_reply_to_id !== null;
+}
+
+/**
+ * Check if a PR/issue has actionable feedback
  * 
  * Used to filter out PRs where only bots have commented, since those don't
- * require the author's attention for human feedback.
+ * require the author's attention.
+ * 
+ * Logic for author's own feedback:
+ * - Author's inline comments (standalone) → trigger (self-review on code)
+ * - Author's inline comments (replies) → ignore (responding to reviewer)
+ * - Author's PR reviews → trigger (formal self-review)
+ * - Author's top-level comments → ignore (conversation noise)
  * 
- * Also skips approval-only reviews (APPROVED state with no body text) since
- * approvals don't require action from the author.
+ * Logic for others' feedback:
+ * - Bot comments → ignore
+ * - Human comments/reviews → trigger (except approval-only with no body)
  * 
- * @param {Array} comments - Array of comment objects with user.login and user.type
+ * @param {Array} comments - Array of comment/review objects with user.login and user.type
  * @param {string} authorUsername - Username of the PR/issue author
- * @returns {boolean} True if there's at least one non-bot, non-author, actionable comment
+ * @returns {boolean} True if there's at least one actionable feedback item
  */
 export function hasNonBotFeedback(comments, authorUsername) {
   // Handle null/undefined/empty
@@ -97,16 +144,30 @@ export function hasNonBotFeedback(comments, authorUsername) {
     const username = user.login;
     const userType = user.type;
     
-    // Skip if it's a bot
+    // Skip if it's a bot (but Copilot is NOT in bot list, so Copilot reviews are kept)
     if (isBot(username, userType)) continue;
     
-    // Skip if it's the author themselves
-    if (authorLower && username?.toLowerCase() === authorLower) continue;
+    // For author's own feedback, apply special rules
+    if (authorLower && username?.toLowerCase() === authorLower) {
+      // Author's PR reviews → trigger
+      if (isPrReview(comment)) {
+        // Continue to check if it's actionable (not approval-only)
+      }
+      // Author's inline comments (standalone only) → trigger
+      else if (isInlineComment(comment)) {
+        if (isReply(comment)) continue; // Skip replies
+        // Standalone inline comment - continue to actionable check
+      }
+      // Author's top-level comments → ignore
+      else {
+        continue;
+      }
+    }
     
     // Skip approval-only reviews (no actionable feedback)
     if (isApprovalOnly(comment)) continue;
     
-    // Found a non-bot, non-author, actionable comment
+    // Found actionable feedback
     return true;
   }