@ikunin/sprintpilot 2.2.18 → 2.2.20

package/_Sprintpilot/bin/autopilot.js

@@ -867,31 +867,123 @@ function decorateGitOp(action, state, profile, projectRoot) {
 // options), inline the resulting `steps[]` onto the action.
 function decorateRunScript(action, state, profile, projectRoot) {
   if (!action || action.type !== 'run_script') return action;
-  if (action.op !== 'land_story') return action;
-  try {
+  if (action.op === 'land_story') {
+    try {
+      const root = projectRoot || process.cwd();
+      const scriptsDir = path.join(root, '_Sprintpilot', 'scripts');
+      const snapshotPath = path.join(
+        root,
+        '_bmad-output',
+        'implementation-artifacts',
+        '.land-snapshots',
+        `${state.story_key || 'sprint'}.json`,
+      );
+      const branch = gitPlan.branchName(profile, state.story_key, state.current_epic, state);
+      const platform = profile.platform_provider || 'auto';
+      const planned = land.planLand(state, profile, {
+        scriptsDir,
+        snapshotPath,
+        branch,
+        platform,
+        projectRoot: root,
+      });
+      return { ...action, branch: planned.branch, steps: planned.steps };
+    } catch (e) {
+      log.warn(`land-plan failed for op=${action.op}: ${e.message}`);
+      return action;
+    }
+  }
+  if (action.op === 'install_dependencies') {
     const root = projectRoot || process.cwd();
-    const scriptsDir = path.join(root, '_Sprintpilot', 'scripts');
-    const snapshotPath = path.join(
-      root,
-      '_bmad-output',
-      'implementation-artifacts',
-      '.land-snapshots',
-      `${state.story_key || 'sprint'}.json`,
-    );
-    const branch = gitPlan.branchName(profile, state.story_key, state.current_epic, state);
-    const platform = profile.platform_provider || 'auto';
-    const planned = land.planLand(state, profile, {
-      scriptsDir,
-      snapshotPath,
-      branch,
-      platform,
-      projectRoot: root,
-    });
-    return { ...action, branch: planned.branch, steps: planned.steps };
-  } catch (e) {
-    log.warn(`land-plan failed for op=${action.op}: ${e.message}`);
-    return action;
+    const steps = planDependencyInstall(root);
+    if (steps.length === 0) {
+      // No manifest detected — fall back to a no-op success rather than
+      // halting the autopilot on an unrecognized project shape. The LLM
+      // already had a recoverable blocker; the orchestrator's retry will
+      // either succeed (the LLM resolves the dependency another way) or
+      // hit the retry budget and prompt.
+      return { ...action, steps: [], no_manifest_detected: true };
+    }
+    return { ...action, steps };
+  }
+  return action;
+}
+
+// Detect manifest files in the project root and return install steps
+// for each language. Returns [] when no manifest is found (caller can
+// degrade to a no-op rather than hardcoding npm install).
+//
+// Order matters: the first match wins for the install. We pick the
+// first detected, since most projects are single-language at the root.
+// Monorepos with multiple manifests still install for the primary
+// (and the LLM can run additional installs via subsequent signals).
+function planDependencyInstall(projectRoot) {
+  const exists = (rel) => {
+    try {
+      return fs.existsSync(path.join(projectRoot, rel));
+    } catch {
+      return false;
+    }
+  };
+  // pnpm / yarn / npm: pick the lockfile that exists; fall back to npm.
+  if (exists('package.json')) {
+    if (exists('pnpm-lock.yaml')) {
+      return [{ args: ['pnpm', 'install', '--frozen-lockfile'], description: 'install pnpm deps' }];
+    }
+    if (exists('yarn.lock')) {
+      return [{ args: ['yarn', 'install', '--frozen-lockfile'], description: 'install yarn deps' }];
+    }
+    if (exists('bun.lockb')) {
+      return [{ args: ['bun', 'install', '--frozen-lockfile'], description: 'install bun deps' }];
+    }
+    return [{ args: ['npm', 'install'], description: 'install npm deps' }];
+  }
+  // Python: prefer uv > poetry > pipenv > pip
+  if (exists('pyproject.toml')) {
+    if (exists('uv.lock')) return [{ args: ['uv', 'sync'], description: 'install python deps via uv' }];
+    if (exists('poetry.lock')) {
+      return [{ args: ['poetry', 'install'], description: 'install python deps via poetry' }];
+    }
+    return [{ args: ['pip', 'install', '-e', '.'], description: 'install python project deps' }];
+  }
+  if (exists('requirements.txt')) {
+    return [{ args: ['pip', 'install', '-r', 'requirements.txt'], description: 'install pip requirements' }];
+  }
+  if (exists('Pipfile')) {
+    return [{ args: ['pipenv', 'install'], description: 'install python deps via pipenv' }];
+  }
+  // Rust
+  if (exists('Cargo.toml')) {
+    return [{ args: ['cargo', 'fetch'], description: 'fetch rust deps via cargo' }];
+  }
+  // Go
+  if (exists('go.mod')) {
+    return [{ args: ['go', 'mod', 'download'], description: 'download go modules' }];
+  }
+  // Ruby
+  if (exists('Gemfile')) {
+    return [{ args: ['bundle', 'install'], description: 'install ruby deps via bundler' }];
+  }
+  // Java / Kotlin
+  if (exists('pom.xml')) {
+    return [{ args: ['mvn', '-q', 'dependency:resolve'], description: 'resolve maven deps' }];
+  }
+  if (exists('build.gradle') || exists('build.gradle.kts')) {
+    return [{ args: ['./gradlew', '--quiet', 'dependencies'], description: 'resolve gradle deps' }];
+  }
+  // PHP
+  if (exists('composer.json')) {
+    return [{ args: ['composer', 'install'], description: 'install composer deps' }];
+  }
+  // .NET
+  if (exists('global.json') || exists('*.csproj')) {
+    return [{ args: ['dotnet', 'restore'], description: 'restore dotnet deps' }];
+  }
+  // Swift
+  if (exists('Package.swift')) {
+    return [{ args: ['swift', 'package', 'resolve'], description: 'resolve swift packages' }];
   }
+  return [];
 }
 
 // Detect whether a branch exists, locally OR on origin. Used by

package/_Sprintpilot/lib/orchestrator/adapt.js

@@ -273,6 +273,11 @@ function handleBlocked(state, signal, profile, sideEffects) {
   // Recoverable blockers: deterministic recovery per kind (initial set).
   switch (kind) {
     case 'missing_dependency':
+      // Emit an abstract install action. The CLI edge (autopilot.js
+      // decorateRunScript) detects the project's language(s) from
+      // manifest files and inlines the concrete `command`. Pre-2.2.19
+      // this hardcoded `npm install`, which failed on non-Node projects
+      // (Python, Rust, Go, Ruby, etc.).
       return {
         newState: state,
         newProfile: profile,
@@ -280,7 +285,8 @@ function handleBlocked(state, signal, profile, sideEffects) {
           type: 'run_script',
           phase: state.phase,
           reason: 'install_missing_dependency',
-          command: ['npm', 'install'],
+          op: 'install_dependencies',
+          details: signal.details || null,
         },
         sideEffects,
         verdict: 'retry',

package/_Sprintpilot/lib/orchestrator/git-plan.js

@@ -523,6 +523,27 @@ function buildPrBody(state, profile, projectRoot, warnings) {
 // Both paths honor profile.squash_on_merge. The PR-merge path also
 // requires profile.platform_provider; non-github platforms fall through
 // to the local-merge sequence with a description note.
+// Build the worktree-cleanup steps appended to every merge_epic plan
+// when profile.worktree_cleanup_on_merge is true. Documented in
+// modules/git/config.yaml ("false = keep worktrees after epic
+// completion for inspection"). Falls back silently when the helper
+// script isn't available (partial install).
+function buildCleanupSteps(profile) {
+  if (!profile.worktree_cleanup_on_merge) return [];
+  if (!profile.worktree_enabled) return [];
+  return [
+    {
+      args: ['node', '_Sprintpilot/scripts/cleanup-worktrees.js'],
+      description: 'remove orphan worktrees whose branches were merged + deleted',
+      // SKIPPED (no .worktrees/ dir) returns 0; real failures here should
+      // not halt the merge — the epic is already merged, cleanup is
+      // best-effort housekeeping.
+      tolerate_exit_codes: [0, 1, 2],
+      optional: true,
+    },
+  ];
+}
+
 function planMergeEpic(state, profile, _action, branch) {
   const baseBranch = profile.base_branch || 'main';
   const squash = !!profile.squash_on_merge;
@@ -610,6 +631,7 @@ function planMergeEpic(state, profile, _action, branch) {
             description: `merge epic PR for ${branch} via gh (${squash ? 'squash' : 'merge'}, delete branch)`,
             env: Object.keys(env).length ? env : undefined,
           },
+          ...buildCleanupSteps(profile),
         ],
       };
     }
@@ -635,6 +657,7 @@ function planMergeEpic(state, profile, _action, branch) {
             description: `merge epic MR for ${branch} via glab${squash ? ' (squash)' : ''}`,
             env: Object.keys(env).length ? env : undefined,
           },
+          ...buildCleanupSteps(profile),
         ],
       };
     }
@@ -712,6 +735,7 @@ function planMergeEpic(state, profile, _action, branch) {
       retry: { attempts: 4, backoff_ms: [2000, 4000, 8000, 16000], on: 'network' },
     });
   }
