opencode-pilot 0.15.2 → 0.16.1

package/package.json

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

package/service/actions.js

@@ -10,7 +10,7 @@ import { readFileSync, existsSync } from "fs";
 import { debug } from "./logger.js";
 import { getNestedValue } from "./utils.js";
 import { getServerPort } from "./repo-config.js";
-import { resolveWorktreeDirectory } from "./worktree.js";
+import { resolveWorktreeDirectory, getProjectInfo } from "./worktree.js";
 import path from "path";
 import os from "os";
 
@@ -573,8 +573,20 @@ export async function executeAction(item, config, options = {}) {
   
   // Resolve worktree directory if configured
   // This allows creating sessions in isolated worktrees instead of the main project
+  let worktreeMode = config.worktree;
+  
+  // Auto-detect worktree support: if not explicitly configured and server is running,
+  // check if the project has sandboxes (indicating worktree workflow is set up)
+  if (!worktreeMode && serverUrl) {
+    const projectInfo = await getProjectInfo(serverUrl, { fetch: options.fetch });
+    if (projectInfo?.sandboxes?.length > 0) {
+      debug(`executeAction: auto-detected worktree support (${projectInfo.sandboxes.length} sandboxes)`);
+      worktreeMode = 'new';
+    }
+  }
+  
   const worktreeConfig = {
-    worktree: config.worktree,
+    worktree: worktreeMode,
     // Expand worktree_name template with item fields (e.g., "issue-{number}")
     worktreeName: config.worktree_name ? expandTemplate(config.worktree_name, item) : undefined,
   };

package/service/repo-config.js

@@ -14,6 +14,7 @@ import fs from "fs";
 import path from "path";
 import os from "os";
 import YAML from "yaml";
+import { execSync } from "child_process";
 import { getNestedValue } from "./utils.js";
 import { expandPreset, expandGitHubShorthand, getProviderConfig } from "./presets/index.js";
 
@@ -32,6 +33,86 @@ const DEFAULT_TEMPLATES_DIR = path.join(
 // In-memory config cache (for testing and runtime)
 let configCache = null;
 
+// Cache for discovered repos from repos_dir
+let discoveredReposCache = null;
+
+/**
+ * Parse GitHub owner/repo from a git remote URL
+ * Supports HTTPS and SSH formats
+ * @param {string} url - Git remote URL
+ * @returns {string|null} "owner/repo" or null if not a GitHub URL
+ */
+function parseGitHubRepo(url) {
+  if (!url) return null;
+  
+  // HTTPS: https://github.com/owner/repo.git
+  const httpsMatch = url.match(/github\.com\/([^/]+)\/([^/.]+)/);
+  if (httpsMatch) {
+    return `${httpsMatch[1]}/${httpsMatch[2]}`;
+  }
+  
+  // SSH: git@github.com:owner/repo.git
+  const sshMatch = url.match(/github\.com:([^/]+)\/([^/.]+)/);
+  if (sshMatch) {
+    return `${sshMatch[1]}/${sshMatch[2]}`;
+  }
+  
+  return null;
+}
+
+/**
+ * Discover repos from a repos_dir by scanning git remotes
+ * @param {string} reposDir - Directory containing git repositories
+ * @returns {Map<string, object>} Map of "owner/repo" -> { path }
+ */
+function discoverRepos(reposDir) {
+  const discovered = new Map();
+  
+  if (!reposDir) {
+    return discovered;
+  }
+  
+  const normalizedDir = reposDir.replace(/^~/, os.homedir());
+  
+  if (!fs.existsSync(normalizedDir)) {
+    return discovered;
+  }
+  
+  try {
+    const entries = fs.readdirSync(normalizedDir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      
+      const repoPath = path.join(normalizedDir, entry.name);
+      const gitDir = path.join(repoPath, '.git');
+      
+      // Skip if not a git repo
+      if (!fs.existsSync(gitDir)) continue;
+      
+      // Get remote origin URL via git API
+      try {
+        const remoteUrl = execSync('git remote get-url origin', {
+          cwd: repoPath,
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+        
+        const repoKey = parseGitHubRepo(remoteUrl);
+        if (repoKey) {
+          discovered.set(repoKey, { path: repoPath });
+        }
+      } catch {
+        // Skip repos without origin or git errors
+      }
+    }
+  } catch {
+    // Directory read error
+  }
+  
+  return discovered;
+}
+
 /**
  * Expand template string with item fields
  * Supports {field} and {field.nested} syntax
@@ -53,6 +134,10 @@ export function loadRepoConfig(configOrPath) {
   if (typeof configOrPath === "object") {
     // Direct config object (for testing)
     configCache = configOrPath;
+    // Discover repos if repos_dir is set
+    discoveredReposCache = configCache.repos_dir 
+      ? discoverRepos(configCache.repos_dir) 
+      : null;
     return configCache;
   }
 
@@ -60,16 +145,22 @@ export function loadRepoConfig(configOrPath) {
 
   if (!fs.existsSync(configPath)) {
     configCache = emptyConfig;
+    discoveredReposCache = null;
     return configCache;
   }
 
   try {
     const content = fs.readFileSync(configPath, "utf-8");
     configCache = YAML.parse(content, { merge: true }) || emptyConfig;
+    // Discover repos if repos_dir is set
+    discoveredReposCache = configCache.repos_dir 
+      ? discoverRepos(configCache.repos_dir) 
+      : null;
   } catch (err) {
     // Log error but continue with empty config to allow graceful degradation
     console.error(`Warning: Failed to parse config at ${configPath}: ${err.message}`);
     configCache = emptyConfig;
+    discoveredReposCache = null;
   }
   return configCache;
 }
@@ -86,20 +177,31 @@ function getRawConfig() {
 
 /**
  * Get configuration for a specific repo
+ * Checks explicit repos config first, then falls back to auto-discovered repos
  * @param {string} repoKey - Repository identifier (e.g., "myorg/backend")
  * @returns {object} Repository configuration or empty object
  */
 export function getRepoConfig(repoKey) {
   const config = getRawConfig();
   const repos = config.repos || {};
-  const repoConfig = repos[repoKey] || {};
-
-  // Normalize: support both 'path' and 'repo_path' keys
-  if (repoConfig.path && !repoConfig.repo_path) {
-    return { ...repoConfig, repo_path: repoConfig.path };
+  
+  // Check explicit repos config first
+  if (repos[repoKey]) {
+    const repoConfig = repos[repoKey];
+    // Normalize: support both 'path' and 'repo_path' keys
+    if (repoConfig.path && !repoConfig.repo_path) {
+      return { ...repoConfig, repo_path: repoConfig.path };
+    }
+    return repoConfig;
+  }
+  
+  // Fall back to auto-discovered repos from repos_dir
+  if (discoveredReposCache && discoveredReposCache.has(repoKey)) {
+    const discovered = discoveredReposCache.get(repoKey);
+    return { ...discovered, repo_path: discovered.path };
   }
 
-  return repoConfig;
+  return {};
 }
 
 /**
@@ -324,4 +426,5 @@ export function getServerPort() {
  */
 export function clearConfigCache() {
   configCache = null;
+  discoveredReposCache = null;
 }

package/test/unit/actions.test.js

@@ -693,6 +693,114 @@ describe('actions.js', () => {
       assert.ok(result.command.includes(tempDir), 
         'Should fall back to base directory when worktree creation fails');
     });
+
+    test('auto-detects worktree support when project has sandboxes (dry run)', async () => {
+      const { executeAction } = await import('../../service/actions.js');
+      
+      const item = { number: 456, title: 'New feature' };
+      const config = {
+        path: tempDir,
+        prompt: 'default'
+        // Note: no worktree config - should be auto-detected
+      };
+      
+      // Mock server discovery
+      const mockDiscoverServer = async () => 'http://localhost:4096';
+      
+      // Track API calls
+      let projectInfoCalled = false;
+      let worktreeCreateCalled = false;
+      
+      const mockFetch = async (url, opts) => {
+        // Project info endpoint - returns sandboxes indicating worktree workflow
+        if (url === 'http://localhost:4096/project/current') {
+          projectInfoCalled = true;
+          return {
+            ok: true,
+            json: async () => ({
+              id: 'proj-123',
+              worktree: tempDir,
+              sandboxes: ['/data/worktree/proj-123/sandbox-1'],
+              time: { created: 1 }
+            })
+          };
+        }
+        // Worktree creation endpoint
+        if (url === 'http://localhost:4096/experimental/worktree' && opts?.method === 'POST') {
+          worktreeCreateCalled = true;
+          return {
+            ok: true,
+            json: async () => ({
+              name: 'new-sandbox',
+              branch: 'opencode/new-sandbox',
+              directory: '/data/worktree/proj-123/new-sandbox'
+            })
+          };
+        }
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await executeAction(item, config, { 
+        dryRun: true,
+        discoverServer: mockDiscoverServer,
+        fetch: mockFetch
+      });
+      
+      assert.ok(result.dryRun);
+      assert.ok(projectInfoCalled, 'Should call project/current to check for sandboxes');
+      assert.ok(worktreeCreateCalled, 'Should auto-create worktree when sandboxes detected');
+      assert.ok(result.command.includes('/data/worktree/proj-123/new-sandbox'), 
+        'Should use newly created worktree directory');
+    });
+
+    test('does not auto-create worktree when project has no sandboxes (dry run)', async () => {
+      const { executeAction } = await import('../../service/actions.js');
+      
+      const item = { number: 789, title: 'Simple fix' };
+      const config = {
+        path: tempDir,
+        prompt: 'default'
+        // Note: no worktree config
+      };
+      
+      // Mock server discovery
+      const mockDiscoverServer = async () => 'http://localhost:4096';
+      
+      let projectInfoCalled = false;
+      let worktreeCreateCalled = false;
+      
+      const mockFetch = async (url, opts) => {
+        // Project info endpoint - returns empty sandboxes (no worktree workflow)
+        if (url === 'http://localhost:4096/project/current') {
+          projectInfoCalled = true;
+          return {
+            ok: true,
+            json: async () => ({
+              id: 'proj-456',
+              worktree: tempDir,
+              sandboxes: [],
+              time: { created: 1 }
+            })
+          };
+        }
+        if (url === 'http://localhost:4096/experimental/worktree' && opts?.method === 'POST') {
+          worktreeCreateCalled = true;
+        }
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await executeAction(item, config, { 
+        dryRun: true,
+        discoverServer: mockDiscoverServer,
+        fetch: mockFetch
+      });
+      
+      assert.ok(result.dryRun);
+      assert.ok(projectInfoCalled, 'Should call project/current to check for sandboxes');
+      assert.ok(!worktreeCreateCalled, 'Should NOT create worktree when no sandboxes');
+      assert.ok(result.command.includes(tempDir), 
+        'Should use base directory when no worktree workflow detected');
+    });
   });
 
   describe('createSessionViaApi', () => {

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

@@ -7,6 +7,7 @@ import assert from 'node:assert';
 import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
+import { execSync } from 'child_process';
 
 describe('repo-config.js', () => {
   let tempDir;
@@ -119,6 +120,104 @@ repos:
     });
   });
 
+  describe('repos_dir auto-discovery', () => {
+    let reposDir;
+
+    beforeEach(() => {
+      reposDir = join(tempDir, 'code');
+      mkdirSync(reposDir);
+    });
+
+    function createGitRepo(name, remoteUrl) {
+      const repoPath = join(reposDir, name);
+      mkdirSync(repoPath);
+      execSync('git init', { cwd: repoPath, stdio: 'ignore' });
+      execSync(`git remote add origin ${remoteUrl}`, { cwd: repoPath, stdio: 'ignore' });
+      return repoPath;
+    }
+
+    test('discovers repos from git remote origin', async () => {
+      const repoPath = createGitRepo('my-project', 'https://github.com/myorg/my-project.git');
+
+      writeFileSync(configPath, `
+repos_dir: ${reposDir}
+`);
+
+      const { loadRepoConfig, getRepoConfig } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      
+      const config = getRepoConfig('myorg/my-project');
+      assert.strictEqual(config.path, repoPath);
+      assert.strictEqual(config.repo_path, repoPath);
+    });
+
+    test('handles SSH git URLs', async () => {
+      const repoPath = createGitRepo('backend', 'git@github.com:myorg/backend.git');
+
+      writeFileSync(configPath, `
+repos_dir: ${reposDir}
+`);
+
+      const { loadRepoConfig, getRepoConfig } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      
+      const config = getRepoConfig('myorg/backend');
+      assert.strictEqual(config.path, repoPath);
+    });
+
+    test('explicit repos override auto-discovered', async () => {
+      createGitRepo('my-project', 'https://github.com/myorg/my-project.git');
+
+      writeFileSync(configPath, `
+repos_dir: ${reposDir}
+repos:
+  myorg/my-project:
+    path: /custom/path
+    prompt: custom
+`);
+
+      const { loadRepoConfig, getRepoConfig } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      
+      const config = getRepoConfig('myorg/my-project');
+      // Explicit config should win
+      assert.strictEqual(config.path, '/custom/path');
+      assert.strictEqual(config.prompt, 'custom');
+    });
+
+    test('skips directories without .git', async () => {
+      const notARepo = join(reposDir, 'not-a-repo');
+      mkdirSync(notARepo);
+      writeFileSync(join(notARepo, 'file.txt'), 'hello');
+
+      writeFileSync(configPath, `
+repos_dir: ${reposDir}
+`);
+
+      const { loadRepoConfig, getRepoConfig } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      
+      // Should not find this as a repo
+      const config = getRepoConfig('not-a-repo');
+      assert.deepStrictEqual(config, {});
+    });
+
+    test('returns empty for unknown repo even with repos_dir', async () => {
+      createGitRepo('my-project', 'https://github.com/myorg/my-project.git');
+
+      writeFileSync(configPath, `
+repos_dir: ${reposDir}
+`);
+
+      const { loadRepoConfig, getRepoConfig } = await import('../../service/repo-config.js');
+      loadRepoConfig(configPath);
+      
+      const config = getRepoConfig('unknown/repo');
+      assert.deepStrictEqual(config, {});
+    });
+
+  });
+
   describe('sources', () => {
     test('returns sources array from top-level', async () => {
       writeFileSync(configPath, `