opencode-pilot 0.10.0 → 0.11.1

package/README.md

@@ -94,6 +94,18 @@ opencode-pilot test-mapping MCP   # Test field mappings
 
 ## Known Issues
 
+### Sessions attached to global server run in wrong directory
+
+When using `server_port` to attach sessions to a global OpenCode server (e.g., OpenCode Desktop with worktree="/"), sessions are created in the server's working directory (typically home) instead of the project directory. This means:
+
+- File tools resolve paths relative to home, not the project
+- The agent sees the wrong `Working directory` in system prompt
+- Git operations may target the wrong repository
+
+**Workaround**: Don't set `server_port` in your config. Sessions will run in the correct directory but won't appear in OpenCode Desktop.
+
+**Upstream issue**: [anomalyco/opencode#7376](https://github.com/anomalyco/opencode/issues/7376)
+
 ### Working directory doesn't switch when templates create worktrees/devcontainers
 
 When a template instructs the agent to create a git worktree or switch to a devcontainer, OpenCode's internal working directory context (`Instance.directory`) doesn't update. This means:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-pilot",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "type": "module",
   "main": "plugin/index.js",
   "description": "Automation daemon for OpenCode - polls for work and spawns sessions",

package/service/poll-service.js

@@ -10,7 +10,7 @@
  */
 
 import { loadRepoConfig, getRepoConfig, getAllSources, getToolProviderConfig, resolveRepoForItem, getCleanupTtlDays } from "./repo-config.js";
-import { createPoller, pollGenericSource } from "./poller.js";
+import { createPoller, pollGenericSource, enrichItemsWithComments } from "./poller.js";
 import { evaluateReadiness, sortByPriority } from "./readiness.js";
 import { executeAction, buildCommand } from "./actions.js";
 import { debug } from "./logger.js";
@@ -126,6 +126,12 @@ export async function pollOnce(options = {}) {
         toolProviderConfig = getToolProviderConfig(source.tool.mcp);
         items = await pollGenericSource(source, { toolProviderConfig });
         debug(`Fetched ${items.length} items from ${sourceName}`);
+        
+        // Enrich items with comments for bot filtering if configured
+        if (source.filter_bot_comments) {
+          items = await enrichItemsWithComments(items, source);
+          debug(`Enriched ${items.length} items with comments for bot filtering`);
+        }
       } catch (err) {
         console.error(`[poll] Error fetching from ${sourceName}: ${err.message}`);
         continue;

package/service/poller.js

@@ -273,6 +273,163 @@ 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.
+ * 
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} number - Issue/PR number
+ * @param {number} timeout - Timeout in ms
+ * @returns {Promise<Array>} Array of comment objects
+ */
+async function fetchIssueCommentsViaCli(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}/issues/${number}/comments`),
+      createTimeout(timeout, "gh api call"),
+    ]);
+    
+    const comments = JSON.parse(stdout);
+    return Array.isArray(comments) ? comments : [];
+  } catch (err) {
+    // gh CLI might not be available or authenticated
+    console.error(`[poller] Error fetching issue 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
+ * 
+ * This is necessary because bots like Linear post to issue comments, not PR review comments.
+ * 
+ * @param {object} item - Item with owner, repo_short, 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 = {}) {
+  const timeout = options.timeout || DEFAULT_MCP_TIMEOUT;
+  
+  // Extract owner and repo from item
+  // The item should have repository_full_name (e.g., "owner/repo") from mapping
+  const fullName = item.repository_full_name;
+  if (!fullName) {
+    console.error("[poller] Cannot fetch comments: missing repository_full_name");
+    return [];
+  }
+  
+  const [owner, repo] = fullName.split("/");
+  const number = item.number;
+  
+  if (!owner || !repo || !number) {
+    console.error("[poller] Cannot fetch comments: missing owner, repo, or number");
+    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)
+      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
+    }
+  }
+}
+
+/**
+ * Enrich items with comments for bot filtering
+ * 
+ * For items from sources with filter_bot_comments: true, fetches comments
+ * and attaches them as _comments field for readiness evaluation.
+ * 
+ * @param {Array} items - Items to enrich
+ * @param {object} source - Source configuration with optional filter_bot_comments
+ * @param {object} [options] - Options passed to fetchGitHubComments
+ * @returns {Promise<Array>} Items with _comments field added
+ */
+export async function enrichItemsWithComments(items, source, options = {}) {
+  // Skip if not configured or not a GitHub source
+  if (!source.filter_bot_comments || source.tool?.mcp !== "github") {
+    return items;
+  }
+  
+  // Fetch comments for each item (could be parallelized with Promise.all for speed)
+  const enrichedItems = [];
+  for (const item of items) {
+    // Only fetch if item has comments
+    if (item.comments > 0) {
+      const comments = await fetchGitHubComments(item, options);
+      enrichedItems.push({ ...item, _comments: comments });
+    } else {
+      enrichedItems.push(item);
+    }
+  }
+  
+  return enrichedItems;
+}
+
 /**
  * Create a poller instance with state tracking
  * 

package/service/presets/github.yaml

@@ -57,3 +57,6 @@ my-prs-feedback:
   reprocess_on:
     - state
     - updated_at
+  # Filter out PRs where all comments are from bots or the PR author
+  # Fetches comments via API and enriches items with _comments for readiness check
+  filter_bot_comments: true

package/service/readiness.js

@@ -4,9 +4,12 @@
  * Evaluates whether an issue is ready to be worked on based on:
  * - Label constraints (blocking labels, required labels)
  * - Dependencies (blocked by references in body)
+ * - Bot comment filtering (for PR feedback sources)
  * - Priority scoring (label weights, age bonus)
  */
 
