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

package/dist/runtime/commands/config.js

@@ -11,21 +11,21 @@ import { resolveActiveCredential } from '../../core/credentials.js';
  * `pugi config` — operator-level configuration surface.
  *
  * Subcommands:
- *   - `pugi config get <key>`              read a value from `~/.pugi/config.json`
- *   - `pugi config set <key> <value>`      write a value
- *   - `pugi config list`                   dump all values
- *   - `pugi config trust .`                trust the current workspace (delegates to core/trust.ts)
- *   - `pugi config mcp trust <name>`       flip MCP server to trusted
- *   - `pugi config mcp deny <name>`        flip MCP server to denied
- *   - `pugi config mcp list`               show declared servers + their trust state
+ *  - `pugi config get <key>`             read a value from `~/.pugi/config.json`
+ *  - `pugi config set <key> <value>`     write a value
+ *  - `pugi config list`                  dump all values
+ *  - `pugi config trust .`               trust the current workspace (delegates to core/trust.ts)
+ *  - `pugi config mcp trust <name>`      flip MCP server to trusted
+ *  - `pugi config mcp deny <name>`       flip MCP server to denied
+ *  - `pugi config mcp list`              show declared servers + their trust state
  *
  * Schema (pugi-config-v1):
- *   {
- *     "permissionMode": "ask" | "acceptEdits" | "auto" | "plan" | "dontAsk" | "bypassPermissions",
- *     "privacy":        "local-only" | "metadata" | "full",
- *     "model":          "<id>" | null,
- *     "preferredEndpoint": "https://api.pugi.io"
- *   }
+ *  {
+ *    "permissionMode": "ask" | "acceptEdits" | "auto" | "plan" | "dontAsk" | "bypassPermissions",
+ *    "privacy":       "local-only" | "metadata" | "full",
+ *    "model":         "<id>" | null,
+ *    "preferredEndpoint": "https://api.pugi.io"
+ *  }
  *
  * The config file lives at `~/.pugi/config.json` (PUGI_HOME-aware) and uses
  * mode 0o600. Unknown keys are rejected by `set` so a typo never silently
@@ -39,9 +39,41 @@ const configSchema = z
     privacy: z.enum(['local-only', 'metadata', 'full']).optional(),
     model: z.string().nullable().optional(),
     preferredEndpoint: z.string().url().optional(),
+    // PUGI-260 — persistent default for the 1M context tier opt-in.
+    // `pugi config set contextTier 1m` (or the dotted form
+    // `context.tier 1m`) writes this; per-invocation `--context-tier=...`
+    // flags override it at request time. Closed enum mirrors the CLI
+    // flag и the admin-api DTO so a typo here surfaces as a Zod parse
+    // error при load, not a silent fallback. Stored on the flat user-
+    // level config (~/.pugi/config.json) so all workspaces inherit the
+    // same default — operators с consistent long-context workloads
+    // (large monorepos, audits) set it once instead of remembering к
+    // pass --context-tier=1m on every dispatch.
+    contextTier: z.enum(['1m', 'standard']).optional(),
 })
     .strict();
