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

package/dist/runtime/commands/style.js

@@ -0,0 +1,194 @@
+/**
+ * — `pugi style` top-level command + REPL slash
+ * companion.
+ *
+ * Operator surface:
+ *
+ *  pugi style                      Show active preset + table.
+ *  pugi style <name>               Switch workspace preset (current cwd).
+ *  pugi style <name> --persist     Switch + also write user default.
+ *  pugi style --reset              Clear workspace override → back to default.
+ *  pugi style --reset --user       Also clear the user default.
+ *  pugi style --list               Print the catalogue (no flip).
+ *  pugi style --json               Structured envelope variant.
+ *
+ * The same runner powers `/style` from inside the REPL. The REPL
+ * dispatcher (see `core/repl/session.ts`) routes through here so the
+ * two surfaces stay single-sourced — operators trained on one read
+ * the same payload + table on the other.
+ *
+ * Exit codes:
+ *  0 — show / switch / reset all succeed
+ *  1 — unknown preset slug (returned BEFORE any write)
+ *  2 — conflicting flags (e.g. `--reset` with a positional slug)
+ *
+ * The exit codes are surfaced through `process.exitCode` by the
+ * dispatcher in `cli.ts` — this module returns a structured payload
+ * + writes via the injected `writeOutput`. Throwing is reserved for
+ * truly unexpected errors (fs permissions etc.); the spec hooks the
+ * happy + sad paths through `writeOutput` shape, not via try/catch
+ * on the throw.
+ */
+import { DEFAULT_OUTPUT_STYLE, isOutputStyleSlug, OUTPUT_STYLE_SLUGS, renderStyleTable, } from '../../core/output-style/presets.js';
+import { clearUserOutputStyle, clearWorkspaceOutputStyle, resolveOutputStyle, setUserOutputStyle, setWorkspaceOutputStyle, } from '../../core/output-style/state.js';
+/**
+ * Entry point. Parses `args`, applies the operation, emits the
+ * payload + text via `ctx.writeOutput`, and returns the exit code the
+ * dispatcher should hand back to the shell.
+ */
+export async function runStyleCommand(args, ctx) {
+    const flags = parseFlags(args);
+    // Reset path
+    if (flags.reset) {
+        if (flags.slug !== null) {
+            const payload = buildPayload({
+                status: 'invalid_flags',
+                ctx,
+                message: '/style --reset cannot be combined with a preset name. Use one or the other.',
+            });
+            ctx.writeOutput(payload, payload.message);
+            return 2;
+        }
+        if (flags.persist) {
+            const payload = buildPayload({
+                status: 'invalid_flags',
+                ctx,
+                message: '/style --reset cannot be combined with --persist. Use --reset --user to also clear the user default.',
+            });
+            ctx.writeOutput(payload, payload.message);
+            return 2;
+        }
+        clearWorkspaceOutputStyle({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        if (flags.user) {
+            clearUserOutputStyle({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        }
+        const payload = buildPayload({
+            status: 'reset',
+            ctx,
+            message: flags.user
+                ? `Cleared workspace + user output style. Active: ${DEFAULT_OUTPUT_STYLE} (default).`
+                : `Cleared workspace output style. Active: ${describeActive(ctx)}.`,
+        });
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    // List path
+    if (flags.list && flags.slug === null) {
+        const resolved = resolveOutputStyle({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        const payload = buildPayload({
+            status: 'listed',
+            ctx,
+            message: renderStyleTable(resolved.slug),
+        });
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    // Switch path
+    if (flags.slug !== null) {
+        if (!isOutputStyleSlug(flags.slug)) {
+            const payload = buildPayload({
+                status: 'invalid_slug',
+                ctx,
+                attemptedSlug: flags.slug,
+                message: `Unknown style "${flags.slug}". Try one of: ${OUTPUT_STYLE_SLUGS.join(', ')}.`,
+            });
+            ctx.writeOutput(payload, payload.message);
+            return 1;
+        }
+        const before = resolveOutputStyle({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        setWorkspaceOutputStyle(flags.slug, { workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        if (flags.persist) {
+            setUserOutputStyle(flags.slug, { workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        }
+        const tail = flags.persist ? ' (workspace + user default)' : ' (workspace)';
+        const payload = buildPayload({
+            status: 'switched',
+            ctx,
+            previous: before.slug,
+            persistedToUser: flags.persist,
+            message: `Output style → ${flags.slug}${tail}. Was: ${before.slug} (${before.source}).`,
+        });
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    // Show path (no args)
+    const resolved = resolveOutputStyle({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+    const banner = `Active output style: ${resolved.slug} (${resolved.source})`;
+    const table = renderStyleTable(resolved.slug);
+    const payload = buildPayload({
+        status: 'show',
+        ctx,
+        message: `${banner}\n\n${table}`,
+    });
+    ctx.writeOutput(payload, payload.message);
+    return 0;
+}
+function describeActive(ctx) {
+    const resolved = resolveOutputStyle({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+    return `${resolved.slug} (${resolved.source})`;
+}
+function buildPayload(args) {
+    const resolved = resolveOutputStyle({ workspaceRoot: args.ctx.workspaceRoot, env: args.ctx.env });
+    const payload = {
+        command: 'style',
+        status: args.status,
+        active: resolved.slug,
+        source: resolved.source,
+        presets: OUTPUT_STYLE_SLUGS,
+        message: args.message,
+    };
+    if (args.previous !== undefined)
+        payload.previous = args.previous;
+    if (args.persistedToUser !== undefined)
+        payload.persistedToUser = args.persistedToUser;
+    if (args.attemptedSlug !== undefined)
+        payload.attemptedSlug = args.attemptedSlug;
+    return payload;
+}
+function parseFlags(args) {
+    const flags = {
+        slug: null,
+        persist: false,
+        reset: false,
+        user: false,
+        list: false,
+    };
+    for (const arg of args) {
+        if (arg === '--persist')
+            flags.persist = true;
+        else if (arg === '--reset')
+            flags.reset = true;
+        else if (arg === '--user')
+            flags.user = true;
+        else if (arg === '--list')
+            flags.list = true;
+        else if (arg.startsWith('-')) {
+            // Unknown flag — keep simple parser. Treat as positional so the
+            // downstream isOutputStyleSlug check rejects it with a clear
+            // "unknown style" message rather than swallowing silently.
+            if (flags.slug === null)
+                flags.slug = arg;
+        }
+        else if (flags.slug === null) {
+            flags.slug = arg;
+        }
+    }
+    // Normalise the slug to lowercase so `pugi style TERSE` works the
+    // same as `pugi style terse`. The catalogue is lowercase-only by
+    // contract; this keeps operators from tripping on shift-key habits.
+    if (flags.slug !== null)
+        flags.slug = flags.slug.toLowerCase();
+    return flags;
+}
+/**
+ * Re-export for the slash-command dispatcher in `core/repl/session.ts`
+ * so it can render a compiled prompt block when the operator runs
+ * `/style --preview` (follow-up surface; current slash returns the
+ * runner's standard payload).
+ *
+ * Kept here so the runtime module is the single import point for
+ * style-related surfaces; consumers should NOT reach into
+ * `core/output-style/*` directly.
+ */
+export { OUTPUT_STYLES as OUTPUT_STYLE_CATALOGUE, } from '../../core/output-style/presets.js';
+//# sourceMappingURL=style.js.map

package/dist/runtime/commands/theme.js

@@ -0,0 +1,196 @@
+/**
+ * — `pugi theme` top-level command + REPL slash
+ * companion.
+ *
+ * Operator surface:
+ *
+ *  pugi theme                      Show active theme + table.
+ *  pugi theme <name>               Switch workspace theme (current cwd).
+ *  pugi theme <name> --persist     Switch + also write user default.
+ *  pugi theme --reset              Clear workspace override → back to default.
+ *  pugi theme --reset --user       Also clear the user default.
+ *  pugi theme --list               Print the catalogue (no flip).
+ *  pugi theme --json               Structured envelope variant.
+ *
+ * The same runner powers `/theme` from inside the REPL. The REPL
+ * dispatcher (see `core/repl/session.ts`) routes through here so the
+ * two surfaces stay single-sourced — operators trained on one read
+ * the same payload + table on the other. Matches the
+ * `/style` runner exactly so the two settings surfaces are
+ * paste-comparable for the operator + grep-comparable for future
+ * maintenance.
+ *
+ * Exit codes:
+ *  0 — show / switch / reset all succeed
+ *  1 — unknown preset slug (returned BEFORE any write)
+ *  2 — conflicting flags (e.g. `--reset` with a positional slug)
+ *
+ * The exit codes are surfaced through `process.exitCode` by the
+ * dispatcher in `cli.ts` — this module returns a structured payload
+ * + writes via the injected `writeOutput`. Throwing is reserved for
+ * truly unexpected errors (fs permissions etc.); the spec hooks the
+ * happy + sad paths through `writeOutput` shape, not via try/catch
+ * on the throw.
+ */
+import { DEFAULT_THEME, isThemeSlug, renderThemeTable, THEME_SLUGS, } from '../../core/theme/presets.js';
+import { clearUserTheme, clearWorkspaceTheme, resolveTheme, setUserTheme, setWorkspaceTheme, } from '../../core/theme/state.js';
+/**
+ * Entry point. Parses `args`, applies the operation, emits the
+ * payload + text via `ctx.writeOutput`, and returns the exit code the
+ * dispatcher should hand back to the shell.
+ */
+export async function runThemeCommand(args, ctx) {
+    const flags = parseFlags(args);
+    // Reset path
+    if (flags.reset) {
+        if (flags.slug !== null) {
+            const payload = buildPayload({
+                status: 'invalid_flags',
+                ctx,
+                message: '/theme --reset cannot be combined with a preset name. Use one or the other.',
+            });
+            ctx.writeOutput(payload, payload.message);
+            return 2;
+        }
+        if (flags.persist) {
+            const payload = buildPayload({
+                status: 'invalid_flags',
+                ctx,
+                message: '/theme --reset cannot be combined with --persist. Use --reset --user to also clear the user default.',
+            });
+            ctx.writeOutput(payload, payload.message);
+            return 2;
+        }
+        clearWorkspaceTheme({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        if (flags.user) {
+            clearUserTheme({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        }
+        const payload = buildPayload({
+            status: 'reset',
+            ctx,
+            message: flags.user
+                ? `Cleared workspace + user theme. Active: ${DEFAULT_THEME} (default).`
+                : `Cleared workspace theme. Active: ${describeActive(ctx)}.`,
+        });
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    // List path
+    if (flags.list && flags.slug === null) {
+        const resolved = resolveTheme({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        const payload = buildPayload({
+            status: 'listed',
+            ctx,
+            message: renderThemeTable(resolved.slug),
+        });
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    // Switch path
+    if (flags.slug !== null) {
+        if (!isThemeSlug(flags.slug)) {
+            const payload = buildPayload({
+                status: 'invalid_slug',
+                ctx,
+                attemptedSlug: flags.slug,
+                message: `Unknown theme "${flags.slug}". Try one of: ${THEME_SLUGS.join(', ')}.`,
+            });
+            ctx.writeOutput(payload, payload.message);
+            return 1;
+        }
+        const before = resolveTheme({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        setWorkspaceTheme(flags.slug, { workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        if (flags.persist) {
+            setUserTheme(flags.slug, { workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        }
+        const tail = flags.persist ? ' (workspace + user default)' : ' (workspace)';
+        const payload = buildPayload({
+            status: 'switched',
+            ctx,
+            previous: before.slug,
+            persistedToUser: flags.persist,
+            message: `Theme → ${flags.slug}${tail}. Was: ${before.slug} (${before.source}).`,
+        });
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    // Show path (no args)
+    const resolved = resolveTheme({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+    const banner = `Active theme: ${resolved.slug} (${resolved.source})`;
+    const table = renderThemeTable(resolved.slug);
+    const payload = buildPayload({
+        status: 'show',
+        ctx,
+        message: `${banner}\n\n${table}`,
+    });
+    ctx.writeOutput(payload, payload.message);
+    return 0;
+}
+function describeActive(ctx) {
+    const resolved = resolveTheme({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+    return `${resolved.slug} (${resolved.source})`;
+}
+function buildPayload(args) {
+    const resolved = resolveTheme({ workspaceRoot: args.ctx.workspaceRoot, env: args.ctx.env });
+    const payload = {
+        command: 'theme',
+        status: args.status,
+        active: resolved.slug,
+        source: resolved.source,
+        presets: THEME_SLUGS,
+        message: args.message,
+    };
+    if (args.previous !== undefined)
+        payload.previous = args.previous;
+    if (args.persistedToUser !== undefined)
+        payload.persistedToUser = args.persistedToUser;
+    if (args.attemptedSlug !== undefined)
+        payload.attemptedSlug = args.attemptedSlug;
+    return payload;
+}
+function parseFlags(args) {
+    const flags = {
+        slug: null,
+        persist: false,
+        reset: false,
+        user: false,
+        list: false,
+    };
+    for (const arg of args) {
+        if (arg === '--persist')
+            flags.persist = true;
+        else if (arg === '--reset')
+            flags.reset = true;
+        else if (arg === '--user')
+            flags.user = true;
+        else if (arg === '--list')
+            flags.list = true;
+        else if (arg.startsWith('-')) {
+            // Unknown flag — keep simple parser. Treat as positional so the
+            // downstream isThemeSlug check rejects it with a clear "unknown
+            // theme" message rather than swallowing silently. Mirrors the
+            // L18 style runner's behaviour for grep-parity.
+            if (flags.slug === null)
+                flags.slug = arg;
+        }
+        else if (flags.slug === null) {
+            flags.slug = arg;
+        }
+    }
+    // Normalise the slug to lowercase so `pugi theme DARK` works the
+    // same as `pugi theme dark`. The catalogue is lowercase-only by
+    // contract; this keeps operators from tripping on shift-key habits.
+    if (flags.slug !== null)
+        flags.slug = flags.slug.toLowerCase();
+    return flags;
+}
+/**
+ * Re-export for the slash-command dispatcher in
+ * `core/repl/session.ts` so it can render a preview block if a
+ * future surface (`/theme --preview`) lands. Kept here so the
+ * runtime module is the single import point for theme-related
+ * surfaces; consumers should NOT reach into `core/theme/*` directly
+ * unless they are Ink components that need the React context.
+ */
+export { THEMES as THEME_CATALOGUE, } from '../../core/theme/presets.js';
+//# sourceMappingURL=theme.js.map

package/dist/runtime/commands/undo.js

@@ -3,34 +3,35 @@ import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from
 import { resolve } from 'node:path';
 import { hashContent } from '../../core/file-cache.js';
 import { recordFileMutation, recordToolCall, recordToolResult, } from '../../core/session.js';
+import { writeBlob } from './redo-blob-store.js';
 /**
  * `pugi undo` — revert the file mutations from the most recent successful
  * `write` / `edit` / `multi_edit` tool result.
  *
  * Walk strategy:
- *   1. Read `.pugi/events.jsonl` line by line into an array.
- *   2. Walk backwards. Find the most recent `tool_result` whose
- *      `status === 'success'` and whose linked `tool_call` names a
- *      mutating tool (write / edit / multi_edit).
- *   3. From that point, gather every `file_mutation` event that shares
- *      the same `toolCallId`. M1 records one `file_mutation` per
- *      mutating tool call, but the loop is shaped for the multi_edit
- *      future case where a single tool call mutates many files.
+ *  1. Read `.pugi/events.jsonl` line by line into an array.
+ *  2. Walk backwards. Find the most recent `tool_result` whose
+ *     `status === 'success'` and whose linked `tool_call` names a
+ *     mutating tool (write / edit / multi_edit).
+ *  3. From that point, gather every `file_mutation` event that shares
+ *     the same `toolCallId`. M1 records one `file_mutation` per
+ *     mutating tool call, but the loop is shaped for the multi_edit
+ *     future case where a single tool call mutates many files.
  *
  * Restore strategy (M1 — no blob store yet):
- *   For each mutation we restore from the workspace's git history when
- *   possible, with a strict safety gate to avoid silently overwriting
- *   the user's WORK-IN-PROGRESS:
+ *  For each mutation we restore from the workspace's git history when
+ *  possible, with a strict safety gate to avoid silently overwriting
+ *  the user's WORK-IN-PROGRESS:
  *
- *   - `operation: create`  → unlink the created file iff its current
- *     sha256 matches the recorded `afterHash`. Skip otherwise (the user
- *     has edited it since; refuse to delete their work).
- *   - `operation: update`  → restore from `HEAD:<path>` iff (a) the file
- *     was tracked at HEAD AND (b) the HEAD content's sha256 matches the
- *     recorded `beforeHash`. Otherwise abort the turn (no partial
- *     reverts — the spec is atomic).
- *   - `operation: delete`  → restore the deleted file from `HEAD:<path>`
- *     if tracked there; skip otherwise.
+ *  - `operation: create` → unlink the created file iff its current
+ *    sha256 matches the recorded `afterHash`. Skip otherwise (the user
+ *    has edited it since; refuse to delete their work).
+ *  - `operation: update` → restore from `HEAD:<path>` iff (a) the file
+ *    was tracked at HEAD AND (b) the HEAD content's sha256 matches the
+ *    recorded `beforeHash`. Otherwise abort the turn (no partial
+ *    reverts — the spec is atomic).
+ *  - `operation: delete` → restore the deleted file from `HEAD:<path>`
+ *    if tracked there; skip otherwise.
  *
  * If any single restore is unsafe the whole turn aborts with exit code
  * 1 and no files are touched.
@@ -39,7 +40,7 @@ import { recordFileMutation, recordToolCall, recordToolResult, } from '../../cor
  * but NOT raw content (see `core/file-cache.ts`). M1 ships without a
  * dedicated blob CAS; `git show HEAD:<path>` is the cheapest authoritative
  * source for pre-mutation content as long as the workspace is a git
- * repository. The α6.4 SQLite session store will replace this with a
+ * repository. The SQLite session store will replace this with a
  * proper before-blob ledger.
  */
 const MUTATING_TOOLS = new Set(['write', 'edit', 'multi_edit']);
@@ -81,6 +82,37 @@ export async function runUndoCommand(_args, ctx) {
     const restored = [];
     for (const step of plan.steps) {
         try {
+            // : snapshot the AFTER state into the redo
+            // blob store BEFORE we revert the file on disk. /redo reads this
+            // blob keyed by `step.beforeHash` (= original afterHash) to
+            // reapply the change. We only snapshot for operations that have
+            // on-disk AFTER content: `create` (file exists, about to be
+            // deleted) and `update` (file exists, about to be overwritten).
+            // For `delete` reverts (file was deleted by Pugi, the "after" is
+            // nothing) redo replays the delete itself — no content needed.
+            // Best-effort: a blob-store failure must not abort the undo, so
+            // the writeBlob call is wrapped и any error swallowed.
+            if (step.operation === 'create' || step.operation === 'update') {
+                try {
+                    const abs = resolve(ctx.workspaceRoot, step.path);
+                    if (existsSync(abs) && step.beforeHash) {
+                        const current = readFileSync(abs, 'utf8');
+                        // Defensive: only snapshot if the current sha matches the
+                        // pre-revert hash the planner verified. The planner already
+                        // gated this, but a TOCTOU between plan + execute would
+                        // produce a wrong blob — silently dropping it is safer than
+                        // shipping content under the wrong sha.
+                        if (hashContent(current) === step.beforeHash) {
+                            writeBlob(ctx.workspaceRoot, current);
+                        }
+                    }
+                }
+                catch {
+                    // Best-effort. Failure to snapshot means /redo will report
+                    // "no captured content" — operator can re-run the mutation
+                    // manually. Better than aborting the undo.
+                }
+            }
             executeRevert(ctx.workspaceRoot, step);
             restored.push({ path: step.path, operation: step.operation });
         }
@@ -119,7 +151,7 @@ export async function runUndoCommand(_args, ctx) {
         restored,
     }, [
         `Undid ${restored.length} mutation(s) from ${target.toolCallId}:`,
-        ...restored.map((entry) => `  ${entry.operation.padEnd(7)} ${entry.path}`),
+        ...restored.map((entry) => ` ${entry.operation.padEnd(7)} ${entry.path}`),
     ].join('\n'));
 }
 function parseEvents(eventsPath) {