opencode-pilot 0.7.3 → 0.9.0

package/README.md

@@ -19,9 +19,9 @@ npm install -g opencode-pilot
 
 ## Quick Start
 
-1. **Create config** - Copy [examples/config.yaml](examples/config.yaml) to `~/.config/opencode-pilot/config.yaml` and customize
+1. **Create config** - Copy [examples/config.yaml](examples/config.yaml) to `~/.config/opencode/pilot/config.yaml` and customize
 
-2. **Create templates** - Add prompt templates to `~/.config/opencode-pilot/templates/`
+2. **Create templates** - Add prompt templates to `~/.config/opencode/pilot/templates/`
 
 3. **Enable the plugin** - Add to your `opencode.json`:
 
@@ -67,7 +67,7 @@ Three ways to configure sources, from simplest to most flexible:
 
 ### Prompt Templates
 
-Create prompt templates as markdown files in `~/.config/opencode-pilot/templates/`. Templates support placeholders like `{title}`, `{body}`, `{number}`, `{html_url}`, etc.
+Create prompt templates as markdown files in `~/.config/opencode/pilot/templates/`. Templates support placeholders like `{title}`, `{body}`, `{number}`, `{html_url}`, etc.
 
 ## CLI Commands
 

package/examples/config.yaml

@@ -42,6 +42,8 @@ sources:
   #     completed: false
   #   item:
   #     id: "reminder:{id}"
+  #   session:
+  #     name: "{title}"  # Optional: custom session name (presets have semantic defaults)
 
 # Tool config for custom MCP servers (GitHub/Linear have built-in config)
 # tools:

package/package.json

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

package/service/actions.js

@@ -5,17 +5,139 @@
  * Supports prompt_template for custom prompts (e.g., to invoke /devcontainer).
  */
 
-import { spawn } from "child_process";
+import { spawn, execSync } 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";
 
