opencode-pilot 0.11.0 → 0.11.2

package/package.json

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

package/service/poller.js

@@ -273,17 +273,53 @@ 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
  * 
- * Uses the github_get_pull_request_comments tool to fetch review comments,
- * or falls back to direct API call for issue comments.
+ * 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
+ * @returns {Promise<Array>} Array of comment objects (merged from both endpoints)
  */
 export async function fetchGitHubComments(item, options = {}) {
   const timeout = options.timeout || DEFAULT_MCP_TIMEOUT;
@@ -322,24 +358,31 @@ export async function fetchGitHubComments(item, options = {}) {
       createTimeout(timeout, "MCP connection for comments"),
     ]);
     
-    // Use github_get_pull_request_comments for PR review comments
-    const result = await Promise.race([
+    // 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 } 
-      }),
-      createTimeout(timeout, "fetch comments"),
+      }).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),
     ]);
     
-    const text = result.content?.[0]?.text;
-    if (!text) return [];
-    
-    try {
-      const comments = JSON.parse(text);
-      return Array.isArray(comments) ? comments : [];
-    } catch {
-      return [];
+    // 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 [];

package/service/utils.js

@@ -20,6 +20,26 @@ export function getNestedValue(obj, path) {
   return value;
 }
 
+/**
+ * Check if a comment/review is an approval-only (no actionable feedback)
+ * 
+ * PR reviews have a state field (APPROVED, CHANGES_REQUESTED, COMMENTED).
+ * An approval without substantive body text doesn't require action from the author.
+ * 
+ * @param {object} comment - Comment or review object with optional state and body
+ * @returns {boolean} True if this is a pure approval with no actionable feedback
+ */
+export function isApprovalOnly(comment) {
+  // Only applies to PR reviews with APPROVED state
+  if (comment.state !== 'APPROVED') return false;
+  
+  // If there's substantive body text, it might contain feedback
+  const body = comment.body || '';
+  if (body.trim().length > 0) return false;
+  
+  return true;
+}
+
 /**
  * Check if a username represents a bot account
  * 
@@ -50,9 +70,12 @@ export function isBot(username, type) {
  * Used to filter out PRs where only bots have commented, since those don't
  * require the author's attention for human feedback.
  * 
+ * Also skips approval-only reviews (APPROVED state with no body text) since
+ * approvals don't require action from the author.
+ * 
  * @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
+ * @returns {boolean} True if there's at least one non-bot, non-author, actionable comment
  */
 export function hasNonBotFeedback(comments, authorUsername) {
   // Handle null/undefined/empty
@@ -75,7 +98,10 @@ export function hasNonBotFeedback(comments, authorUsername) {
     // Skip if it's the author themselves
     if (authorLower && username?.toLowerCase() === authorLower) continue;
     
-    // Found a non-bot, non-author comment
+    // Skip approval-only reviews (no actionable feedback)
+    if (isApprovalOnly(comment)) continue;
+    
+    // Found a non-bot, non-author, actionable comment
     return true;
   }
   

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/utils.test.js

@@ -100,6 +100,77 @@ describe('utils.js', () => {
       
       assert.strictEqual(hasNonBotFeedback(comments, 'contributor'), true);
     });
+
+    test('returns false when only approval-only reviews (no feedback body)', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      // PR reviews with APPROVED state but no body should not trigger feedback
+      const comments = [
+        { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+        { user: { login: 'reviewer', type: 'User' }, state: 'APPROVED', body: '' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'author'), false);
+    });
+
+    test('returns true when approval includes feedback body', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      // If someone approves but leaves feedback, we should consider it actionable
+      const comments = [
+        { user: { login: 'reviewer', type: 'User' }, state: 'APPROVED', body: 'LGTM but consider adding a test for edge cases' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'author'), true);
+    });
+
+    test('returns true for CHANGES_REQUESTED reviews', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'reviewer', type: 'User' }, state: 'CHANGES_REQUESTED', body: 'Please fix this' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'author'), true);
+    });
+  });
+
+  describe('isApprovalOnly', () => {
+    test('returns true for APPROVED state with no body', async () => {
+      const { isApprovalOnly } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isApprovalOnly({ state: 'APPROVED' }), true);
+      assert.strictEqual(isApprovalOnly({ state: 'APPROVED', body: '' }), true);
+      assert.strictEqual(isApprovalOnly({ state: 'APPROVED', body: null }), true);
+    });
+
+    test('returns false for APPROVED with substantive body', async () => {
+      const { isApprovalOnly } = await import('../../service/utils.js');
+      
+      // If someone approves but leaves feedback, we should still consider it feedback
+      assert.strictEqual(isApprovalOnly({ state: 'APPROVED', body: 'LGTM but consider renaming this function' }), false);
+    });
+
+    test('returns false for CHANGES_REQUESTED', async () => {
+      const { isApprovalOnly } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isApprovalOnly({ state: 'CHANGES_REQUESTED', body: 'Please fix this' }), false);
+      assert.strictEqual(isApprovalOnly({ state: 'CHANGES_REQUESTED' }), false);
+    });
+
+    test('returns false for COMMENTED state', async () => {
+      const { isApprovalOnly } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isApprovalOnly({ state: 'COMMENTED', body: 'This looks good' }), false);
+    });
+
+    test('returns false for regular comments without state', async () => {
+      const { isApprovalOnly } = await import('../../service/utils.js');
+      
+      // Issue comments don't have state field
+      assert.strictEqual(isApprovalOnly({ body: 'Please address this' }), false);
+      assert.strictEqual(isApprovalOnly({}), false);
+    });
   });
 
   describe('getNestedValue', () => {