+  for (const s of buildCleanupSteps(profile)) steps.push(s);
   return { branch, steps };
 }
 

package/_Sprintpilot/lib/orchestrator/profile-rules.js

@@ -105,6 +105,15 @@ function flatToProfile(resolved, profileName) {
       get(resolved, 'git.worktree.health_check_on_boot'),
       true,
     ),
+    // git.worktree.cleanup_on_merge — when true, planMergeEpic appends
+    // `git worktree prune` + per-directory cleanup steps so .worktrees/
+    // doesn't accumulate orphans after an epic merges. Documented in
+    // modules/git/config.yaml ("false = keep worktrees after epic
+    // completion for inspection").
+    worktree_cleanup_on_merge: coerceBool(
+      get(resolved, 'git.worktree.cleanup_on_merge'),
+      true,
+    ),
     squash_on_merge: coerceBool(get(resolved, 'git.squash_on_merge'), false),
     reuse_user_branch: coerceBool(get(resolved, 'git.reuse_user_branch'), false),
     merge_strategy: coerceEnum(

package/_Sprintpilot/manifest.yaml

@@ -1,6 +1,6 @@
 addon:
   name: sprintpilot
-  version: 2.2.18
+  version: 2.2.20
   description: Sprintpilot — autopilot and multi-agent addon for BMad Method (git workflow, parallel agents, autonomous story execution)
   bmad_compatibility: ">=6.2.0"
   modules:

package/_Sprintpilot/scripts/cleanup-worktrees.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+// cleanup-worktrees.js — remove orphan worktrees under .worktrees/.
+//
+// After `gh pr merge --delete-branch` (or any branch deletion), the
+// branch is gone but the `.worktrees/<name>/` directory remains. Git's
+// `git worktree prune` removes the `.git/worktrees/<name>/` metadata
+// but NOT the actual directory. Without explicit cleanup, .worktrees/
+// accumulates orphans every epic merge.
+//
+// This script:
+//   1. Runs `git worktree prune --expire now` to clear metadata.
+//   2. Walks `.worktrees/*` and removes directories whose branches no
+//      longer resolve (locally and on origin).
+//
+// Honors `git.worktree.cleanup_on_merge` via the orchestrator's plan —
+// this script is only invoked when that flag is true. Standalone use:
+//
+//   node _Sprintpilot/scripts/cleanup-worktrees.js \
+//     [--worktrees-dir .worktrees] [--project-root <path>] [--dry-run]
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const cp = require('node:child_process');
+
+const { parseArgs } = require('../lib/runtime/args');
+const log = require('../lib/runtime/log');
+
+function git(cwd, args, opts) {
+  return cp.spawnSync('git', ['-C', cwd, ...args], Object.assign({
+    encoding: 'utf8',
+    timeout: 10000,
+  }, opts || {}));
+}
+
+function localBranchExists(projectRoot, branch) {
+  const r = git(projectRoot, ['show-ref', '--verify', '--quiet', 'refs/heads/' + branch], {
+    stdio: 'ignore',
+  });
+  return r.status === 0;
+}
+
+function remoteBranchExists(projectRoot, branch) {
+  const r = git(
+    projectRoot,
+    ['show-ref', '--verify', '--quiet', 'refs/remotes/origin/' + branch],
+    { stdio: 'ignore' },
+  );
+  return r.status === 0;
+}
+
+function detectBranchFromGitfile(worktreeDir) {
+  const gitfile = path.join(worktreeDir, '.git');
+  let raw;
+  try {
+    raw = fs.readFileSync(gitfile, 'utf8');
+  } catch (_e) {
+    return { kind: 'unknown', branch: null };
+  }
+  const m = /^gitdir:\s*(.+)$/m.exec(raw);
+  if (!m) return { kind: 'unknown', branch: null };
+  const gitdir = m[1].trim();
+  if (!fs.existsSync(gitdir)) {
+    return { kind: 'orphan', branch: null };
+  }
+  const headPath = path.join(gitdir, 'HEAD');
+  let head;
+  try {
+    head = fs.readFileSync(headPath, 'utf8').trim();
+  } catch (_e) {
+    return { kind: 'orphan', branch: null };
+  }
+  const refMatch = /^ref:\s*refs\/heads\/(.+)$/m.exec(head);
+  if (!refMatch) return { kind: 'detached', branch: null };
+  return { kind: 'attached', branch: refMatch[1] };
+}
+
+function main() {
+  const { opts } = parseArgs(process.argv.slice(2));
+  if (opts.help) {
+    log.out(
+      'Usage: cleanup-worktrees.js [--worktrees-dir .worktrees] [--project-root <path>] [--dry-run]',
+    );
+    process.exit(0);
+  }
+  const projectRoot = opts['project-root'] || process.cwd();
+  const worktreesDir = opts['worktrees-dir']
+    ? path.resolve(opts['worktrees-dir'])
+    : path.join(projectRoot, '.worktrees');
+  const dryRun = !!opts['dry-run'];
+
+  const prune = git(projectRoot, ['worktree', 'prune', '--expire', 'now']);
+  if (prune.status !== 0 && prune.error) {
+    log.error('git worktree prune failed: ' + prune.error.message);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(worktreesDir)) {
+    log.out('SUMMARY:0:0:0');
+    return;
+  }
+  let entries;
+  try {
+    entries = fs.readdirSync(worktreesDir, { withFileTypes: true });
+  } catch (e) {
+    log.error('cannot read ' + worktreesDir + ': ' + e.message);
+    process.exit(1);
+  }
+
+  let inspected = 0;
+  let removed = 0;
+  let kept = 0;
+  for (const ent of entries) {
+    if (!ent.isDirectory()) continue;
+    inspected += 1;
+    const wt = path.join(worktreesDir, ent.name);
+    const info = detectBranchFromGitfile(wt);
+
+    let orphan = false;
+    if (info.kind === 'orphan') {
+      orphan = true;
+    } else if (info.kind === 'attached' && info.branch) {
+      const localOk = localBranchExists(projectRoot, info.branch);
+      const remoteOk = remoteBranchExists(projectRoot, info.branch);
+      if (!localOk && !remoteOk) orphan = true;
+    } else {
+      kept += 1;
+      continue;
+    }
+
+    if (!orphan) {
+      kept += 1;
+      continue;
+    }
+
+    log.out('ORPHAN:' + ent.name);
+    if (dryRun) {
+      removed += 1;
+      continue;
+    }
+    const r = git(projectRoot, ['worktree', 'remove', '--force', wt], { stdio: 'ignore' });
+    if (r.status !== 0) {
+      try {
+        fs.rmSync(wt, { recursive: true, force: true });
+      } catch (e) {
+        log.err('WARN: cannot remove ' + wt + ': ' + e.message);
+        continue;
+      }
+    }
+    removed += 1;
+  }
+
+  log.out('SUMMARY:' + inspected + ':' + removed + ':' + kept);
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikunin/sprintpilot",
-  "version": "2.2.18",
+  "version": "2.2.20",
   "description": "Sprintpilot — autopilot and multi-agent addon for BMad Method v6: git workflow, parallel agents, autonomous story execution",
   "license": "Apache-2.0",
   "repository": {