opencode-pilot 0.11.2 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-pilot",
-  "version": "0.11.2",
+  "version": "0.13.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/poller.js

@@ -67,15 +67,33 @@ export function applyMappings(item, mappings) {
 
 /**
  * Get tool configuration from a source
+ * Supports both MCP tools and CLI commands.
+ * 
  * @param {object} source - Source configuration from config.yaml
- * @returns {object} Tool configuration
+ * @returns {object} Tool configuration with type indicator
  */
 export function getToolConfig(source) {
-  if (!source.tool || !source.tool.mcp || !source.tool.name) {
-    throw new Error(`Source '${source.name || 'unknown'}' missing tool configuration (requires tool.mcp and tool.name)`);
+  if (!source.tool) {
+    throw new Error(`Source '${source.name || 'unknown'}' missing tool configuration`);
+  }
+
+  // CLI command support
+  if (source.tool.command) {
+    return {
+      type: 'cli',
+      command: source.tool.command,
+      args: source.args || {},
+      idTemplate: source.item?.id || null,
+    };
+  }
+
+  // MCP tool support (existing behavior)
+  if (!source.tool.mcp || !source.tool.name) {
+    throw new Error(`Source '${source.name || 'unknown'}' missing tool configuration (requires tool.mcp and tool.name, or tool.command)`);
   }
 
   return {
+    type: 'mcp',
     mcpServer: source.tool.mcp,
     toolName: source.tool.name,
     args: source.args || {},
@@ -214,7 +232,84 @@ function createTimeout(ms, operation) {
 }
 
 /**
- * Poll a source using MCP tools
+ * Execute a CLI command and return parsed JSON output
+ * 
+ * @param {string|string[]} command - Command to execute (string or array)
+ * @param {object} args - Arguments to substitute into command
+ * @param {number} timeout - Timeout in ms
+ * @returns {Promise<string>} Command output
+ */
+async function executeCliCommand(command, args, timeout) {
+  const { exec } = await import('child_process');
+  const { promisify } = await import('util');
+  const execAsync = promisify(exec);
+
+  // Build command string
+  let cmdStr;
+  if (Array.isArray(command)) {
+    // Substitute args into command array
+    const expandedCmd = command.map(part => {
+      if (typeof part === 'string' && part.startsWith('$')) {
+        const argName = part.slice(1);
+        return args[argName] !== undefined ? String(args[argName]) : part;
+      }
+      return part;
+    });
+    // Quote parts with spaces
+    cmdStr = expandedCmd.map(p => p.includes(' ') ? `"${p}"` : p).join(' ');
+  } else {
+    // String command - substitute ${argName} patterns
+    cmdStr = command.replace(/\$\{(\w+)\}/g, (_, name) => {
+      return args[name] !== undefined ? String(args[name]) : '';
+    });
+  }
+
+  const { stdout } = await Promise.race([
+    execAsync(cmdStr, { env: { ...process.env } }),
+    createTimeout(timeout, `CLI command: ${cmdStr.slice(0, 50)}...`),
+  ]);
+
+  return stdout;
+}
+
+/**
+ * Poll a source using CLI command
+ * 
+ * @param {object} source - Source configuration from config.yaml
+ * @param {object} toolConfig - Tool config from getToolConfig()
+ * @param {object} [options] - Additional options
+ * @param {number} [options.timeout] - Timeout in ms (default: 30000)
+ * @param {object} [options.toolProviderConfig] - Tool provider config (response_key, mappings)
+ * @returns {Promise<Array>} Array of items from the source with IDs and mappings applied
+ */
+async function pollCliSource(source, toolConfig, options = {}) {
+  const timeout = options.timeout || DEFAULT_MCP_TIMEOUT;
+  const toolProviderConfig = options.toolProviderConfig || {};
+  const responseKey = toolProviderConfig.response_key;
+  const mappings = toolProviderConfig.mappings || null;
+
+  try {
+    const output = await executeCliCommand(toolConfig.command, toolConfig.args, timeout);
+    
+    if (!output || !output.trim()) return [];
+
+    const rawItems = parseJsonArray(output, source.name, responseKey);
+
+    // Apply field mappings before transforming
+    const mappedItems = mappings
+      ? rawItems.map(item => applyMappings(item, mappings))
+      : rawItems;
+
+    // Transform items (add IDs)
+    return transformItems(mappedItems, toolConfig.idTemplate);
+  } catch (err) {
+    console.error(`[poller] CLI command failed for ${source.name}: ${err.message}`);
+    return [];
+  }
+}
+
+/**
+ * Poll a source using MCP tools or CLI commands
  * 
  * @param {object} source - Source configuration from config.yaml
  * @param {object} [options] - Additional options
@@ -225,6 +320,13 @@ function createTimeout(ms, operation) {
  */
 export async function pollGenericSource(source, options = {}) {
   const toolConfig = getToolConfig(source);
+
+  // Route to CLI handler if command-based
+  if (toolConfig.type === 'cli') {
+    return pollCliSource(source, toolConfig, options);
+  }
+
+  // MCP-based polling (existing behavior)
   const timeout = options.timeout || DEFAULT_MCP_TIMEOUT;
   const toolProviderConfig = options.toolProviderConfig || {};
   const responseKey = toolProviderConfig.response_key;

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

@@ -57,6 +57,60 @@ describe('poller.js', () => {
     });
   });
 
+  describe('getToolConfig', () => {
+    test('returns MCP config for mcp-based sources', async () => {
+      const { getToolConfig } = await import('../../service/poller.js');
+      
+      const source = {
+        name: 'test-source',
+        tool: { mcp: 'github', name: 'search_issues' },
+        args: { q: 'is:open' },
+        item: { id: '{html_url}' }
+      };
+      
+      const config = getToolConfig(source);
+      assert.strictEqual(config.type, 'mcp');
+      assert.strictEqual(config.mcpServer, 'github');
+      assert.strictEqual(config.toolName, 'search_issues');
+      assert.deepStrictEqual(config.args, { q: 'is:open' });
+      assert.strictEqual(config.idTemplate, '{html_url}');
+    });
+
+    test('returns CLI config for command-based sources', async () => {
+      const { getToolConfig } = await import('../../service/poller.js');
+      
+      const source = {
+        name: 'test-source',
+        tool: { command: ['granola-cli', 'meetings', 'list', '20'] },
+        item: { id: 'meeting:{id}' }
+      };
+      
+      const config = getToolConfig(source);
+      assert.strictEqual(config.type, 'cli');
+      assert.deepStrictEqual(config.command, ['granola-cli', 'meetings', 'list', '20']);
+      assert.strictEqual(config.idTemplate, 'meeting:{id}');
+    });
+
+    test('throws for sources missing tool config', async () => {
+      const { getToolConfig } = await import('../../service/poller.js');
+      
+      const source = { name: 'bad-source' };
+      
+      assert.throws(() => getToolConfig(source), /missing tool configuration/);
+    });
+
+    test('throws for mcp sources missing name', async () => {
+      const { getToolConfig } = await import('../../service/poller.js');
+      
+      const source = {
+        name: 'bad-source',
+        tool: { mcp: 'github' } // missing name
+      };
+      
+      assert.throws(() => getToolConfig(source), /missing tool configuration/);
+    });
+  });
+
   describe('createPoller', () => {
     test('creates poller with state tracking', async () => {
       const { createPoller } = await import('../../service/poller.js');

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