-const CONFIG_KEYS = ['permissionMode', 'privacy', 'model', 'preferredEndpoint'];
+const CONFIG_KEYS = [
+    'permissionMode',
+    'privacy',
+    'model',
+    'preferredEndpoint',
+    // PUGI-260 — exposed на `pugi config list` so operators see the
+    // current default. Hidden synonym `context.tier` accepted by
+    // runConfigSet / runConfigGet for a dotted-key familiar UX.
+    'contextTier',
+];
+/**
+ * PUGI-260: legacy / nested key aliasing. `pugi config set context.tier 1m`
+ * is the documented form в the feat doc; we normalise it onto the flat
+ * `contextTier` key before the strict-schema validation так future
+ * settings.json migrations keep one canonical key. Mirrors the
+ * legacy privacy-mode aliasing that already lives in the file.
+ */
+function normaliseConfigKey(raw) {
+    if (raw === 'context.tier')
+        return 'contextTier';
+    return raw;
+}
 export async function runConfigCommand(args, ctx) {
     const sub = args[0];
     if (!sub || sub === '--help' || sub === '-h') {
@@ -63,18 +95,18 @@ export async function runConfigCommand(args, ctx) {
             ],
         }, [
             'Usage:',
-            '  pugi config get <key>                            Read a config value.',
-            '  pugi config set <key> <value>                    Write a config value.',
-            '  pugi config list                                 Show all config values.',
-            '  pugi config trust .                              Trust the current workspace for hooks + MCP.',
-            '  pugi config mcp trust <name>                     Mark an MCP server as trusted.',
-            '  pugi config mcp deny <name>                      Block an MCP server.',
-            '  pugi config mcp list                             Show declared MCP servers + trust state.',
-            '  pugi config get routing                          Show effective routing table (defaults + tenant overrides).',
-            '  pugi config set routing.<tag>.<budget>=<model>   Override the model for one (tag, budget) lane.',
-            '  pugi config unset routing.<tag>.<budget>         Remove a routing override (revert to default).',
-            '  pugi config get privacy                          Show current tenant privacy mode + last-flip metadata.',
-            '  pugi config set privacy=<mode>                   Flip privacy mode (strict | balanced | permissive).',
+            ' pugi config get <key>                           Read a config value.',
+            ' pugi config set <key> <value>                   Write a config value.',
+            ' pugi config list                                Show all config values.',
+            ' pugi config trust .                             Trust the current workspace for hooks + MCP.',
+            ' pugi config mcp trust <name>                    Mark an MCP server as trusted.',
+            ' pugi config mcp deny <name>                     Block an MCP server.',
+            ' pugi config mcp list                            Show declared MCP servers + trust state.',
+            ' pugi config get routing                         Show effective routing table (defaults + tenant overrides).',
+            ' pugi config set routing.<tag>.<budget>=<model>  Override the model for one (tag, budget) lane.',
+            ' pugi config unset routing.<tag>.<budget>        Remove a routing override (revert to default).',
+            ' pugi config get privacy                         Show current tenant privacy mode + last-flip metadata.',
+            ' pugi config set privacy=<mode>                  Flip privacy mode (strict | balanced | permissive).',
         ].join('\n'));
         return;
     }
