@pugi/cli 0.1.0-beta.24 → 0.1.0-beta.26

package/dist/runtime/commands/dispatch.js

@@ -0,0 +1,126 @@
+/**
+ * `pugi dispatch <sub>` — fork-subagent cache-handoff surface (Leak L10 — 2026-05-27).
+ *
+ * Sub-commands:
+ *
+ *   - `pugi dispatch list-cache-refs` — show active cache-inherit refs
+ *     persisted under `.pugi/cache-refs/`. Renders an aligned table or
+ *     JSON depending on `--json`.
+ *
+ *   - `pugi dispatch clear-cache-refs [--older-than 1h] [-v]` — GC stale
+ *     refs. Without `--older-than`, defaults to 24h (the same cutoff
+ *     the REPL boot-time auto-sweep uses). The flag accepts duration
+ *     strings the `parseDuration` helper recognises (`1h`, `30m`,
+ *     `7d`, `500ms`, ...).
+ *
+ * The command lives in its own module (not inline in cli.ts) so the
+ * dispatch table stays narrow and tests can drive it without spinning
+ * up the full CLI.
+ */
+import { cleanupStaleCacheRefs, parseDuration, } from '../../core/dispatch/cache-cleanup.js';
+import { listCacheRefs } from '../../core/dispatch/cache-handoff.js';
+const USAGE = [
+    'Usage:',
+    '  pugi dispatch list-cache-refs',
+    '                                       Show every active subagent cache-inherit',
+    '                                       reference persisted under .pugi/cache-refs/.',
+    '',
+    '  pugi dispatch clear-cache-refs [--older-than <duration>] [-v]',
+    '                                       Evict stale refs. Accepts 500ms / 30s / 5m /',
+    '                                       1h / 7d. Default --older-than 24h.',
+].join('\n');
+export async function runDispatchCommand(args, ctx) {
+    const sub = args[0];
+    if (!sub || sub === '--help' || sub === '-h') {
+        ctx.writeOutput({ command: 'dispatch', usage: USAGE.split('\n') }, USAGE);
+        return;
+    }
+    switch (sub) {
+        case 'list-cache-refs':
+            return runListCacheRefs(ctx);
+        case 'clear-cache-refs':
+            return runClearCacheRefs(args.slice(1), ctx);
+        default:
+            ctx.writeOutput({
+                ok: false,
+                error: `unknown subcommand: ${sub}`,
+                usage: USAGE.split('\n'),
+            }, `pugi dispatch: unknown subcommand '${sub}'\n\n${USAGE}`);
+            process.exitCode = 2;
+            return;
+    }
+}
+function runListCacheRefs(ctx) {
+    const refs = listCacheRefs(ctx.workspaceRoot);
+    if (ctx.json) {
+        ctx.writeOutput({ ok: true, count: refs.length, refs }, '');
+        return;
+    }
+    if (refs.length === 0) {
+        ctx.writeOutput({ ok: true, count: 0, refs: [] }, 'No active cache-inherit refs under .pugi/cache-refs/.');
+        return;
+    }
+    // Aligned column table. Widths derived from the data — no hardcoded
+    // sizes so a long childAgentId does not overflow the layout.
+    const header = ['CHILD AGENT', 'CACHE ID', 'PARENT SESSION', 'CREATED'];
+    const rows = refs.map((r) => [
+        r.childAgentId,
+        r.cacheId,
+        r.parentSessionId,
+        r.createdAt,
+    ]);
+    const widths = header.map((h, i) => Math.max(h.length, ...rows.map((row) => (row[i] ?? '').length)));
+    const lines = [];
+    lines.push(header.map((h, i) => h.padEnd(widths[i] ?? 0)).join('  '));
+    lines.push(widths.map((w) => '-'.repeat(w)).join('  '));
+    for (const row of rows) {
+        lines.push(row.map((cell, i) => (cell ?? '').padEnd(widths[i] ?? 0)).join('  '));
+    }
+    ctx.writeOutput({ ok: true, count: refs.length, refs }, lines.join('\n'));
+}
+function runClearCacheRefs(args, ctx) {
+    let olderThanArg;
+    let verbose = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--older-than') {
+            olderThanArg = args[i + 1];
+            i++;
+            continue;
+        }
+        if (arg && arg.startsWith('--older-than=')) {
+            olderThanArg = arg.slice('--older-than='.length);
+            continue;
+        }
+        if (arg === '-v' || arg === '--verbose') {
+            verbose = true;
+            continue;
+        }
+    }
+    // Default 24h matches the REPL boot-time auto-sweep cutoff.
+    const olderThanMs = olderThanArg ? parseDuration(olderThanArg) : 24 * 60 * 60 * 1000;
+    if (olderThanMs === null) {
+        ctx.writeOutput({
+            ok: false,
+            error: `invalid --older-than value: ${olderThanArg ?? '(missing)'}`,
+            usage: USAGE.split('\n'),
+        }, `pugi dispatch clear-cache-refs: invalid --older-than '${olderThanArg ?? '(missing)'}'\n\n${USAGE}`);
+        process.exitCode = 2;
+        return;
+    }
+    const result = cleanupStaleCacheRefs(ctx.workspaceRoot, {
+        olderThanMs,
+        verbose,
+    });
+    const summary = `Removed ${result.removedCount} ref(s) (${result.corruptCount} corrupt), kept ${result.keptCount}.`;
+    ctx.writeOutput({
+        ok: true,
+        olderThanMs,
+        removedCount: result.removedCount,
+        keptCount: result.keptCount,
+        corruptCount: result.corruptCount,
+        removed: result.removed,
+        corrupt: result.corrupt,
+    }, summary);
+}
+//# sourceMappingURL=dispatch.js.map

