@pugi/cli 0.1.0-beta.8 → 0.1.0-beta.9

package/dist/runtime/commands/worktree.js

@@ -0,0 +1,177 @@
+/**
+ * `pugi worktree <op>` — α7.7 Phase 1.
+ *
+ * Manual control over the scratch worktree primitive. Three subcommands:
+ *
+ *   pugi worktree create [branch]    # spawns `.pugi/worktrees/<uuid>`
+ *   pugi worktree promote <path>     # applies the worktree's diff back to cwd
+ *   pugi worktree drop <path>        # removes the worktree (idempotent)
+ *
+ * Output: human-readable by default, structured JSON under --json so
+ * scripted callers can chain (`pugi worktree create --json | jq .path`).
+ *
+ * The same primitives are used by the `pugi build` and
+ * `pugi review --consensus` paths internally; this surface is the
+ * operator escape hatch for debugging / manual experimentation.
+ *
+ * Brand voice: ASCII only, no emoji, no banned words.
+ */
+import { spawnSync } from 'node:child_process';
+import { resolve, sep } from 'node:path';
+import { createWorktree, dropWorktree, promoteWorktree } from '../../core/edits/worktree.js';
+/**
+ * R1 fix (2026-05-26, PR #413 r1, P2 #10): operator-facing path
+ * validation. The core `promoteWorktree` / `dropWorktree` primitives
+ * already gate their inputs, but mirroring the check at the CLI surface
+ * gives the operator a clean error message before we even attempt the
+ * git invocation (which would otherwise leak `git rev-parse HEAD` stderr).
+ */
+function isUnderScratchRoot(cwd, candidate) {
+    const scratchRoot = resolve(cwd, '.pugi', 'worktrees');
+    const abs = resolve(cwd, candidate);
+    return abs.startsWith(scratchRoot + sep) && abs !== scratchRoot;
+}
+export async function runWorktreeCommand(args, opts) {
+    const [op, ...rest] = args;
+    if (!op)
+        return usage();
+    if (op === 'create') {
+        const branch = rest[0];
+        const result = createWorktree({
+            cwd: opts.cwd,
+            ...(branch ? { branch } : {}),
+        });
+        if (!result.ok) {
+            return {
+                ok: false,
+                text: opts.json
+                    ? JSON.stringify(result, null, 2)
+                    : `worktree create failed: ${result.reason}: ${result.detail}`,
+                exitCode: 1,
+            };
+        }
+        const handle = result.value;
+        return {
+            ok: true,
+            text: opts.json
+                ? JSON.stringify({ path: handle.path, baseSha: handle.baseSha }, null, 2)
+                : `worktree created: ${handle.path}\nbase: ${handle.baseSha}`,
+            exitCode: 0,
+        };
+    }
+    if (op === 'promote') {
+        const worktreePath = rest[0];
+        if (!worktreePath) {
+            return {
+                ok: false,
+                text: 'Usage: pugi worktree promote <path>',
+                exitCode: 2,
+            };
+        }
+        if (!isUnderScratchRoot(opts.cwd, worktreePath)) {
+            return {
+                ok: false,
+                text: opts.json
+                    ? JSON.stringify({
+                        ok: false,
+                        reason: 'invalid_worktree_path',
+                        detail: `worktree path must live under <cwd>/.pugi/worktrees/`,
+                    }, null, 2)
+                    : `promote failed: invalid_worktree_path: ${worktreePath} is not under .pugi/worktrees/`,
+                exitCode: 3,
+            };
+        }
+        // Resolve the worktree path's base SHA from its own git HEAD so
+        // the operator never has to remember it after `worktree create`.
+        const abs = resolve(opts.cwd, worktreePath);
+        const head = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: abs, encoding: 'utf8' });
+        if (head.status !== 0) {
+            return {
+                ok: false,
+                text: `cannot read HEAD of ${abs}: ${head.stderr.trim() || 'git rev-parse failed'}`,
+                exitCode: 1,
+            };
+        }
+        const baseSha = head.stdout.trim();
+        const result = promoteWorktree({
+            cwd: opts.cwd,
+            worktreePath: abs,
+            baseSha,
+            ...(opts.dryRun ? { dryRun: true } : {}),
+        });
+        if (!result.ok) {
+            return {
+                ok: false,
+                text: opts.json
+                    ? JSON.stringify(result, null, 2)
+                    : `promote failed: ${result.reason}: ${result.detail}`,
+                exitCode: result.reason === 'protected_file_in_worktree' ? 3 : 1,
+            };
+        }
+        const prefix = opts.dryRun ? 'dry-run: would promote' : 'promoted';
+        return {
+            ok: true,
+            text: opts.json
+                ? JSON.stringify({ filesChanged: result.value.filesChanged, dryRun: opts.dryRun ?? false }, null, 2)
+                : `${prefix} ${result.value.filesChanged} files from ${abs}`,
+            exitCode: 0,
+        };
+    }
+    if (op === 'drop') {
+        const worktreePath = rest[0];
+        if (!worktreePath) {
+            return {
+                ok: false,
+                text: 'Usage: pugi worktree drop <path>',
+                exitCode: 2,
+            };
+        }
+        if (!isUnderScratchRoot(opts.cwd, worktreePath)) {
+            return {
+                ok: false,
+                text: opts.json
+                    ? JSON.stringify({
+                        ok: false,
+                        reason: 'invalid_worktree_path',
+                        detail: `worktree path must live under <cwd>/.pugi/worktrees/`,
+                    }, null, 2)
+                    : `drop failed: invalid_worktree_path: ${worktreePath} is not under .pugi/worktrees/`,
+                exitCode: 3,
+            };
+        }
+        const abs = resolve(opts.cwd, worktreePath);
+        const result = dropWorktree(abs, opts.cwd);
+        if (!result.ok) {
+            return {
+                ok: false,
+                text: opts.json
+                    ? JSON.stringify(result, null, 2)
+                    : `drop failed: ${result.reason}: ${result.detail}`,
+                exitCode: result.reason === 'invalid_worktree_path' ? 3 : 1,
+            };
+        }
+        return {
+            ok: true,
+            text: opts.json
+                ? JSON.stringify({ dropped: abs }, null, 2)
+                : `worktree dropped: ${abs}`,
+            exitCode: 0,
+        };
+    }
+    return {
+        ok: false,
+        text: `unknown worktree operation: ${op}. Supported: create, promote, drop`,
+        exitCode: 2,
+    };
+}
+function usage() {
+    return {
+        ok: false,
+        text: 'Usage: pugi worktree <op>\n' +
+            '  pugi worktree create [branch]\n' +
+            '  pugi worktree promote <path>\n' +
+            '  pugi worktree drop <path>',
+        exitCode: 2,
+    };
+}
+//# sourceMappingURL=worktree.js.map