opencode-pilot 0.24.4 → 0.24.5

package/Formula/opencode-pilot.rb

@@ -1,8 +1,8 @@
 class OpencodePilot < Formula
   desc "Automation daemon for OpenCode - polls GitHub/Linear issues and spawns sessions"
   homepage "https://github.com/athal7/opencode-pilot"
-  url "https://github.com/athal7/opencode-pilot/archive/refs/tags/v0.24.3.tar.gz"
-  sha256 "39b5b418b5af1c3731de56f549303b0af55591b5730522802d95267724889f6f"
+  url "https://github.com/athal7/opencode-pilot/archive/refs/tags/v0.24.4.tar.gz"
+  sha256 "7a697b9543877054b0ae42a4bbfff69f1bb9b91c3c724cbee9cc256bd75d2e83"
   license "MIT"
 
   depends_on "node"

package/package.json

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

package/service/poll-service.js

@@ -310,6 +310,9 @@ export async function pollOnce(options = {}) {
                 // Store attention state for detecting new feedback on PRs
                 // _has_attention is boolean for enriched items, undefined for non-PR sources
                 hasAttention: item._has_attention ?? null,
+                // Store latest feedback timestamp for detecting new reviews on PRs
+                // that were already processed with existing feedback (true -> true)
+                latestFeedbackAt: item._latest_feedback_at ?? null,
                 dedupKeys: dedupKeys.length > 0 ? dedupKeys : undefined,
               });
             }

package/service/poller.js

@@ -12,7 +12,7 @@ import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import fs from "fs";
 import path from "path";
 import os from "os";
-import { getNestedValue, hasNonBotFeedback, extractIssueRefs } from "./utils.js";
+import { getNestedValue, hasNonBotFeedback, getLatestFeedbackTimestamp, extractIssueRefs } from "./utils.js";
 
 /**
  * Expand template string with item fields
@@ -809,6 +809,7 @@ export function detectStacks(items) {
 export function computeAttentionLabels(items, source) {
   return items.map(item => {
     const reasons = [];
+    let latestFeedbackAt = null;
     
     // Check for merge conflicts
     if (item._mergeable === 'CONFLICTING') {
@@ -821,6 +822,8 @@ export function computeAttentionLabels(items, source) {
       const authorUsername = item.user?.login || item.author?.login;
       if (hasNonBotFeedback(item._comments, authorUsername)) {
         reasons.push('Feedback');
+        // Track the latest feedback timestamp for detecting new reviews
+        latestFeedbackAt = getLatestFeedbackTimestamp(item._comments, authorUsername);
       }
     }
     
@@ -831,6 +834,7 @@ export function computeAttentionLabels(items, source) {
       ...item,
       _attention_label: label,
       _has_attention: reasons.length > 0,
+      _latest_feedback_at: latestFeedbackAt,
     };
   });
 }
@@ -1253,15 +1257,28 @@ export function createPoller(options = {}) {
         }
         
         // Handle attention field (detect new feedback on PRs)
-        // Only reprocess when attention changes from false to true
+        // Triggers when:
+        // 1. Attention changes from false to true (new feedback on a clean PR)
+        // 2. Attention stays true but latest feedback is newer (re-review or additional feedback)
         if (field === 'attention') {
           const storedHasAttention = meta.hasAttention;
           const currentHasAttention = item._has_attention;
           
-          // Only trigger if we have stored state (not legacy items) and attention changed false -> true
+          // Trigger if attention changed false -> true
           if (storedHasAttention === false && currentHasAttention === true) {
             return true;
           }
+          
+          // Trigger if attention stayed true but there's newer feedback
+          // This catches re-reviews and additional feedback on PRs already processed with feedback
+          if (storedHasAttention === true && currentHasAttention === true) {
+            const storedFeedbackAt = meta.latestFeedbackAt;
+            const currentFeedbackAt = item._latest_feedback_at;
+            
+            if (storedFeedbackAt && currentFeedbackAt && currentFeedbackAt > storedFeedbackAt) {
+              return true;
+            }
+          }
         }
       }
       

package/service/utils.js

@@ -192,34 +192,7 @@ export function hasNonBotFeedback(comments, authorUsername) {
   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 (but Copilot is NOT in bot list, so Copilot reviews are kept)
-    if (isBot(username, userType)) 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;
+    if (!isActionableFeedback(comment, authorLower)) continue;
     
     // Found actionable feedback
     return true;
@@ -227,3 +200,84 @@ export function hasNonBotFeedback(comments, authorUsername) {
   
   return false;
 }
+
+/**
+ * Check if a single comment/review is actionable feedback
+ * 
+ * Extracted from hasNonBotFeedback to allow reuse in getLatestFeedbackTimestamp.
+ * 
+ * @param {object} comment - Comment or review object
+ * @param {string} [authorLower] - Lowercase author username
+ * @returns {boolean} True if the comment is actionable feedback
+ */
+function isActionableFeedback(comment, authorLower) {
+  const user = comment.user;
+  if (!user) return false;
+  
+  const username = user.login;
+  const userType = user.type;
+  
+  // Skip if it's a bot (but Copilot is NOT in bot list, so Copilot reviews are kept)
+  if (isBot(username, userType)) return false;
+  
+  // 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)) return false; // Skip replies
+      // Standalone inline comment - continue to actionable check
+    }
+    // Author's top-level comments → ignore
+    else {
+      return false;
+    }
+  }
+  
+  // Skip approval-only reviews (no actionable feedback)
+  if (isApprovalOnly(comment)) return false;
+  
+  return true;
+}
+
+/**
+ * Get the timestamp of the latest actionable feedback on a PR/issue
+ * 
+ * Uses the same filtering logic as hasNonBotFeedback to identify actionable
+ * comments, then returns the most recent timestamp. This allows detecting
+ * new feedback even when the PR was already processed with existing feedback.
+ * 
+ * GitHub API timestamp fields:
+ * - PR reviews: submitted_at
+ * - PR review comments (inline): updated_at, created_at
+ * - Issue comments: updated_at, created_at
+ * 
+ * @param {Array} comments - Array of comment/review objects
+ * @param {string} authorUsername - Username of the PR/issue author
+ * @returns {string|null} ISO timestamp of latest feedback, or null if none
+ */
+export function getLatestFeedbackTimestamp(comments, authorUsername) {
+  if (!comments || !Array.isArray(comments) || comments.length === 0) {
+    return null;
+  }
+  
+  const authorLower = authorUsername?.toLowerCase();
+  let latest = null;
+  
+  for (const comment of comments) {
+    if (!isActionableFeedback(comment, authorLower)) continue;
+    
+    // PR reviews use submitted_at, comments use updated_at or created_at
+    const timestamp = comment.submitted_at || comment.updated_at || comment.created_at;
+    if (!timestamp) continue;
+    
+    if (!latest || timestamp > latest) {
+      latest = timestamp;
+    }
+  }
+  
+  return latest;
+}

