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

package/dist/runtime/commands/cancel.js

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