@@ -108,7 +140,7 @@ export async function runConfigCommand(args, ctx) {
             // names. The unit spec for config.ts has a regression test for
             // both code paths.
             //
-            // Triple-review P2 fix (2026-05-25): the prior disambiguation
+            // Triple-review P2 fix : the prior disambiguation
             // only excluded the bare form (`privacy local-only`) - the `=`
             // form (`privacy=local-only`) still routed to runPrivacySet and
             // 4xx'd. We now check the value AFTER `=` and route legacy local
@@ -178,25 +210,27 @@ function isConfigKey(value) {
     return CONFIG_KEYS.includes(value);
 }
 function runConfigGet(args, ctx) {
-    const key = args[0];
-    if (!key)
+    const rawKey = args[0];
+    if (!rawKey)
         throw new Error('pugi config get requires a key.');
+    const key = normaliseConfigKey(rawKey);
     if (!isConfigKey(key)) {
-        throw new Error(`Unknown config key "${key}". Allowed: ${CONFIG_KEYS.join(', ')}.`);
+        throw new Error(`Unknown config key "${rawKey}". Allowed: ${CONFIG_KEYS.join(', ')}.`);
     }
     const config = readConfig();
     const value = config[key] ?? null;
     ctx.writeOutput({ command: 'config.get', key, value }, value === null || value === undefined ? `${key} = (unset)` : `${key} = ${String(value)}`);
 }
 function runConfigSet(args, ctx) {
-    const key = args[0];
+    const rawKey = args[0];
     const value = args.slice(1).join(' ');
-    if (!key)
+    if (!rawKey)
         throw new Error('pugi config set requires a key.');
     if (value.length === 0)
         throw new Error('pugi config set requires a value.');
+    const key = normaliseConfigKey(rawKey);
     if (!isConfigKey(key)) {
-        throw new Error(`Unknown config key "${key}". Allowed: ${CONFIG_KEYS.join(', ')}.`);
+        throw new Error(`Unknown config key "${rawKey}". Allowed: ${CONFIG_KEYS.join(', ')}.`);
     }
     const current = readConfig();
     // Build the candidate and validate via the schema so an invalid value
@@ -279,7 +313,7 @@ async function runConfigMcpList(ctx) {
     }
     ctx.writeOutput({ command: 'config.mcp.list', servers: declared, ledger }, [
         'MCP servers:',
-        ...declared.map((server) => `  ${server.name.padEnd(20)} ${server.trust.padEnd(8)} ${server.command} ${server.args.join(' ')}`),
+        ...declared.map((server) => ` ${server.name.padEnd(20)} ${server.trust.padEnd(8)} ${server.command} ${server.args.join(' ')}`),
     ].join('\n'));
 }
 async function runConfigMcpFlip(args, ctx, state) {
@@ -297,7 +331,7 @@ async function runConfigMcpFlip(args, ctx, state) {
         : `MCP server "${name}" is now denied.`);
 }
 /* ------------------------------------------------------------------ */
-/* α6.10 multi-model routing — config.routing.* subcommands            */
+/* multi-model routing — config.routing.* subcommands           */
 /* ------------------------------------------------------------------ */
 /**
  * Closed sets — match
@@ -360,7 +394,7 @@ async function runRoutingGet(ctx) {
     });
     const text = [
         'Routing table (effective = override | default):',
-        ...cells.map((cell) => `  routing.${cell.tag.padEnd(10)}.${cell.budgetHint.padEnd(3)} = ${cell.model.padEnd(28)} (${cell.source})`),
+        ...cells.map((cell) => ` routing.${cell.tag.padEnd(10)}.${cell.budgetHint.padEnd(3)} = ${cell.model.padEnd(28)} (${cell.source})`),
     ].join('\n');
     ctx.writeOutput({
         command: 'config.routing.get',
@@ -439,7 +473,7 @@ async function runRoutingUnset(args, ctx) {
         : `routing.${tag}.${budget} had no override (nothing to remove).`);
 }
 /* ------------------------------------------------------------------ */
-/* alpha 6.13 privacy 3-mode - config.privacy.* subcommands             */
+/* alpha 6.13 privacy 3-mode - config.privacy.* subcommands            */
 /* ------------------------------------------------------------------ */
 /**
  * Closed mirror of the server-side PRIVACY_MODES enum
@@ -459,7 +493,7 @@ function isPrivacyMode(value) {
  * Legacy local-config privacy values from before alpha 6.13. Kept so
  * `pugi config set privacy=local-only` continues to write to the local
  * config file (matching the bare-form behaviour). Triple-review P2 fix
- * (2026-05-25): the prior disambiguation only excluded the bare form;
+ * : the prior disambiguation only excluded the bare form;
  * the `=` form routed to runPrivacySet and 4xx'd on the unknown mode.
  */
 const LEGACY_LOCAL_PRIVACY_VALUES = [
@@ -536,7 +570,7 @@ async function runPrivacySet(args, ctx) {
  * — undici's `request` honours the global dispatcher reliably across the
  * pinned undici version. Kept local (not shared with `pugi whoami`) so
  * the routing surface is self-contained — extracting a common helper is
- * α6.10b cleanup once we see two callers.
+ * cleanup once we see two callers.
  */
 async function fetchJson(url, apiKey, options = {}) {
     const method = options.method ?? 'GET';

package/dist/runtime/commands/cost.js

@@ -0,0 +1,199 @@
+/**
+ * `pugi cost` / `pugi usage` command handler — L19 sprint .
+ *
+ * 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