package/test/unit/poller.test.js

@@ -813,23 +813,65 @@ describe('poller.js', () => {
       );
     });
 
-    test('shouldReprocess returns false when attention stays true', async () => {
+    test('shouldReprocess returns false when attention stays true with same feedback timestamp', async () => {
       const { createPoller } = await import('../../service/poller.js');
       
       const poller = createPoller({ stateFile });
-      // Item was processed with attention
+      // Item was processed with attention and a feedback timestamp
+      poller.markProcessed('pr-1', { 
+        source: 'my-prs-attention', 
+        itemState: 'open',
+        hasAttention: true,
+        latestFeedbackAt: '2026-01-15T10:00:00Z'
+      });
+      
+      // Item still has attention with the same feedback timestamp
+      const item = { id: 'pr-1', state: 'open', _has_attention: true, _latest_feedback_at: '2026-01-15T10:00:00Z' };
+      assert.strictEqual(
+        poller.shouldReprocess(item, { reprocessOn: ['attention'] }), 
+        false,
+        'Should NOT reprocess when attention stays true with same feedback'
+      );
+    });
+
+    test('shouldReprocess returns true when attention stays true but feedback is newer (re-review)', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      // Item was processed with attention and a feedback timestamp
+      poller.markProcessed('pr-1', { 
+        source: 'my-prs-attention', 
+        itemState: 'open',
+        hasAttention: true,
+        latestFeedbackAt: '2026-01-15T10:00:00Z'
+      });
+      
+      // Item has newer feedback (re-review or additional comments)
+      const item = { id: 'pr-1', state: 'open', _has_attention: true, _latest_feedback_at: '2026-01-16T14:30:00Z' };
+      assert.strictEqual(
+        poller.shouldReprocess(item, { reprocessOn: ['attention'] }), 
+        true,
+        'Should reprocess when there is newer feedback (re-review)'
+      );
+    });
+
+    test('shouldReprocess returns false when attention stays true with no timestamps', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+      
+      const poller = createPoller({ stateFile });
+      // Legacy item processed with attention but no timestamp
       poller.markProcessed('pr-1', { 
         source: 'my-prs-attention', 
         itemState: 'open',
         hasAttention: true
       });
       
-      // Item still has attention
+      // Item still has attention (no timestamp available either)
       const item = { id: 'pr-1', state: 'open', _has_attention: true };
       assert.strictEqual(
         poller.shouldReprocess(item, { reprocessOn: ['attention'] }), 
         false,
-        'Should NOT reprocess when attention stays true'
+        'Should NOT reprocess when no timestamps available (legacy)'
       );
     });
 
@@ -1388,6 +1430,43 @@ describe('poller.js', () => {
       assert.strictEqual(result[0]._attention_label, 'PR');
       assert.strictEqual(result[0]._has_attention, false);
     });
