@pugi/cli 0.1.0-beta.7 → 0.1.0-beta.87

package/dist/runtime/commands/update.js

@@ -0,0 +1,289 @@
+/**
+ * — `pugi update` dispatcher.
+ *
+ * Top-level command + in-REPL `/update` slash share this handler.
+ * Both surfaces delegate IO + persistence here so the channel
+ * resolution, the registry probe, and the install shell-out stay
+ * single-sourced.
+ *
+ * Command grammar:
+ *
+ *  pugi update                    -> probe + interactive prompt
+ *  pugi update --check            -> probe + JSON envelope (scripted)
+ *  pugi update --channel <name>   -> switch channel + probe
+ *  pugi update --apply            -> probe + shell `npm i -g …`
+ *                                     (confirms unless --yes)
+ *  pugi update --apply --yes      -> probe + shell, no confirmation
+ *
+ * Exit codes:
+ *
+ *  0 — happy path (no update OR update completed) OR `--check` JSON
+ *  1 — install / probe failure with structured error envelope
+ *  2 — argument error (bad channel, conflicting flags)
+ *
+ * R2 atomic swap deferred (sprint plan L27 mention): the upstream behavior
+ * also describes the upstream tool's R2-backed binary swap. Pugi ships
+ * exclusively via npm today; building a parallel R2 distribution
+ * channel + checksum verification + rollback is materially more work
+ * than the L27 acceptance criteria allow. Document the deferral in
+ * the PR body and revisit when npm's once-per-day rate-limit or
+ * outage cadence justifies the parallel pipeline.
+ */
+import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
+import { DEFAULT_UPDATE_CHANNEL, UPDATE_CHANNELS, describeChannel, npmTagForChannel, parseUpdateChannel, } from '../../core/auto-update/channels.js';
+import { checkForChannelUpdate, } from '../../core/auto-update/checker.js';
+import { resolveEffectiveChannel, setUpdateChannel, writeLastCheckedAt, } from '../../core/auto-update/state.js';
+import { PUGI_CLI_VERSION } from '../version.js';
+/**
+ * Default subprocess runner. Spawns `npm install -g @pugi/cli@<tag>`
+ * inheriting stdio so the operator sees the live npm output.
+ */
+export function defaultSpawnInstaller(channel) {
+    const tag = npmTagForChannel(channel);
+    const args = ['install', '-g', `@pugi/cli@${tag}`];
+    return new Promise((resolvePromise) => {
+        const child = spawn('npm', args, { stdio: 'inherit' });
+        child.on('exit', (code) => {
+            resolvePromise(typeof code === 'number' ? code : 1);
+        });
+        child.on('error', () => {
+            // ENOENT / EACCES — npm not on PATH or permission denied. We
+            // surface a non-zero code so the dispatcher's JSON envelope
+            // tells the operator the apply failed; the inherited stdio
+            // already printed the underlying error to the terminal.
+            resolvePromise(127);
+        });
+    });
+}
+/**
+ * Parse a CLI / slash argv into our `UpdateCommandFlags`. Returns
+ * `null` AND writes the usage error via `writeError` for conflicting
+ * combinations. Both `pugi update` and the in-REPL `/update <args>`
+ * surface call through this so the validation lives in one place.
+ */
+export function parseUpdateArgs(argv, options = {}) {
+    let check = false;
+    let apply = false;
+    let yes = false;
+    let json = options.jsonDefault ?? false;
+    let channel = null;
+    let channelInvalid;
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i] ?? '';
+        if (token === '--check') {
+            check = true;
+        }
+        else if (token === '--apply') {
+            apply = true;
+        }
+        else if (token === '--yes' || token === '-y') {
+            yes = true;
+        }
+        else if (token === '--json') {
+            json = true;
+        }
+        else if (token === '--channel') {
+            const value = argv[i + 1];
+            i += 1;
+            const parsed = parseUpdateChannel(value);
+            if (!parsed) {
+                channelInvalid = value ?? '';
+                continue;
+            }
+            channel = parsed;
+        }
+        else if (token.startsWith('--channel=')) {
+            const value = token.slice('--channel='.length);
+            const parsed = parseUpdateChannel(value);
+            if (!parsed) {
+                channelInvalid = value;
+                continue;
+            }
+            channel = parsed;
+        }
+        else {
+            return {
+                error: `pugi update: unknown argument '${token}'. See \`pugi update --help\`.`,
+            };
+        }
+    }
+    if (channelInvalid !== undefined) {
+        return {
+            error: `pugi update: unknown channel '${channelInvalid}'. Allowed: ${UPDATE_CHANNELS.join(' / ')}.`,
+        };
+    }
+    return {
+        check,
+        apply,
+        yes,
+        json,
+        channel,
+    };
+}
+/**
+ * Run the full command. Returns the structured envelope so the in-
+ * REPL slash can decide whether to render the human-readable text OR
+ * pretty-print the JSON.
+ */
+export async function runUpdateCommand(ctx) {
+    const flags = ctx.flags;
+    const home = ctx.home;
+    // 1. Resolve channel. `--channel <name>` wins; otherwise read the
+    //   persisted preference; otherwise hard default `beta`.
+    const cliFlagChannel = flags.channel;
+    const effectiveChannel = resolveEffectiveChannel({
+        cliFlag: cliFlagChannel,
+        homeDir: home,
+    });
+    // 2. Persist the channel switch BEFORE the probe so a probe failure
+    //   still leaves the operator on the channel they asked for.
+    let switched = false;
+    if (cliFlagChannel) {
+        setUpdateChannel(cliFlagChannel, home);
+        switched = true;
+    }
+    // 3. Probe the registry.
+    const outcome = await checkForChannelUpdate({
+        channel: effectiveChannel,
+        currentVersion: PUGI_CLI_VERSION,
+        ...(ctx.fetchImpl ? { fetchImpl: ctx.fetchImpl } : {}),
+        ...(ctx.registryUrl ? { registryUrl: ctx.registryUrl } : {}),
+    });
+    // 4. Record the timestamp on a successful probe (regardless of
+    //   whether an update is available). Failed probes do NOT update
+    //   the timestamp so the cold-start banner retries on the next
+    //   invocation.
+    if (!outcome.error) {
+        const now = ctx.now ? new Date(ctx.now()) : new Date();
+        try {
+            writeLastCheckedAt(now, home);
+        }
+        catch {
+            // Best-effort — a read-only home should not crash the dispatcher.
+        }
+    }
+    // 5. Build the envelope shape ALL action paths share.
+    const baseEnvelope = {
+        command: 'update',
+        ok: outcome.error === null,
+        available: outcome.available,
+        channel: outcome.channel,
+        npmTag: outcome.npmTag,
+        current: outcome.current,
+        latest: outcome.latest,
+        gap: outcome.gap,
+        installCommand: outcome.installCommand,
+        action: outcome.error ? 'error' : 'probe',
+        error: outcome.error,
+        meta: { cliVersion: PUGI_CLI_VERSION },
+    };
+    // 6. --check: emit the envelope, never prompt, never apply.
+    if (flags.check) {
+        const text = renderHumanText(baseEnvelope, { switched });
+        ctx.writeOutput(baseEnvelope, text);
+        return baseEnvelope;
+    }
+    // 7. No update available — bail with a friendly message.
+    if (!outcome.available || !outcome.latest) {
+        const envelope = {
+            ...baseEnvelope,
+            action: outcome.error ? 'error' : (switched ? 'switch' : 'no_update'),
+        };
+        const text = renderHumanText(envelope, { switched });
+        ctx.writeOutput(envelope, text);
+        return envelope;
+    }
+    // 8. Update IS available. Branch on --apply.
+    if (!flags.apply) {
+        // Default: print the offer, suggest the install command, leave
+        // the install to the operator. Mirrors the upstream behavior note:
+        // operators install side-effects must remain explicit on the CLI
+        // happy path — `pugi update` showing the gap is informational,
+        // `pugi update --apply` is the destructive verb.
+        const envelope = {
+            ...baseEnvelope,
+            action: switched ? 'switch' : 'probe',
+        };
+        const text = renderHumanText(envelope, { switched });
+        ctx.writeOutput(envelope, text);
+        return envelope;
+    }
+    // 9. --apply path. Confirm unless --yes, then spawn npm.
+    const installer = ctx.spawnInstaller ?? defaultSpawnInstaller;
+    let confirmed = flags.yes;
+    if (!confirmed) {
+        confirmed = await ctx.promptConfirm(`Run \`${outcome.installCommand}\` to update ${outcome.current} -> ${outcome.latest}? [y/N]`);
+    }
+    if (!confirmed) {
+        const envelope = {
+            ...baseEnvelope,
+            action: 'probe',
+            ok: false,
+            error: 'apply_cancelled_by_operator',
+        };
+        const text = `Cancelled. Run \`${outcome.installCommand}\` manually when you are ready.`;
+        ctx.writeOutput(envelope, text);
+        return envelope;
+    }
+    const exitCode = await installer(outcome.channel);
+    const applyEnvelope = {
+        ...baseEnvelope,
+        action: 'apply',
+        installExitCode: exitCode,
+        ok: exitCode === 0,
+        error: exitCode === 0 ? null : `npm_install_exit_${exitCode}`,
+    };
+    const applyText = exitCode === 0
+        ? `Updated to @pugi/cli@${outcome.latest}. Restart your shell so the new binary takes effect.`
+        : `Update failed (npm exit ${exitCode}). Try \`${outcome.installCommand}\` manually.`;
+    ctx.writeOutput(applyEnvelope, applyText);
+    return applyEnvelope;
+}
+/**
+ * Build the operator-readable hint that lives next to the JSON
+ * envelope. The text + the JSON are both passed to `writeOutput`; the
+ * caller (`writeOutput` in cli.ts) picks based on `--json`. Exported
+ * so the spec can assert the literal strings the operator sees.
+ */
+export function renderHumanText(envelope, options = {}) {
+    const { current, latest, channel, installCommand, available, error } = envelope;
+    const lines = [];
+    lines.push(`Channel: ${channel} — ${describeChannel(channel)}`);
+    if (options.switched) {
+        lines.push(`Persisted channel selection -> ${channel}.`);
+    }
+    if (error) {
+        lines.push(`Update check failed: ${error}`);
+        lines.push(`Manual: \`${installCommand}\` (no probe necessary).`);
+        return lines.join('\n');
+    }
+    if (available && latest) {
+        lines.push(`Update available: ${current} -> ${latest}.`);
+        lines.push(`Run \`${installCommand}\` to upgrade.`);
+        lines.push(`Or \`pugi update --apply\` to upgrade with confirmation.`);
+        return lines.join('\n');
+    }
+    lines.push(`Up to date (${current} is the latest on ${channel}).`);
+    return lines.join('\n');
+}
+/**
+ * Render a one-line cold-start hint that callers (REPL boot, doctor
+ * banner) splice above their own UI. Returns `null` when there is
+ * nothing to nudge the operator about. Pure — no IO.
+ */
+export function renderUpdateHint(outcome) {
+    if (!outcome.available || !outcome.latest)
+        return null;
+    return `Update available: ${outcome.current} -> ${outcome.latest}. Run \`pugi update\`.`;
+}
+/**
+ * Convenience entry point — resolve the effective channel from
+ * `~/.pugi/config.json` + DEFAULT_UPDATE_CHANNEL without forcing the
+ * caller to import multiple modules. Used by the cold-start banner +
+ * the doctor probe.
+ */
+export function effectiveChannel(home = homedir()) {
+    return resolveEffectiveChannel({ homeDir: home }) ?? DEFAULT_UPDATE_CHANNEL;
+}
+//# sourceMappingURL=update.js.map

package/dist/runtime/commands/vim.js

@@ -0,0 +1,140 @@
+/**
+ * — `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 upstream behavior 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 upstream behavior ). 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

@@ -0,0 +1,177 @@
+/**
+ * `pugi worktree <op>` — 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 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