opencode-pilot 0.1.0

package/service/actions.js

@@ -0,0 +1,334 @@
+/**
+ * actions.js - Action system for starting sessions
+ *
+ * Starts OpenCode sessions with configurable prompts.
+ * Supports prompt_template for custom prompts (e.g., to invoke /devcontainer).
+ */
+
+import { spawn } from "child_process";
+import { readFileSync, existsSync } from "fs";
+import { debug } from "./logger.js";
+import { getNestedValue } from "./utils.js";
+import path from "path";
+import os from "os";
+
+// Default templates directory
+const DEFAULT_TEMPLATES_DIR = path.join(
+  os.homedir(),
+  ".config/opencode-pilot/templates"
+);
+
+/**
+ * Expand ~ to home directory
+ */
+function expandPath(p) {
+  if (p.startsWith("~")) {
+    return path.join(os.homedir(), p.slice(1));
+  }
+  return p;
+}
+
+/**
+ * Expand a template string with item fields
+ * Supports both simple ({field}) and nested ({field.subfield}) references
+ * @param {string} template - Template with {placeholders}
+ * @param {object} item - Item with fields to substitute
+ * @returns {string} Expanded string
+ */
+export function expandTemplate(template, item) {
+  return template.replace(/\{([\w.]+)\}/g, (match, key) => {
+    const value = getNestedValue(item, key);
+    return value !== undefined ? String(value) : match;
+  });
+}
+
+/**
+ * Build session name from template
+ * @param {string} template - Template with {placeholders}
+ * @param {object} item - Item with fields to substitute
+ * @returns {string} Expanded session name
+ */
+export function buildSessionName(template, item) {
+  return expandTemplate(template, item);
+}
+
+/**
+ * Load a template file and expand it with item fields
+ * @param {string} templateName - Template name (without .md extension)
+ * @param {object} item - Item with fields to substitute
+ * @param {string} [templatesDir] - Templates directory path (for testing)
+ * @returns {string} Expanded template, or fallback to title+body
+ */
+export function buildPromptFromTemplate(templateName, item, templatesDir) {
+  const dir = templatesDir || DEFAULT_TEMPLATES_DIR;
+  const templatePath = path.join(dir, `${templateName}.md`);
+
+  let template;
+  if (existsSync(templatePath)) {
+    template = readFileSync(templatePath, "utf-8");
+  } else {
+    // Fallback: combine title and body
+    const parts = [];
+    if (item.title) parts.push(item.title);
+    if (item.body) parts.push(item.body);
+    return parts.join("\n\n");
+  }
+
+  return expandTemplate(template, item);
+}
+
+/**
+ * Merge source, repo config, and defaults into action config
+ * Priority: source > repo > defaults
+ * @param {object} source - Source configuration
+ * @param {object} repoConfig - Repository configuration
+ * @param {object} defaults - Default configuration
+ * @returns {object} Merged action config
+ */
+export function getActionConfig(source, repoConfig, defaults) {
+  return {
+    // Defaults first
+    ...defaults,
+    // Repo config overrides defaults
+    ...repoConfig,
+    // Preserve nested session config
+    session: {
+      ...(defaults.session || {}),
+      ...(repoConfig.session || {}),
+    },
+    // Source-level overrides (highest priority)
+    ...(source.prompt && { prompt: source.prompt }),
+    ...(source.agent && { agent: source.agent }),
+    ...(source.model && { model: source.model }),
+    ...(source.working_dir && { working_dir: source.working_dir }),
+  };
+}
+
+/**
+ * Get command info using new config format
+ * @param {object} item - Item to create session for
+ * @param {object} config - Merged action config
+ * @param {string} [templatesDir] - Templates directory path (for testing)
+ * @returns {object} { args: string[], cwd: string }
+ */
+export function getCommandInfoNew(item, config, templatesDir) {
+  // Determine working directory: working_dir > path > repo_path > home
+  const workingDir = config.working_dir || config.path || config.repo_path || "~";
+  const cwd = expandPath(workingDir);
+
+  // Build session name
+  const sessionName = config.session?.name
+    ? buildSessionName(config.session.name, item)
+    : `session-${item.number || item.id || Date.now()}`;
+
+  // Build command args
+  const args = ["opencode", "run"];
+  
+  // Add session title
+  args.push("--title", sessionName);
+  
+  // Add agent if specified
+  if (config.agent) {
+    args.push("--agent", config.agent);
+  }
+  
+  // Add model if specified
+  if (config.model) {
+    args.push("--model", config.model);
+  }
+
+  // Build prompt from template
+  const prompt = buildPromptFromTemplate(config.prompt || "default", item, templatesDir);
+  if (prompt) {
+    args.push(prompt);
+  }
+
+  return { args, cwd };
+}
+
+/**
+ * Build the prompt from item and config
+ * Uses prompt_template if provided, otherwise combines title and body
+ * @param {object} item - Item with title, body, etc.
+ * @param {object} config - Config with optional session.prompt_template
+ * @returns {string} The prompt to send to opencode
+ */
+function buildPrompt(item, config) {
+  // If prompt_template is provided, expand it
+  if (config.session?.prompt_template) {
+    return expandTemplate(config.session.prompt_template, item);
+  }
+  
+  // Default: combine title and body
+  const parts = [];
+  if (item.title) parts.push(item.title);
+  if (item.body) parts.push(item.body);
+  return parts.join("\n\n");
+}
+
+/**
+ * Build command args for action
+ * Uses "opencode run" for non-interactive execution
+ * @returns {object} { args: string[], cwd: string }
+ */
+function buildCommandArgs(item, config) {
+  const repoPath = expandPath(config.repo_path || ".");
+  const sessionTitle = config.session?.name_template
+    ? buildSessionName(config.session.name_template, item)
+    : `issue-${item.number || Date.now()}`;
+
+  // Build opencode run command args array (non-interactive)
+  // Note: --title sets session title (--session is for continuing existing sessions)
+  const args = ["opencode", "run"];
+
+  // Add title for the session (helps identify it later)
+  args.push("--title", sessionTitle);
+
+  // Add agent if specified
+  if (config.session?.agent) {
+    args.push("--agent", config.session.agent);
+  }
+
+  // Add prompt (must be last for "run" command)
+  const prompt = buildPrompt(item, config);
+  if (prompt) {
+    args.push(prompt);
+  }
+
+  return { args, cwd: repoPath };
+}
+
+/**
+ * Get command info for an action
+ * @param {object} item - Item to create session for
+ * @param {object} config - Repo config with action settings
+ * @returns {object} { args: string[], cwd: string }
+ */
+export function getCommandInfo(item, config) {
+  return getCommandInfoNew(item, config);
+}
+
+/**
+ * Build command string for display/logging
+ * @param {object} item - Item to create session for
+ * @param {object} config - Repo config with action settings
+ * @returns {string} Command string (for display only)
+ */
+export function buildCommand(item, config) {
+  const cmdInfo = getCommandInfo(item, config);
+  
+  const quoteArgs = (args) => args.map(a => 
+    a.includes(" ") || a.includes("\n") ? `"${a.replace(/"/g, '\\"')}"` : a
+  ).join(" ");
+  
+  const cmdStr = quoteArgs(cmdInfo.args);
+  return cmdInfo.cwd ? `(cd ${cmdInfo.cwd} && ${cmdStr})` : cmdStr;
+}
+
+/**
+ * Execute a spawn command and return a promise
+ */
+function runSpawn(args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const [cmd, ...cmdArgs] = args;
+    const spawnOpts = {
+      stdio: ["ignore", "pipe", "pipe"],
+      ...options,
+    };
+    const child = spawn(cmd, cmdArgs, spawnOpts);
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    child.on("close", (code) => {
+      resolve({ stdout, stderr, exitCode: code, success: code === 0 });
+    });
+
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Execute an action
+ * @param {object} item - Item to create session for
+ * @param {object} config - Repo config with action settings
+ * @param {object} [options] - Execution options
+ * @param {boolean} [options.dryRun] - If true, return command without executing
+ * @returns {Promise<object>} Result with command, stdout, stderr, exitCode
+ */
+export async function executeAction(item, config, options = {}) {
+  const cmdInfo = getCommandInfo(item, config);
+  const command = buildCommand(item, config); // For logging/display
+
+  debug(`executeAction: command=${command}`);
+  debug(`executeAction: args=${JSON.stringify(cmdInfo.args)}, cwd=${cmdInfo.cwd}`);
+
+  if (options.dryRun) {
+    return {
+      command,
+      dryRun: true,
+    };
+  }
+
+  // Execute opencode run in background (detached)
+  // We don't wait for completion since sessions can run for a long time
+  debug(`executeAction: spawning opencode run (detached)`);
+  const [cmd, ...cmdArgs] = cmdInfo.args;
+  const child = spawn(cmd, cmdArgs, {
+    cwd: cmdInfo.cwd,
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+  
+  debug(`executeAction: spawned pid=${child.pid}`);
+  return {
+    command,
+    success: true,
+    pid: child.pid,
+  };
+}
+
+/**
+ * Check if opencode is available
+ * @returns {Promise<boolean>}
+ */
+export async function checkOpencode() {
+  return new Promise((resolve) => {
+    const child = spawn("which", ["opencode"]);
+    child.on("close", (code) => {
+      resolve(code === 0);
+    });
+    child.on("error", () => {
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * Validate that required tools are available
+ * @returns {Promise<object>} { valid: boolean, missing?: string[] }
+ */
+export async function validateTools() {
+  const missing = [];
+
+  const hasOpencode = await checkOpencode();
+  if (!hasOpencode) {
+    missing.push("opencode");
+  }
+
+  return {
+    valid: missing.length === 0,
+    missing,
+  };
+}

package/service/io.opencode.ntfy.plist

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>io.opencode.ntfy</string>
+    
+    <key>ProgramArguments</key>
+    <array>
+        <string>/usr/local/bin/node</string>
+        <string>/usr/local/opt/opencode-ntfy/libexec/server.js</string>
+    </array>
+    
+    <key>RunAtLoad</key>
+    <true/>
+    
+    <key>KeepAlive</key>
+    <true/>
+    
+    <key>StandardOutPath</key>
+    <string>/usr/local/var/log/opencode-ntfy.log</string>
+    
+    <key>StandardErrorPath</key>
+    <string>/usr/local/var/log/opencode-ntfy.log</string>
+    
+    <key>WorkingDirectory</key>
+    <string>/usr/local/opt/opencode-ntfy/libexec</string>
+</dict>
+</plist>

package/service/logger.js

@@ -0,0 +1,82 @@
+// Debug logging module for opencode-pilot service
+// Writes to ~/.local/share/opencode-pilot/debug.log when enabled via PILOT_DEBUG=true
+
+import { appendFileSync, existsSync, mkdirSync, statSync, unlinkSync } from 'fs'
+import { join, dirname } from 'path'
+import { homedir } from 'os'
+
+// Maximum log file size before rotation (1MB)
+export const MAX_LOG_SIZE = 1024 * 1024
+
+// Default log path
+const DEFAULT_LOG_PATH = join(homedir(), '.local', 'share', 'opencode-pilot', 'debug.log')
+
+// Module state
+let enabled = false
+let logPath = DEFAULT_LOG_PATH
+
+/**
+ * Initialize the logger
+ * Checks PILOT_DEBUG env var
+ */
+export function initLogger() {
+  const envDebug = process.env.PILOT_DEBUG
+  enabled = envDebug !== undefined && envDebug !== '' && envDebug !== 'false' && envDebug !== '0'
+  
+  if (enabled) {
+    try {
+      const dir = dirname(logPath)
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true })
+      }
+    } catch {
+      // Silently ignore
+    }
+  }
+}
+
+/**
+ * Write a debug log entry
+ * @param {string} message - Log message
+ * @param {Object} [data] - Optional data to include
+ */
+export function debug(message, data) {
+  if (!enabled) return
+  
+  try {
+    rotateIfNeeded()
+    
+    const timestamp = new Date().toISOString()
+    let entry = `[${timestamp}] ${message}`
+    
+    if (data !== undefined) {
+      entry += typeof data === 'object' ? ' ' + JSON.stringify(data) : ' ' + String(data)
+    }
+    
+    entry += '\n'
+    
+    const dir = dirname(logPath)
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true })
+    }
+    
+    appendFileSync(logPath, entry)
+  } catch {
+    // Silently ignore
+  }
+}
+
+function rotateIfNeeded() {
+  try {
+    if (!existsSync(logPath)) return
+    const stats = statSync(logPath)
+    if (stats.size > MAX_LOG_SIZE) {
+      unlinkSync(logPath)
+    }
+  } catch {
+    // Silently ignore
+  }
+}
+
+// Auto-init on import
+initLogger()

package/service/poll-service.js

@@ -0,0 +1,246 @@
+/**
+ * poll-service.js - Polling orchestration service
+ *
+ * Orchestrates the polling loop:
+ * 1. Load repo configuration
+ * 2. Fetch items from sources via MCP
+ * 3. Evaluate readiness
+ * 4. Execute actions for ready items
+ * 5. Track processed items to avoid duplicates
+ */
+
+import { loadRepoConfig, getRepoConfig, getAllSources, getToolMappings } from "./repo-config.js";
+import { createPoller, pollGenericSource } from "./poller.js";
+import { evaluateReadiness, sortByPriority } from "./readiness.js";
+import { executeAction, buildCommand } from "./actions.js";
+import { debug } from "./logger.js";
+import path from "path";
+import os from "os";
+
+// Default configuration
+const DEFAULT_POLL_INTERVAL = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Check if a source has tool configuration
+ * @param {object} source - Source configuration
+ * @returns {boolean} True if source has tool.mcp and tool.name
+ */
+export function hasToolConfig(source) {
+  return !!(source.tool && source.tool.mcp && source.tool.name);
+}
+
+/**
+ * Build action config from source and repo config
+ * Source fields override repo config fields
+ * @param {object} source - Source configuration
+ * @param {object} repoConfig - Repository configuration
+ * @returns {object} Merged action config
+ */
+export function buildActionConfigFromSource(source, repoConfig) {
+  return {
+    // Repo config as base
+    ...repoConfig,
+    // Normalize path to repo_path
+    repo_path: source.working_dir || repoConfig.path || repoConfig.repo_path,
+    // Session from source or repo
+    session: source.session || repoConfig.session || {},
+    // Source-level overrides (highest priority)
+    ...(source.prompt && { prompt: source.prompt }),
+    ...(source.agent && { agent: source.agent }),
+    ...(source.model && { model: source.model }),
+    ...(source.working_dir && { working_dir: source.working_dir }),
+  };
+}
+
+// Global state
+let pollingInterval = null;
+let pollerInstance = null;
+
+/**
+ * Run a single poll cycle
+ * @param {object} options - Poll options
+ * @param {boolean} [options.dryRun] - If true, don't execute actions
+ * @param {boolean} [options.skipMcp] - If true, skip MCP fetching (for testing)
+ * @param {string} [options.configPath] - Path to config.yaml
+ * @returns {Promise<Array>} Results of actions taken
+ */
+export async function pollOnce(options = {}) {
+  const {
+    dryRun = false,
+    skipMcp = false,
+    configPath,
+  } = options;
+
+  const results = [];
+
+  // Load configuration
+  loadRepoConfig(configPath);
+
+  // Get all sources
+  const sources = getAllSources();
+
+  if (sources.length === 0) {
+    debug("No sources configured");
+    return results;
+  }
+
+  // Process each source
+  for (const source of sources) {
+    const sourceName = source.name || 'unknown';
+    const repoKey = source.name || 'default';
+    const repoConfig = getRepoConfig(repoKey) || {};
+
+    if (!hasToolConfig(source)) {
+      console.error(`[poll] Source '${sourceName}' missing tool configuration (requires tool.mcp and tool.name)`);
+      continue;
+    }
+
+    let items = [];
+
+    // Fetch items from source
+    if (!skipMcp) {
+      try {
+        const mappings = getToolMappings(source.tool.mcp);
+        items = await pollGenericSource(source, { mappings });
+        debug(`Fetched ${items.length} items from ${sourceName}`);
+      } catch (err) {
+        console.error(`[poll] Error fetching from ${sourceName}: ${err.message}`);
+        continue;
+      }
+    }
+
+    // Evaluate readiness and filter
+    const readyItems = items
+      .map((item) => {
+        const readiness = evaluateReadiness(item, repoConfig);
+        debug(`Item ${item.id}: ready=${readiness.ready}, reason=${readiness.reason || 'none'}`);
+        return {
+          ...item,
+          repo_key: repoKey,
+          repo_short: repoKey.split("/").pop(),
+          _readiness: readiness,
+        };
+      })
+      .filter((item) => item._readiness.ready);
+    
+    debug(`${readyItems.length} items ready out of ${items.length}`);
+
+    // Sort by priority
+    const sortedItems = sortByPriority(readyItems, repoConfig);
+
+    // Process ready items
+    debug(`Processing ${sortedItems.length} sorted items`);
+    for (const item of sortedItems) {
+      // Check if already processed
+      if (pollerInstance && pollerInstance.isProcessed(item.id)) {
+        debug(`Skipping ${item.id} - already processed`);
+        continue;
+      }
+
+      debug(`Executing action for ${item.id}`);
+      // Build action config from source (includes agent, model, prompt, working_dir)
+      const actionConfig = buildActionConfigFromSource(source, repoConfig);
+
+      // Execute or dry-run
+      if (dryRun) {
+        const command = buildCommand(item, actionConfig);
+        results.push({
+          item,
+          command,
+          dryRun: true,
+        });
+        console.log(`[poll] Would execute: ${command}`);
+      } else {
+        try {
+          const result = await executeAction(item, actionConfig);
+          results.push({
+            item,
+            ...result,
+          });
+
+          if (result.success) {
+            // Mark as processed to avoid re-triggering
+            if (pollerInstance) {
+              pollerInstance.markProcessed(item.id, { repoKey, command: result.command });
+            }
+            console.log(`[poll] Started session for ${item.id}`);
+          } else {
+            console.error(`[poll] Failed to start session: ${result.stderr}`);
+          }
+        } catch (err) {
+          console.error(`[poll] Error executing action: ${err.message}`);
+          results.push({
+            item,
+            error: err.message,
+          });
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Start the polling loop
+ * @param {object} options - Polling options
+ * @param {number} [options.interval] - Poll interval in ms
+ * @param {string} [options.configPath] - Path to config.yaml
+ * @returns {object} Polling state with stop() method
+ */
+export function startPolling(options = {}) {
+  const { interval = DEFAULT_POLL_INTERVAL, configPath } = options;
+
+  // Initialize poller for state tracking
+  pollerInstance = createPoller({ configPath });
+
+  // Run first poll immediately
+  pollOnce({ configPath }).catch((err) => {
+    console.error("[poll] Error in poll cycle:", err.message);
+  });
+
+  // Start interval
+  pollingInterval = setInterval(() => {
+    pollOnce({ configPath }).catch((err) => {
+      console.error("[poll] Error in poll cycle:", err.message);
+    });
+  }, interval);
+
+  console.log(`[poll] Started polling every ${interval / 1000}s`);
+
+  return {
+    interval: pollingInterval,
+    poller: pollerInstance,
+    stop: stopPolling,
+  };
+}
+
+/**
+ * Stop the polling loop
+ */
+export function stopPolling() {
+  if (pollingInterval) {
+    clearInterval(pollingInterval);
+    pollingInterval = null;
+    console.log("[poll] Stopped polling");
+  }
+}
+
+/**
+ * Clear processed state for an item (e.g., when issue is closed/reopened)
+ * @param {string} itemId - Item ID to clear
+ */
+export function clearProcessed(itemId) {
+  if (pollerInstance) {
+    // Access the poller's internal state - need to expose this
+    console.log(`[poll] Cleared processed state for ${itemId}`);
+  }
+}
+
+/**
+ * Get the poller instance (for external state management)
+ * @returns {object|null} Poller instance or null if not started
+ */
+export function getPoller() {
+  return pollerInstance;
+}