+
+    test('tracks latest feedback timestamp for detecting re-reviews', async () => {
+      const { computeAttentionLabels } = await import('../../service/poller.js');
+      
+      const items = [{
+        number: 123,
+        title: 'Test PR',
+        user: { login: 'author' },
+        _mergeable: 'MERGEABLE',
+        _comments: [
+          { user: { login: 'reviewer1', type: 'User' }, body: 'Fix this', created_at: '2026-01-10T10:00:00Z', updated_at: '2026-01-10T10:00:00Z' },
+          { user: { login: 'reviewer2', type: 'User' }, state: 'CHANGES_REQUESTED', body: 'Also this', submitted_at: '2026-01-15T14:30:00Z' },
+        ]
+      }];
+      
+      const result = computeAttentionLabels(items, {});
+      
+      assert.strictEqual(result[0]._has_attention, true);
+      assert.strictEqual(result[0]._latest_feedback_at, '2026-01-15T14:30:00Z');
+    });
+
+    test('sets latest feedback timestamp to null when no feedback', async () => {
+      const { computeAttentionLabels } = await import('../../service/poller.js');
+      
+      const items = [{
+        number: 123,
+        title: 'Test PR',
+        user: { login: 'author' },
+        _mergeable: 'MERGEABLE',
+        _comments: []
+      }];
+      
+      const result = computeAttentionLabels(items, {});
+      
+      assert.strictEqual(result[0]._has_attention, false);
+      assert.strictEqual(result[0]._latest_feedback_at, null);
+    });
   });
 
   describe('enrichItemsWithComments', () => {

package/test/unit/utils.test.js

@@ -192,6 +192,71 @@ describe('utils.js', () => {
     });
   });
 
+  describe('getLatestFeedbackTimestamp', () => {
+    test('returns null for empty/null/undefined comments', async () => {
+      const { getLatestFeedbackTimestamp } = await import('../../service/utils.js');
+      
+      assert.strictEqual(getLatestFeedbackTimestamp([], 'author'), null);
+      assert.strictEqual(getLatestFeedbackTimestamp(null, 'author'), null);
+      assert.strictEqual(getLatestFeedbackTimestamp(undefined, 'author'), null);
+    });
+
+    test('returns latest timestamp from actionable feedback', async () => {
+      const { getLatestFeedbackTimestamp } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'reviewer1', type: 'User' }, body: 'Fix this', created_at: '2026-01-10T10:00:00Z', updated_at: '2026-01-10T10:00:00Z' },
+        { user: { login: 'reviewer2', type: 'User' }, body: 'Also this', created_at: '2026-01-15T14:30:00Z', updated_at: '2026-01-15T14:30:00Z' },
+      ];
+      
+      assert.strictEqual(getLatestFeedbackTimestamp(comments, 'author'), '2026-01-15T14:30:00Z');
+    });
+
+    test('uses submitted_at for PR reviews', async () => {
+      const { getLatestFeedbackTimestamp } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'reviewer', type: 'User' }, state: 'CHANGES_REQUESTED', body: 'Fix this', submitted_at: '2026-01-20T09:00:00Z', created_at: '2026-01-15T10:00:00Z' },
+      ];
+      
+      assert.strictEqual(getLatestFeedbackTimestamp(comments, 'author'), '2026-01-20T09:00:00Z');
+    });
+
+    test('ignores bot comments when computing latest timestamp', async () => {
+      const { getLatestFeedbackTimestamp } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'reviewer', type: 'User' }, body: 'Fix this', created_at: '2026-01-10T10:00:00Z', updated_at: '2026-01-10T10:00:00Z' },
+        { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed', created_at: '2026-01-20T10:00:00Z', updated_at: '2026-01-20T10:00:00Z' },
+      ];
+      
+      assert.strictEqual(getLatestFeedbackTimestamp(comments, 'author'), '2026-01-10T10:00:00Z');
+    });
+
+    test('ignores approval-only reviews', async () => {
+      const { getLatestFeedbackTimestamp } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'reviewer', type: 'User' }, body: 'Fix this', created_at: '2026-01-10T10:00:00Z', updated_at: '2026-01-10T10:00:00Z' },
+        { user: { login: 'approver', type: 'User' }, state: 'APPROVED', body: '', submitted_at: '2026-01-20T10:00:00Z' },
+      ];
+      
+      // Approval-only should be filtered out, latest is the first comment
+      assert.strictEqual(getLatestFeedbackTimestamp(comments, 'author'), '2026-01-10T10:00:00Z');
+    });
+
+    test('returns null when only bot comments exist', async () => {
+      const { getLatestFeedbackTimestamp } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'linear', type: 'User' }, body: 'ENG-123', created_at: '2026-01-10T10:00:00Z' },
+        { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed', created_at: '2026-01-15T10:00:00Z' },
+      ];
+      
+      assert.strictEqual(getLatestFeedbackTimestamp(comments, 'author'), null);
+    });
+  });
+
   describe('isApprovalOnly', () => {
     test('returns true for APPROVED state with no body', async () => {
       const { isApprovalOnly } = await import('../../service/utils.js');