package/dist/runtime/commands/hooks.js

@@ -0,0 +1,184 @@
+/**
+ * `pugi hooks` — operator surface for user-config hooks (Leak L12 MVP).
+ *
+ * Two subcommands ship in the MVP:
+ *
+ *   pugi hooks list         List configured hooks per event.
+ *   pugi hooks doctor       Validate the config and surface any
+ *                           parse / schema errors.
+ *
+ * Both accept `--json` for scripted callers. Argument grammar is
+ * intentionally narrow — no `add` / `remove` / `test` subcommands in
+ * the MVP. Operators hand-edit `~/.pugi/hooks-mvp.json` for now.
+ *
+ * Exit codes:
+ *   0  -> happy path (no hooks OR config valid).
+ *   1  -> config present but invalid (only `doctor` returns this).
+ *   2  -> unknown subcommand / argument error.
+ *
+ * Brand voice: ASCII only.
+ */
+import { ALL_HOOK_EVENTS_V2, defaultHooksMvpPath, loadHooksConfig, } from '../../core/hooks/index.js';
+function parseFlags(args) {
+    const rest = [];
+    const flags = { json: false };
+    for (const arg of args) {
+        if (arg === '--json') {
+            flags.json = true;
+            continue;
+        }
+        rest.push(arg);
+    }
+    return { rest, flags };
+}
+/**
+ * Top-level dispatcher for `pugi hooks <subcommand>`. Returns the
+ * intended process exit code. `cli.ts` is expected to set
+ * `process.exitCode = <return value>` so error states propagate to
+ * scripted callers without throwing.
+ */
+export async function runHooksCommand(args, ctx) {
+    const { rest, flags } = parseFlags(args);
+    const sub = rest[0];
+    if (!sub || sub === 'help' || sub === '--help') {
+        emitUsage(ctx, flags);
+        return sub ? 0 : 2;
+    }
+    if (sub === 'list') {
+        return runList(ctx, flags);
+    }
+    if (sub === 'doctor') {
+        return runDoctor(ctx, flags);
+    }
+    ctx.writeOutput({ ok: false, error: `unknown subcommand: ${sub}` }, `pugi hooks: unknown subcommand '${sub}'. Try 'pugi hooks --help'.`);
+    return 2;
+}
+function emitUsage(ctx, flags) {
+    const text = [
+        'pugi hooks — user-config lifecycle hooks (MVP).',
+        '',
+        'Subcommands:',
+        '  pugi hooks list        Show hooks configured per event.',
+        '  pugi hooks doctor      Validate ~/.pugi/hooks-mvp.json.',
+        '',
+        'Flags:',
+        '  --json                 Emit a JSON envelope instead of human text.',
+        '',
+        'Config file:',
+        '  ~/.pugi/hooks-mvp.json',
+        '',
+        'Status:',
+        '  MVP — 2 events out of 8. Remaining events (PostToolUse,',
+        "  UserPromptSubmit, Stop, SubagentStop, PreCompact, Notification)",
+        '  deferred to fast-follow PR.',
+    ].join('\n');
+    ctx.writeOutput({
+        ok: true,
+        command: 'hooks',
+        usage: text,
+    }, text);
+    if (flags.json) {
+        // The structured payload is already emitted by writeOutput when
+        // --json is on; nothing extra to do.
+    }
+}
+function runList(ctx, flags) {
+    let config;
+    try {
+        config = loadHooksConfig(ctx.configPath);
+    }
+    catch (error) {
+        const msg = error.message;
+        ctx.writeOutput({ ok: false, error: msg }, `pugi hooks list: ${msg}\nFix the config or remove the file. Run 'pugi hooks doctor' for details.`);
+        return 1;
+    }
+    const perEvent = {
+        SessionStart: [],
+        PreToolUse: [],
+        PostToolUse: [],
+        UserPromptSubmit: [],
+        Stop: [],
+        SubagentStop: [],
+        PreCompact: [],
+        Notification: [],
+    };
+    for (const event of ALL_HOOK_EVENTS_V2) {
+        perEvent[event] = config.list(event).map((entry) => ({
+            matcher: entry.matcher,
+            command: entry.command,
+            timeoutMs: entry.timeoutMs,
+            blocking: entry.blocking,
+        }));
+    }
+    const total = Object.values(perEvent).reduce((acc, list) => acc + list.length, 0);
+    const payload = {
+        ok: true,
+        configPath: config.configPath(),
+        total,
+        perEvent,
+    };
+    if (flags.json) {
+        ctx.writeOutput(payload, JSON.stringify(payload, null, 2));
+        return 0;
+    }
+    const lines = [];
+    lines.push(`pugi hooks (${total} configured)`);
+    lines.push(`  config: ${config.configPath()}`);
+    if (total === 0) {
+        lines.push('  no hooks configured — create the file above to add one.');
+    }
+    else {
+        for (const event of ALL_HOOK_EVENTS_V2) {
+            const list = perEvent[event];
+            if (list.length === 0)
+                continue;
+            lines.push(`  ${event}:`);
+            for (const entry of list) {
+                const tags = [];
+                if (entry.matcher)
+                    tags.push(`matcher=${entry.matcher}`);
+                if (entry.timeoutMs)
+                    tags.push(`timeoutMs=${entry.timeoutMs}`);
+                if (entry.blocking)
+                    tags.push('blocking');
+                const suffix = tags.length ? `  [${tags.join(', ')}]` : '';
+                lines.push(`    - ${entry.command}${suffix}`);
+            }
+        }
+    }
+    const text = lines.join('\n');
+    ctx.writeOutput(payload, text);
+    return 0;
+}
+function runDoctor(ctx, flags) {
+    const path = ctx.configPath ?? defaultHooksMvpPath();
+    try {
+        const config = loadHooksConfig(ctx.configPath);
+        const total = config.flatten().length;
+        const payload = {
+            ok: true,
+            configPath: config.configPath(),
+            total,
+            issues: [],
+        };
+        const text = total
+            ? `pugi hooks doctor: ${path} OK (${total} hooks).`
+            : `pugi hooks doctor: ${path} not present (no hooks configured).`;
+        ctx.writeOutput(payload, text);
+        return 0;
+    }
+    catch (error) {
+        const msg = error.message;
+        const payload = {
+            ok: false,
+            configPath: path,
+            error: msg,
+        };
+        const text = `pugi hooks doctor: ${msg}`;
+        ctx.writeOutput(payload, text);
+        return 1;
+    }
+    // flags.json is consumed by writeOutput in the host shell.
+    void flags;
+}
+//# sourceMappingURL=hooks.js.map

