@taranek/orche 0.0.12 → 0.0.13

package/dist/cli.js

@@ -3,6 +3,7 @@ import { readFileSync, existsSync, watch, unlinkSync, writeFileSync, mkdirSync }
 import { execFileSync, spawn } from "node:child_process";
 import path from "node:path";
 import { createWorktree } from "./worktree.js";
+import { pruneCommand } from "./prune.js";
 import { getMultiplexer } from "./multiplexer.js";
 import { buildLayout } from "./layout.js";
 import { getReviewBinaryPath } from "./review-manager.js";
@@ -60,6 +61,16 @@ function deliverReview(pendingPath) {
 }
 async function runReview(worktreePath) {
     const resolvedPath = path.resolve(worktreePath);
+    // Refuse to run unless the target is inside a git worktree — otherwise the
+    // review app may try to recursively watch enormous trees (e.g. $HOME).
+    try {
+        execFileSync("git", ["-C", resolvedPath, "rev-parse", "--show-toplevel"], {
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+    }
+    catch {
+        die(`not a git worktree: ${resolvedPath}`);
+    }
     const args = ["--worktree=" + resolvedPath];
     console.log(`opening review for ${worktreePath}...`);
     // Watch for .pending files from the Electron app and deliver them
@@ -78,6 +89,15 @@ async function runReview(worktreePath) {
             process.exit(0);
         }
     });
+    // Exit the CLI when the review app quits — otherwise the fs watcher
+    // keeps the event loop alive and the user has to ctrl+c.
+    const onReviewExit = (code) => {
+        try {
+            watcher.close();
+        }
+        catch { }
+        process.exit(code ?? 0);
+    };
     // Dev mode: launch electron from local monorepo
     const cliDir = path.dirname(new URL(import.meta.url).pathname);
     const localReviewDir = path.resolve(cliDir, "../../review");
@@ -88,18 +108,20 @@ async function runReview(worktreePath) {
         const electronBin = path.join(devReviewPath, "node_modules/.bin/electron");
         if (debug)
             console.error(`[review] launching: ${electronBin} ${[devReviewPath, ...args].join(" ")}`);
-        spawn(electronBin, [devReviewPath, ...args], {
+        const child = spawn(electronBin, [devReviewPath, ...args], {
             stdio: ["ignore", "inherit", "inherit"],
             env: { ...process.env, VITE_DEV_SERVER_URL: undefined },
         });
+        child.on("exit", onReviewExit);
         return;
     }
     const binaryPath = await getReviewBinaryPath();
     if (debug)
         console.error(`[review] launching: ${binaryPath} ${args.join(" ")}`);
-    spawn(binaryPath, args, {
+    const child = spawn(binaryPath, args, {
         stdio: ["ignore", "inherit", "inherit"],
     });
+    child.on("exit", onReviewExit);
 }
 function getRepoRoot(cwd) {
     // If we're inside an orche worktree, walk up to the real repo
@@ -137,11 +159,15 @@ orche — orchestrate agents across git worktrees
 Usage:
   orche start <task>         Start a new session for <task>
   orche review [path]        Open the review UI for a worktree
+  orche prune [--all] [-f]   Remove orche worktrees (interactive multiselect)
 
 Examples:
   orche start fix-auth       Create worktree + session for "fix-auth"
   orche review               Review changes in current directory
   orche review ./worktree    Review changes in a specific worktree
+  orche prune                Pick worktrees to remove
+  orche prune --all          Remove all orche worktrees
+  orche prune --force        Allow removing worktrees with uncommitted changes
 
 Requires a ${CONFIG_NAME} file in the current directory.
 Use ${CONFIG_LOCAL_NAME} for local overrides (not committed).
@@ -157,6 +183,10 @@ async function main() {
     if (subcommand === "start") {
         startSession();
     }
+    else if (subcommand === "prune") {
+        const repoRoot = getRepoRoot(process.cwd());
+        await pruneCommand(repoRoot, process.argv.slice(3));
+    }
     else if (subcommand === "review") {
         const explicitPath = process.argv[3] && !process.argv[3].startsWith("--")
             ? process.argv[3]

package/dist/prune.d.ts

@@ -0,0 +1 @@
+export declare function pruneCommand(repoRoot: string, argv: string[]): Promise<void>;

package/dist/prune.js

@@ -0,0 +1,79 @@
+import path from "node:path";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { listOrcheWorktrees, removeWorktree, } from "./worktree.js";
+function parseOptions(argv) {
+    return {
+        all: argv.includes("--all"),
+        force: argv.includes("--force") || argv.includes("-f"),
+    };
+}
+async function selectWorktrees(worktrees) {
+    const choice = await p.multiselect({
+        message: "Select worktrees to remove",
+        required: false,
+        options: worktrees.map((wt) => {
+            const branch = wt.branch ? ` ${pc.cyan(wt.branch)}` : "";
+            const hint = wt.dirty ? "uncommitted changes" : undefined;
+            return {
+                value: wt.worktreePath,
+                label: `${path.basename(wt.worktreePath)}${branch}`,
+                hint,
+            };
+        }),
+    });
+    if (p.isCancel(choice))
+        return null;
+    const picked = choice;
+    return worktrees.filter((wt) => picked.includes(wt.worktreePath));
+}
+function pruneWorktrees(repoRoot, targets, force) {
+    let removed = 0;
+    let skipped = 0;
+    let failed = 0;
+    for (const wt of targets) {
+        const name = path.basename(wt.worktreePath);
+        if (wt.dirty && !force) {
+            p.log.warn(`${name} — uncommitted changes (pass --force to remove)`);
+            skipped++;
+            continue;
+        }
+        try {
+            removeWorktree(repoRoot, wt.worktreePath, force);
+            p.log.success(`removed ${name}`);
+            removed++;
+        }
+        catch (err) {
+            p.log.error(`${name}: ${err?.message ?? err}`);
+            failed++;
+        }
+    }
+    return { removed, skipped, failed };
+}
+export async function pruneCommand(repoRoot, argv) {
+    const opts = parseOptions(argv);
+    p.intro("orche prune");
+    const worktrees = listOrcheWorktrees(repoRoot);
+    if (worktrees.length === 0) {
+        p.outro("no orche worktrees found");
+        return;
+    }
+    let targets;
+    if (opts.all) {
+        targets = worktrees;
+    }
+    else {
+        const picked = await selectWorktrees(worktrees);
+        if (picked === null) {
+            p.cancel("cancelled");
+            return;
+        }
+        if (picked.length === 0) {
+            p.outro("nothing selected");
+            return;
+        }
+        targets = picked;
+    }
+    const { removed, skipped, failed } = pruneWorktrees(repoRoot, targets, opts.force);
+    p.outro(`${removed} removed · ${skipped} skipped · ${failed} failed`);
+}

package/dist/worktree.d.ts

@@ -3,3 +3,10 @@ export interface WorktreeInfo {
     branchName: string;
 }
 export declare function createWorktree(repoPath: string, name: string): WorktreeInfo;
+export interface OrcheWorktree {
+    worktreePath: string;
+    branch: string | null;
+    dirty: boolean;
+}
+export declare function listOrcheWorktrees(repoPath: string): OrcheWorktree[];
+export declare function removeWorktree(repoPath: string, worktreePath: string, force: boolean): void;

package/dist/worktree.js

@@ -1,4 +1,4 @@
-import { execSync } from "node:child_process";
+import { execSync, execFileSync } from "node:child_process";
 import { existsSync, readFileSync, appendFileSync, mkdirSync, symlinkSync, readdirSync, lstatSync, } from "node:fs";
 import path from "node:path";
 function slugify(text) {
@@ -43,6 +43,57 @@ export function createWorktree(repoPath, name) {
     console.log(`  worktree: ${worktreePath} (${branchName})`);
     return { worktreePath, branchName };
 }
+const ORCHE_SEGMENT = `${path.sep}.orche${path.sep}worktrees${path.sep}`;
+function parseWorktreeList(output) {
+    const result = [];
+    for (const block of output.split(/\n\n+/)) {
+        if (!block.trim())
+            continue;
+        let worktreePath = null;
+        let branch = null;
+        for (const line of block.split("\n")) {
+            if (line.startsWith("worktree "))
+                worktreePath = line.slice("worktree ".length);
+            else if (line.startsWith("branch "))
+                branch = line.slice("branch ".length).replace(/^refs\/heads\//, "");
+        }
+        if (worktreePath)
+            result.push({ worktreePath, branch });
+    }
+    return result;
+}
+function isWorktreeDirty(worktreePath) {
+    try {
+        const out = execFileSync("git", ["status", "--porcelain"], {
+            cwd: worktreePath,
+            encoding: "utf-8",
+        });
+        return out.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function listOrcheWorktrees(repoPath) {
+    const out = execFileSync("git", ["worktree", "list", "--porcelain"], {
+        cwd: repoPath,
+        encoding: "utf-8",
+    });
+    return parseWorktreeList(out)
+        .filter((w) => w.worktreePath.includes(ORCHE_SEGMENT))
+        .map((w) => ({
+        worktreePath: w.worktreePath,
+        branch: w.branch,
+        dirty: isWorktreeDirty(w.worktreePath),
+    }));
+}
+export function removeWorktree(repoPath, worktreePath, force) {
+    const args = ["worktree", "remove"];
+    if (force)
+        args.push("--force");
+    args.push(worktreePath);
+    execFileSync("git", args, { cwd: repoPath, stdio: "inherit" });
+}
 function symlinkNodeModules(repoPath, worktreePath) {
     // Symlink root node_modules
     const rootNm = path.join(repoPath, "node_modules");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taranek/orche",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "type": "module",
   "bin": {
     "orche": "./dist/cli.js"
@@ -19,7 +19,11 @@
     "dev": "tsc --watch"
   },
   "devDependencies": {
-    "typescript": "^5.2.2",
-    "@types/node": "^25.2.0"
+    "@types/node": "^25.2.0",
+    "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.2.0",
+    "picocolors": "^1.1.1"
   }
 }

package/src/cli.ts

@@ -4,6 +4,7 @@ import { readFileSync, existsSync, watch, unlinkSync, writeFileSync, mkdirSync }
 import { execFileSync, spawn } from "node:child_process";
 import path from "node:path";
 import { createWorktree } from "./worktree.js";
+import { pruneCommand } from "./prune.js";
 import { getMultiplexer } from "./multiplexer.js";
 import { buildLayout } from "./layout.js";
 import { getReviewBinaryPath } from "./review-manager.js";
@@ -64,6 +65,17 @@ function deliverReview(pendingPath: string): void {
 
 async function runReview(worktreePath: string): Promise<void> {
   const resolvedPath = path.resolve(worktreePath);
+
+  // Refuse to run unless the target is inside a git worktree — otherwise the
+  // review app may try to recursively watch enormous trees (e.g. $HOME).
+  try {
+    execFileSync("git", ["-C", resolvedPath, "rev-parse", "--show-toplevel"], {
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+  } catch {
+    die(`not a git worktree: ${resolvedPath}`);
+  }
+
   const args = ["--worktree=" + resolvedPath];
 
   console.log(`opening review for ${worktreePath}...`);
@@ -86,6 +98,13 @@ async function runReview(worktreePath: string): Promise<void> {
     }
   });
 
+  // Exit the CLI when the review app quits — otherwise the fs watcher
+  // keeps the event loop alive and the user has to ctrl+c.
+  const onReviewExit = (code: number | null): void => {
+    try { watcher.close(); } catch {}
+    process.exit(code ?? 0);
+  };
+
   // Dev mode: launch electron from local monorepo
   const cliDir = path.dirname(new URL(import.meta.url).pathname);
   const localReviewDir = path.resolve(cliDir, "../../review");
@@ -95,18 +114,20 @@ async function runReview(worktreePath: string): Promise<void> {
   if (devReviewPath) {
     const electronBin = path.join(devReviewPath, "node_modules/.bin/electron");
     if (debug) console.error(`[review] launching: ${electronBin} ${[devReviewPath, ...args].join(" ")}`);
-    spawn(electronBin, [devReviewPath, ...args], {
+    const child = spawn(electronBin, [devReviewPath, ...args], {
       stdio: ["ignore", "inherit", "inherit"],
       env: { ...process.env, VITE_DEV_SERVER_URL: undefined },
     });
+    child.on("exit", onReviewExit);
     return;
   }
 
   const binaryPath = await getReviewBinaryPath();
   if (debug) console.error(`[review] launching: ${binaryPath} ${args.join(" ")}`);
-  spawn(binaryPath, args, {
+  const child = spawn(binaryPath, args, {
     stdio: ["ignore", "inherit", "inherit"],
   });
+  child.on("exit", onReviewExit);
 }
 
 function getRepoRoot(cwd: string): string {
@@ -157,11 +178,15 @@ orche — orchestrate agents across git worktrees
 Usage:
   orche start <task>         Start a new session for <task>
   orche review [path]        Open the review UI for a worktree
+  orche prune [--all] [-f]   Remove orche worktrees (interactive multiselect)
 
 Examples:
   orche start fix-auth       Create worktree + session for "fix-auth"
   orche review               Review changes in current directory
   orche review ./worktree    Review changes in a specific worktree
+  orche prune                Pick worktrees to remove
+  orche prune --all          Remove all orche worktrees
+  orche prune --force        Allow removing worktrees with uncommitted changes
 
 Requires a ${CONFIG_NAME} file in the current directory.
 Use ${CONFIG_LOCAL_NAME} for local overrides (not committed).
@@ -179,6 +204,9 @@ async function main(): Promise<void> {
 
   if (subcommand === "start") {
     startSession();
+  } else if (subcommand === "prune") {
+    const repoRoot = getRepoRoot(process.cwd());
+    await pruneCommand(repoRoot, process.argv.slice(3));
   } else if (subcommand === "review") {
     const explicitPath = process.argv[3] && !process.argv[3].startsWith("--")
       ? process.argv[3]

package/src/prune.ts

@@ -0,0 +1,102 @@
+import path from "node:path";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import {
+  listOrcheWorktrees,
+  removeWorktree,
+  type OrcheWorktree,
+} from "./worktree.js";
+
+interface PruneOptions {
+  all: boolean;
+  force: boolean;
+}
+
+function parseOptions(argv: string[]): PruneOptions {
+  return {
+    all: argv.includes("--all"),
+    force: argv.includes("--force") || argv.includes("-f"),
+  };
+}
+
+async function selectWorktrees(
+  worktrees: OrcheWorktree[]
+): Promise<OrcheWorktree[] | null> {
+  const choice = await p.multiselect<string>({
+    message: "Select worktrees to remove",
+    required: false,
+    options: worktrees.map((wt) => {
+      const branch = wt.branch ? ` ${pc.cyan(wt.branch)}` : "";
+      const hint = wt.dirty ? "uncommitted changes" : undefined;
+      return {
+        value: wt.worktreePath,
+        label: `${path.basename(wt.worktreePath)}${branch}`,
+        hint,
+      };
+    }),
+  });
+
+  if (p.isCancel(choice)) return null;
+  const picked = choice as string[];
+  return worktrees.filter((wt) => picked.includes(wt.worktreePath));
+}
+
+function pruneWorktrees(
+  repoRoot: string,
+  targets: OrcheWorktree[],
+  force: boolean
+): { removed: number; skipped: number; failed: number } {
+  let removed = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  for (const wt of targets) {
+    const name = path.basename(wt.worktreePath);
+    if (wt.dirty && !force) {
+      p.log.warn(`${name} — uncommitted changes (pass --force to remove)`);
+      skipped++;
+      continue;
+    }
+    try {
+      removeWorktree(repoRoot, wt.worktreePath, force);
+      p.log.success(`removed ${name}`);
+      removed++;
+    } catch (err: any) {
+      p.log.error(`${name}: ${err?.message ?? err}`);
+      failed++;
+    }
+  }
+
+  return { removed, skipped, failed };
+}
+
+export async function pruneCommand(repoRoot: string, argv: string[]): Promise<void> {
+  const opts = parseOptions(argv);
+
+  p.intro("orche prune");
+
+  const worktrees = listOrcheWorktrees(repoRoot);
+  if (worktrees.length === 0) {
+    p.outro("no orche worktrees found");
+    return;
+  }
+
+  let targets: OrcheWorktree[];
+  if (opts.all) {
+    targets = worktrees;
+  } else {
+    const picked = await selectWorktrees(worktrees);
+    if (picked === null) {
+      p.cancel("cancelled");
+      return;
+    }
+    if (picked.length === 0) {
+      p.outro("nothing selected");
+      return;
+    }
+    targets = picked;
+  }
+
+  const { removed, skipped, failed } = pruneWorktrees(repoRoot, targets, opts.force);
+  p.outro(`${removed} removed · ${skipped} skipped · ${failed} failed`);
+}

package/src/worktree.ts

@@ -1,4 +1,4 @@
-import { execSync } from "node:child_process";
+import { execSync, execFileSync } from "node:child_process";
 import {
   existsSync,
   readFileSync,
@@ -69,6 +69,62 @@ export function createWorktree(repoPath: string, name: string): WorktreeInfo {
   return { worktreePath, branchName };
 }
 
+export interface OrcheWorktree {
+  worktreePath: string;
+  branch: string | null;
+  dirty: boolean;
+}
+
+const ORCHE_SEGMENT = `${path.sep}.orche${path.sep}worktrees${path.sep}`;
+
+function parseWorktreeList(output: string): { worktreePath: string; branch: string | null }[] {
+  const result: { worktreePath: string; branch: string | null }[] = [];
+  for (const block of output.split(/\n\n+/)) {
+    if (!block.trim()) continue;
+    let worktreePath: string | null = null;
+    let branch: string | null = null;
+    for (const line of block.split("\n")) {
+      if (line.startsWith("worktree ")) worktreePath = line.slice("worktree ".length);
+      else if (line.startsWith("branch ")) branch = line.slice("branch ".length).replace(/^refs\/heads\//, "");
+    }
+    if (worktreePath) result.push({ worktreePath, branch });
+  }
+  return result;
+}
+
+function isWorktreeDirty(worktreePath: string): boolean {
+  try {
+    const out = execFileSync("git", ["status", "--porcelain"], {
+      cwd: worktreePath,
+      encoding: "utf-8",
+    });
+    return out.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+export function listOrcheWorktrees(repoPath: string): OrcheWorktree[] {
+  const out = execFileSync("git", ["worktree", "list", "--porcelain"], {
+    cwd: repoPath,
+    encoding: "utf-8",
+  });
+  return parseWorktreeList(out)
+    .filter((w) => w.worktreePath.includes(ORCHE_SEGMENT))
+    .map((w) => ({
+      worktreePath: w.worktreePath,
+      branch: w.branch,
+      dirty: isWorktreeDirty(w.worktreePath),
+    }));
+}
+
+export function removeWorktree(repoPath: string, worktreePath: string, force: boolean): void {
+  const args = ["worktree", "remove"];
+  if (force) args.push("--force");
+  args.push(worktreePath);
+  execFileSync("git", args, { cwd: repoPath, stdio: "inherit" });
+}
+
 function symlinkNodeModules(repoPath: string, worktreePath: string): void {
   // Symlink root node_modules
   const rootNm = path.join(repoPath, "node_modules");