+import { hasNonBotFeedback } from "./utils.js";
+
 /**
  * Dependency reference patterns in issue body
  */
@@ -131,6 +134,45 @@ export function checkDependencies(issue, config) {
   return { ready: true };
 }
 
+/**
+ * Check if a PR/issue has meaningful (non-bot, non-author) comments
+ * 
+ * This check is only applied when the item has been enriched with `_comments`
+ * (an array of comment objects with user.login and user.type fields).
+ * Items without `_comments` are considered ready (check is skipped).
+ * 
+ * Used to filter PRs from feedback sources where bot comments (CI, coverage, etc.)
+ * should not trigger the author to take action.
+ * 
+ * @param {object} item - Item with optional _comments array and user.login
+ * @param {object} config - Repo config (currently unused but kept for API consistency)
+ * @returns {object} { ready: boolean, reason?: string }
+ */
+export function checkBotComments(item, config) {
+  // Skip check if no _comments field (item not enriched)
+  if (!item._comments) {
+    return { ready: true };
+  }
+  
+  // Empty comments array means no comments - consider ready (no feedback)
+  if (item._comments.length === 0) {
+    return { ready: true };
+  }
+  
+  // Get author username
+  const authorUsername = item.user?.login;
+  
+  // Check if there's non-bot, non-author feedback
+  if (hasNonBotFeedback(item._comments, authorUsername)) {
+    return { ready: true };
+  }
+  
+  return {
+    ready: false,
+    reason: "Only bot or author comments - no human feedback requiring action",
+  };
+}
+
 /**
  * Calculate priority score for an issue
  * @param {object} issue - Issue with labels and created_at
@@ -194,6 +236,16 @@ export function evaluateReadiness(issue, config) {
     };
   }
 
+  // Check bot comments (for PRs enriched with _comments)
+  const botResult = checkBotComments(issue, config);
+  if (!botResult.ready) {
+    return {
+      ready: false,
+      reason: botResult.reason,
+      priority: 0,
+    };
+  }
+
   // Calculate priority for ready issues
   const priority = calculatePriority(issue, config);
 

package/service/utils.js

@@ -19,3 +19,65 @@ export function getNestedValue(obj, path) {
   }
   return value;
 }
+
+/**
+ * Check if a username represents a bot account
+ * 
+ * Detects bots by:
+ * 1. Username suffix: [bot] (e.g., "github-actions[bot]", "dependabot[bot]")
+ * 2. User type field: "Bot" (GitHub API provides this)
+ * 
+ * @param {string} username - GitHub username to check
+ * @param {string} [type] - User type from API (e.g., "Bot", "User")
+ * @returns {boolean} True if the user is a bot
+ */
+export function isBot(username, type) {
+  // Handle null/undefined/empty
+  if (!username) return false;
+  
+  // Check user type field (GitHub API provides "Bot" type)
+  if (type && type.toLowerCase() === "bot") return true;
+  
+  // Check for [bot] suffix in username
+  if (username.toLowerCase().endsWith("[bot]")) return true;
+  
+  return false;
+}
+
+/**
+ * Check if a PR/issue has non-bot feedback (comments from humans other than the author)
+ * 
+ * Used to filter out PRs where only bots have commented, since those don't
+ * require the author's attention for human feedback.
+ * 
+ * @param {Array} comments - Array of comment 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 comment
+ */
+export function hasNonBotFeedback(comments, authorUsername) {
+  // Handle null/undefined/empty
+  if (!comments || !Array.isArray(comments) || comments.length === 0) {
+    return false;
+  }
+  
+  const authorLower = authorUsername?.toLowerCase();
+  
+  for (const comment of comments) {
+    const user = comment.user;
+    if (!user) continue;
+    
+    const username = user.login;
+    const userType = user.type;
+    
+    // Skip if it's a bot
+    if (isBot(username, userType)) continue;
+    
+    // Skip if it's the author themselves
+    if (authorLower && username?.toLowerCase() === authorLower) continue;
+    
+    // Found a non-bot, non-author comment
+    return true;
+  }
+  
+  return false;
+}

