@pugi/cli 0.1.0-alpha.3 → 0.1.0-alpha.5

package/dist/runtime/cli.js

@@ -16,7 +16,13 @@ import { globTool, grepTool, readTool } from '../tools/file-tools.js';
 import { toolRegistry, toolSchemaBundleHashInput } from '../tools/registry.js';
 import { emptyIndex, rebuildIndex, readIndex, upsertArtifact, writeIndex, } from '../core/index-store.js';
 import { buildRuntimeConfig, loadRuntimeConfig, pollDeviceFlow, pugiHandoffBundleSchema, pugiSyncDryRunPlanSchema, pugiSyncPrivacyModeSchema, pugiSyncRequestSchema, pugiSyncUploadPlanSchema, pugiTripleReviewRequestSchema, startDeviceFlow, submitSync, submitTripleReview, } from '@pugi/sdk';
+import { PUGI_TAGLINE } from '@pugi/personas';
 import { clearApiKey, DEFAULT_API_URL, listStoredCredentials, maskApiKey, normalizeApiUrl, purgeAllCredentials, readCredentialsFile, resolveActiveCredential, storeApiKey, switchActiveAccount, } from '../core/credentials.js';
+import { runJobsCommand } from '../commands/jobs.js';
+import { runConfigCommand } from './commands/config.js';
+import { runPrivacyCommand } from './commands/privacy.js';
+import { runUndoCommand } from './commands/undo.js';
+import { runBudgetCommand } from './commands/budget.js';
 /**
  * CLI version shown by `pugi version` and embedded in `pugi doctor --json`.
  *
@@ -32,8 +38,9 @@ const PUGI_CLI_VERSION = '0.1.0-alpha.1';
 const handlers = {
     accounts,
     build: runEngineTask('build_task'),
+    budget: dispatchBudget,
     code: runEngineTask('code'),
-    config: notImplemented('config'),
+    config: dispatchConfig,
     doctor,
     explain: runEngineTask('explain'),
     fix: runEngineTask('fix'),
@@ -41,20 +48,70 @@ const handlers = {
     help,
     idea,
     init,
+    jobs,
     login,
     logout,
     plan: runEngineTask('plan'),
-    privacy: notImplemented('privacy'),
+    privacy: dispatchPrivacy,
     review,
     resume,
     sessions,
     sync,
-    undo: notImplemented('undo'),
+    undo: dispatchUndo,
     version,
     whoami,
 };
+async function dispatchConfig(args, flags, _session) {
+    await runConfigCommand(args, {
+        workspaceRoot: process.cwd(),
+        json: flags.json,
+        writeOutput: (payload, text) => writeOutput(flags, payload, text),
+    });
+}
+async function dispatchPrivacy(args, flags, _session) {
+    await runPrivacyCommand(args, {
+        json: flags.json,
+        writeOutput: (payload, text) => writeOutput(flags, payload, text),
+    });
+}
+async function dispatchUndo(args, flags, session) {
+    await runUndoCommand(args, {
+        workspaceRoot: process.cwd(),
+        session,
+        writeOutput: (payload, text) => writeOutput(flags, payload, text),
+    });
+}
+async function dispatchBudget(args, flags, _session) {
+    await runBudgetCommand(args, {
+        workspaceRoot: process.cwd(),
+        writeOutput: (payload, text) => writeOutput(flags, payload, text),
+    });
+}
 export async function runCli(argv) {
-    const { command, args, flags } = parseArgs(argv);
+    const { command, args, flags, isBareInvocation } = parseArgs(argv);
+    // Bare `pugi` on a TTY enters the REPL-by-default agentic session
+    // (Sprint α5.7, ADR-0056). The REPL is the customer-facing surface
+    // that brings Pugi to parity with Claude Code / Codex CLI. When the
+    // operator has no credentials yet, we fall back to the α5.0 splash
+    // so the install-time `pugi` surface still shows the wordmark +
+    // quick-start hints. Non-TTY (CI, pipes, `--no-tty`) also falls
+    // through to the splash because the REPL needs raw input and SSE.
+    if (isBareInvocation && isInteractive(flags)) {
+        const runtimeConfig = resolveRuntimeConfig();
+        if (runtimeConfig) {
+            const { renderRepl } = await import('../tui/repl-render.js');
+            await renderRepl({
+                apiUrl: runtimeConfig.apiUrl,
+                apiKey: runtimeConfig.apiKey,
+                workspaceLabel: workspaceLabel(process.cwd()),
+                cliVersion: PUGI_CLI_VERSION,
+            });
+            return;
+        }
+        const { renderSplash } = await import('../tui/render.js');
+        await renderSplash(PUGI_CLI_VERSION);
+        return;
+    }
     const handler = handlers[command] ?? help;
     const session = openSession(process.cwd());
     recordCommandStarted(session, command);
@@ -80,6 +137,7 @@ function parseArgs(argv) {
         dryRun: false,
         triple: false,
         offline: false,
+        noTty: false,
     };
     const args = [];
     // Sprint 2E: `pugi --version` / `-v` are universal install-test conventions
@@ -87,10 +145,10 @@ function parseArgs(argv) {
     // the test block). Normalize them to the `version` command so users can
     // discover the CLI works without knowing our subcommand grammar.
     if (argv[0] === '--version' || argv[0] === '-v') {
-        return { command: 'version', args: [], flags };
+        return { command: 'version', args: [], flags, isBareInvocation: false };
     }
     if (argv[0] === '--help' || argv[0] === '-h') {
-        return { command: 'help', args: [], flags };
+        return { command: 'help', args: [], flags, isBareInvocation: false };
     }
     for (let index = 0; index < argv.length; index += 1) {
         const arg = argv[index] ?? '';
@@ -112,6 +170,9 @@ function parseArgs(argv) {
         else if (arg === '--offline') {
             flags.offline = true;
         }
+        else if (arg === '--no-tty') {
+            flags.noTty = true;
+        }
         else if (arg.startsWith('--privacy=')) {
             flags.privacy = parsePrivacyMode(arg.slice('--privacy='.length));
         }
@@ -126,10 +187,12 @@ function parseArgs(argv) {
             args.push(arg);
         }
     }
+    const isBareInvocation = args.length === 0;
     return {
         command: args.shift() ?? 'help',
         args,
         flags,
+        isBareInvocation,
     };
 }
 async function version(_args, flags, _session) {
@@ -144,7 +207,7 @@ async function help(_args, flags, _session) {
     writeOutput(flags, { commands }, [
         'Pugi CLI',
         '',
-        'Usage: pugi <command> [--json] [--web] [--remote]',
+        'Usage: pugi <command> [--json] [--web] [--remote] [--no-tty]',
         '',
         'Commands:',
         ...commands.map((command) => `  ${command}`),
@@ -163,6 +226,11 @@ async function help(_args, flags, _session) {
         'Sync safety:',
         '  pugi sync --dry-run --privacy metadata',
         '',
+        'Interactivity:',
+        '  --no-tty                Force the line-buffered output path (CI, pipes,',
+        '                          recording flows, dumb terminals).',
+        '',
+        PUGI_TAGLINE,
         'Execution defaults to local. Use --remote or --web to create a handoff bundle.',
     ].join('\n'));
 }
@@ -1711,17 +1779,30 @@ function parseProviderFlag(args) {
     return lower;
 }
 /**
- * Returns true when stdin is attached to a TTY AND `--json` was not
- * supplied. We only prompt interactively when the human is plausibly
- * looking at the screen. The two-condition gate matches Claude Code,
- * gh CLI, and Codex CLI conventions.
+ * Returns true when BOTH stdin and stdout are attached to a TTY AND
+ * `--json` / `--no-tty` / CI markers were not supplied. We only
+ * prompt or render Ink surfaces when a human is plausibly watching
+ * the screen. The multi-condition gate matches Claude Code, gh CLI,
+ * Codex CLI, and the npm CLI conventions.
  */
 function isInteractive(flags) {
     if (flags.json)
         return false;
-    // `process.stdin.isTTY` is `undefined` when stdin is a pipe (CI) and
-    // `true` when attached to a real terminal.
-    return Boolean(process.stdin.isTTY);
+    if (flags.noTty)
+        return false;
+    // Common CI / scripted-context markers. CI is set by every major
+    // provider (GitHub Actions, GitLab, CircleCI, Travis, Buildkite).
+    if (process.env.CI)
+        return false;
+    if (process.env.PUGI_NO_TTY)
+        return false;
+    // `process.stdin.isTTY` / `process.stdout.isTTY` are `undefined`
+    // when the stream is a pipe and `true` when attached to a real
+    // terminal. Require both so a `pugi | tee` invocation falls back
+    // to the line-buffered output path.
+    const stdinTty = Boolean(process.stdin.isTTY);
+    const stdoutTty = Boolean(process.stdout.isTTY);
+    return stdinTty && stdoutTty;
 }
 async function login(args, flags, _session) {
     if (args.includes('--help') || args.includes('-h')) {
@@ -1742,7 +1823,7 @@ async function login(args, flags, _session) {
             '  --provider env      Promote PUGI_API_KEY from the environment into the store.',
             '  --token <PAT>       Inline API key (visible in `ps`).',
             '  --token-stdin       Read API key from stdin (gh-CLI style).',
-            '  --label <name>      Friendly label for `pugi accounts list`.',
+            '  --label <name>      Short label surfaced in `pugi accounts list`.',
             '  --api-url <url>     Override the Anvil endpoint (self-hosted).',
             '  --no-device-flow    Refuse the device flow; fail fast in CI without a token.',
             '',
@@ -1818,6 +1899,14 @@ async function login(args, flags, _session) {
     // Path 4: interactive menu (TTY, not --json, no token args).
     if (isInteractive(flags)) {
         const choice = await promptLoginVariant(apiUrl);
+        if (choice === null) {
+            // User dismissed the picker via Esc / q. Use exit 130, the
+            // standard "terminated by user signal" exit code (gh CLI,
+            // codex, ssh, vim all use this).
+            writeOutput(flags, { status: 'cancelled' }, 'Login cancelled.');
+            process.exitCode = 130;
+            return;
+        }
         await dispatchLoginProvider(choice, {
             apiUrl,
             flags,
@@ -1826,39 +1915,31 @@ async function login(args, flags, _session) {
         });
         return;
     }
-    // Path 5: no token, no TTY → preserve existing behaviour (device flow
-    // unless explicitly opted out).
-    if (noDeviceFlow) {
-        throw new Error('pugi login requires a token under `--no-device-flow`. Pass `--token <PAT>`, pipe via `--token-stdin`, set PUGI_LOGIN_TOKEN, or use `--provider env` with PUGI_API_KEY exported.');
-    }
-    await performDeviceFlowLogin(apiUrl, flags, labelFlag);
+    // Path 5: no token, no TTY → previously fell through to a silent
+    // device flow that nobody could answer. The Ink-TUI work refuses
+    // that branch and raises a deterministic error so CI surfaces a
+    // failed login immediately. The message lists every escape hatch.
+    throw new Error('pugi login requires a token in non-interactive mode. Pass `--provider device|token|env`, `--token <PAT>`, pipe via `--token-stdin`, set PUGI_LOGIN_TOKEN, or use `--provider env` with PUGI_API_KEY exported.');
 }
 /**
- * Render the interactive picker shown when `pugi login` runs on a TTY
- * with no token args. Reads a single digit from stdin and returns the
- * provider keyword. Mirrors Claude Code's auth picker UX.
+ * Render the interactive Ink picker shown when `pugi login` runs on
+ * a TTY with no token args. Returns the chosen provider, or `null`
+ * when the user dismisses the picker via Esc / q. Mirrors the
+ * Claude Code / Codex CLI auth picker UX.
+ *
+ * The Ink import is dynamic so a non-interactive `pugi <anything>`
+ * never pays the React+Ink module-load cost. ESM dynamic-import is
+ * cached after first call (same as require).
  */
 async function promptLoginVariant(apiUrl) {
-    process.stderr.write([
-        '',
-        `How would you like to log in to Pugi? (endpoint: ${apiUrl})`,
-        '',
-        '  1) Browser-based OAuth (recommended) — opens app.pugi.io, you approve',
-        '  2) Paste an API key (PAT)',
-        '  3) Use PUGI_API_KEY from environment',
-        '',
-    ].join('\n'));
-    const answer = await readSingleChoice('Enter choice [1-3] (default 1): ');
-    switch (answer) {
-        case '':
-        case '1':
-            return 'device';
-        case '2':
-            return 'token';
-        case '3':
-            return 'env';
-        default:
-            throw new Error(`Invalid login choice "${answer}". Expected 1, 2, or 3.`);
+    const { renderLoginPicker, LoginCancelledError } = await import('../tui/render.js');
+    try {
+        return await renderLoginPicker(apiUrl);
+    }
+    catch (error) {
+        if (error instanceof LoginCancelledError)
+            return null;
+        throw error;
     }
 }
 /**
@@ -2441,7 +2522,7 @@ function formatResetSuffix(resetAtIso) {
  * Render the login-method label shown in `pugi whoami` and emitted in
  * the JSON envelope. Aliases the resolver's `source` discriminator (env
  * vs file) plus the stored `fileSource` (token vs device-flow vs env
- * promotion) into a single human-friendly word.
+ * promotion) into a single short word.
  */
 function describeLoginMethod(credential) {
     if (credential.source === 'env')
@@ -2604,6 +2685,22 @@ function extractApiUrlFlag(args) {
 function extractLabelFlag(args) {
     return extractNamedFlagValue(args, 'label');
 }
+/**
+ * `pugi jobs` — surface the persistent JobRegistry on the CLI.
+ * Sprint α5.9 (ADR-0056 PR-PUGI-CLI-M1-GAP-J). Subcommand parsing
+ * (list/status/tail/kill) lives in `src/commands/jobs.ts`; this
+ * handler is a thin shim so the existing command map dispatch
+ * remains the single entry point.
+ */
+async function jobs(args, flags, session) {
+    const exitCode = await runJobsCommand(args, { json: flags.json }, {
+        write: (text) => process.stdout.write(text),
+        writeError: (text) => process.stderr.write(text.endsWith('\n') ? text : `${text}\n`),
+    }, session.id);
+    if (exitCode !== 0) {
+        process.exitCode = exitCode;
+    }
+}
 function notImplemented(command) {
     return async (_args, flags) => {
         const payload = {
@@ -2632,6 +2729,21 @@ function ensurePugiGitIgnore(cwd, created, skipped) {
     writeFileSync(gitignorePath, next, { encoding: 'utf8' });
     created.push(`${gitignorePath} (+${marker})`);
 }
+/**
+ * Compute the workspace label surfaced in the REPL header bar
+ * (Sprint α5.7). We prefer the basename of the workspace root because
+ * that is what the operator sees in their shell prompt — keeping the
+ * REPL header in sync with `pwd` lets the operator orient at a glance.
+ * Empty / pathological cwd values (a worktree resolved to `/`) fall
+ * back to `workspace` so the header never collapses.
+ */
+function workspaceLabel(cwd) {
+    const segments = cwd.split('/').filter((s) => s.length > 0);
+    const last = segments[segments.length - 1];
+    if (!last || last.length === 0)
+        return 'workspace';
+    return last;
+}
 function ensureDir(path, created, skipped) {
     if (existsSync(path)) {
         skipped.push(path);

package/dist/runtime/commands/budget.js

@@ -0,0 +1,192 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+const RATE_INPUT_USD_PER_TOKEN = 0.000003;
+const RATE_OUTPUT_USD_PER_TOKEN = 0.000015;
+export async function runBudgetCommand(args, ctx) {
+    const flags = parseFlags(args);
+    const eventsPath = resolve(ctx.workspaceRoot, '.pugi/events.jsonl');
+    if (!existsSync(eventsPath)) {
+        ctx.writeOutput({
+            command: 'budget',
+            status: 'noop',
+            reason: 'no_session',
+            tokens: 0,
+            dollars: 0,
+        }, 'No session events found. Run a Pugi command first.');
+        return;
+    }
+    const events = readEvents(eventsPath);
+    const cutoff = flags.sinceMs === null ? 0 : Date.now() - flags.sinceMs;
+    const summary = summarise(events, cutoff);
+    const dollars = estimateDollars(summary.tokens);
+    const payload = {
+        command: 'budget',
+        status: 'ok',
+        workspaceRoot: ctx.workspaceRoot,
+        window: flags.sinceMs === null ? 'session' : `last ${args.find((a) => a.startsWith('--since='))?.slice('--since='.length) ?? ''}`,
+        tokens: summary.tokens,
+        dollars,
+        perCommand: summary.perCommand,
+        perPersona: summary.perPersona,
+        rate: {
+            inputUsdPerToken: RATE_INPUT_USD_PER_TOKEN,
+            outputUsdPerToken: RATE_OUTPUT_USD_PER_TOKEN,
+            assumedSplit: 'event log does not break tokens into in/out; rate uses output-token assumption',
+        },
+    };
+    const text = [
+        'Pugi budget',
+        `Window: ${payload.window}`,
+        `Tokens: ${summary.tokens}`,
+        `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`)
+                .join('\n')}`
+            : 'Per command: (no entries)',
+        summary.perPersona.length > 0
+            ? `Per persona:\n${summary.perPersona
+                .map((entry) => `  ${entry.persona.padEnd(20)} ${entry.tokens} tokens`)
+                .join('\n')}`
+            : 'Per persona: (no entries)',
+    ].join('\n');
+    ctx.writeOutput(payload, text);
+}
+function summarise(events, cutoffMs) {
+    let tokens = 0;
+    const perCommand = new Map();
+    const perPersona = new Map();
+    // Track the active command via command_started / command_completed
+    // bookends so we can attribute tool_result tokens to the surrounding
+    // command. Multiple commands per session are normal.
+    let activeCommand = null;
+    for (const event of events) {
+        if (!matchesWindow(event, cutoffMs))
+            continue;
+        if (event.type === 'session' && event.name === 'command_started' && typeof event.command === 'string') {
+            activeCommand = event.command;
+            continue;
+        }
+        if (event.type === 'session' && event.name === 'command_completed') {
+            activeCommand = null;
+            continue;
+        }
+        const eventTokens = extractTokens(event);
+        if (eventTokens > 0) {
+            tokens += eventTokens;
+            if (activeCommand) {
+                perCommand.set(activeCommand, (perCommand.get(activeCommand) ?? 0) + eventTokens);
+            }
+            const persona = extractPersona(event);
+            if (persona) {
+                perPersona.set(persona, (perPersona.get(persona) ?? 0) + eventTokens);
+            }
+        }
+    }
+    return {
+        tokens,
+        perCommand: Array.from(perCommand.entries())
+            .map(([command, value]) => ({ command, tokens: value }))
+            .sort((a, b) => b.tokens - a.tokens),
+        perPersona: Array.from(perPersona.entries())
+            .map(([persona, value]) => ({ persona, tokens: value }))
+            .sort((a, b) => b.tokens - a.tokens),
+    };
+}
+function matchesWindow(event, cutoffMs) {
+    if (cutoffMs === 0)
+        return true;
+    const ts = typeof event.timestamp === 'string' ? Date.parse(event.timestamp) : NaN;
+    if (!Number.isFinite(ts))
+        return false;
+    return ts >= 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.
+ *
+ * Unknown events return 0 so adding new event types upstream never
+ * breaks `pugi budget`.
+ */
+function extractTokens(event) {
+    const direct = numericField(event, 'tokensUsed');
+    if (direct > 0)
+        return direct;
+    const tIn = numericField(event, 'tokensIn');
+    const tOut = numericField(event, 'tokensOut');
+    if (tIn + tOut > 0)
+        return tIn + tOut;
+    return 0;
+}
+function numericField(event, key) {
+    const raw = event[key];
+    if (typeof raw !== 'number' || !Number.isFinite(raw) || raw < 0)
+        return 0;
+    return Math.floor(raw);
+}
+function extractPersona(event) {
+    const candidate = event['persona'] ?? event['personaSlug'] ?? event['subagent'];
+    if (typeof candidate === 'string' && candidate.length > 0)
+        return candidate;
+    return null;
+}
+function estimateDollars(totalTokens) {
+    // Use output-token rate as the worst case so a user planning to upgrade
+    // a tier is not surprised by an under-estimate.
+    return Number((totalTokens * RATE_OUTPUT_USD_PER_TOKEN).toFixed(6));
+}
+function parseFlags(args) {
+    const flags = { json: false, sinceMs: null };
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i] ?? '';
+        if (arg === '--json')
+            flags.json = true;
+        else if (arg.startsWith('--since='))
+            flags.sinceMs = parseDuration(arg.slice('--since='.length));
+        else if (arg === '--since') {
+            const value = args[i + 1];
+            if (!value)
+                throw new Error('--since requires a duration like 24h, 30m, or 7d.');
+            flags.sinceMs = parseDuration(value);
+            i += 1;
+        }
+    }
+    return flags;
+}
+function parseDuration(raw) {
+    const match = /^(\d+)(h|m|d|s)?$/.exec(raw.trim());
+    if (!match) {
+        throw new Error(`Invalid --since duration "${raw}". Expected forms: 24h, 30m, 7d, 90s.`);
+    }
+    const amount = Number(match[1]);
+    const unit = match[2] ?? 'h';
+    const multiplier = unit === 'h'
+        ? 60 * 60 * 1000
+        : unit === 'm'
+            ? 60 * 1000
+            : unit === 'd'
+                ? 24 * 60 * 60 * 1000
+                : 1000;
+    return amount * multiplier;
+}
+function readEvents(path) {
+    const raw = readFileSync(path, 'utf8');
+    const lines = raw.split('\n').filter((line) => line.trim().length > 0);
+    const out = [];
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                out.push(parsed);
+            }
+        }
+        catch {
+            // partial-write lines are ignored
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=budget.js.map