@pugi/cli 0.1.0-beta.3 → 0.1.0-beta.31

package/dist/runtime/commands/vim.js

@@ -0,0 +1,140 @@
+/**
+ * Leak L26 (2026-05-27) — `pugi vim` top-level command + REPL slash
+ * companion.
+ *
+ * Operator surface:
+ *
+ *   pugi vim                       Show current vim-mode state.
+ *   pugi vim on                    Enable + persist (~/.pugi/config.json).
+ *   pugi vim off                   Disable + persist (default).
+ *   /vim                           Toggle from inside the REPL.
+ *   /vim on                        Enable from inside the REPL.
+ *   /vim off                       Disable from inside the REPL.
+ *
+ * The same runner backs both surfaces so the slash + the shell verb
+ * stay single-sourced — operators trained on one read the same
+ * payload + banner on the other.
+ *
+ * Exit codes:
+ *   0 — show / enable / disable / toggle happy path
+ *   2 — unknown subcommand (e.g. `pugi vim chaos`)
+ *
+ * NOTE: there are NO `--persist` flag and no workspace tier. Vim mode
+ * is a single user-level preference, matching the leak research note
+ * that operators expect modal editing to be a body-memory trait, not
+ * a per-repo concern (see `core/vim/state.ts` header).
+ */
+import { resolveVimMode, setVimMode } from '../../core/vim/state.js';
+/**
+ * Banner shown on enable so the operator can see the binding cheat
+ * sheet without reaching for `/help`. Echoed by both surfaces.
+ */
+export const VIM_ENABLED_BANNER = 'Vim mode on. Esc=normal, i=insert, :w=submit, :q=cancel.';
+/**
+ * Entry point. Parses `args`, flips persistence as needed, emits the
+ * payload + text via `ctx.writeOutput`, and returns the exit code.
+ */
+export async function runVimCommand(args, ctx) {
+    // Validate args before reading state so a bad call never has a
+    // side-effect.
+    if (args.length > 1) {
+        const payload = {
+            command: 'vim',
+            status: 'invalid_args',
+            active: resolveVimMode({ env: ctx.env }),
+            message: `pugi vim takes at most one argument (on / off / toggle). Got: ${args.join(' ')}`,
+            attemptedArg: args.join(' '),
+        };
+        ctx.writeOutput(payload, payload.message);
+        return 2;
+    }
+    const current = resolveVimMode({ env: ctx.env });
+    const verb = args[0]?.toLowerCase() ?? '';
+    // No args → toggle (slash convention from the leak research). The
+    // CLI shell surface ALSO toggles on bare invocation so the two
+    // surfaces converge; if the operator wants the read-only show they
+    // can pipe through `pugi vim --json` or query the config directly.
+    // We surface the change as a `show` status when nothing flipped so
+    // scripts can distinguish read from write.
+    if (verb === '') {
+        const next = !current;
+        setVimMode(next, { env: ctx.env });
+        const status = next ? 'enabled' : 'disabled';
+        const message = next ? VIM_ENABLED_BANNER : 'Vim mode off.';
+        const payload = {
+            command: 'vim',
+            status,
+            active: next,
+            previous: current,
+            message,
+        };
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    if (verb === 'on' || verb === 'enable' || verb === 'true') {
+        if (current) {
+            const payload = {
+                command: 'vim',
+                status: 'unchanged',
+                active: true,
+                previous: true,
+                message: 'Vim mode already on.',
+            };
+            ctx.writeOutput(payload, payload.message);
+            return 0;
+        }
+        setVimMode(true, { env: ctx.env });
+        const payload = {
+            command: 'vim',
+            status: 'enabled',
+            active: true,
+            previous: current,
+            message: VIM_ENABLED_BANNER,
+        };
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    if (verb === 'off' || verb === 'disable' || verb === 'false') {
+        if (!current) {
+            const payload = {
+                command: 'vim',
+                status: 'unchanged',
+                active: false,
+                previous: false,
+                message: 'Vim mode already off.',
+            };
+            ctx.writeOutput(payload, payload.message);
+            return 0;
+        }
+        setVimMode(false, { env: ctx.env });
+        const payload = {
+            command: 'vim',
+            status: 'disabled',
+            active: false,
+            previous: current,
+            message: 'Vim mode off.',
+        };
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    if (verb === 'status' || verb === 'show') {
+        const payload = {
+            command: 'vim',
+            status: 'show',
+            active: current,
+            message: current ? 'Vim mode is on.' : 'Vim mode is off.',
+        };
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    const payload = {
+        command: 'vim',
+        status: 'invalid_args',
+        active: current,
+        message: `Unknown vim subcommand "${verb}". Try one of: on, off, status.`,
+        attemptedArg: verb,
+    };
+    ctx.writeOutput(payload, payload.message);
+    return 2;
+}
+//# sourceMappingURL=vim.js.map

package/dist/runtime/commands/worktree.js

@@ -16,9 +16,21 @@
  *
  * Brand voice: ASCII only, no emoji, no banned words.
  */
-import { resolve } from 'node:path';
 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)
@@ -56,6 +68,19 @@ export async function runWorktreeCommand(args, opts) {
                 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);
@@ -68,21 +93,27 @@ export async function runWorktreeCommand(args, opts) {
             };
         }
         const baseSha = head.stdout.trim();
-        const result = promoteWorktree({ cwd: opts.cwd, worktreePath: abs, baseSha });
+        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: 1,
+                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 }, null, 2)
-                : `promoted ${result.value.filesChanged} files from ${abs}`,
+                ? JSON.stringify({ filesChanged: result.value.filesChanged, dryRun: opts.dryRun ?? false }, null, 2)
+                : `${prefix} ${result.value.filesChanged} files from ${abs}`,
             exitCode: 0,
         };
     }
@@ -95,6 +126,19 @@ export async function runWorktreeCommand(args, opts) {
                 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) {
@@ -103,7 +147,7 @@ export async function runWorktreeCommand(args, opts) {
                 text: opts.json
                     ? JSON.stringify(result, null, 2)
                     : `drop failed: ${result.reason}: ${result.detail}`,
-                exitCode: 1,
+                exitCode: result.reason === 'invalid_worktree_path' ? 3 : 1,
             };
         }
         return {