package/test/unit/poller.test.js

@@ -734,6 +734,29 @@ describe('poller.js', () => {
     });
   });
 
+  describe('fetchGitHubComments', () => {
+    // Note: These tests document the expected behavior
+    // Actual MCP calls require mocking which is complex
+
+    test('should fetch both PR review comments AND issue comments', async () => {
+      // The issue: Linear bot posts to issue comments endpoint, not PR review comments
+      // PR review comments: GET /repos/{owner}/{repo}/pulls/{pull_number}/comments
+      // Issue comments: GET /repos/{owner}/{repo}/issues/{issue_number}/comments
+      //
+      // For proper bot filtering, we need to check BOTH endpoints
+      // Currently only PR review comments are fetched, causing Linear bot
+      // comments to be missed (they appear in issue comments)
+      
+      // This test documents the expected behavior - fetchGitHubComments should
+      // return comments from both endpoints merged together
+      const { fetchGitHubComments } = await import('../../service/poller.js');
+      
+      // Without proper mocking, we can only test the function exists
+      // and accepts the right parameters
+      assert.strictEqual(typeof fetchGitHubComments, 'function');
+    });
+  });
+
   describe('parseJsonArray', () => {
     test('parses direct array response', async () => {
       const { parseJsonArray } = await import('../../service/poller.js');

package/test/unit/readiness.test.js

@@ -0,0 +1,210 @@
+/**
+ * Tests for readiness.js - Issue/PR readiness evaluation
+ */
+
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('readiness.js', () => {
+  let tempDir;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'opencode-pilot-readiness-test-'));
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('checkLabels', () => {
+    test('returns ready when no label constraints', async () => {
+      const { checkLabels } = await import('../../service/readiness.js');
+      
+      const issue = { labels: ['bug', 'help wanted'] };
+      const config = {};
+      
+      const result = checkLabels(issue, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns not ready when has blocking label', async () => {
+      const { checkLabels } = await import('../../service/readiness.js');
+      
+      const issue = { labels: ['bug', 'wip'] };
+      const config = {
+        readiness: {
+          labels: {
+            exclude: ['wip', 'do-not-merge']
+          }
+        }
+      };
+      
+      const result = checkLabels(issue, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('wip'));
+    });
+
+    test('returns not ready when missing required label', async () => {
+      const { checkLabels } = await import('../../service/readiness.js');
+      
+      const issue = { labels: ['bug'] };
+      const config = {
+        readiness: {
+          labels: {
+            required: ['approved', 'ready']
+          }
+        }
+      };
+      
+      const result = checkLabels(issue, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('approved'));
+    });
+
+    test('handles label objects with name property', async () => {
+      const { checkLabels } = await import('../../service/readiness.js');
+      
+      const issue = { 
+        labels: [
+          { name: 'bug' },
+          { name: 'approved' }
+        ]
+      };
+      const config = {
+        readiness: {
+          labels: {
+            required: ['approved']
+          }
+        }
+      };
+      
+      const result = checkLabels(issue, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+  });
+
+  describe('checkBotComments', () => {
+    test('returns ready when there are non-bot comments', async () => {
+      const { checkBotComments } = await import('../../service/readiness.js');
+      
+      const pr = {
+        user: { login: 'author' },
+        _comments: [
+          { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+          { user: { login: 'reviewer', type: 'User' }, body: 'Please fix the bug' },
+        ]
+      };
+      const config = {};
+      
+      const result = checkBotComments(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns not ready when all comments are from bots', async () => {
+      const { checkBotComments } = await import('../../service/readiness.js');
+      
+      const pr = {
+        user: { login: 'author' },
+        _comments: [
+          { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+          { user: { login: 'codecov[bot]', type: 'Bot' }, body: 'Coverage report' },
+        ]
+      };
+      const config = {};
+      
+      const result = checkBotComments(pr, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('bot'));
+    });
+
+    test('returns not ready when only author and bots have commented', async () => {
+      const { checkBotComments } = await import('../../service/readiness.js');
+      
+      const pr = {
+        user: { login: 'athal7' },
+        _comments: [
+          { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+          { user: { login: 'athal7', type: 'User' }, body: 'Added screenshots' },
+        ]
+      };
+      const config = {};
+      
+      const result = checkBotComments(pr, config);
+      
+      assert.strictEqual(result.ready, false);
+    });
+
+    test('returns ready when no _comments field (skip check)', async () => {
+      const { checkBotComments } = await import('../../service/readiness.js');
+      
+      const pr = {
+        user: { login: 'author' },
+        comments: 5  // count only, no _comments enrichment
+      };
+      const config = {};
+      
+      const result = checkBotComments(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns ready when _comments is empty (no comments yet)', async () => {
+      const { checkBotComments } = await import('../../service/readiness.js');
+      
+      const pr = {
+        user: { login: 'author' },
+        _comments: []
+      };
+      const config = {};
+      
+      const result = checkBotComments(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+  });
+
+  describe('evaluateReadiness', () => {
+    test('checks bot comments when _comments is present', async () => {
+      const { evaluateReadiness } = await import('../../service/readiness.js');
+      
+      const pr = {
+        user: { login: 'author' },
+        _comments: [
+          { user: { login: 'dependabot[bot]', type: 'Bot' }, body: 'Bump dependency' },
+        ]
+      };
+      const config = {};
+      
+      const result = evaluateReadiness(pr, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('bot'));
+    });
+
+    test('passes when there is real human feedback', async () => {
+      const { evaluateReadiness } = await import('../../service/readiness.js');
+      
+      const pr = {
+        user: { login: 'author' },
+        _comments: [
+          { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+          { user: { login: 'teammate', type: 'User' }, body: 'LGTM!' },
+        ]
+      };
+      const config = {};
+      
+      const result = evaluateReadiness(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+  });
+});

package/test/unit/utils.test.js

@@ -6,6 +6,102 @@ import { test, describe } from 'node:test';
 import assert from 'node:assert';
 
 describe('utils.js', () => {
+  describe('isBot', () => {
+    test('detects GitHub bot usernames with [bot] suffix', async () => {
+      const { isBot } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isBot('github-actions[bot]'), true);
+      assert.strictEqual(isBot('dependabot[bot]'), true);
+      assert.strictEqual(isBot('renovate[bot]'), true);
+      assert.strictEqual(isBot('codecov[bot]'), true);
+    });
+
+    test('detects bots by type field', async () => {
+      const { isBot } = await import('../../service/utils.js');
+      
+      // When user object has type: "Bot"
+      assert.strictEqual(isBot('some-user', 'Bot'), true);
+      assert.strictEqual(isBot('another-user', 'bot'), true);
+    });
+
+    test('returns false for regular users', async () => {
+      const { isBot } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isBot('athal7'), false);
+      assert.strictEqual(isBot('octocat'), false);
+      assert.strictEqual(isBot('some-developer'), false);
+    });
+
+    test('returns false for regular users with type User', async () => {
+      const { isBot } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isBot('athal7', 'User'), false);
+      assert.strictEqual(isBot('octocat', 'user'), false);
+    });
+
+    test('handles edge cases', async () => {
+      const { isBot } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isBot(''), false);
+      assert.strictEqual(isBot(null), false);
+      assert.strictEqual(isBot(undefined), false);
+    });
+  });
+
+  describe('hasNonBotFeedback', () => {
+    test('returns true when there are non-bot, non-author comments', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+        { user: { login: 'reviewer', type: 'User' }, body: 'Please fix the bug' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), true);
+    });
+
+    test('returns false when all comments are from bots', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+        { user: { login: 'codecov[bot]', type: 'Bot' }, body: 'Coverage report' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), false);
+    });
+
+    test('returns false when only author has commented', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+        { user: { login: 'athal7', type: 'User' }, body: 'Added screenshots' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), false);
+    });
+
+    test('returns false for empty comments array', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      assert.strictEqual(hasNonBotFeedback([], 'athal7'), false);
+      assert.strictEqual(hasNonBotFeedback(null, 'athal7'), false);
+      assert.strictEqual(hasNonBotFeedback(undefined, 'athal7'), false);
+    });
+
+    test('handles nested user object with login and type', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'dependabot[bot]', type: 'Bot' }, body: 'Bump lodash' },
+        { user: { login: 'maintainer', type: 'User' }, body: 'LGTM' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'contributor'), true);
+    });
+  });
+
   describe('getNestedValue', () => {
     test('gets top-level value', async () => {
       const { getNestedValue } = await import('../../service/utils.js');