@pugi/cli 0.1.0-beta.10 → 0.1.0-beta.100

package/dist/runtime/commands/status.js

@@ -0,0 +1,186 @@
+/**
+ * `pugi status` — concise session-state probe ().
+ *
+ * Different from `pugi doctor` (environment health). The status
+ * command answers "what is this Pugi session doing right now?" —
+ * session id + age, cwd, permission mode, CLI version, token
+ * usage, dispatch counts, last command, compact boundaries, auth
+ * identity.
+ *
+ * # Module contract
+ *
+ *  - This file owns the WIRING from CLI flags + ambient process
+ *    state к the snapshot collector. The data collector itself
+ *    lives in `core/diagnostics/probes/status-snapshot.ts` and
+ *    has zero coupling к the CLI dispatch surface.
+ *
+ *  - `runStatusCommand` is the single entry point. Both the
+ *    top-level `pugi status` handler in `runtime/cli.ts` AND the
+ *    in-REPL `/status` slash command call it. The function
+ *    returns the `StatusSnapshot` so the REPL slash handler can
+ *    mount the Ink renderer without re-collecting fields.
+ *
+ *  - The credential resolver is captured behind a function so the
+ *    spec can stub it without monkey-patching `core/credentials.ts`.
+ *
+ *  - The permission state module is dynamic-imported with a
+ *    try/catch so this command lands cleanly before the L6
+ *    permission-mode work — when the module is absent the field
+ *    degrades к "unknown" instead of crashing the snapshot.
+ *
+ *  - Exit code is 0 unless the snapshot itself throws. The
+ *    command is intentionally informational — even a fully
+ *    "unavailable" snapshot (everything degraded к sentinels)
+ *    exits 0 so monitoring scripts can rely on a stable contract.
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolveActiveCredential } from '../../core/credentials.js';
+import { PUGI_CLI_VERSION } from '../version.js';
+import { collectStatusSnapshot, } from '../../core/diagnostics/probes/status-snapshot.js';
+/**
+ * Default production filesystem stubs. Wraps node:fs so the
+ * snapshot collector can stay sync + structurally testable.
+ */
+const DEFAULT_FS = {
+    existsSync,
+    statSync,
+    readdirSync: (p) => readdirSync(p),
+    readFileSync: (p, encoding) => readFileSync(p, encoding),
+};
+/**
+ * Default credential resolver. Wraps `resolveActiveCredential` so
+ * the snapshot only sees the trimmed `ResolvedCredentialSummary`
+ * shape and не the full store record.
+ */
+function defaultResolveCredential(env, home) {
+    const cred = resolveActiveCredential(env, home);
+    if (!cred)
+        return null;
+    // Tier is не yet recorded в the credentials file — set к null
+    // until a future sprint surfaces `tier` on the stored record.
+    // The renderer hides the parenthetical when tier is null.
+    return {
+        apiUrl: cred.apiUrl,
+        label: cred.label ?? null,
+        tier: null,
+        identity: cred.label ?? null,
+    };
+}
+/**
+ * Default permission-mode loader. Dynamic-imports
+ * `core/permissions/state.ts` (L6 in the leak-parity roadmap);
+ * returns null when the module is absent OR malformed, which the
+ * snapshot field degrades к the "unknown" sentinel.
+ */
+async function defaultResolvePermissionMode() {
+    try {
+        const mod = (await import('../../core/permissions/state.js').catch(() => null));
+        if (!mod || typeof mod.getCurrentPermissionMode !== 'function') {
+            return null;
+        }
+        const mode = mod.getCurrentPermissionMode();
+        return typeof mode === 'string' && mode.length > 0 ? mode : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Collect the snapshot + emit the output via the supplied
+ * writeOutput sink. Returns the snapshot so REPL callers can
+ * route it к the Ink renderer instead of the plain-text fallback.
+ */
+export async function runStatusCommand(ctx) {
+    // Resolve the permission mode upfront — the snapshot is sync but
+    // the L6 loader is async (dynamic import). We materialise the
+    // value here and hand the snapshot a sync getter.
+    const permissionMode = ctx.resolvePermissionMode === undefined
+        ? await defaultResolvePermissionMode()
+        : null;
+    const deps = {
+        cwd: ctx.cwd,
+        home: ctx.home,
+        cliVersion: PUGI_CLI_VERSION,
+        now: ctx.now ?? Date.now,
+        liveSessionId: ctx.liveSessionId ?? null,
+        sessionStartedAtEpochMs: ctx.sessionStartedAtEpochMs ?? null,
+        liveTokensUsed: ctx.liveTokensUsed ?? null,
+        lastCommand: ctx.lastCommand ?? null,
+        lastCommandAtEpochMs: ctx.lastCommandAtEpochMs ?? null,
+        liveApiUrl: ctx.liveApiUrl ?? null,
+        workspaceLabel: ctx.workspaceLabel ?? null,
+        fs: ctx.fs ?? DEFAULT_FS,
+        resolveCredential: ctx.resolveCredential ?? (() => defaultResolveCredential(ctx.env, ctx.home)),
+        resolvePermissionMode: ctx.resolvePermissionMode ?? (() => permissionMode),
+    };
+    let snapshot;
+    try {
+        snapshot = collectStatusSnapshot(deps);
+    }
+    catch (error) {
+        // Defensive: the snapshot collector is fail-soft per field, but
+        // a structural crash (e.g. a hostile env that throws on
+        // `process.version` access) must не bring down `pugi status`.
+        // We synthesise a minimal envelope and surface the error в the
+        // text output so the operator can file a bug.
+        const message = error instanceof Error ? error.message : String(error);
+        snapshot = {
+            command: 'status',
+            fields: [
+                {
+                    key: 'session',
+                    label: 'Session',
+                    value: 'unknown',
+                    available: false,
+                    note: `snapshot collector crashed: ${message}`,
+                },
+            ],
+            meta: {
+                cliVersion: PUGI_CLI_VERSION,
+                nodeVersion: process.version,
+                cwd: ctx.cwd,
+                capturedAt: new Date((ctx.now ?? Date.now)()).toISOString(),
+            },
+        };
+    }
+    const text = renderStatusTable(snapshot);
+    ctx.writeOutput(snapshot, text);
+    // Always exit 0 — `pugi status` is informational, never a gate.
+    process.exitCode = 0;
+    return snapshot;
+}
+/**
+ * Plain-text table renderer. Lays out the snapshot as a two-column
+ * (LABEL / VALUE) table with the brand-voice header `Pugi status`.
+ * Matches the column-light pattern used by `renderDoctorTable` so
+ * narrow terminals stay legible without a layout library.
+ */
+export function renderStatusTable(snapshot) {
+    // Row syntax: `${Label}: ${value}` with exactly ONE space after the
+    // colon, then the value verbatim. The colon doubles as a visual
+    // anchor and the REPL spec assertions match on the single-space
+    // form (`Backend: https://api.pugi.io`) — multi-space column
+    // padding broke `.includes('Backend: https://...')` substring
+    // checks. Operators who want a column layout can run the Ink
+    // renderer (`<StatusTable>`); the plain-text fallback stays
+    // narrow-terminal friendly without padding columns.
+    const lines = [];
+    lines.push('Pugi status');
+    lines.push('═'.repeat(50));
+    for (const field of snapshot.fields) {
+        lines.push(`${field.label}: ${field.value}`);
+    }
+    lines.push('');
+    lines.push(`CLI ${snapshot.meta.cliVersion} Node ${snapshot.meta.nodeVersion} cwd ${snapshot.meta.cwd}`);
+    return lines.join('\n');
+}
+/**
+ * Default home dir resolver. Centralised so the CLI handler can
+ * call `runStatusCommand` without re-importing `os.homedir`
+ * everywhere.
+ */
+export function defaultStatusHome() {
+    return homedir();
+}
+//# sourceMappingURL=status.js.map

package/dist/runtime/commands/stickers.js

@@ -0,0 +1,82 @@
+/**
+ * `pugi stickers` — brand-personality gimmick command ().
+ *
+ * Parity command with the upstream tool's `/stickers` easter egg. Claude
+ * ships physical stickers OR shows ASCII brand art; Pugi's variant
+ * focuses на the ASCII branch — picks one of the curated pug-face
+ * variants at random and footers it with a rotating brand quote.
+ *
+ * # Module contract
+ *
+ *  - This file owns the WIRING from CLI flags + ambient state to the
+ *    art + quote pickers. The corpus + pure renderers live in
+ *    `tui/stickers-art.tsx` and have zero coupling к the CLI dispatch
+ *    surface.
+ *
+ *  - `runStickersCommand` is the single entry point. Both the top-
+ *    level `pugi stickers` handler в `runtime/cli.ts` AND the in-REPL
+ *    `/stickers` slash command call it. The function returns the
+ *    resolved `StickersResult` so the slash dispatcher can route the
+ *    output к the REPL's system pane without re-picking the art.
+ *
+ *  - Exit code is ALWAYS 0. The command is a brand surface — never a
+ *    gate. Even when the corpus is somehow exhausted (impossible
+ *    today, the lists are frozen), the handler synthesises a fallback
+ *    line and exits 0 instead of crashing.
+ *
+ *  - The random source is injected so the spec can pin the chosen
+ *    art + quote without monkey-patching `Math.random`.
+ */
+import { PUG_QUOTES, PUG_STICKERS, pickArtVariant, pickQuote, renderPugStickersText, } from '../../tui/stickers-art.js';
+/**
+ * Pick + render the sticker, hand it к the output sink, exit 0.
+ * Returns the picked result so the REPL slash handler can mount the
+ * Ink renderer without re-picking.
+ */
+export function runStickersCommand(ctx) {
+    const rng = ctx.rng ?? Math.random;
+    let art;
+    let quote;
+    try {
+        art = pickArtVariant(rng);
+        quote = pickQuote(rng);
+    }
+    catch {
+        // Defensive: the pickers are pure + the corpus is frozen, so this
+        // path is unreachable in production. If a future refactor swaps
+        // the corpus к an empty array we still want к exit 0 with a
+        // deterministic fallback so monitoring scripts that probe
+        // `pugi stickers` do not flap.
+        art = {
+            id: 'fallback',
+            caption: 'fallback',
+            art: '/\\___/\\\n( o o )\n( =^= )',
+        };
+        quote = 'Pugi: your engineering co-pilot.';
+    }
+    const text = renderPugStickersText(art, quote);
+    const result = {
+        command: 'stickers',
+        art,
+        quote,
+        text,
+        meta: {
+            artVariants: PUG_STICKERS.length,
+            quotes: PUG_QUOTES.length,
+        },
+    };
+    ctx.writeOutput(result, text);
+    // Brand surface — never a gate. The caller may have set a different
+    // exit code (e.g. dispatch loop reused this handler for an inline
+    // brand banner); we explicitly stamp 0 so `pugi stickers && echo ok`
+    // stays predictable.
+    process.exitCode = 0;
+    // Silence the unused-import warning in the rare case `ctx.asciiOnly`
+    // is added in a future surface without a switch. Today the flag is
+    // honoured by the CLI handler choosing the writeOutput sink — the
+    // result.text is the same regardless because the boxed renderer
+    // never lands в the plain stdout sink.
+    void ctx.asciiOnly;
+    return result;
+}
+//# sourceMappingURL=stickers.js.map

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