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

package/dist/core/coordinator/fsm.js

@@ -1,73 +0,0 @@
-export class CoordinatorFSM {
-    state;
-    constructor() {
-        this.state = {
-            phase: 'research',
-            inflightOps: [],
-            completedPhases: [],
-        };
-    }
-    getState() {
-        // Return a shallow copy to prevent direct mutation of the internal state.
-        return {
-            ...this.state,
-            inflightOps: [...this.state.inflightOps],
-            completedPhases: [...this.state.completedPhases],
-        };
-    }
-    canStart(op) {
-        switch (this.state.phase) {
-            case 'research':
-                return op === 'read';
-            case 'synth':
-                return op === 'read';
-            case 'impl':
-                if (op === 'write') {
-                    // 'write' is only allowed when no other operations are in flight.
-                    return this.state.inflightOps.length === 0;
-                }
-                // 'read' and 'exec' are allowed as long as no 'write' is in flight.
-                return !this.state.inflightOps.includes('write');
-            case 'done':
-                return false;
-            default:
-                return false;
-        }
-    }
-    start(op) {
-        if (!this.canStart(op)) {
-            throw new Error(`Operation '${op}' cannot be started in phase '${this.state.phase}' with inflight ops: [${this.state.inflightOps.join(', ')}]`);
-        }
-        this.state.inflightOps.push(op);
-    }
-    finish(op) {
-        const opIndex = this.state.inflightOps.indexOf(op);
-        if (opIndex === -1) {
-            throw new Error(`Cannot finish operation '${op}' as it is not in flight. Inflight ops: [${this.state.inflightOps.join(', ')}]`);
-        }
-        this.state.inflightOps.splice(opIndex, 1);
-    }
-    advance() {
-        if (this.state.inflightOps.length > 0) {
-            throw new Error(`Cannot advance phase with operations in flight: [${this.state.inflightOps.join(', ')}]`);
-        }
-        const currentPhase = this.state.phase;
-        let nextPhase;
-        switch (currentPhase) {
-            case 'research':
-                nextPhase = 'synth';
-                break;
-            case 'synth':
-                nextPhase = 'impl';
-                break;
-            case 'impl':
-                nextPhase = 'done';
-                break;
-            case 'done':
-                throw new Error("Cannot advance from final phase 'done'.");
-        }
-        this.state.completedPhases.push(currentPhase);
-        this.state.phase = nextPhase;
-    }
-}
-//# sourceMappingURL=fsm.js.map

package/dist/core/coordinator/mode-fsm.js

@@ -1,70 +0,0 @@
-const isQuiescent = (state) => state.readTasks === 0 && !state.writeTaskActive;
-export const MODE_TRANSITIONS = [
-    { from: 'idle', to: 'research', trigger: 'plan', guard: isQuiescent },
-    { from: 'research', to: 'synth', trigger: 'synthesize', guard: isQuiescent },
-    { from: 'synth', to: 'impl', trigger: 'execute', guard: isQuiescent },
-    { from: 'impl', to: 'review', trigger: 'verify', guard: isQuiescent },
-    { from: 'review', to: 'done', trigger: 'accept', guard: isQuiescent },
-    { from: 'review', to: 'impl', trigger: 'fix', guard: isQuiescent },
-    { from: 'idle', to: 'idle', trigger: 'reset' },
-    { from: 'research', to: 'idle', trigger: 'reset' },
-    { from: 'synth', to: 'idle', trigger: 'reset' },
-    { from: 'impl', to: 'idle', trigger: 'reset' },
-    { from: 'review', to: 'idle', trigger: 'reset' },
-    { from: 'done', to: 'idle', trigger: 'reset' },
-];
-class CoordinatorModeFSM {
-    state;
-    constructor(initial = 'idle') {
-        this.state = {
-            mode: initial,
-            enteredAt: Date.now(),
-            readTasks: 0,
-            writeTaskActive: false,
-        };
-    }
-    current() {
-        return { ...this.state };
-    }
-    trigger(event) {
-        const transition = MODE_TRANSITIONS.find((candidate) => candidate.from === this.state.mode && candidate.trigger === event);
-        if (!transition) {
-            return {
-                ok: false,
-                reason: `No transition for event '${event}' from mode '${this.state.mode}'.`,
-            };
-        }
-        if (transition.guard && !transition.guard(this.current())) {
-            return {
-                ok: false,
-                reason: `Guard blocked event '${event}' from mode '${this.state.mode}'.`,
-            };
-        }
-        this.state = {
-            ...this.state,
-            mode: transition.to,
-            enteredAt: Date.now(),
-        };
-        return { ok: true };
-    }
-    beginRead() {
-        this.state.readTasks += 1;
-    }
-    endRead() {
-        this.state.readTasks = Math.max(0, this.state.readTasks - 1);
-    }
-    beginWrite() {
-        if (this.state.writeTaskActive) {
-            return { ok: false, reason: 'A write task is already active.' };
-        }
-        this.state.writeTaskActive = true;
-        return { ok: true };
-    }
-    endWrite() {
-        this.state.writeTaskActive = false;
-    }
-}
-export function createFSM(initial) {
-    return new CoordinatorModeFSM(initial);
-}
-//# sourceMappingURL=mode-fsm.js.map