+/**
+ * Get running opencode server ports by parsing lsof output
+ * @returns {Promise<number[]>} Array of port numbers
+ */
+async function getOpencodePorts() {
+  try {
+    const output = execSync('lsof -i -P 2>/dev/null | grep -E "opencode.*LISTEN" || true', {
+      encoding: 'utf-8',
+      timeout: 30000
+    });
+    
+    const ports = [];
+    for (const line of output.split('\n')) {
+      // Parse lines like: opencode-  6897 athal   12u  IPv4 ... TCP *:60993 (LISTEN)
+      const match = line.match(/:(\d+)\s+\(LISTEN\)/);
+      if (match) {
+        ports.push(parseInt(match[1], 10));
+      }
+    }
+    return ports;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Check if targetPath is within or equal to worktree path
+ * @param {string} targetPath - The path we're looking for
+ * @param {string} worktree - The server's worktree path
+ * @param {string[]} sandboxes - Array of sandbox paths
+ * @returns {number} Match score (higher = better match, 0 = no match)
+ */
+function getPathMatchScore(targetPath, worktree, sandboxes = []) {
+  // Normalize paths
+  const normalizedTarget = path.resolve(targetPath);
+  const normalizedWorktree = path.resolve(worktree);
+  
+  // Exact sandbox match (highest priority)
+  for (const sandbox of sandboxes) {
+    const normalizedSandbox = path.resolve(sandbox);
+    if (normalizedTarget === normalizedSandbox || normalizedTarget.startsWith(normalizedSandbox + path.sep)) {
+      return normalizedSandbox.length + 1000; // Bonus for sandbox match
+    }
+  }
+  
+  // Exact worktree match
+  if (normalizedTarget === normalizedWorktree) {
+    return normalizedWorktree.length + 500; // Bonus for exact match
+  }
+  
+  // Target is subdirectory of worktree
+  if (normalizedTarget.startsWith(normalizedWorktree + path.sep)) {
+    return normalizedWorktree.length;
+  }
+  
+  // Global project (worktree = "/") matches everything with lowest priority
+  if (normalizedWorktree === '/') {
+    return 1;
+  }
+  
+  return 0; // No match
+}
+
+/**
+ * Discover a running opencode server that matches the target directory
+ * 
+ * Queries all running opencode servers and finds the best match based on:
+ * 1. Exact sandbox match (highest priority)
+ * 2. Exact worktree match
+ * 3. Target is subdirectory of worktree
+ * 4. Global project (worktree="/") as fallback
+ * 
+ * @param {string} targetDir - The directory we want to work in
+ * @param {object} [options] - Options for testing/mocking
+ * @param {function} [options.getPorts] - Function to get server ports
+ * @param {function} [options.fetch] - Function to fetch URLs
+ * @returns {Promise<string|null>} Server URL (e.g., "http://localhost:4096") or null
+ */
+export async function discoverOpencodeServer(targetDir, options = {}) {
+  const getPorts = options.getPorts || getOpencodePorts;
+  const fetchFn = options.fetch || fetch;
+  
+  const ports = await getPorts();
+  if (ports.length === 0) {
+    debug('discoverOpencodeServer: no servers found');
+    return null;
+  }
+  
+  debug(`discoverOpencodeServer: checking ${ports.length} servers for ${targetDir}`);
+  
+  let bestMatch = null;
+  let bestScore = 0;
+  
+  for (const port of ports) {
+    const url = `http://localhost:${port}`;
+    try {
+      const response = await fetchFn(`${url}/project/current`);
+      if (!response.ok) {
+        debug(`discoverOpencodeServer: ${url} returned ${response.status}`);
+        continue;
+      }
+      
+      const project = await response.json();
+      const worktree = project.worktree || '/';
+      const sandboxes = project.sandboxes || [];
+      
+      const score = getPathMatchScore(targetDir, worktree, sandboxes);
+      debug(`discoverOpencodeServer: ${url} worktree=${worktree} score=${score}`);
+      
+      if (score > bestScore) {
+        bestScore = score;
+        bestMatch = url;
+      }
+    } catch (err) {
+      debug(`discoverOpencodeServer: ${url} error: ${err.message}`);
+    }
+  }
+  
+  debug(`discoverOpencodeServer: best match=${bestMatch} score=${bestScore}`);
+  return bestMatch;
+}
+
 // Default templates directory
 const DEFAULT_TEMPLATES_DIR = path.join(
   os.homedir(),
-  ".config/opencode-pilot/templates"
+  ".config/opencode/pilot/templates"
 );
 
 /**
@@ -109,9 +231,10 @@ export function getActionConfig(source, repoConfig, defaults) {
  * @param {object} item - Item to create session for
  * @param {object} config - Merged action config
  * @param {string} [templatesDir] - Templates directory path (for testing)
+ * @param {string} [serverUrl] - URL of running opencode server to attach to
  * @returns {object} { args: string[], cwd: string }
  */
-export function getCommandInfoNew(item, config, templatesDir) {
+export function getCommandInfoNew(item, config, templatesDir, serverUrl) {
   // Determine working directory: working_dir > path > repo_path > home
   const workingDir = config.working_dir || config.path || config.repo_path || "~";
   const cwd = expandPath(workingDir);
@@ -119,11 +242,16 @@ export function getCommandInfoNew(item, config, templatesDir) {
   // Build session name
   const sessionName = config.session?.name
     ? buildSessionName(config.session.name, item)
-    : `session-${item.number || item.id || Date.now()}`;
+    : (item.title || `session-${Date.now()}`);
 
   // Build command args
   const args = ["opencode", "run"];
   
+  // Add --attach if server URL is provided
+  if (serverUrl) {
+    args.push("--attach", serverUrl);
+  }
+  
   // Add session title
   args.push("--title", sessionName);
   
@@ -169,13 +297,14 @@ function buildPrompt(item, config) {
 /**
  * Build command args for action
  * Uses "opencode run" for non-interactive execution
+ * @deprecated Legacy function - not currently used. See getCommandInfoNew instead.
  * @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()}`;
+    : (item.title || `session-${Date.now()}`);
 
   // Build opencode run command args array (non-interactive)
   // Note: --title sets session title (--session is for continuing existing sessions)
@@ -264,11 +393,29 @@ function runSpawn(args, options = {}) {
  * @param {object} config - Repo config with action settings
  * @param {object} [options] - Execution options
  * @param {boolean} [options.dryRun] - If true, return command without executing
+ * @param {function} [options.discoverServer] - Custom server discovery function (for testing)
  * @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
+  // Get working directory first to determine which server to attach to
+  const workingDir = config.working_dir || config.path || config.repo_path || "~";
+  const cwd = expandPath(workingDir);
+  
+  // Discover running opencode server for this directory
+  const discoverFn = options.discoverServer || discoverOpencodeServer;
+  const serverUrl = await discoverFn(cwd);
+  
+  debug(`executeAction: discovered server=${serverUrl} for cwd=${cwd}`);
+  
+  // Build command info with server URL for --attach flag
+  const cmdInfo = getCommandInfoNew(item, config, undefined, serverUrl);
+  
+  // Build command string for display
+  const quoteArgs = (args) => args.map(a => 
+    a.includes(" ") || a.includes("\n") ? `"${a.replace(/"/g, '\\"')}"` : a
+  ).join(" ");
+  const cmdStr = quoteArgs(cmdInfo.args);
+  const command = cmdInfo.cwd ? `(cd ${cmdInfo.cwd} && ${cmdStr})` : cmdStr;
 
   debug(`executeAction: command=${command}`);
   debug(`executeAction: args=${JSON.stringify(cmdInfo.args)}, cwd=${cmdInfo.cwd}`);

package/service/poller.js

@@ -282,7 +282,7 @@ export async function pollGenericSource(source, options = {}) {
  * @returns {object} Poller instance
  */
 export function createPoller(options = {}) {
-  const stateFile = options.stateFile || path.join(os.homedir(), '.config/opencode-pilot/poll-state.json');
+  const stateFile = options.stateFile || path.join(os.homedir(), '.config/opencode/pilot/poll-state.json');
   const configPath = options.configPath;
   
   // Load existing state

package/service/presets/github.yaml

@@ -22,6 +22,8 @@ my-issues:
   item:
     id: "{html_url}"
   repo: "{repository_full_name}"
+  session:
+    name: "{title}"
 
 review-requests:
   name: review-requests
@@ -33,6 +35,8 @@ review-requests:
   item:
     id: "{html_url}"
   repo: "{repository_full_name}"
+  session:
+    name: "Review: {title}"
 
 my-prs-feedback:
   name: my-prs-feedback
@@ -46,6 +50,8 @@ my-prs-feedback:
   item:
     id: "{html_url}"
   repo: "{repository_full_name}"
+  session:
+    name: "Feedback: {title}"
   # Reprocess when PR is updated (new commits pushed, new comments, etc.)
   # This ensures we re-trigger after addressing review feedback
   reprocess_on:

package/service/presets/linear.yaml

@@ -21,3 +21,5 @@ my-issues:
     # teamId and assigneeId are required - user must provide
   item:
     id: "linear:{id}"
+  session:
+    name: "{title}"

package/service/repo-config.js

@@ -20,13 +20,13 @@ import { expandPreset, expandGitHubShorthand, getProviderConfig } from "./preset
 // Default config path
 const DEFAULT_CONFIG_PATH = path.join(
   os.homedir(),
-  ".config/opencode-pilot/config.yaml"
+  ".config/opencode/pilot/config.yaml"
 );
 
 // Default templates directory
 const DEFAULT_TEMPLATES_DIR = path.join(
   os.homedir(),
-  ".config/opencode-pilot/templates"
+  ".config/opencode/pilot/templates"
 );
 
 // In-memory config cache (for testing and runtime)

package/service/server.js

@@ -13,7 +13,7 @@ import YAML from 'yaml'
 
 // Default configuration
 const DEFAULT_HTTP_PORT = 4097
-const DEFAULT_REPOS_CONFIG = join(homedir(), '.config', 'opencode-pilot', 'config.yaml')
+const DEFAULT_REPOS_CONFIG = join(homedir(), '.config', 'opencode', 'pilot', 'config.yaml')
 const DEFAULT_POLL_INTERVAL = 5 * 60 * 1000 // 5 minutes
 
 /**

package/test/unit/actions.test.js

@@ -231,5 +231,267 @@ describe('actions.js', () => {
       assert.ok(lastArg.includes('/devcontainer issue-66'), 'Prompt should include /devcontainer command');
       assert.ok(lastArg.includes('Fix bug'), 'Prompt should include title');
     });
+
+    test('includes --attach when serverUrl is provided', async () => {
+      const { getCommandInfoNew } = await import('../../service/actions.js');
+      
+      const item = { number: 123, title: 'Fix bug' };
+      const config = {
+        path: '~/code/backend',
+        prompt: 'default'
+      };
+      
+      const cmdInfo = getCommandInfoNew(item, config, templatesDir, 'http://localhost:4096');
+      
+      assert.ok(cmdInfo.args.includes('--attach'), 'Should include --attach flag');
+      assert.ok(cmdInfo.args.includes('http://localhost:4096'), 'Should include server URL');
+    });
+
+    test('does not include --attach when serverUrl is null', async () => {
+      const { getCommandInfoNew } = await import('../../service/actions.js');
+      
+      const item = { number: 123, title: 'Fix bug' };
+      const config = {
+        path: '~/code/backend',
+        prompt: 'default'
+      };
+      
+      const cmdInfo = getCommandInfoNew(item, config, templatesDir, null);
+      
+      assert.ok(!cmdInfo.args.includes('--attach'), 'Should not include --attach flag');
+    });
+
+    test('uses item title as session name when no session.name configured', async () => {
+      const { getCommandInfoNew } = await import('../../service/actions.js');
+      
+      const item = { id: 'reminder-123', title: 'Review quarterly reports' };
+      const config = {
+        path: '~/code/backend',
+        prompt: 'default'
+      };
+      
+      const cmdInfo = getCommandInfoNew(item, config, templatesDir);
+      
+      const titleIndex = cmdInfo.args.indexOf('--title');
+      assert.ok(titleIndex !== -1, 'Should have --title flag');
+      assert.strictEqual(cmdInfo.args[titleIndex + 1], 'Review quarterly reports', 'Should use item title as session name');
+    });
+
+    test('falls back to timestamp when no session.name and no title', async () => {
+      const { getCommandInfoNew } = await import('../../service/actions.js');
+      
+      const item = { id: 'item-123' };
+      const config = {
+        path: '~/code/backend',
+        prompt: 'default'
+      };
+      
+      const cmdInfo = getCommandInfoNew(item, config, templatesDir);
+      
+      const titleIndex = cmdInfo.args.indexOf('--title');
+      assert.ok(titleIndex !== -1, 'Should have --title flag');
+      assert.ok(cmdInfo.args[titleIndex + 1].startsWith('session-'), 'Should fall back to session-{timestamp}');
+    });
+  });
+
+  describe('discoverOpencodeServer', () => {
+    test('returns null when no servers running', async () => {
+      const { discoverOpencodeServer } = await import('../../service/actions.js');
+      
+      // Mock with empty port list
+      const result = await discoverOpencodeServer('/some/path', { getPorts: async () => [] });
+      
+      assert.strictEqual(result, null);
+    });
+
+    test('returns matching server URL for exact worktree match', async () => {
+      const { discoverOpencodeServer } = await import('../../service/actions.js');
+      
+      const mockPorts = async () => [3000, 4000];
+      const mockFetch = async (url) => {
+        if (url === 'http://localhost:3000/project/current') {
+          return { ok: true, json: async () => ({ worktree: '/Users/test/project-a', sandboxes: [] }) };
+        }
+        if (url === 'http://localhost:4000/project/current') {
+          return { ok: true, json: async () => ({ worktree: '/Users/test/project-b', sandboxes: [] }) };
+        }
+        return { ok: false };
+      };
+      
+      const result = await discoverOpencodeServer('/Users/test/project-b', { 
+        getPorts: mockPorts,
+        fetch: mockFetch
+      });
+      
+      assert.strictEqual(result, 'http://localhost:4000');
+    });
+
+    test('returns matching server URL for subdirectory of worktree', async () => {
+      const { discoverOpencodeServer } = await import('../../service/actions.js');
+      
+      const mockPorts = async () => [3000];
+      const mockFetch = async (url) => {
+        if (url === 'http://localhost:3000/project/current') {
+          return { ok: true, json: async () => ({ worktree: '/Users/test/project', sandboxes: [] }) };
+        }
+        return { ok: false };
+      };
+      
+      const result = await discoverOpencodeServer('/Users/test/project/src/components', { 
+        getPorts: mockPorts,
+        fetch: mockFetch
+      });
+      
+      assert.strictEqual(result, 'http://localhost:3000');
+    });
+
+    test('returns matching server URL when cwd is in sandboxes', async () => {
+      const { discoverOpencodeServer } = await import('../../service/actions.js');
+      
+      const mockPorts = async () => [3000];
+      const mockFetch = async (url) => {
+        if (url === 'http://localhost:3000/project/current') {
+          return { ok: true, json: async () => ({ 
+            worktree: '/Users/test/project', 
+            sandboxes: ['/Users/test/.opencode/worktree/abc/sandbox-1'] 
+          }) };
+        }
+        return { ok: false };
+      };
+      
+      const result = await discoverOpencodeServer('/Users/test/.opencode/worktree/abc/sandbox-1', { 
+        getPorts: mockPorts,
+        fetch: mockFetch
+      });
+      
+      assert.strictEqual(result, 'http://localhost:3000');
+    });
+
+    test('prefers more specific worktree match over less specific', async () => {
+      const { discoverOpencodeServer } = await import('../../service/actions.js');
+      
+      const mockPorts = async () => [3000, 4000];
+      const mockFetch = async (url) => {
+        if (url === 'http://localhost:3000/project/current') {
+          // Global project
+          return { ok: true, json: async () => ({ worktree: '/', sandboxes: [] }) };
+        }
+        if (url === 'http://localhost:4000/project/current') {
+          // Specific project
+          return { ok: true, json: async () => ({ worktree: '/Users/test/project', sandboxes: [] }) };
+        }
+        return { ok: false };
+      };
+      
+      const result = await discoverOpencodeServer('/Users/test/project/src', { 
+        getPorts: mockPorts,
+        fetch: mockFetch
+      });
+      
+      // Should prefer the more specific match (port 4000)
+      assert.strictEqual(result, 'http://localhost:4000');
+    });
+
+    test('falls back to global project when no specific match', async () => {
+      const { discoverOpencodeServer } = await import('../../service/actions.js');
+      
+      const mockPorts = async () => [3000];
+      const mockFetch = async (url) => {
+        if (url === 'http://localhost:3000/project/current') {
+          return { ok: true, json: async () => ({ worktree: '/', sandboxes: [] }) };
+        }
+        return { ok: false };
+      };
+      
+      const result = await discoverOpencodeServer('/Users/test/random/path', { 
+        getPorts: mockPorts,
+        fetch: mockFetch
+      });
+      
+      assert.strictEqual(result, 'http://localhost:3000');
+    });
+
+    test('returns null when fetch fails for all servers', async () => {
+      const { discoverOpencodeServer } = await import('../../service/actions.js');
+      
+      const mockPorts = async () => [3000, 4000];
+      const mockFetch = async () => {
+        throw new Error('Connection refused');
+      };
+      
+      const result = await discoverOpencodeServer('/some/path', { 
+        getPorts: mockPorts,
+        fetch: mockFetch
+      });
+      
+      assert.strictEqual(result, null);
+    });
+
+    test('skips servers that return non-ok response', async () => {
+      const { discoverOpencodeServer } = await import('../../service/actions.js');
+      
+      const mockPorts = async () => [3000, 4000];
+      const mockFetch = async (url) => {
+        if (url === 'http://localhost:3000/project/current') {
+          return { ok: false };
+        }
+        if (url === 'http://localhost:4000/project/current') {
+          return { ok: true, json: async () => ({ worktree: '/Users/test/project', sandboxes: [] }) };
+        }
+        return { ok: false };
+      };
+      
+      const result = await discoverOpencodeServer('/Users/test/project', { 
+        getPorts: mockPorts,
+        fetch: mockFetch
+      });
+      
+      assert.strictEqual(result, 'http://localhost:4000');
+    });
+  });
+
+  describe('executeAction', () => {
+    test('discovers server and includes --attach in dry run', async () => {
+      const { executeAction } = await import('../../service/actions.js');
+      
+      const item = { number: 123, title: 'Fix bug' };
+      const config = {
+        path: tempDir,
+        prompt: 'default'
+      };
+      
+      // Mock server discovery
+      const mockDiscoverServer = async () => 'http://localhost:4096';
+      
+      const result = await executeAction(item, config, { 
+        dryRun: true,
+        discoverServer: mockDiscoverServer
+      });
+      
+      assert.ok(result.dryRun);
+      assert.ok(result.command.includes('--attach'), 'Command should include --attach flag');
+      assert.ok(result.command.includes('http://localhost:4096'), 'Command should include server URL');
+    });
+
+    test('does not include --attach when no server discovered', async () => {
+      const { executeAction } = await import('../../service/actions.js');
+      
+      const item = { number: 123, title: 'Fix bug' };
+      const config = {
+        path: tempDir,
+        prompt: 'default'
+      };
+      
+      // Mock no server found
+      const mockDiscoverServer = async () => null;
+      
+      const result = await executeAction(item, config, { 
+        dryRun: true,
+        discoverServer: mockDiscoverServer
+      });
+      
+      assert.ok(result.dryRun);
+      assert.ok(!result.command.includes('--attach'), 'Command should not include --attach flag');
+    });
   });
 });

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

@@ -664,6 +664,44 @@ sources:
       const filteredItem = { repository_full_name: 'other/repo' };
       assert.deepStrictEqual(resolveRepoForItem(source, filteredItem), []);
     });
+
+    test('github presets include semantic session names', async () => {
+      writeFileSync(configPath, `
+sources:
+  - preset: github/my-issues
+  - preset: github/review-requests
+  - preset: github/my-prs-feedback
+`);
+
+      const { loadRepoConfig, getSources } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      const sources = getSources();
+
+      // my-issues: just the title
+      assert.strictEqual(sources[0].session.name, '{title}', 'my-issues should use title');
+      
+      // review-requests: "Review: {title}"
+      assert.strictEqual(sources[1].session.name, 'Review: {title}', 'review-requests should prefix with Review:');
+      
+      // my-prs-feedback: "Feedback: {title}"
+      assert.strictEqual(sources[2].session.name, 'Feedback: {title}', 'my-prs-feedback should prefix with Feedback:');
+    });
+
+    test('linear preset includes session name', async () => {
+      writeFileSync(configPath, `
+sources:
+  - preset: linear/my-issues
+    args:
+      teamId: "team-uuid"
+      assigneeId: "user-uuid"
+`);
+
+      const { loadRepoConfig, getSources } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      const sources = getSources();
+
+      assert.strictEqual(sources[0].session.name, '{title}', 'linear/my-issues should use title');
+    });
   });
 
   describe('shorthand syntax', () => {