opencode-pilot 0.1.0

package/service/poller.js

@@ -0,0 +1,339 @@
+/**
+ * poller.js - MCP-based polling for automation sources
+ *
+ * Connects to MCP servers (GitHub, Linear) to fetch items for automation.
+ * Tracks processed items to avoid duplicate handling.
+ */
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { getNestedValue } from "./utils.js";
+
+/**
+ * Expand template string with item fields
+ * Supports {field} and {field.nested} syntax
+ * @param {string} template - Template with {placeholders}
+ * @param {object} item - Item with fields to substitute
+ * @returns {string} Expanded string
+ */
+export function expandItemId(template, item) {
+  return template.replace(/\{([^}]+)\}/g, (match, fieldPath) => {
+    const value = getNestedValue(item, fieldPath);
+    return value !== undefined ? String(value) : match;
+  });
+}
+
+/**
+ * Apply field mappings to an item
+ * Mappings define how to map source fields to standard fields
+ * 
+ * Supports:
+ * - Simple path: "fieldName" or "nested.field.path"
+ * - Regex extraction: "url:/issue/([A-Z]+-\d+)/" extracts from url field using regex
+ * 
+ * @param {object} item - Raw item from MCP tool
+ * @param {object|null} mappings - Field mappings { targetField: "source.field.path" }
+ * @returns {object} Item with mapped fields added (original fields preserved)
+ */
+export function applyMappings(item, mappings) {
+  if (!mappings) return item;
+
+  const result = { ...item };
+
+  for (const [targetField, sourcePath] of Object.entries(mappings)) {
+    // Check for regex extraction syntax: "field:/regex/"
+    const regexMatch = sourcePath.match(/^(\w+):\/(.+)\/$/);
+    if (regexMatch) {
+      const [, field, pattern] = regexMatch;
+      const fieldValue = getNestedValue(item, field);
+      if (fieldValue) {
+        const regex = new RegExp(pattern);
+        const match = String(fieldValue).match(regex);
+        result[targetField] = match ? (match[1] || match[0]) : undefined;
+      }
+    } else {
+      // Simple field path
+      result[targetField] = getNestedValue(item, sourcePath);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Get tool configuration from a source
+ * @param {object} source - Source configuration from config.yaml
+ * @returns {object} Tool configuration
+ */
+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)`);
+  }
+
+  return {
+    mcpServer: source.tool.mcp,
+    toolName: source.tool.name,
+    args: source.args || {},
+    idTemplate: source.item?.id || null,
+  };
+}
+
+/**
+ * Transform items by adding IDs using template
+ * @param {Array} items - Raw items from MCP tool
+ * @param {string|null} idTemplate - Template for generating IDs
+ * @returns {Array} Items with id field added
+ */
+export function transformItems(items, idTemplate) {
+  let counter = 0;
+  return items.map((item) => {
+    let id;
+    if (idTemplate) {
+      id = expandItemId(idTemplate, item);
+    } else if (item.id) {
+      id = item.id;
+    } else {
+      // Generate a fallback ID
+      id = `item-${Date.now()}-${counter++}`;
+    }
+    return { ...item, id };
+  });
+}
+
+/**
+ * Parse JSON text as an array with error handling
+ */
+function parseJsonArray(text, sourceName) {
+  try {
+    const data = JSON.parse(text);
+    if (Array.isArray(data)) return data;
+    if (data.items) return data.items;
+    if (data.issues) return data.issues;
+    if (data.nodes) return data.nodes;
+    return [data];
+  } catch (err) {
+    console.error(`[poller] Failed to parse ${sourceName} response:`, err.message);
+    return [];
+  }
+}
+
+/**
+ * Expand environment variables in a string
+ */
+function expandEnvVars(str) {
+  return str.replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] || "");
+}
+
+/**
+ * Create appropriate transport based on MCP config
+ */
+async function createTransport(mcpConfig) {
+  const headers = {};
+  if (mcpConfig.headers) {
+    for (const [key, value] of Object.entries(mcpConfig.headers)) {
+      headers[key] = expandEnvVars(value);
+    }
+  }
+
+  if (mcpConfig.type === "remote") {
+    const url = new URL(mcpConfig.url);
+    if (mcpConfig.url.includes("linear.app/sse")) {
+      return new SSEClientTransport(url, { requestInit: { headers } });
+    } else {
+      return new StreamableHTTPClientTransport(url, { requestInit: { headers } });
+    }
+  } else if (mcpConfig.type === "local") {
+    const command = mcpConfig.command;
+    if (!command || command.length === 0) {
+      throw new Error("Local MCP config missing command");
+    }
+    const [cmd, ...args] = command;
+    return new StdioClientTransport({
+      command: cmd,
+      args,
+      env: { ...process.env },
+    });
+  }
+
+  throw new Error(`Unknown MCP type: ${mcpConfig.type}`);
+}
+
+/**
+ * Get MCP config from opencode.json
+ */
+function getMcpConfig(serverName, configPath) {
+  const actualPath = configPath || path.join(os.homedir(), ".config/opencode/opencode.json");
+  
+  if (!fs.existsSync(actualPath)) {
+    throw new Error(`MCP config not found: ${actualPath}`);
+  }
+
+  const config = JSON.parse(fs.readFileSync(actualPath, "utf-8"));
+  const mcpConfig = config.mcp?.[serverName];
+
+  if (!mcpConfig) {
+    throw new Error(`MCP server '${serverName}' not configured`);
+  }
+
+  if (mcpConfig.enabled === false) {
+    throw new Error(`MCP server '${serverName}' is disabled`);
+  }
+
+  return mcpConfig;
+}
+
+// Default timeout for MCP connections (30 seconds)
+const DEFAULT_MCP_TIMEOUT = 30000;
+
+/**
+ * Create a timeout promise that rejects after specified ms
+ */
+function createTimeout(ms, operation) {
+  return new Promise((_, reject) => {
+    setTimeout(() => reject(new Error(`${operation} timed out after ${ms}ms`)), ms);
+  });
+}
+
+/**
+ * Poll a source using MCP tools
+ * 
+ * @param {object} source - Source configuration from config.yaml
+ * @param {object} [options] - Additional options
+ * @param {number} [options.timeout] - Timeout in ms (default: 30000)
+ * @param {string} [options.opencodeConfigPath] - Path to opencode.json for MCP config
+ * @param {object} [options.mappings] - Field mappings to apply to items
+ * @returns {Promise<Array>} Array of items from the source with IDs and mappings applied
+ */
+export async function pollGenericSource(source, options = {}) {
+  const toolConfig = getToolConfig(source);
+  const timeout = options.timeout || DEFAULT_MCP_TIMEOUT;
+  const mappings = options.mappings || null;
+  const mcpConfig = getMcpConfig(toolConfig.mcpServer, options.opencodeConfigPath);
+  const client = new Client({ name: "opencode-pilot", version: "1.0.0" });
+
+  try {
+    const transport = await createTransport(mcpConfig);
+    
+    // Connect with timeout
+    await Promise.race([
+      client.connect(transport),
+      createTimeout(timeout, "MCP connection"),
+    ]);
+
+    // Call the tool directly with provided args
+    const result = await Promise.race([
+      client.callTool({ name: toolConfig.toolName, arguments: toolConfig.args }),
+      createTimeout(timeout, "callTool"),
+    ]);
+
+    // Parse the response
+    const text = result.content?.[0]?.text;
+    if (!text) return [];
+    
+    const rawItems = parseJsonArray(text, source.name);
+    
+    // Apply field mappings before transforming
+    const mappedItems = mappings 
+      ? rawItems.map(item => applyMappings(item, mappings))
+      : rawItems;
+    
+    // Transform items (add IDs)
+    return transformItems(mappedItems, toolConfig.idTemplate);
+  } finally {
+    try {
+      // Close with timeout to prevent hanging on unresponsive MCP servers
+      await Promise.race([
+        client.close(),
+        new Promise(resolve => setTimeout(resolve, 3000)),
+      ]);
+    } catch {
+      // Ignore close errors
+    }
+  }
+}
+
+/**
+ * Create a poller instance with state tracking
+ * 
+ * @param {object} options - Poller options
+ * @param {string} [options.stateFile] - Path to state file for tracking processed items
+ * @param {string} [options.configPath] - Path to opencode.json
+ * @returns {object} Poller instance
+ */
+export function createPoller(options = {}) {
+  const stateFile = options.stateFile || path.join(os.homedir(), '.config/opencode-pilot/poll-state.json');
+  const configPath = options.configPath;
+  
+  // Load existing state
+  let processedItems = new Map();
+  if (fs.existsSync(stateFile)) {
+    try {
+      const state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+      if (state.processed) {
+        processedItems = new Map(Object.entries(state.processed));
+      }
+    } catch {
+      // Start fresh if state is corrupted
+    }
+  }
+  
+  function saveState() {
+    const dir = path.dirname(stateFile);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const state = {
+      processed: Object.fromEntries(processedItems),
+      savedAt: new Date().toISOString(),
+    };
+    fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
+  }
+  
+  return {
+    /**
+     * Check if an item has been processed
+     */
+    isProcessed(itemId) {
+      return processedItems.has(itemId);
+    },
+    
+    /**
+     * Mark an item as processed
+     */
+    markProcessed(itemId, metadata = {}) {
+      processedItems.set(itemId, {
+        processedAt: new Date().toISOString(),
+        ...metadata,
+      });
+      saveState();
+    },
+    
+    /**
+     * Clear a specific item from processed state
+     */
+    clearProcessed(itemId) {
+      processedItems.delete(itemId);
+      saveState();
+    },
+    
+    /**
+     * Clear all processed state
+     */
+    clearState() {
+      processedItems.clear();
+      saveState();
+    },
+    
+    /**
+     * Get all processed item IDs
+     */
+    getProcessedIds() {
+      return Array.from(processedItems.keys());
+    },
+  };
+}

package/service/readiness.js

@@ -0,0 +1,234 @@
+/**
+ * readiness.js - Issue readiness evaluation for self-iteration
+ *
+ * Evaluates whether an issue is ready to be worked on based on:
+ * - Label constraints (blocking labels, required labels)
+ * - Dependencies (blocked by references in body)
+ * - Priority scoring (label weights, age bonus)
+ */
+
+/**
+ * Dependency reference patterns in issue body
+ */
+const DEPENDENCY_PATTERNS = [
+  /blocked by #\d+/i,
+  /blocked by [a-zA-Z0-9_-]+\/[a-zA-Z0-9_-]+#\d+/i,
+  /depends on #\d+/i,
+  /depends on [a-zA-Z0-9_-]+\/[a-zA-Z0-9_-]+#\d+/i,
+  /requires #\d+/i,
+  /waiting on #\d+/i,
+  /waiting for #\d+/i,
+  /after #\d+/i,
+];
+
+/**
+ * Check if issue passes label constraints
+ * @param {object} issue - Issue with labels array
+ * @param {object} config - Repo config with readiness settings
+ * @returns {object} { ready: boolean, reason?: string }
+ */
+export function checkLabels(issue, config) {
+  const labels = issue.labels || [];
+  const labelNames = labels.map((l) =>
+    typeof l === "string" ? l.toLowerCase() : (l.name || "").toLowerCase()
+  );
+
+  const readinessConfig = config.readiness || {};
+  const labelConfig = readinessConfig.labels || {};
+
+  // Check exclude labels (blocking)
+  const excludeLabels = (labelConfig.exclude || []).map((l) => l.toLowerCase());
+  const blockingLabels = (
+    readinessConfig.dependencies?.blocking_labels || []
+  ).map((l) => l.toLowerCase());
+
+  const allBlocked = [...new Set([...excludeLabels, ...blockingLabels])];
+
+  for (const blockedLabel of allBlocked) {
+    if (labelNames.includes(blockedLabel)) {
+      return {
+        ready: false,
+        reason: `Has blocking label: ${blockedLabel}`,
+      };
+    }
+  }
+
+  // Check required labels (must have all)
+  const requiredLabels = (labelConfig.required || []).map((l) =>
+    l.toLowerCase()
+  );
+  for (const required of requiredLabels) {
+    if (!labelNames.includes(required)) {
+      return {
+        ready: false,
+        reason: `Missing required label: ${required}`,
+      };
+    }
+  }
+
+  // Check any_of labels (must have at least one)
+  const anyOfLabels = (labelConfig.any_of || []).map((l) => l.toLowerCase());
+  if (anyOfLabels.length > 0) {
+    const hasAny = anyOfLabels.some((l) => labelNames.includes(l));
+    if (!hasAny) {
+      return {
+        ready: false,
+        reason: `Missing one of required labels: ${anyOfLabels.join(", ")}`,
+      };
+    }
+  }
+
+  return { ready: true };
+}
+
+/**
+ * Check if issue has dependency references in body
+ * @param {object} issue - Issue with body string
+ * @param {object} config - Repo config with readiness settings
+ * @returns {object} { ready: boolean, reason?: string, dependencies?: string[] }
+ */
+export function checkDependencies(issue, config) {
+  const readinessConfig = config.readiness || {};
+  const depConfig = readinessConfig.dependencies || {};
+
+  // Check if body reference checking is enabled
+  if (depConfig.check_body_references === false) {
+    return { ready: true };
+  }
+
+  const body = issue.body || "";
+  const bodyLower = body.toLowerCase();
+  const foundDependencies = [];
+
+  // Check explicit dependency patterns
+  for (const pattern of DEPENDENCY_PATTERNS) {
+    const match = bodyLower.match(pattern);
+    if (match) {
+      foundDependencies.push(match[0]);
+    }
+  }
+
+  if (foundDependencies.length > 0) {
+    return {
+      ready: false,
+      reason: `Has dependency references: ${foundDependencies.join(", ")}`,
+      dependencies: foundDependencies,
+    };
+  }
+
+  // Check for unchecked task list items (GitHub checkbox syntax)
+  const uncheckedTasks = body.match(/^\s*[-*]\s*\[ \]/gm) || [];
+  const checkedTasks = body.match(/^\s*[-*]\s*\[x\]/gim) || [];
+
+  // If this looks like a tracking issue with subtasks and has unchecked items
+  if (uncheckedTasks.length > 0 && checkedTasks.length + uncheckedTasks.length > 1) {
+    return {
+      ready: false,
+      reason: `Has ${uncheckedTasks.length} unchecked subtasks`,
+    };
+  }
+
+  return { ready: true };
+}
+
+/**
+ * Calculate priority score for an issue
+ * @param {object} issue - Issue with labels and created_at
+ * @param {object} config - Repo config with readiness settings
+ * @returns {number} Priority score (higher = more urgent)
+ */
+export function calculatePriority(issue, config) {
+  const readinessConfig = config.readiness || {};
+  const priorityConfig = readinessConfig.priority || {};
+
+  let score = 0;
+
+  // Label-based priority
+  const labels = issue.labels || [];
+  const labelNames = labels.map((l) =>
+    typeof l === "string" ? l.toLowerCase() : (l.name || "").toLowerCase()
+  );
+
+  const labelWeights = priorityConfig.labels || [];
+  for (const { label, weight } of labelWeights) {
+    if (labelNames.includes(label.toLowerCase())) {
+      score += weight || 0;
+    }
+  }
+
+  // Age-based priority (older issues get higher priority)
+  const ageWeight = priorityConfig.age_weight || 0;
+  if (ageWeight > 0 && issue.created_at) {
+    const createdAt = new Date(issue.created_at);
+    const ageInDays = (Date.now() - createdAt.getTime()) / (1000 * 60 * 60 * 24);
+    score += ageInDays * ageWeight;
+  }
+
+  return Math.round(score * 100) / 100;
+}
+
+/**
+ * Evaluate overall readiness of an issue
+ * @param {object} issue - Issue object
+ * @param {object} config - Repo config with readiness settings
+ * @returns {object} { ready: boolean, reason?: string, priority: number }
+ */
+export function evaluateReadiness(issue, config) {
+  // Check labels first
+  const labelResult = checkLabels(issue, config);
+  if (!labelResult.ready) {
+    return {
+      ready: false,
+      reason: labelResult.reason,
+      priority: 0,
+    };
+  }
+
+  // Check dependencies
+  const depResult = checkDependencies(issue, config);
+  if (!depResult.ready) {
+    return {
+      ready: false,
+      reason: depResult.reason,
+      priority: 0,
+    };
+  }
+
+  // Calculate priority for ready issues
+  const priority = calculatePriority(issue, config);
+
+  return {
+    ready: true,
+    priority,
+  };
+}
+
+/**
+ * Sort issues by priority (highest first)
+ * @param {Array} issues - Array of issues
+ * @param {object} config - Repo config
+ * @returns {Array} Sorted issues with priority scores
+ */
+export function sortByPriority(issues, config) {
+  return issues
+    .map((issue) => ({
+      ...issue,
+      _priority: calculatePriority(issue, config),
+    }))
+    .sort((a, b) => b._priority - a._priority);
+}
+
+/**
+ * Filter issues to only ready ones
+ * @param {Array} issues - Array of issues
+ * @param {object} config - Repo config
+ * @returns {Array} Ready issues with evaluation results
+ */
+export function filterReady(issues, config) {
+  return issues
+    .map((issue) => ({
+      ...issue,
+      _readiness: evaluateReadiness(issue, config),
+    }))
+    .filter((issue) => issue._readiness.ready);
+}