package/dist/core/cost/rate-card.js

@@ -1,129 +0,0 @@
-/**
- * Rate card for the `pugi cost` / `/cost` / `/usage` surface — L19 sprint.
- *
- * Distinct from `core/repl/model-pricing.ts` on purpose:
- *
- *  - `model-pricing.ts` powers the TUI cost meter (per-turn flash, status
- *    row USD). Its ladder is keyed against the live Anvil model slugs and
- *    intentionally inflates an honest worst-case figure via the Sonnet
- *    fallback so an operator on a quiet model never gets billed by a
- *    surprise. It rounds to USD per 1M tokens at runtime.
- *
- *  - `rate-card.ts` (this file) powers the persisted `/cost` table the
- *    operator reads to plan budget. It distinguishes open-weight models
- *    ($0 / $0 — infra cost only) from hosted closed models so the table
- *    does not double-charge an operator running a self-hosted Qwen or
- *    Kimi behind Pugi. The L19 spec calls these out by name.
- *
- * Both ladders intentionally agree on Anthropic Claude family pricing so
- * the TUI flash and the persisted table cannot disagree on a Claude turn.
- * If they diverge, the per-model-pricing ladder wins for live UI; the
- * rate card here wins for the persisted `.pugi/cost.json` aggregate.
- *
- * Prices are USD per 1,000,000 tokens, sourced from the L19 spec
- * which mirrors provider list-price pages as of that date.
- */
-/**
- * Exact-match price ladder keyed by model slug. Slugs match the L19 task
- * spec verbatim so a copy-paste from the sprint doc resolves without
- * normalisation.
- */
-export const RATES_PER_MTOKEN = Object.freeze({
-    // Anthropic Claude family (hosted, billed).
-    'claude-opus-4-7': { input: 15, output: 75 },
-    'claude-opus-4-6': { input: 15, output: 75 },
-    'claude-sonnet-4-6': { input: 3, output: 15 },
-    'claude-sonnet-4-5': { input: 3, output: 15 },
-    'claude-haiku-4-5-20251001': { input: 1, output: 5 },
-    'claude-haiku-4-5': { input: 1, output: 5 },
-    // Open-weight models — infra cost only, never per-token billed. The
-    // note column surfaces the reason so a CFO reading the JSON envelope
-    // does not assume the row is broken.
-    'qwen3-coder-480b-instruct-fp8': { input: 0, output: 0, note: 'open-weight' },
-    'kimi-k2.6': { input: 0, output: 0, note: 'open-weight' },
-    'deepseek-v4-pro': { input: 0, output: 0, note: 'open-weight' },
-});
-/**
- * Family-prefix fallback — used only when an exact slug miss. Mirrors the
- * approach in `model-pricing.ts` so a future model rebind (e.g.
- * `claude-opus-4-8`) prices reasonably without a code edit.
- */
-const FAMILY_FALLBACKS = [
-    ['claude-opus-', { input: 15, output: 75 }],
-    ['claude-sonnet-', { input: 3, output: 15 }],
-    ['claude-haiku-', { input: 1, output: 5 }],
-    ['qwen', { input: 0, output: 0, note: 'open-weight' }],
-    ['kimi', { input: 0, output: 0, note: 'open-weight' }],
-    ['deepseek', { input: 0, output: 0, note: 'open-weight' }],
-];
-/**
- * Final fallback for unknown slugs. Pinned to Sonnet-tier — same posture
- * as `model-pricing.ts`'s default, so an unrecognised hosted model bills
- * "honestly conservative" rather than $0 (which would silently hide cost
- * from the operator).
- */
-const DEFAULT_RATE = { input: 3, output: 15, note: 'unknown model — Sonnet-tier estimate' };
-/**
- * Look up the rate for a model slug.
- *
- * Resolution order:
- *  1. Exact match in `RATES_PER_MTOKEN`.
- *  2. Family-prefix match (first hit wins).
- *  3. Default Sonnet-tier estimate.
- *
- * Pure, never throws. Called on every cost-tracker write so the hot path
- * stays branch-cheap.
- */
-export function rateFor(model) {
-    if (!model || typeof model !== 'string')
-        return DEFAULT_RATE;
-    const exact = RATES_PER_MTOKEN[model];
-    if (exact)
-        return exact;
-    for (const [prefix, rate] of FAMILY_FALLBACKS) {
-        if (model.startsWith(prefix))
-            return rate;
-    }
-    return DEFAULT_RATE;
-}
-/**
- * Compute the USD cost for a single (model, inputTokens, outputTokens)
- * triple. Defensive against negative / NaN inputs — out-of-range values
- * floor to zero so a buggy upstream cannot credit a negative cost.
- */
-export function estimateUsd(model, inputTokens, outputTokens) {
-    const rate = rateFor(model);
-    const safeIn = Number.isFinite(inputTokens) && inputTokens > 0 ? inputTokens : 0;
-    const safeOut = Number.isFinite(outputTokens) && outputTokens > 0 ? outputTokens : 0;
-    const usd = (safeIn * rate.input + safeOut * rate.output) / 1_000_000;
-    return Number.isFinite(usd) && usd > 0 ? usd : 0;
-}
-/**
- * Format a USD figure for the `/cost` table.
- *
- *  - `≥ $0.01` → two decimals (`$0.46`).
- *  - `< $0.01` but `> 0` → three decimals (`$0.003`) so fractions of a
- *    cent are honest instead of rounding to `$0.00`.
- *  - Exactly `0` or NaN → `$0.00`.
- *
- * Mirrors `formatCostUsd` from `model-pricing.ts` intentionally — both
- * surfaces should print the same number in the same shape.
- */
-export function formatUsd(value) {
-    if (!Number.isFinite(value) || value <= 0)
-        return '$0.00';
-    if (value >= 0.01)
-        return `$${value.toFixed(2)}`;
-    return `$${value.toFixed(3)}`;
-}
-/**
- * Format a token count for the `/cost` table. Uses comma-thousands so the
- * table reads `14,300` instead of `14.3k` — distinct from the TUI status
- * row which uses `k`/`m` shortening to save column width.
- */
-export function formatTokensWithCommas(value) {
-    if (!Number.isFinite(value) || value <= 0)
-        return '0';
-    return Math.floor(value).toLocaleString('en-US');
-}
-//# sourceMappingURL=rate-card.js.map

