opencode-pilot 0.19.0 → 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/package.json

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

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;
   }
   

package/test/unit/utils.test.js

@@ -71,9 +71,10 @@ describe('utils.js', () => {
       assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), false);
     });
 
-    test('returns false when only author has commented', async () => {
+    test('returns false when only author has top-level comments', async () => {
       const { hasNonBotFeedback } = await import('../../service/utils.js');
       
+      // Top-level comments from author (no state, no path) are ignored
       const comments = [
         { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
         { user: { login: 'athal7', type: 'User' }, body: 'Added screenshots' },
@@ -82,6 +83,62 @@ describe('utils.js', () => {
       assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), false);
     });
 
+    test('returns true when author has submitted a PR review (self-review)', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      // PR reviews from author (have state field) ARE actionable - self-review feedback
+      const comments = [
+        { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+        { user: { login: 'athal7', type: 'User' }, state: 'COMMENTED', body: 'TODO: add tests' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), true);
+    });
+
+    test('returns true when author has standalone inline comment', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      // Standalone inline comments from author (have path, no in_reply_to_id) ARE actionable
+      const comments = [
+        { 
+          user: { login: 'athal7', type: 'User' }, 
+          body: 'Need to refactor this', 
+          path: 'src/index.js',
+          diff_hunk: '@@ -1,3 +1,4 @@',
+        },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), true);
+    });
+
+    test('returns false when author has reply inline comment', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      // Reply inline comments from author (have in_reply_to_id) are ignored
+      const comments = [
+        { 
+          user: { login: 'athal7', type: 'User' }, 
+          body: 'Fixed!', 
+          path: 'src/index.js',
+          diff_hunk: '@@ -1,3 +1,4 @@',
+          in_reply_to_id: 12345,
+        },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), false);
+    });
+
+    test('returns false when author self-approves with no feedback', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      // Author's approval-only (no body) should not trigger
+      const comments = [
+        { user: { login: 'athal7', type: 'User' }, state: 'APPROVED', body: '' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), false);
+    });
+
     test('returns false for empty comments array', async () => {
       const { hasNonBotFeedback } = await import('../../service/utils.js');
       
@@ -173,6 +230,66 @@ describe('utils.js', () => {
     });
   });
 
+  describe('isPrReview', () => {
+    test('returns true for objects with state field', async () => {
+      const { isPrReview } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isPrReview({ state: 'APPROVED' }), true);
+      assert.strictEqual(isPrReview({ state: 'CHANGES_REQUESTED' }), true);
+      assert.strictEqual(isPrReview({ state: 'COMMENTED' }), true);
+    });
+
+    test('returns false for objects without state field', async () => {
+      const { isPrReview } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isPrReview({ body: 'Comment' }), false);
+      assert.strictEqual(isPrReview({}), false);
+      // null/undefined returns falsy (null), which is fine for boolean checks
+      assert.ok(!isPrReview(null));
+      assert.ok(!isPrReview(undefined));
+    });
+  });
+
+  describe('isInlineComment', () => {
+    test('returns true for comments with path field', async () => {
+      const { isInlineComment } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isInlineComment({ path: 'src/index.js', body: 'Fix this' }), true);
+    });
+
+    test('returns true for comments with diff_hunk field', async () => {
+      const { isInlineComment } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isInlineComment({ diff_hunk: '@@ -1,3 +1,4 @@', body: 'Nice' }), true);
+    });
+
+    test('returns false for top-level comments', async () => {
+      const { isInlineComment } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isInlineComment({ body: 'Great work!' }), false);
+      assert.strictEqual(isInlineComment({}), false);
+      assert.strictEqual(isInlineComment(null), false);
+    });
+  });
+
+  describe('isReply', () => {
+    test('returns true for comments with in_reply_to_id', async () => {
+      const { isReply } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isReply({ in_reply_to_id: 12345 }), true);
+      assert.strictEqual(isReply({ in_reply_to_id: 0 }), true);
+    });
+
+    test('returns false for standalone comments', async () => {
+      const { isReply } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isReply({ body: 'Standalone' }), false);
+      assert.strictEqual(isReply({ in_reply_to_id: null }), false);
+      assert.strictEqual(isReply({ in_reply_to_id: undefined }), false);
+      assert.strictEqual(isReply(null), false);
+    });
+  });
+
   describe('getNestedValue', () => {
     test('gets top-level value', async () => {
       const { getNestedValue } = await import('../../service/utils.js');