opencode-pilot 0.11.1 → 0.12.0

package/package.json

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

package/service/poll-service.js

@@ -146,7 +146,17 @@ export async function pollOnce(options = {}) {
         const repoKey = repoKeys.length > 0 ? repoKeys[0] : null;
         const repoConfig = repoKey ? getRepoConfig(repoKey) : {};
         
-        const readiness = evaluateReadiness(item, repoConfig);
+        // Merge source-level readiness config with repo config
+        // Source readiness takes precedence
+        const readinessConfig = {
+          ...repoConfig,
+          readiness: {
+            ...repoConfig.readiness,
+            ...source.readiness,
+          },
+        };
+        
+        const readiness = evaluateReadiness(item, readinessConfig);
         debug(`Item ${item.id}: ready=${readiness.ready}, reason=${readiness.reason || 'none'}`);
         return {
           ...item,

package/service/readiness.js

@@ -134,6 +134,46 @@ export function checkDependencies(issue, config) {
   return { ready: true };
 }
 
+/**
+ * Check if item fields match required values
+ * 
+ * Generic field-based readiness check. Configured via readiness.fields in config.
+ * All specified fields must match their required values for the item to be ready.
+ * 
+ * Example config:
+ *   readiness:
+ *     fields:
+ *       has_notes: true
+ *       type: "meeting"
+ * 
+ * @param {object} item - Item with fields to check
+ * @param {object} config - Config with optional readiness.fields
+ * @returns {object} { ready: boolean, reason?: string }
+ */
+export function checkFields(item, config) {
+  const readinessConfig = config.readiness || {};
+  const fieldsConfig = readinessConfig.fields || {};
+  
+  // No fields configured - skip check
+  if (Object.keys(fieldsConfig).length === 0) {
+    return { ready: true };
+  }
+  
+  // Check each required field
+  for (const [field, requiredValue] of Object.entries(fieldsConfig)) {
+    const actualValue = item[field];
+    
+    if (actualValue !== requiredValue) {
+      return {
+        ready: false,
+        reason: `Field '${field}' is ${JSON.stringify(actualValue)}, required ${JSON.stringify(requiredValue)}`,
+      };
+    }
+  }
+  
+  return { ready: true };
+}
+
 /**
  * Check if a PR/issue has meaningful (non-bot, non-author) comments
  * 
@@ -246,6 +286,16 @@ export function evaluateReadiness(issue, config) {
     };
   }
 
+  // Check required field values
+  const fieldsResult = checkFields(issue, config);
+  if (!fieldsResult.ready) {
+    return {
+      ready: false,
+      reason: fieldsResult.reason,
+      priority: 0,
+    };
+  }
+
   // Calculate priority for ready issues
   const priority = calculatePriority(issue, config);
 

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

@@ -172,6 +172,143 @@ describe('readiness.js', () => {
     });
   });
 
+  describe('checkFields', () => {
+    test('returns ready when no fields configured', async () => {
+      const { checkFields } = await import('../../service/readiness.js');
+      
+      const item = { id: 'item-1', has_notes: false };
+      const config = {};
+      
+      const result = checkFields(item, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns ready when field matches required value (boolean)', async () => {
+      const { checkFields } = await import('../../service/readiness.js');
+      
+      const meeting = { id: 'meeting-1', has_notes: true };
+      const config = {
+        readiness: {
+          fields: {
+            has_notes: true
+          }
+        }
+      };
+      
+      const result = checkFields(meeting, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns not ready when field does not match required value', async () => {
+      const { checkFields } = await import('../../service/readiness.js');
+      
+      const meeting = { id: 'meeting-1', has_notes: false };
+      const config = {
+        readiness: {
+          fields: {
+            has_notes: true
+          }
+        }
+      };
+      
+      const result = checkFields(meeting, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('has_notes'));
+    });
+
+    test('returns not ready when required field is missing', async () => {
+      const { checkFields } = await import('../../service/readiness.js');
+      
+      const item = { id: 'item-1', title: 'Test' };
+      const config = {
+        readiness: {
+          fields: {
+            has_notes: true
+          }
+        }
+      };
+      
+      const result = checkFields(item, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('has_notes'));
+    });
+
+    test('checks multiple fields (all must match)', async () => {
+      const { checkFields } = await import('../../service/readiness.js');
+      
+      const item = { id: 'item-1', has_notes: true, type: 'meeting' };
+      const config = {
+        readiness: {
+          fields: {
+            has_notes: true,
+            type: 'meeting'
+          }
+        }
+      };
+      
+      const result = checkFields(item, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('fails if any field does not match', async () => {
+      const { checkFields } = await import('../../service/readiness.js');
+      
+      const item = { id: 'item-1', has_notes: true, type: 'note' };
+      const config = {
+        readiness: {
+          fields: {
+            has_notes: true,
+            type: 'meeting'
+          }
+        }
+      };
+      
+      const result = checkFields(item, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('type'));
+    });
+
+    test('supports string field values', async () => {
+      const { checkFields } = await import('../../service/readiness.js');
+      
+      const item = { id: 'item-1', state: 'open' };
+      const config = {
+        readiness: {
+          fields: {
+            state: 'open'
+          }
+        }
+      };
+      
+      const result = checkFields(item, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('supports numeric field values', async () => {
+      const { checkFields } = await import('../../service/readiness.js');
+      
+      const item = { id: 'item-1', participant_count: 3 };
+      const config = {
+        readiness: {
+          fields: {
+            participant_count: 3
+          }
+        }
+      };
+      
+      const result = checkFields(item, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+  });
+
   describe('evaluateReadiness', () => {
     test('checks bot comments when _comments is present', async () => {
       const { evaluateReadiness } = await import('../../service/readiness.js');
@@ -206,5 +343,48 @@ describe('readiness.js', () => {
       
       assert.strictEqual(result.ready, true);
     });
+
+    test('checks fields when readiness.fields is configured', async () => {
+      const { evaluateReadiness } = await import('../../service/readiness.js');
+      
+      const meeting = {
+        id: 'meeting-123',
+        title: 'Team Standup',
+        has_notes: false
+      };
+      const config = {
+        readiness: {
+          fields: {
+            has_notes: true
+          }
+        }
+      };
+      
+      const result = evaluateReadiness(meeting, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('has_notes'));
+    });
+
+    test('passes when field matches required value', async () => {
+      const { evaluateReadiness } = await import('../../service/readiness.js');
+      
+      const meeting = {
+        id: 'meeting-123',
+        title: 'Team Standup',
+        has_notes: true
+      };
+      const config = {
+        readiness: {
+          fields: {
+            has_notes: true
+          }
+        }
+      };
+      
+      const result = evaluateReadiness(meeting, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
   });
 });

package/test/unit/repo-config.test.js

@@ -700,8 +700,9 @@ sources:
       loadRepoConfig(configPath);
       const sources = getSources();
 
-      assert.strictEqual(sources[0].session.name, '{title}', 'linear/my-issues should use title');
+      assert.strictEqual(sources[0].session.name, '{title}', 'linear preset should use title');
     });
+
   });
 
   describe('shorthand syntax', () => {

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', () => {