package/dist/runtime/commands/lsp.js

@@ -24,8 +24,8 @@
  *
  * Brand voice: ASCII only, no emoji, no banned words.
  */
-import { extname } from 'node:path';
 import { inspectLspServers, startLspClient } from '../../core/lsp/client.js';
+import { languageForFile as inferLanguage } from '../../core/lsp/language-detect.js';
 import { loadSettings } from '../../core/settings.js';
 export async function runLspCommand(args, opts) {
     const [op, file, ...rest] = args;
@@ -96,6 +96,25 @@ export async function runLspCommand(args, opts) {
         };
     }
     const settings = loadSettings(opts.cwd);
+    // Leak L15 (2026-05-27): `pugi lsp check <file>` — manual probe of
+    // the post-edit diagnostics pipeline. Identical output to what the
+    // model sees appended to its tool envelope after a successful
+    // edit/write. Lets operators dry-run the auto-diagnostic surface
+    // without dispatching an actual edit.
+    if (op === 'check') {
+        const { runPostEditDiagnostics } = await import('../../core/lsp/post-edit-diagnostics.js');
+        const result = await runPostEditDiagnostics(file, {
+            cwd: opts.cwd,
+            ...(settings.lsp ? { lspSettings: settings.lsp } : {}),
+        });
+        if (opts.json) {
+            return { ok: true, text: JSON.stringify(result, null, 2), exitCode: 0 };
+        }
+        if (result.skip) {
+            return { ok: true, text: `${file}: skipped (${result.reason})`, exitCode: 0 };
+        }
+        return { ok: true, text: result.tail, exitCode: 0 };
+    }
     const clientResult = await startLspClient(lang, {
         cwd: opts.cwd,
         ...(settings.lsp ? { lspSettings: settings.lsp } : {}),
@@ -204,6 +223,7 @@ function usage() {
             '  pugi lsp definition <file> <line> <col>\n' +
             '  pugi lsp references <file> <line> <col>\n' +
             '  pugi lsp diagnostics <file>\n' +
+            '  pugi lsp check <file>          (Leak L15: probe post-edit tail)\n' +
             '  pugi lsp find_definition <file> <symbol>\n' +
             '  pugi lsp servers',
         exitCode: 2,
@@ -341,26 +361,8 @@ function pullLangFlag(args) {
 function isLspLanguage(value) {
     return value === 'ts' || value === 'js' || value === 'py' || value === 'go' || value === 'rust';
 }
-export function inferLanguage(file) {
-    const ext = extname(file).toLowerCase();
-    switch (ext) {
-        case '.ts':
-        case '.tsx':
-            return 'ts';
-        case '.js':
-        case '.jsx':
-        case '.mjs':
-        case '.cjs':
-            return 'js';
-        case '.py':
-        case '.pyi':
-            return 'py';
-        case '.go':
-            return 'go';
-        case '.rs':
-            return 'rust';
-        default:
-            return undefined;
-    }
-}
+// Leak L15 (2026-05-27): single source of truth for ext → language
+// lives in `core/lsp/language-detect.ts`. The CLI surface re-exports
+// the lookup so existing call sites keep their import path.
+export { inferLanguage };
 //# sourceMappingURL=lsp.js.map