package/dist/core/cost/tracker.js

@@ -1,221 +0,0 @@
-/**
- * Persisted per-session cost tracker — L19 sprint .
- *
- * Mission: every Anvil-mediated LLM call goes through `recordCall`, which
- * aggregates per-model token + USD totals and atomically persists them
- * to `.pugi/cost.json` so the operator can read `/cost` across REPL
- * restarts and reconcile a 14-min session that crossed a process boundary.
- *
- * Why a fresh module instead of bolting onto `core/repl/session.ts`?
- *
- *  - `session.ts` accumulates in-memory state for the live TUI status
- *    row, which is by-design ephemeral and cleared on REPL boot. The
- *    operator's "what did I spend across the project?" question needs
- *    a durable surface that survives a process restart.
- *  - L19 also has to read `--all-sessions` (last 30 days). The natural
- *    store for that is a per-workspace history of session aggregates,
- *    which is easy with the JSON file pattern below and would be
- *    awkward stitched into the REPL reducer.
- *
- * On-disk shape (single JSON file, atomic tmp+rename writes):
- *
- *  {
- *    "version": 1,
- *    "current": { sessionId, startedAt, models: { <slug>: ModelEntry } },
- *    "history": [
- *      { sessionId, startedAt, endedAt, models: { ... } }
- *    ]
- *  }
- *
- * History rotation: when `recordCall` is invoked with a sessionId
- * different from `current.sessionId`, the existing `current` row is
- * stamped with `endedAt = now()` and pushed onto `history`, then a new
- * `current` row is initialised. History is capped at 90 entries (the L19
- * `--all-sessions` window is 30 days; 90 gives a generous buffer for
- * operators on >1 session/day cadence without unbounded growth).
- *
- * The tracker is workspace-scoped — every workspace has its own
- * `.pugi/cost.json`. This matches the existing `.pugi/events.jsonl` /
- * `.pugi/index.json` pattern and means a multi-repo operator's costs
- * are billed against the repo they were incurred in.
- */
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, unlinkSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { estimateUsd } from './rate-card.js';
-/** On-disk schema version. Bump if the file shape changes. */
-export const COST_FILE_SCHEMA_VERSION = 1;
-/** Maximum number of historical sessions persisted in `.pugi/cost.json`. */
-export const COST_HISTORY_CAP = 90;
-export function createCostTracker(opts) {
-    const filePath = resolve(opts.workspaceRoot, '.pugi/cost.json');
-    const now = opts.now ?? Date.now;
-    let state = readOrInit(filePath);
-    function ensureCurrent(sessionId) {
-        if (state.current && state.current.sessionId === sessionId) {
-            return state.current;
-        }
-        // Session rotation: stamp the previous current with endedAt and push
-        // onto history. Idempotent — calling rotate twice with the same
-        // session id is a no-op.
-        if (state.current) {
-            const ended = {
-                ...state.current,
-                endedAt: new Date(now()).toISOString(),
-            };
-            state.history = [ended, ...state.history].slice(0, COST_HISTORY_CAP);
-        }
-        state.current = {
-            sessionId,
-            startedAt: new Date(now()).toISOString(),
-            models: {},
-        };
-        return state.current;
-    }
-    function persist() {
-        try {
-            mkdirSync(dirname(filePath), { recursive: true });
-        }
-        catch {
-            // best-effort directory create; the write below surfaces the real
-            // error if the parent is genuinely unwritable
-        }
-        const tmp = `${filePath}.tmp`;
-        writeFileSync(tmp, JSON.stringify(state, null, 2), 'utf8');
-        renameSync(tmp, filePath);
-    }
-    return {
-        recordCall(input) {
-            const sessionId = opts.sessionIdProvider();
-            if (!sessionId)
-                return;
-            const current = ensureCurrent(sessionId);
-            const slug = typeof input.model === 'string' && input.model.length > 0 ? input.model : 'unknown';
-            const safeIn = Number.isFinite(input.inputTokens) && input.inputTokens > 0 ? input.inputTokens : 0;
-            const safeOut = Number.isFinite(input.outputTokens) && input.outputTokens > 0 ? input.outputTokens : 0;
-            const existing = current.models[slug] ?? { input: 0, output: 0, callCount: 0 };
-            current.models[slug] = {
-                input: existing.input + safeIn,
-                output: existing.output + safeOut,
-                callCount: existing.callCount + 1,
-            };
-            persist();
-        },
-        current() {
-            return state.current;
-        },
-        history() {
-            return state.history;
-        },
-        aggregateWithin(withinDays) {
-            const cutoffMs = now() - withinDays * 24 * 60 * 60 * 1000;
-            const aggregate = {
-                sessionId: 'aggregate',
-                startedAt: new Date(cutoffMs).toISOString(),
-                endedAt: new Date(now()).toISOString(),
-                models: {},
-            };
-            const rows = [];
-            if (state.current)
-                rows.push(state.current);
-            for (const row of state.history) {
-                const stamp = Date.parse(row.startedAt);
-                if (Number.isFinite(stamp) && stamp >= cutoffMs)
-                    rows.push(row);
-            }
-            for (const row of rows) {
-                for (const [slug, entry] of Object.entries(row.models)) {
-                    const existing = aggregate.models[slug] ?? { input: 0, output: 0, callCount: 0 };
-                    aggregate.models[slug] = {
-                        input: existing.input + entry.input,
-                        output: existing.output + entry.output,
-                        callCount: existing.callCount + entry.callCount,
-                    };
-                }
-            }
-            return aggregate;
-        },
-        resetCurrent() {
-            const wiped = state.current;
-            state.current = null;
-            persist();
-            return wiped;
-        },
-        flush() {
-            persist();
-        },
-    };
-}
-/**
- * Compute the per-session USD total from a `SessionAggregate`. Pure —
- * uses the rate card to bind a price to every model entry. Open-weight
- * models contribute $0 (their entries always have $0/$0 rate).
- */
-export function totalUsd(aggregate) {
-    let total = 0;
-    for (const [slug, entry] of Object.entries(aggregate.models)) {
-        total += estimateUsd(slug, entry.input, entry.output);
-    }
-    return total;
-}
-/**
- * Compute total input + output token sums across all models in an
- * aggregate. Used by the CLI table footer.
- */
-export function totalTokens(aggregate) {
-    let input = 0;
-    let output = 0;
-    for (const entry of Object.values(aggregate.models)) {
-        input += entry.input;
-        output += entry.output;
-    }
-    return { input, output };
-}
-/**
- * Read the persisted file (or initialise an empty one). Tolerates a
- * corrupted file by returning a fresh empty state — losing one
- * session's history is preferable to throwing from the boot path of
- * every `pugi cost` invocation.
- */
-function readOrInit(filePath) {
-    if (!existsSync(filePath)) {
-        return { version: COST_FILE_SCHEMA_VERSION, current: null, history: [] };
-    }
-    try {
-        const raw = readFileSync(filePath, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return { version: COST_FILE_SCHEMA_VERSION, current: null, history: [] };
-        }
-        const obj = parsed;
-        return {
-            version: typeof obj.version === 'number' ? obj.version : COST_FILE_SCHEMA_VERSION,
-            current: isAggregate(obj.current) ? obj.current : null,
-            history: Array.isArray(obj.history) ? obj.history.filter(isAggregate) : [],
-        };
-    }
-    catch {
-        return { version: COST_FILE_SCHEMA_VERSION, current: null, history: [] };
-    }
-}
-function isAggregate(v) {
-    if (!v || typeof v !== 'object' || Array.isArray(v))
-        return false;
-    const obj = v;
-    if (typeof obj.sessionId !== 'string' || typeof obj.startedAt !== 'string')
-        return false;
-    if (!obj.models || typeof obj.models !== 'object')
-        return false;
-    return true;
-}
-/**
- * Test helper — wipe the `.pugi/cost.json` file. Not exported through the
- * public CostTracker surface because production code must never call
- * this; an operator-facing reset goes through `resetCurrent()` which
- * preserves history.
- */
-export function _danger_wipeCostFile_forTests(workspaceRoot) {
-    const filePath = resolve(workspaceRoot, '.pugi/cost.json');
-    if (existsSync(filePath))
-        unlinkSync(filePath);
-}
-//# sourceMappingURL=tracker.js.map