@pugi/cli 0.1.0-beta.8 → 0.1.0-beta.88

package/dist/runtime/commands/agents.js

@@ -8,19 +8,19 @@ import { cleanupTmp, fetchSource } from '../../core/skills/sources.js';
 import { hashAgentFile, recordTrust, revokeTrust, verifyTrust, } from '../../core/skills/trust.js';
 const USAGE = [
     'Usage:',
-    '  pugi agents list [--global|--workspace]            Show installed agents.',
-    '  pugi agents install <source> [--global|--workspace] [--yes] [--as <slug>]',
-    '                                                     Fetch + trust-prompt + activate an agent.',
-    '  pugi agents info <slug>                            Show metadata + body preview.',
-    '  pugi agents remove <slug> [--global|--workspace]   Delete an installed agent.',
+    ' pugi agents list [--global|--workspace]           Show installed agents.',
+    ' pugi agents install <source> [--global|--workspace] [--yes] [--as <slug>]',
+    '                                                    Fetch + trust-prompt + activate an agent.',
+    ' pugi agents info <slug>                           Show metadata + body preview.',
+    ' pugi agents remove <slug> [--global|--workspace]  Delete an installed agent.',
     '',
     'Source forms accepted by `install` (same as `pugi skills install`):',
-    '  gh:owner/repo/path/to/agent.md[@ref]',
-    '  https://github.com/...',
-    '  anthropic:<slug>',
-    '  npm:<package>',
-    '  ./path/to/agent.md  or  /abs/path/to/agent.md',
-    '  <slug>                         Catalog lookup (catalog.pugi.dev).',
+    ' gh:owner/repo/path/to/agent.md[@ref]',
+    ' https://github.com/...',
+    ' anthropic:<slug>',
+    ' npm:<package>',
+    ' ./path/to/agent.md or /abs/path/to/agent.md',
+    ' <slug>                        Catalog lookup (catalog.pugi.dev).',
 ].join('\n');
 export async function runAgentsCommand(args, ctx) {
     const sub = args[0];
@@ -101,8 +101,8 @@ async function runAgentsList(args, ctx) {
     for (const { agent, trust } of verdicts) {
         const model = agent.frontmatter.metadata.model ? ` model=${String(agent.frontmatter.metadata.model)}` : '';
         const trustMark = trust.status === 'trusted' ? '[trusted]' : trust.status === 'unsigned' ? '[unsigned]' : '[mismatch]';
-        lines.push(`  ${agent.slug.padEnd(28)} ${agent.scope.padEnd(10)} ${trustMark.padEnd(11)}${model}`);
-        lines.push(`    ${truncate(agent.frontmatter.description, 80)}`);
+        lines.push(` ${agent.slug.padEnd(28)} ${agent.scope.padEnd(10)} ${trustMark.padEnd(11)}${model}`);
+        lines.push(`   ${truncate(agent.frontmatter.description, 80)}`);
     }
     ctx.writeOutput({ command: 'agents.list', agents: verdicts }, lines.join('\n'));
 }
@@ -243,9 +243,9 @@ async function runAgentsInstall(args, ctx) {
         source: fetched.sourceUrl,
     }, [
         `Installed agent "${slug}" (${scope}).`,
-        `  Path:    ${targetPath}`,
-        `  Source:  ${fetched.sourceUrl}`,
-        `  sha256:  ${sha256}`,
+        ` Path:   ${targetPath}`,
+        ` Source: ${fetched.sourceUrl}`,
+        ` sha256: ${sha256}`,
     ].join('\n'));
 }
 async function runAgentsInfo(args, ctx) {
@@ -270,13 +270,13 @@ async function runAgentsInfo(args, ctx) {
     const preview = agent.body.slice(0, 800);
     const lines = [
         `Agent: ${agent.slug}`,
-        `  Scope:        ${agent.scope}`,
-        `  Path:         ${agent.filePath}`,
-        `  Description:  ${agent.frontmatter.description}`,
-        `  Model:        ${String(agent.frontmatter.metadata.model ?? '(default)')}`,
-        `  Tools:        ${(agent.frontmatter.metadata.tools ?? []).join(', ') || '(none)'}`,
-        `  Trust:        ${trust.status}`,
-        `  sha256:       ${actualSha}`,
+        ` Scope:       ${agent.scope}`,
+        ` Path:        ${agent.filePath}`,
+        ` Description: ${agent.frontmatter.description}`,
+        ` Model:       ${String(agent.frontmatter.metadata.model ?? '(default)')}`,
+        ` Tools:       ${(agent.frontmatter.metadata.tools ?? []).join(', ') || '(none)'}`,
+        ` Trust:       ${trust.status}`,
+        ` sha256:      ${actualSha}`,
         '',
         'Body preview:',
         preview,
@@ -347,13 +347,13 @@ 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}`,
+        ` 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] ',

package/dist/runtime/commands/budget.js

@@ -41,12 +41,12 @@ export async function runBudgetCommand(args, ctx) {
         `Estimated cost: $${dollars.toFixed(4)} (output-token rate)`,
         summary.perCommand.length > 0
             ? `Per command:\n${summary.perCommand
-                .map((entry) => `  ${entry.command.padEnd(12)} ${entry.tokens} tokens`)
+                .map((entry) => ` ${entry.command.padEnd(12)} ${entry.tokens} tokens`)
                 .join('\n')}`
             : 'Per command: (no entries)',
         summary.perPersona.length > 0
             ? `Per persona:\n${summary.perPersona
-                .map((entry) => `  ${entry.persona.padEnd(20)} ${entry.tokens} tokens`)
+                .map((entry) => ` ${entry.persona.padEnd(20)} ${entry.tokens} tokens`)
                 .join('\n')}`
             : 'Per persona: (no entries)',
     ].join('\n');
@@ -104,9 +104,9 @@ function matchesWindow(event, cutoffMs) {
 /**
  * Extract a token count from any event shape we know about.
  *
- *   - `tool_result.tokensUsed`        — engine adapter emits this.
- *   - `subagent.completed.tokensUsed` — α5.4 subagent runner.
- *   - `engine.turn.tokensIn/tokensOut` — Anvil F1 metric mirror, future.
+ *  - `tool_result.tokensUsed`       — engine adapter emits this.
+ *  - `subagent.completed.tokensUsed` — subagent runner.
+ *  - `engine.turn.tokensIn/tokensOut` — Anvil F1 metric mirror, future.
  *
  * Unknown events return 0 so adding new event types upstream never
  * breaks `pugi budget`.

package/dist/runtime/commands/cancel.js

@@ -0,0 +1,231 @@
+/**
+ * `pugi /cancel` slash command — small-CC-parity batch .
+ *
+ * Bridges the gap between `/jobs` (read-only list of in-flight agents)
+ * and `/stop <persona>` (kill-by-persona via admin-api). Cancel is
+ * dispatch-id-keyed — operators read `.pugi/agent-progress/*.json` for
+ * the active list, then run `/cancel <id>` (or `/cancel all`) to halt.
+ *
+ * Behaviour matrix:
+ *
+ *  /cancel                 → table of active dispatches (id · persona
+ *                             · started-at · elapsed · status)
+ *  /cancel <id>            → mark the progress JSON as failed (closest
+ *                             valid schema status to "cancelled" — the
+ *                             schema's closed status set is running/
+ *                             completed/failed) + best-effort POST to
+ *                             the future `/api/pugi/dispatches/:id/cancel`
+ *                             endpoint. If the endpoint 404s we still
+ *                             update the local JSON so /jobs reflects
+ *                             the operator's intent.
+ *  /cancel all             → loop over every running entry
+ *
+ * # Module contract
+ *
+ *  - Single entry point: `runCancelCommand(args, io, opts)`. The slash
+ *    dispatcher in `core/repl/session.ts` calls this with the parsed
+ *    verdict; a future `pugi cancel` shell surface would call it with
+ *    the same shape. Exit code semantics mirror `/feedback` — cancel
+ *    never returns non-zero from inside the REPL because the slash
+ *    surface ignores it; the shell wrapper can branch on the returned
+ *    result variant.
+ *
+ *  - No real network I/O is required for the unit test path. The
+ *    `fetcher` seam accepts a stub that resolves to `{ ok: false,
+ *    status: 404 }` so the spec exercises the local-fallback branch
+ *    deterministically.
+ *
+ *  - Filesystem reads are best-effort. A missing progress dir / a
+ *    malformed JSON file simply degrades to "no active dispatches"
+ *    rather than throwing — the cancel command is a brand surface,
+ *    never a gate.
+ *
+ *  - followup: a dedicated `/api/pugi/dispatches/:id/cancel`
+ *    endpoint on admin-api ships in a sibling PR. Until then, the
+ *    local progress JSON write is the source of truth so `/jobs`
+ *    and the live `pugi jobs --watch` TUI both reflect the operator
+ *    verdict instantly.
+ */
+import { existsSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveProgressDir, } from '../../core/agent-progress/writer.js';
+import { validateAgentProgress, } from '../../core/agent-progress/schema.js';
+/**
+ * Read every progress file under `dir` and return the running ones.
+ * Malformed entries are silently skipped — operator sees a smaller list
+ * rather than a crash banner.
+ */
+export function readActiveDispatches(dir) {
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    const files = readdirSync(dir).filter((f) => f.endsWith('.json'));
+    for (const file of files) {
+        try {
+            const body = readFileSync(join(dir, file), 'utf8');
+            const parsed = JSON.parse(body);
+            const verdict = validateAgentProgress(parsed);
+            if (verdict.ok && verdict.value.status === 'running') {
+                out.push(verdict.value);
+            }
+        }
+        catch {
+            // Skip malformed files; the watcher / writer is the source of
+            // truth, not the snapshot — a partial read on a half-written
+            // tmp file would otherwise crash the cancel surface.
+        }
+    }
+    // Newest-first so the operator's eye lands on the freshest agent.
+    return out.sort((a, b) => Date.parse(b.lastUpdate) - Date.parse(a.lastUpdate));
+}
+/**
+ * Atomic update: rewrite the progress JSON as `status='failed'`
+ * (closest valid status to "cancelled" in the closed schema set) with
+ * a marker step description so `/jobs` and the live TUI both display
+ * the cancellation. Returns the path on success; bubbles I/O errors.
+ *
+ * The write uses the same `<file>.tmp-<pid>-<seq>` → rename pattern as
+ * the writer module so a chokidar watcher never reads a half-written
+ * document. We do NOT import the writer's `writeProgress` because that
+ * helper validates and re-clamps every field, which would also reset
+ * fields the operator may want to inspect post-cancel (elapsedMs,
+ * percentComplete). Cancel preserves the snapshot and only swaps the
+ * status + stepDescription + lastUpdate.
+ */
+let writeSequence = 0;
+export function markCancelled(dir, agentId, nowIso) {
+    const path = join(dir, `${agentId}.json`);
+    const body = readFileSync(path, 'utf8');
+    const parsed = JSON.parse(body);
+    parsed.status = 'failed';
+    parsed.stepDescription = '(cancelled by /cancel)';
+    parsed.lastUpdate = nowIso;
+    writeSequence += 1;
+    const tmp = `${path}.tmp-${process.pid}-${writeSequence}`;
+    writeFileSync(tmp, `${JSON.stringify(parsed, null, 2)}\n`, 'utf8');
+    renameSync(tmp, path);
+    return path;
+}
+/**
+ * Render a single-line cancel snapshot row. Pure helper so the spec
+ * can pin the exact shape without standing up an Ink renderer.
+ */
+export function renderCancelRow(entry, nowEpochMs) {
+    const id = entry.agentId.length > 24
+        ? `${entry.agentId.slice(0, 23)}…`
+        : entry.agentId;
+    const persona = entry.agentType.length > 18
+        ? `${entry.agentType.slice(0, 17)}…`
+        : entry.agentType;
+    const startedMs = Date.parse(entry.startedAt);
+    const elapsedSec = Number.isFinite(startedMs)
+        ? Math.max(0, Math.floor((nowEpochMs - startedMs) / 1000))
+        : Math.max(0, Math.floor(entry.elapsedMs / 1000));
+    const elapsed = elapsedSec >= 60
+        ? `${Math.floor(elapsedSec / 60)}m${String(elapsedSec % 60).padStart(2, '0')}s`
+        : `${elapsedSec}s`;
+    return ` ${id.padEnd(24, ' ')} ${persona.padEnd(18, ' ')} ${elapsed.padStart(6, ' ')} ${entry.status}`;
+}
+/**
+ * Main entry point. The slash dispatcher passes a tokenised
+ * `CancelMode`; the function returns a structured outcome so the
+ * caller can keep / drop the verdict line without re-parsing the I/O
+ * sink.
+ */
+export async function runCancelCommand(mode, io, opts = {}) {
+    const dir = opts.dir ?? resolveProgressDir();
+    const now = opts.now ?? Date.now;
+    const nowIso = new Date(now()).toISOString();
+    let active;
+    try {
+        active = readActiveDispatches(dir);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        io.write(`/cancel failed reading progress dir: ${message}`);
+        return { kind: 'error', message };
+    }
+    if (mode.kind === 'list') {
+        if (active.length === 0) {
+            io.write('No active dispatches. Brief one with /brief <text>.');
+            return { kind: 'listed', count: 0 };
+        }
+        io.write(`Active dispatches (${active.length}):`);
+        io.write(' dispatch-id             persona            elapsed status');
+        for (const entry of active) {
+            io.write(renderCancelRow(entry, now()));
+        }
+        io.write('Tip: /cancel <dispatch-id> to halt one, /cancel all к halt every running.');
+        return { kind: 'listed', count: active.length };
+    }
+    if (mode.kind === 'all') {
+        if (active.length === 0) {
+            io.write('Nothing к cancel — no active dispatches.');
+            return { kind: 'empty' };
+        }
+        const cancelled = [];
+        let endpointHit = false;
+        for (const entry of active) {
+            try {
+                if (opts.fetcher) {
+                    const verdict = await opts.fetcher(entry.agentId);
+                    if (verdict.ok)
+                        endpointHit = true;
+                }
+                markCancelled(dir, entry.agentId, nowIso);
+                cancelled.push(entry.agentId);
+                io.write(`Cancelled ${entry.agentId}`);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                io.write(` could not cancel ${entry.agentId}: ${message}`);
+            }
+        }
+        io.write(`Cancelled ${cancelled.length} of ${active.length} dispatch(es).`);
+        return { kind: 'cancelled', count: cancelled.length, ids: cancelled, endpointHit };
+    }
+    // kind === 'one'
+    const target = active.find((a) => a.agentId === mode.dispatchId);
+    if (!target) {
+        // Try prefix match — operators often type the first 8 chars.
+        const prefix = mode.dispatchId.toLowerCase();
+        const prefixMatch = active.find((a) => a.agentId.toLowerCase().startsWith(prefix));
+        if (!prefixMatch) {
+            io.write(`No active dispatch matching '${mode.dispatchId}'. Run /cancel to see the list.`);
+            return { kind: 'not-found', query: mode.dispatchId };
+        }
+        return cancelOne(prefixMatch, dir, nowIso, io, opts);
+    }
+    return cancelOne(target, dir, nowIso, io, opts);
+}
+async function cancelOne(entry, dir, nowIso, io, opts) {
+    let endpointHit = false;
+    if (opts.fetcher) {
+        try {
+            const verdict = await opts.fetcher(entry.agentId);
+            endpointHit = verdict.ok;
+        }
+        catch {
+            // network fail → fall through to local-only cancel
+        }
+    }
+    try {
+        markCancelled(dir, entry.agentId, nowIso);
+        io.write(`Cancelled dispatch ${entry.agentId}.`);
+        if (!endpointHit && opts.fetcher) {
+            io.write(' (backend cancel endpoint not reachable; progress JSON marked locally)');
+        }
+        return {
+            kind: 'cancelled',
+            count: 1,
+            ids: [entry.agentId],
+            endpointHit,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        io.write(`/cancel ${entry.agentId} failed: ${message}`);
+        return { kind: 'error', message };
+    }
+}
+//# sourceMappingURL=cancel.js.map