@pugi/cli 0.1.0-beta.2 → 0.1.0-beta.20

package/dist/runtime/commands/compact.js

@@ -0,0 +1,296 @@
+/**
+ * `pugi compact` — top-level command + companion to the REPL slash.
+ *
+ * Summarises older events from the most recent SessionStore session
+ * into a single boundary marker, freeing context budget for the next
+ * REPL session that resumes the same id.
+ *
+ * Wire: writeOutput contract matches every other dispatch in cli.ts
+ * (one structured payload + one human line). Exit code:
+ *   0  — boundary marker appended
+ *   1  — summarizer transport failed / store unavailable
+ *   2  — no events to compact / nothing to do
+ *
+ * The companion REPL slash dispatches through this same runner so the
+ * surface stays single-sourced.
+ */
+import { homedir } from 'node:os';
+import { loadRuntimeConfig } from '@pugi/sdk';
+import { AnvilEngineLoopClient } from '../../core/engine/anvil-client.js';
+import { SqliteSessionStore, resolveProjectStoreDir, } from '../../core/repl/store/session-store.js';
+import { appendCompactBoundary, isCompactBoundary, } from '../../core/compact/buffer-rewriter.js';
+import { summarizeEvents, SummarizerError } from '../../core/compact/summarizer.js';
+/** Number of tail turns preserved verbatim on every compaction. */
+export const KEPT_TAIL_TURNS = 5;
+/** Minimum source events before we accept a compaction. */
+const MIN_EVENTS_TO_COMPACT = 6;
+/**
+ * Entry point reused by the slash command + the top-level dispatcher.
+ *
+ * The function is exhaustive: every early-exit branch produces a
+ * structured `CompactCommandResult` for the JSON path AND a one-line
+ * human message for the TTY path. Tests assert on the returned shape;
+ * the top-level dispatcher forwards it to `writeOutput`.
+ */
+export async function runCompactCommand(_args, ctx) {
+    const trigger = ctx.trigger ?? 'manual';
+    // Resolve the target session id. When the caller supplied a store
+    // (REPL slash path, tests) we trust it has the session bound; the
+    // standalone CLI path needs to discover the most-recent id via the
+    // read-only view + then open the live store on that id.
+    let store = ctx.store ?? null;
+    let sessionId = ctx.sessionId ?? null;
+    if (store === null) {
+        sessionId = sessionId ?? (await pickMostRecentSessionIdReadOnly(ctx.workspaceRoot));
+        if (!sessionId) {
+            return emit(ctx, {
+                command: 'compact',
+                status: 'failed_no_session',
+                trigger,
+                reason: 'No active session to compact. Start a REPL with `pugi`.',
+            });
+        }
+        store = await openStoreForCwd(ctx.workspaceRoot, sessionId);
+        if (!store) {
+            return emit(ctx, {
+                command: 'compact',
+                status: 'failed_no_session',
+                trigger,
+                reason: 'Local session store unavailable (lock held by REPL?).',
+            });
+        }
+    }
+    else if (sessionId === null) {
+        // Caller supplied a store but no session id — try to discover one.
+        sessionId = await pickMostRecentSessionId(store, ctx.workspaceRoot);
+        if (!sessionId) {
+            return emit(ctx, {
+                command: 'compact',
+                status: 'failed_no_session',
+                trigger,
+                reason: 'No active session to compact.',
+            });
+        }
+    }
+    // Snapshot the events. We pass `coversUntilOffset` as the count of
+    // events at the moment of the snapshot so the marker's anchor is
+    // accurate even if other writers race afterwards.
+    let events;
+    try {
+        events = await store.loadEvents(sessionId);
+    }
+    catch (error) {
+        return emit(ctx, {
+            command: 'compact',
+            status: 'failed_store',
+            sessionId,
+            trigger,
+            reason: `Could not load events: ${errMsg(error)}`,
+        });
+    }
+    if (events.length < MIN_EVENTS_TO_COMPACT) {
+        return emit(ctx, {
+            command: 'compact',
+            status: 'noop_empty',
+            sessionId,
+            trigger,
+            reason: `Only ${events.length} events on disk; need at least ${MIN_EVENTS_TO_COMPACT}.`,
+        });
+    }
+    // Locate the source slice: everything strictly after the latest
+    // compact-boundary, EXCLUDING the kept-tail window. If no prior
+    // boundary exists, walk from offset 0.
+    const lastBoundaryIdx = findLastCompactBoundaryIndex(events);
+    const sliceStart = lastBoundaryIdx === -1 ? 0 : lastBoundaryIdx + 1;
+    const sliceEnd = Math.max(sliceStart, events.length - KEPT_TAIL_TURNS);
+    const sourceSlice = events.slice(sliceStart, sliceEnd);
+    if (sourceSlice.length === 0) {
+        return emit(ctx, {
+            command: 'compact',
+            status: 'noop_recent_marker',
+            sessionId,
+            trigger,
+            reason: 'Conversation already compact — nothing new to fold.',
+        });
+    }
+    // Build the engine client. Production uses Anvil; tests inject a
+    // fixture client to avoid the network round-trip.
+    const engineClient = ctx.engineClient ?? buildAnvilClient();
+    if (!engineClient) {
+        return emit(ctx, {
+            command: 'compact',
+            status: 'failed_transport',
+            sessionId,
+            trigger,
+            reason: 'Could not build engine client (run `pugi login`).',
+        });
+    }
+    // Run the summariser.
+    let summary;
+    try {
+        summary = await summarizeEvents({
+            events: sourceSlice,
+            client: engineClient,
+            personaSlug: 'mira',
+        });
+    }
+    catch (error) {
+        const code = error instanceof SummarizerError ? error.code : 'unknown';
+        const message = error instanceof Error ? error.message : String(error);
+        return emit(ctx, {
+            command: 'compact',
+            status: 'failed_transport',
+            sessionId,
+            trigger,
+            reason: `Summarizer failed (${code}): ${message}`,
+        });
+    }
+    // Append the boundary marker. Recompute `coversUntilOffset` AFTER
+    // the summariser round-trip so any events that landed mid-flight
+    // fall into the kept-tail window — the operator does not lose work
+    // that arrived during compaction. The next event we append (the
+    // marker itself) lands at index `coversUntilOffset` in the on-disk
+    // log.
+    let postRoundTripEvents;
+    try {
+        postRoundTripEvents = await store.loadEvents(sessionId);
+    }
+    catch (error) {
+        return emit(ctx, {
+            command: 'compact',
+            status: 'failed_store',
+            sessionId,
+            trigger,
+            reason: `Could not refresh events: ${errMsg(error)}`,
+        });
+    }
+    const coversUntilOffset = postRoundTripEvents.length;
+    try {
+        await appendCompactBoundary({
+            store,
+            trigger,
+            summary: summary.summary,
+            summaryTokenCount: summary.tokensSummarised,
+            summaryTurnsBefore: summary.eventsSummarised,
+            keptTailTurns: KEPT_TAIL_TURNS,
+            coversUntilOffset,
+            ...(ctx.now !== undefined ? { now: ctx.now } : {}),
+        });
+    }
+    catch (error) {
+        return emit(ctx, {
+            command: 'compact',
+            status: 'failed_store',
+            sessionId,
+            trigger,
+            reason: `Could not append marker: ${errMsg(error)}`,
+        });
+    }
+    return emit(ctx, {
+        command: 'compact',
+        status: 'compacted',
+        sessionId,
+        trigger,
+        turnsBefore: summary.eventsSummarised,
+        tailKept: KEPT_TAIL_TURNS,
+        tokensSummarised: summary.tokensSummarised,
+    }, `Compacted ${summary.eventsSummarised} events (~${summary.tokensSummarised} tokens) into 1 summary. ` +
+        `Last ${KEPT_TAIL_TURNS} turns kept verbatim.`);
+}
+/* ------------------------------------------------------------------ */
+/* Helpers                                                            */
+/* ------------------------------------------------------------------ */
+/**
+ * Emit a payload through the context and return it for the caller. We
+ * keep the function exhaustive so every branch lands on the same
+ * writeOutput contract (JSON-mode + text-mode).
+ */
+function emit(ctx, payload, text) {
+    const human = text ?? payload.reason ?? `compact: ${payload.status}`;
+    ctx.writeOutput(payload, human);
+    return payload;
+}
+function findLastCompactBoundaryIndex(events) {
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        if (isCompactBoundary(events[i]))
+            return i;
+    }
+    return -1;
+}
+function errMsg(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Open the SqliteSessionStore for the workspace's project slug and
+ * bind the active log to `sessionId`. Returns null when the open
+ * fails (lock contention, IO error, missing project dir).
+ *
+ * The PID lockfile contention is the expected failure mode here — a
+ * running REPL holds the lock, and `pugi compact` from a second
+ * terminal cannot grab it. The caller surfaces a clear message rather
+ * than crashing the dispatch.
+ */
+async function openStoreForCwd(workspaceRoot, sessionId) {
+    try {
+        const slug = projectSlugForCwd(workspaceRoot);
+        const store = new SqliteSessionStore({ projectSlug: slug, home: homedir() });
+        await store.open({
+            id: sessionId,
+            workspaceRoot,
+            projectSlug: slug,
+        });
+        return store;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read-only-view variant of `pickMostRecentSessionId` for the
+ * pre-open phase. Walks `~/.pugi/projects/<slug>/session.db` without
+ * taking the lockfile so a live REPL in another terminal does not
+ * make discovery fail.
+ */
+async function pickMostRecentSessionIdReadOnly(workspaceRoot) {
+    try {
+        const slug = projectSlugForCwd(workspaceRoot);
+        const dir = resolveProjectStoreDir(slug, homedir());
+        const view = await SqliteSessionStore.openReadOnly(dir);
+        try {
+            const rows = await view.list({ project: slug, limit: 1, status: 'active' });
+            return rows.length > 0 ? rows[0].id : null;
+        }
+        finally {
+            await view.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Locate the most recent active session for the workspace. Returns
+ * null when no session row exists.
+ */
+async function pickMostRecentSessionId(store, workspaceRoot) {
+    const slug = projectSlugForCwd(workspaceRoot);
+    const rows = await store.listSessions({ project: slug, limit: 1, status: 'active' });
+    if (rows.length === 0)
+        return null;
+    return rows[0].id;
+}
+function projectSlugForCwd(workspaceRoot) {
+    const base = workspaceRoot.split('/').filter((s) => s.length > 0).pop() ?? 'workspace';
+    return base.toLowerCase().replace(/[^a-z0-9-]/g, '-').slice(0, 64);
+}
+/**
+ * Construct an Anvil-backed engine client from env-resolved runtime
+ * config. Returns null when the operator is not authenticated.
+ */
+function buildAnvilClient() {
+    const config = loadRuntimeConfig();
+    if (!config)
+        return null;
+    return new AnvilEngineLoopClient(config);
+}
+//# sourceMappingURL=compact.js.map

package/dist/runtime/commands/cost.js

@@ -0,0 +1,199 @@
+/**
+ * `pugi cost` / `pugi usage` command handler — L19 sprint (2026-05-27).
+ *
+ * Shared backend for three operator surfaces:
+ *
+ *   - `pugi cost`                  current session (default)
+ *   - `pugi cost --all-sessions`   30-day rolling aggregate
+ *   - `pugi cost --reset --yes`    wipe current session counter (operator-only)
+ *   - `pugi usage`                 alias of `pugi cost`
+ *   - `/cost` REPL slash           same handler, in-REPL output
+ *   - `/usage` REPL slash          same handler, alias of /cost
+ *
+ * Why a separate command from the existing `pugi budget`:
+ *
+ *   - `pugi budget` walks `.pugi/events.jsonl` and bills against the
+ *     event-log heuristic (per-command / per-persona attribution). It
+ *     is the right surface for "what did this brief / this persona
+ *     spend?". It does not break down by model and it does not persist
+ *     a cross-session aggregate.
+ *
+ *   - `pugi cost` (this command) reads the persisted `.pugi/cost.json`
+ *     written by the `CostTracker`. It is the right surface for "what
+ *     did this model spend?" and "what did I spend across the last 30
+ *     days?". Token + USD figures are sourced from the rate card, which
+ *     distinguishes hosted Claude (per-token billed) from open-weight
+ *     Qwen / Kimi / DeepSeek (infra cost only).
+ *
+ * Both commands intentionally coexist — they answer adjacent but distinct
+ * operator questions. The L19 spec calls out `/cost` and `/usage` by
+ * name; the budget surface is unaffected.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { createCostTracker, totalTokens, totalUsd, } from '../../core/cost/tracker.js';
+import { buildCostView, renderCostTableText } from '../../tui/cost-table.js';
+/**
+ * Parsed flag bundle. Exported for the test surface; production callers
+ * never touch it directly — `runCostCommand` owns parsing.
+ */
+export function parseCostFlags(args) {
+    const flags = {
+        allSessions: false,
+        reset: false,
+        yes: false,
+        json: false,
+        windowDays: 30,
+    };
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i] ?? '';
+        if (arg === '--all-sessions')
+            flags.allSessions = true;
+        else if (arg === '--reset')
+            flags.reset = true;
+        else if (arg === '--yes' || arg === '-y')
+            flags.yes = true;
+        else if (arg === '--json')
+            flags.json = true;
+        else if (arg.startsWith('--window=')) {
+            const raw = Number.parseInt(arg.slice('--window='.length), 10);
+            if (Number.isFinite(raw) && raw > 0 && raw <= 365)
+                flags.windowDays = raw;
+        }
+    }
+    return flags;
+}
+export async function runCostCommand(args, ctx) {
+    const flags = parseCostFlags(args);
+    const sessionId = ctx.sessionId ?? deriveSessionIdFromEvents(ctx.workspaceRoot) ?? 'no-session';
+    const tracker = createCostTracker({
+        workspaceRoot: ctx.workspaceRoot,
+        sessionIdProvider: () => sessionId,
+        now: ctx.now,
+    });
+    // --reset: clear the current session counter. Operator-only — refuses
+    // without `--yes` so a typo / shell completion never wipes the meter.
+    if (flags.reset) {
+        if (!flags.yes) {
+            ctx.writeOutput({ command: 'cost', status: 'reset_pending_confirmation' }, 'pugi cost --reset clears the current session counter. Re-run with --yes to confirm.');
+            return;
+        }
+        const wiped = tracker.resetCurrent();
+        const payload = {
+            command: 'cost',
+            status: 'reset_ok',
+            wiped: wiped ?? null,
+        };
+        ctx.writeOutput(payload, wiped
+            ? `Cleared session ${wiped.sessionId} (${Object.keys(wiped.models).length} model(s) wiped).`
+            : 'No current session counter to clear.');
+        return;
+    }
+    const aggregate = flags.allSessions ? tracker.aggregateWithin(flags.windowDays) : (tracker.current() ?? emptyAggregate(sessionId, ctx.now ?? Date.now));
+    const tier = ctx.resolveTier ? await safeResolveTier(ctx.resolveTier) : null;
+    const heading = flags.allSessions
+        ? `Pugi cost / usage — aggregate (last ${flags.windowDays} days)`
+        : buildSessionHeading(aggregate, ctx.now ?? Date.now);
+    const view = buildCostView({ aggregate, heading, tier: tier ?? undefined });
+    const text = renderCostTableText(view);
+    ctx.writeOutput({
+        command: flags.allSessions ? 'cost.aggregate' : 'cost.session',
+        status: 'ok',
+        window: flags.allSessions ? `${flags.windowDays}d` : 'current',
+        tokens: {
+            input: view.totalInputTokens,
+            output: view.totalOutputTokens,
+        },
+        dollars: view.totalUsd,
+        perModel: view.rows.map((row) => ({
+            model: row.model,
+            input: row.inputTokens,
+            output: row.outputTokens,
+            usd: row.usd,
+            note: row.note ?? null,
+        })),
+        tier: tier ?? null,
+    }, text);
+}
+/**
+ * Render-only helper for the REPL slash. The slash dispatcher inside
+ * `session.ts` owns the side-effect of pushing system lines; this
+ * function builds the view and the text rendition so the slash handler
+ * can fan the lines into the existing `appendSystemLine` queue.
+ *
+ * Exposed here (not in the Ink module) so the slash path never imports
+ * Ink/React — keeps the REPL bundle slim and the slash handler async-free.
+ */
+export function renderCostForSlash(input) {
+    const aggregate = input.allSessions
+        ? input.tracker.aggregateWithin(input.windowDays)
+        : (input.tracker.current() ?? emptyAggregate('no-session', input.now));
+    const heading = input.allSessions
+        ? `Pugi cost / usage — aggregate (last ${input.windowDays} days)`
+        : buildSessionHeading(aggregate, input.now);
+    const view = buildCostView({ aggregate, heading, tier: input.tier ?? undefined });
+    return { view, lines: renderCostTableText(view).split('\n') };
+}
+/**
+ * Derive a session id from `.pugi/events.jsonl` when the caller does not
+ * pass one. Walks the file once and picks the most recent `session.start`
+ * event's id. Falls back to `null` when the file is missing / corrupted
+ * — the caller substitutes a `'no-session'` placeholder so the table
+ * still renders an empty state instead of crashing.
+ */
+function deriveSessionIdFromEvents(workspaceRoot) {
+    const path = resolve(workspaceRoot, '.pugi/events.jsonl');
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = readFileSync(path, 'utf8');
+        const lines = raw.split('\n').filter((line) => line.trim().length > 0);
+        // Walk from newest to oldest — `session.start` is rare, no reason to
+        // scan the whole file when the answer is at the tail.
+        for (let i = lines.length - 1; i >= 0; i -= 1) {
+            try {
+                const parsed = JSON.parse(lines[i]);
+                if (parsed.type === 'session' && parsed.name === 'start' && typeof parsed.sessionId === 'string') {
+                    return parsed.sessionId;
+                }
+            }
+            catch {
+                // partial-write lines are ignored
+            }
+        }
+    }
+    catch {
+        // best-effort; absent events.jsonl is a normal first-boot state
+    }
+    return null;
+}
+function buildSessionHeading(aggregate, now) {
+    if (!aggregate || aggregate.sessionId === 'no-session' || aggregate.sessionId === 'aggregate') {
+        return 'Pugi cost / usage — no active session';
+    }
+    const start = Date.parse(aggregate.startedAt);
+    if (!Number.isFinite(start)) {
+        return `Pugi cost / usage — session ${aggregate.sessionId}`;
+    }
+    const elapsedMin = Math.max(0, Math.floor((now() - start) / 60_000));
+    return `Pugi cost / usage — session ${aggregate.sessionId} (${elapsedMin} min)`;
+}
+function emptyAggregate(sessionId, now) {
+    return {
+        sessionId,
+        startedAt: new Date(now()).toISOString(),
+        models: {},
+    };
+}
+async function safeResolveTier(resolver) {
+    try {
+        return await resolver();
+    }
+    catch {
+        return null;
+    }
+}
+// Re-export aggregate helpers so the cli.ts wire-up can read totals
+// without reaching into the tracker module directly.
+export { totalUsd, totalTokens };
+//# sourceMappingURL=cost.js.map