@pugi/cli 0.1.0-beta.99 → 1.0.0-alpha.10

package/dist/runtime/commands/skills.js

@@ -1,401 +0,0 @@
-import { createInterface } from 'node:readline/promises';
-import { stdin as input, stdout as output } from 'node:process';
-import { assertValidSlug, globalSkillDir, installSkill, listSkills, parseSkillMarkdown, removeSkill, workspaceSkillDir, } from '../../core/skills/loader.js';
-import { cleanupTmp, fetchSource } from '../../core/skills/sources.js';
-import { hashSkillDir, recordTrust, revokeTrust, verifyTrust, } from '../../core/skills/trust.js';
-import { readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-const USAGE = [
-    'Usage:',
-    ' pugi skills list [--global|--workspace]           Show installed skills.',
-    ' pugi skills install <source> [--global|--workspace] [--yes] [--as <name>]',
-    '                                                    Fetch + trust-prompt + activate a skill.',
-    ' pugi skills info <name>                           Show metadata + body preview.',
-    ' pugi skills remove <name> [--global|--workspace]  Delete an installed skill.',
-    ' pugi skills trust <name> [--global|--workspace]   Re-trust the on-disk payload.',
-    '',
-    'Source forms accepted by `install`:',
-    ' gh:owner/repo[/subdir][@ref]  GitHub tree fetch (default ref: main).',
-    ' https://github.com/...        GitHub tree/blob URL.',
-    ' anthropic:<slug>              Shortcut for gh:anthropics/skills/<slug>@main.',
-    ' npm:<package>[@version]       npm registry tarball.',
-    ' ./path | /abs/path            Local filesystem.',
-    ' <slug>                        Catalog lookup (catalog.pugi.dev).',
-].join('\n');
-export async function runSkillsCommand(args, ctx) {
-    const sub = args[0];
-    if (!sub || sub === '--help' || sub === '-h') {
-        ctx.writeOutput({ command: 'skills', usage: USAGE.split('\n') }, USAGE);
-        return;
-    }
-    switch (sub) {
-        case 'list':
-            return runSkillsList(args.slice(1), ctx);
-        case 'install':
-            return runSkillsInstall(args.slice(1), ctx);
-        case 'info':
-            return runSkillsInfo(args.slice(1), ctx);
-        case 'remove':
-            return runSkillsRemove(args.slice(1), ctx);
-        case 'trust':
-            return runSkillsTrust(args.slice(1), ctx);
-        default:
-            throw new Error(`Unknown sub-command "pugi skills ${sub}". Expected list, install, info, remove, or trust.`);
-    }
-}
-function parseFlags(args) {
-    let scope = 'both';
-    let yes = false;
-    let asName;
-    const positional = [];
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--global')
-            scope = 'global';
-        else if (arg === '--workspace')
-            scope = 'workspace';
-        else if (arg === '--yes' || arg === '-y')
-            yes = true;
-        else if (arg === '--as') {
-            asName = args[++i];
-        }
-        else if (arg && !arg.startsWith('--')) {
-            positional.push(arg);
-        }
-        else if (arg) {
-            throw new Error(`Unknown flag: ${arg}`);
-        }
-    }
-    return { scope, yes, asName, positional };
-}
-async function runSkillsList(args, ctx) {
-    const flags = parseFlags(args);
-    const includeGlobal = flags.scope === 'global' || flags.scope === 'both';
-    const includeWorkspace = flags.scope === 'workspace' || flags.scope === 'both';
-    const global = includeGlobal ? listSkills('global', ctx.workspaceRoot) : [];
-    const workspace = includeWorkspace ? listSkills('workspace', ctx.workspaceRoot) : [];
-    const all = [...global, ...workspace];
-    const trustStatuses = await Promise.all(all.map(async (skill) => {
-        const actual = hashSkillDir(skill.dir);
-        const verdict = await verifyTrust('skill', skill.scope, skill.name, actual);
-        return { skill, trust: verdict };
-    }));
-    if (ctx.json) {
-        ctx.writeOutput({
-            command: 'skills.list',
-            skills: trustStatuses.map(({ skill, trust }) => ({
-                name: skill.name,
-                scope: skill.scope,
-                dir: skill.dir,
-                description: skill.frontmatter.description,
-                version: skill.frontmatter.metadata.version ?? null,
-                tools: skill.frontmatter.metadata.tools ?? [],
-                trust: trust.status,
-            })),
-        }, '');
-        return;
-    }
-    if (trustStatuses.length === 0) {
-        ctx.writeOutput({ command: 'skills.list', skills: [] }, 'No skills installed. Try `pugi skills install anthropic:python-coding-standards`.');
-        return;
-    }
-    const lines = ['Installed skills:'];
-    for (const { skill, trust } of trustStatuses) {
-        const version = skill.frontmatter.metadata.version ? ` v${String(skill.frontmatter.metadata.version)}` : '';
-        const trustMark = trust.status === 'trusted' ? '[trusted]' : trust.status === 'unsigned' ? '[unsigned]' : '[mismatch]';
-        lines.push(` ${skill.name.padEnd(28)} ${skill.scope.padEnd(10)} ${trustMark.padEnd(11)}${version}`);
-        lines.push(`   ${truncate(skill.frontmatter.description, 80)}`);
-    }
-    ctx.writeOutput({ command: 'skills.list', skills: trustStatuses }, lines.join('\n'));
-}
-async function runSkillsInstall(args, ctx) {
-    const flags = parseFlags(args);
-    const source = flags.positional[0];
-    if (!source) {
-        throw new Error('pugi skills install requires a <source> argument. See `pugi skills --help`.');
-    }
-    const scope = flags.scope === 'workspace' ? 'workspace' : 'global';
-    // 1. Fetch payload to tmp dir.
-    let fetched;
-    try {
-        fetched = await fetchSource(source);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        ctx.writeOutput({ command: 'skills.install', status: 'fetch_failed', source, error: message }, `Skill fetch failed: ${message}`);
-        process.exitCode = 1;
-        return;
-    }
-    if (fetched.inferredKind !== 'skill') {
-        cleanupTmp(fetched.tmpDir);
-        const message = `Source ${source} looks like an agent (single .md), not a skill. Use \`pugi agents install\` instead.`;
-        ctx.writeOutput({ command: 'skills.install', status: 'wrong_kind', source }, message);
-        process.exitCode = 1;
-        return;
-    }
-    // 2. Parse SKILL.md to surface metadata in the trust prompt.
-    const skillMdPath = join(fetched.tmpDir, 'SKILL.md');
-    let parsed;
-    try {
-        parsed = parseSkillMarkdown(readFileSync(skillMdPath, 'utf8'));
-    }
-    catch (error) {
-        cleanupTmp(fetched.tmpDir);
-        const message = error instanceof Error ? error.message : String(error);
-        ctx.writeOutput({ command: 'skills.install', status: 'parse_failed', source, error: message }, `Skill parse failed: ${message}`);
-        process.exitCode = 1;
-        return;
-    }
-    const skillName = flags.asName ?? parsed.frontmatter.name;
-    // Fail-fast before any FS or trust-prompt work: a hostile `--as` flag
-    // or a hostile frontmatter `name` must never reach path.join.
-    try {
-        assertValidSlug(skillName, 'skill');
-    }
-    catch (error) {
-        cleanupTmp(fetched.tmpDir);
-        const message = error instanceof Error ? error.message : String(error);
-        ctx.writeOutput({ command: 'skills.install', status: 'invalid_name', source, name: skillName, error: message }, message);
-        process.exitCode = 1;
-        return;
-    }
-    const sha256 = hashSkillDir(fetched.tmpDir);
-    const targetDir = scope === 'global' ? globalSkillDir(skillName) : workspaceSkillDir(ctx.workspaceRoot, skillName);
-    const summary = {
-        name: skillName,
-        description: parsed.frontmatter.description,
-        version: parsed.frontmatter.metadata.version ?? null,
-        tools: parsed.frontmatter.metadata.tools ?? [],
-        files: countFiles(fetched.tmpDir),
-        source: fetched.sourceUrl,
-        targetDir,
-        sha256,
-    };
-    if (!flags.yes) {
-        const decision = await promptTrust('skill', summary, parsed.body);
-        if (decision === 'no') {
-            cleanupTmp(fetched.tmpDir);
-            ctx.writeOutput({ command: 'skills.install', status: 'declined', source, name: skillName }, 'Install declined. Nothing changed.');
-            return;
-        }
-    }
-    // 3. Install to disk.
-    const installedDir = installSkill({
-        payloadDir: fetched.tmpDir,
-        name: skillName,
-        scope,
-        workspaceRoot: ctx.workspaceRoot,
-    });
-    // 4. Record trust.
-    await recordTrust({
-        kind: 'skill',
-        scope,
-        name: skillName,
-        sha256,
-        source: fetched.sourceUrl,
-        signedBy: signerIdentity(),
-    });
-    cleanupTmp(fetched.tmpDir);
-    ctx.writeOutput({
-        command: 'skills.install',
-        status: 'installed',
-        name: skillName,
-        scope,
-        dir: installedDir,
-        sha256,
-        source: fetched.sourceUrl,
-    }, [
-        `Installed skill "${skillName}" (${scope}).`,
-        ` Path:   ${installedDir}`,
-        ` Source: ${fetched.sourceUrl}`,
-        ` sha256: ${sha256}`,
-    ].join('\n'));
-}
-async function runSkillsInfo(args, ctx) {
-    const flags = parseFlags(args);
-    const name = flags.positional[0];
-    if (!name) {
-        throw new Error('pugi skills info requires a <name> argument.');
-    }
-    const matches = findSkill(name, flags.scope, ctx.workspaceRoot);
-    if (matches.length === 0) {
-        ctx.writeOutput({ command: 'skills.info', status: 'not_found', name }, `No skill "${name}" installed. Try \`pugi skills list\`.`);
-        process.exitCode = 1;
-        return;
-    }
-    const skill = matches[0];
-    if (!skill) {
-        ctx.writeOutput({ command: 'skills.info', status: 'not_found', name }, `No skill "${name}" installed.`);
-        process.exitCode = 1;
-        return;
-    }
-    const actualSha = hashSkillDir(skill.dir);
-    const trust = await verifyTrust('skill', skill.scope, skill.name, actualSha);
-    const preview = skill.body.slice(0, 800);
-    const lines = [
-        `Skill: ${skill.name}`,
-        ` Scope:       ${skill.scope}`,
-        ` Path:        ${skill.dir}`,
-        ` Description: ${skill.frontmatter.description}`,
-        ` Version:     ${String(skill.frontmatter.metadata.version ?? '(unset)')}`,
-        ` Tools:       ${(skill.frontmatter.metadata.tools ?? []).join(', ') || '(none)'}`,
-        ` Trust:       ${trust.status}`,
-        ` sha256:      ${actualSha}`,
-        '',
-        'Body preview:',
-        preview,
-        skill.body.length > 800 ? `... (${skill.body.length - 800} more chars)` : '',
-    ]
-        .filter((line) => line !== '')
-        .join('\n');
-    ctx.writeOutput({
-        command: 'skills.info',
-        name: skill.name,
-        scope: skill.scope,
-        dir: skill.dir,
-        frontmatter: skill.frontmatter,
-        sha256: actualSha,
-        trust,
-        bodyPreview: preview,
-        bodyLength: skill.body.length,
-    }, lines);
-}
-async function runSkillsRemove(args, ctx) {
-    const flags = parseFlags(args);
-    const name = flags.positional[0];
-    if (!name) {
-        throw new Error('pugi skills remove requires a <name> argument.');
-    }
-    const matches = findSkill(name, flags.scope, ctx.workspaceRoot);
-    if (matches.length === 0) {
-        ctx.writeOutput({ command: 'skills.remove', status: 'not_found', name }, `No skill "${name}" installed.`);
-        process.exitCode = 1;
-        return;
-    }
-    for (const skill of matches) {
-        removeSkill(skill.name, skill.scope, ctx.workspaceRoot);
-        await revokeTrust('skill', skill.scope, skill.name);
-    }
-    ctx.writeOutput({
-        command: 'skills.remove',
-        status: 'removed',
-        name,
-        removed: matches.map((m) => ({ name: m.name, scope: m.scope, dir: m.dir })),
-    }, `Removed ${matches.length} skill install(s) named "${name}".`);
-}
-async function runSkillsTrust(args, ctx) {
-    const flags = parseFlags(args);
-    const name = flags.positional[0];
-    if (!name) {
-        throw new Error('pugi skills trust requires a <name> argument.');
-    }
-    const matches = findSkill(name, flags.scope, ctx.workspaceRoot);
-    if (matches.length === 0) {
-        ctx.writeOutput({ command: 'skills.trust', status: 'not_found', name }, `No skill "${name}" installed.`);
-        process.exitCode = 1;
-        return;
-    }
-    const skill = matches[0];
-    if (!skill) {
-        process.exitCode = 1;
-        return;
-    }
-    const sha256 = hashSkillDir(skill.dir);
-    await recordTrust({
-        kind: 'skill',
-        scope: skill.scope,
-        name: skill.name,
-        sha256,
-        source: skill.dir,
-        signedBy: signerIdentity(),
-    });
-    ctx.writeOutput({ command: 'skills.trust', status: 'trusted', name: skill.name, scope: skill.scope, sha256 }, `Re-trusted skill "${skill.name}" (${skill.scope}). sha256 = ${sha256}.`);
-}
-/* ----------------------------- shared helpers ----------------------------- */
-function findSkill(name, scope, workspaceRoot) {
-    const scopes = scope === 'both' ? ['global', 'workspace'] : [scope];
-    const out = [];
-    for (const s of scopes) {
-        const all = listSkills(s, workspaceRoot);
-        for (const skill of all) {
-            if (skill.name === name)
-                out.push(skill);
-        }
-    }
-    return out;
-}
-function countFiles(dir) {
-    // Conservative — recurse and count regular files only. Used for the
-    // trust prompt summary so the operator sees payload bulk.
-    let total = 0;
-    const walk = (d) => {
-        for (const entry of readdirSync(d, { withFileTypes: true })) {
-            const full = join(d, entry.name);
-            if (entry.isDirectory())
-                walk(full);
-            else if (entry.isFile())
-                total++;
-        }
-    };
-    walk(dir);
-    return total;
-}
-function truncate(text, max) {
-    if (text.length <= max)
-        return text;
-    return `${text.slice(0, max - 1)}…`;
-}
-function signerIdentity() {
-    return (process.env.PUGI_TRUSTED_BY?.trim() ||
-        process.env.USER?.trim() ||
-        process.env.USERNAME?.trim() ||
-        'cli');
-}
-/**
- * Interactive trust prompt. Reads from stdin; `info` shows the full
- * body; `y` accepts; everything else declines.
- *
- * Bypassable only via the operator-passed `--yes` flag in the caller
- * (never auto-injected from another code path).
- */
-async function promptTrust(kind, summary, body) {
-    const banner = [
-        '',
-        `About to install ${kind} "${summary.name}"`,
-        ` Description: ${summary.description}`,
-        ` Version:     ${summary.version ?? '(unset)'}`,
-        ` Tools:       ${summary.tools.join(', ') || '(none)'}`,
-        ` Files:       ${summary.files}`,
-        ` Source:      ${summary.source}`,
-        ` Target:      ${summary.targetDir}`,
-        ` sha256:      ${summary.sha256}`,
-        '',
-        'This payload becomes part of the system prompt and may influence agent decisions.',
-        'Trust this install? [y/N/info] ',
-    ].join('\n');
-    process.stdout.write(banner);
-    if (!input.isTTY) {
-        // Non-interactive caller without --yes: refuse rather than block.
-        process.stdout.write('\n(non-interactive stdin; declining install)\n');
-        return 'no';
-    }
-    const rl = createInterface({ input, output });
-    try {
-        while (true) {
-            const answer = (await rl.question('')).trim().toLowerCase();
-            if (answer === 'y' || answer === 'yes')
-                return 'yes';
-            if (answer === 'info') {
-                process.stdout.write('\n');
-                process.stdout.write(body);
-                process.stdout.write('\n\nTrust this install? [y/N] ');
-                continue;
-            }
-            return 'no';
-        }
-    }
-    finally {
-        rl.close();
-    }
-}
-//# sourceMappingURL=skills.js.map

package/dist/runtime/commands/status.js

@@ -1,186 +0,0 @@
-/**
- * `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

@@ -1,82 +0,0 @@
-/**
- * `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