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

package/dist/tui/agent-tree.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function AgentTree(props) {
+    if (props.agents.length === 0) {
+        return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: "No agents on watch. Type a brief to dispatch one." }) }));
+    }
+    const now = props.nowEpochMs ?? Date.now();
+    return (_jsx(Box, { flexDirection: "column", children: props.agents.map((agent, index) => (_jsx(AgentRow, { agent: agent, last: index === props.agents.length - 1, nowEpochMs: now }, agent.taskId))) }));
+}
+function AgentRow({ agent, last, nowEpochMs, }) {
+    const branch = last ? '└' : '├';
+    const glyph = statusGlyph(agent.status);
+    const glyphColor = statusColor(agent.status);
+    const elapsed = formatElapsed(agent.startedAtEpochMs, nowEpochMs);
+    const tokens = formatTokens(agent.tokensIn + agent.tokensOut);
+    const name = agent.personaName.padEnd(8, ' ');
+    const role = agent.role.padEnd(10, ' ');
+    const detail = agent.detail.length > 60 ? `${agent.detail.slice(0, 57)}…` : agent.detail;
+    return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: ` ${branch} ` }), _jsx(Text, { bold: true, children: `${name}` }), _jsx(Text, { dimColor: true, children: ` ${role} ` }), _jsx(Text, { color: glyphColor, children: glyph }), _jsx(Text, { children: ` ${detail}` }), _jsx(Text, { dimColor: true, children: `  (${elapsed}${tokens ? ` · ↓ ${tokens}` : ''})` })] }));
+}
+function statusGlyph(status) {
+    switch (status) {
+        case 'queued':
+            return '□';
+        case 'thinking':
+            return '⏳';
+        case 'shipped':
+            return '✓';
+        case 'blocked':
+            return '✗';
+        case 'failed':
+            return '✗';
+    }
+}
+function statusColor(status) {
+    switch (status) {
+        case 'queued':
+            return undefined;
+        case 'thinking':
+            return 'cyan';
+        case 'shipped':
+            return 'green';
+        case 'blocked':
+            return 'yellow';
+        case 'failed':
+            return 'red';
+    }
+}
+function formatElapsed(startedAtEpochMs, nowEpochMs) {
+    const ms = Math.max(0, nowEpochMs - startedAtEpochMs);
+    if (ms < 60_000)
+        return `${Math.floor(ms / 1000)}s`;
+    const minutes = Math.floor(ms / 60_000);
+    const seconds = Math.floor((ms % 60_000) / 1000);
+    return `${minutes}m ${seconds.toString().padStart(2, '0')}s`;
+}
+function formatTokens(total) {
+    if (total <= 0)
+        return '';
+    if (total < 1_000)
+        return total.toString();
+    if (total < 1_000_000)
+        return `${(total / 1_000).toFixed(1)}k`;
+    return `${(total / 1_000_000).toFixed(1)}m`;
+}
+//# sourceMappingURL=agent-tree.js.map

package/dist/tui/conversation-pane.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+const HUE_COLOR_BY_SLUG = {
+    // Mira (Pug) - coordinator
+    main: 'cyan',
+    // Olivia (Honeybee) - release
+    pm: 'yellow',
+    // Marcus (Owl)
+    architect: 'magenta',
+    // Hiroshi (Wolf) - lead dev
+    dev: 'blueBright',
+    // Mia (Hummingbird) - frontend
+    frontend: 'magentaBright',
+    // Vera (Fox) - QA
+    qa: 'red',
+    // Diego (Octopus) - devops
+    devops: 'cyan',
+    // Sofia (Stag) - designer
+    designer: 'green',
+    // Anika (Raven) - researcher
+    researcher: 'gray',
+    // Liam (Spider) - analyst
+    analyst: 'gray',
+};
+export function ConversationPane(props) {
+    if (props.rows.length === 0) {
+        return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: "Brief the workforce to begin. Try a short sentence or /help." }) }));
+    }
+    return (_jsx(Box, { flexDirection: "column", children: props.rows.map((row) => (_jsx(ConversationRow, { row: row, personaNames: props.personaNames }, row.id))) }));
+}
+function ConversationRow({ row, personaNames, }) {
+    switch (row.source) {
+        case 'operator':
+            return (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: '› ' }), _jsx(Text, { children: row.text })] }));
+        case 'system':
+            return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '· ' }), _jsx(Text, { dimColor: true, children: row.text })] }));
+        case 'persona': {
+            const slug = row.personaSlug ?? '';
+            const color = HUE_COLOR_BY_SLUG[slug] ?? 'white';
+            const displayName = personaNames?.get(slug) ?? slug;
+            return (_jsxs(Box, { children: [_jsx(Text, { color: color, bold: true, children: `▸ ${displayName} ` }), _jsx(Text, { children: row.text })] }));
+        }
+    }
+}
+//# sourceMappingURL=conversation-pane.js.map

package/dist/tui/input-box.js

@@ -0,0 +1,91 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * REPL input box - Sprint α5.7 (ADR-0056 acceptance #5, #9).
+ *
+ * Single-line input with:
+ *   - history navigation (↑/↓)
+ *   - slash command palette suggestion when the line starts with `/`
+ *   - Enter submits the line
+ *   - Esc clears the current line
+ *   - Ctrl+C once cancels current line; twice within 1s exits the REPL
+ *
+ * The component owns the cursor + history state. Submission is passed
+ * to the REPL root via the `onSubmit` callback; the root forwards to
+ * `ReplSession.handleInput`. Ctrl+C double-tap is also surfaced via a
+ * dedicated `onExit` callback so the REPL root can stop Ink and let
+ * the runtime exit gracefully.
+ */
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { matchSlashPrefix } from '../core/repl/slash-commands.js';
+const CTRL_C_DOUBLE_TAP_MS = 1_000;
+export function InputBox(props) {
+    const [line, setLine] = useState(props.initial ?? '');
+    const [history, setHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const [lastCtrlCAt, setLastCtrlCAt] = useState(undefined);
+    const now = props.now ?? Date.now;
+    useInput((input, key) => {
+        if (key.ctrl && input === 'c') {
+            const t = now();
+            if (typeof lastCtrlCAt === 'number' && t - lastCtrlCAt <= CTRL_C_DOUBLE_TAP_MS) {
+                props.onExit();
+                return;
+            }
+            setLastCtrlCAt(t);
+            setLine('');
+            return;
+        }
+        if (key.return) {
+            const trimmed = line.trim();
+            if (trimmed.length > 0) {
+                setHistory((prev) => [...prev, trimmed]);
+                setHistoryIndex(-1);
+                props.onSubmit(trimmed);
+            }
+            setLine('');
+            return;
+        }
+        if (key.escape) {
+            setLine('');
+            setHistoryIndex(-1);
+            return;
+        }
+        if (key.upArrow) {
+            if (history.length === 0)
+                return;
+            const nextIndex = historyIndex === -1 ? history.length - 1 : Math.max(0, historyIndex - 1);
+            setHistoryIndex(nextIndex);
+            setLine(history[nextIndex] ?? '');
+            return;
+        }
+        if (key.downArrow) {
+            if (history.length === 0)
+                return;
+            if (historyIndex === -1)
+                return;
+            const nextIndex = historyIndex + 1;
+            if (nextIndex >= history.length) {
+                setHistoryIndex(-1);
+                setLine('');
+                return;
+            }
+            setHistoryIndex(nextIndex);
+            setLine(history[nextIndex] ?? '');
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setLine((prev) => prev.slice(0, -1));
+            return;
+        }
+        if (input && !key.meta && !key.ctrl) {
+            // Ink's typing surface delivers one or more characters per
+            // event; concatenate without filtering so non-Latin and emoji
+            // sequences (the operator's own brief copy) survive paste.
+            setLine((prev) => prev + input);
+        }
+    });
+    const palette = line.startsWith('/') ? matchSlashPrefix(line) : [];
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '› ' }), _jsx(Text, { children: line }), _jsx(Text, { color: "cyan", children: '_' })] }), palette.length > 0 ? (_jsx(Box, { flexDirection: "column", marginTop: 0, children: palette.map((row) => (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: `  /${row.name}${row.args ? ` ${row.args}` : ''}`.padEnd(22, ' ') }), _jsx(Text, { dimColor: true, children: row.gloss })] }, row.name))) })) : null, _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '↑/↓ history  ·  / commands  ·  Enter brief  ·  Esc cancel  ·  Ctrl+C ×2 exit' }) })] }));
+}
+//# sourceMappingURL=input-box.js.map

package/dist/tui/login-picker.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+const ITEMS = [
+    {
+        provider: 'device',
+        title: 'Browser OAuth',
+        hint: 'Opens app.pugi.io in your browser to approve this device',
+    },
+    {
+        provider: 'token',
+        title: 'API key',
+        hint: 'Paste a personal access token (pugi.io/settings/api-keys)',
+    },
+    {
+        provider: 'env',
+        title: 'Environment variable',
+        hint: 'Use PUGI_API_KEY from the current shell',
+    },
+];
+/**
+ * Arrow-key login picker. Driven entirely by Ink's `useInput`. The
+ * component does NOT perform the OAuth flow itself, it only resolves
+ * the selected provider back to the caller (CLI dispatcher), which
+ * then unmounts Ink and hands control to the existing handlers in
+ * runtime/cli.ts.
+ */
+export function LoginPicker(props) {
+    const [index, setIndex] = useState(Math.min(Math.max(props.initialIndex ?? 0, 0), ITEMS.length - 1));
+    useInput((input, key) => {
+        if (key.upArrow || input === 'k') {
+            setIndex((current) => (current === 0 ? ITEMS.length - 1 : current - 1));
+            return;
+        }
+        if (key.downArrow || input === 'j') {
+            setIndex((current) => (current === ITEMS.length - 1 ? 0 : current + 1));
+            return;
+        }
+        if (key.return) {
+            const selected = ITEMS[index];
+            if (selected)
+                props.onSelect(selected.provider);
+            return;
+        }
+        if (key.escape || input === 'q') {
+            props.onCancel();
+            return;
+        }
+        // Number shortcuts mirror the legacy text picker for muscle memory.
+        if (input === '1')
+            props.onSelect('device');
+        if (input === '2')
+            props.onSelect('token');
+        if (input === '3')
+            props.onSelect('env');
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Sign in to Pugi" }), _jsx(Text, { dimColor: true, children: `      (endpoint: ${props.apiUrl})` })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: ITEMS.map((item, itemIndex) => {
+                    const isSelected = itemIndex === index;
+                    return (_jsx(PickerRow, { isSelected: isSelected, title: item.title, hint: item.hint }, item.provider));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: '↑/↓ select   Enter confirm   Esc cancel' }) })] }));
+}
+function PickerRow({ isSelected, title, hint, }) {
+    // Arrow glyph + padded title so highlighted and dim rows share
+    // column alignment.
+    const indicator = isSelected ? '▸ ' : '  ';
+    const padded = title.padEnd(22, ' ');
+    return (_jsxs(Text, { children: [_jsxs(Text, { color: isSelected ? 'cyan' : undefined, bold: isSelected, children: [indicator, padded] }), _jsx(Text, { dimColor: true, children: hint })] }));
+}
+//# sourceMappingURL=login-picker.js.map

package/dist/tui/render.js

@@ -0,0 +1,68 @@
+import React from 'react';
+import { render } from 'ink';
+import { LoginPicker } from './login-picker.js';
+import { Splash } from './splash.js';
+import { collectSplashData } from './splash-data.js';
+/**
+ * Mount `<Splash />` on a TTY, await unmount, return. The CLI
+ * dispatcher only reaches this entry point when `isInteractive()`
+ * already cleared.
+ */
+export async function renderSplash(cliVersion) {
+    const data = collectSplashData({ cliVersion });
+    const instance = render(React.createElement(Splash, { data }));
+    // The splash is static: nothing reads input, nothing animates. Defer
+    // the unmount one macrotask so Ink's log-update flush, Yoga layout
+    // settle, and the initial process.stdout.write all complete before
+    // we tear the runtime down. Without setImmediate, some terminals
+    // batch writes and lose the splash frame entirely on fast exit.
+    await new Promise((resolve) => setImmediate(resolve));
+    instance.unmount();
+    await instance.waitUntilExit();
+}
+/**
+ * Sentinel thrown when the user dismisses the login picker via Esc
+ * or `q`. The CLI dispatcher catches it, prints a one-line abort
+ * message, and exits 130 (the standard exit code for SIGINT-style
+ * user cancellations — matches gh CLI, codex, claude-code).
+ */
+export class LoginCancelledError extends Error {
+    constructor() {
+        super('Login cancelled');
+        this.name = 'LoginCancelledError';
+    }
+}
+/**
+ * Mount `<LoginPicker />`, resolve to the chosen provider. Rejects
+ * with `LoginCancelledError` when the user cancels.
+ *
+ * After selection we call `unmount()` and resolve on the next
+ * macrotask. We deliberately do NOT chain `waitUntilExit()` — under
+ * some shimmed-stdin scenarios (CI test harnesses) Ink's
+ * `waitUntilExit` never settles because its raw-mode-release path
+ * waits on a stdin event that never fires. The next handler in the
+ * CLI dispatcher restores stdin state on its own (the device flow
+ * forks a browser, the token path attaches a fresh data listener).
+ */
+export function renderLoginPicker(apiUrl) {
+    return new Promise((resolveProvider, rejectProvider) => {
+        let settled = false;
+        const finish = (cb) => {
+            if (settled)
+                return;
+            settled = true;
+            instance.unmount();
+            setImmediate(cb);
+        };
+        const instance = render(React.createElement(LoginPicker, {
+            apiUrl,
+            onSelect: (provider) => {
+                finish(() => resolveProvider(provider));
+            },
+            onCancel: () => {
+                finish(() => rejectProvider(new LoginCancelledError()));
+            },
+        }));
+    });
+}
+//# sourceMappingURL=render.js.map

package/dist/tui/repl-render.js

@@ -0,0 +1,218 @@
+/**
+ * Production REPL mount + transport - Sprint α5.7.
+ *
+ * Owns the Ink mount lifecycle for `<Repl />` and wires the real
+ * fetch + SSE transport. The CLI dispatcher in `runtime/cli.ts` calls
+ * `renderRepl` on the bare-`pugi` path when stdin / stdout are TTYs.
+ *
+ * The transport speaks to admin-api:
+ *   POST /api/pugi/sessions             → { sessionId }
+ *   POST /api/pugi/sessions/:id/brief   → { dispatchId }
+ *   POST /api/pugi/sessions/:id/stop    → { stopped }
+ *   GET  /api/pugi/sessions/:id/stream  → text/event-stream
+ *
+ * SSE is parsed client-side from a streaming fetch response - Node 22
+ * native fetch returns a WHATWG `ReadableStream` which we feed through
+ * a tiny `event:`/`data:`/`id:` parser. This keeps the dependency
+ * graph at zero new packages.
+ */
+import React from 'react';
+import { render } from 'ink';
+import { Repl } from './repl.js';
+import { ReplSession } from '../core/repl/session.js';
+/**
+ * Mount the REPL and resolve when the user exits via Ctrl+C × 2 or
+ * `/quit`. The session is closed (server-side stays alive; resume via
+ * `pugi resume <sessionId>` once that command exists).
+ */
+export async function renderRepl(options) {
+    const transport = createProductionTransport();
+    const session = new ReplSession({
+        apiUrl: options.apiUrl,
+        apiKey: options.apiKey,
+        workspaceLabel: options.workspaceLabel,
+        cliVersion: options.cliVersion,
+        transport,
+    });
+    // Kick off the connect; the Repl renders the connecting state until
+    // the session pushes `connection: 'on_watch'` from the SSE onOpen.
+    void session.start();
+    const instance = render(React.createElement(Repl, { session }));
+    try {
+        await instance.waitUntilExit();
+    }
+    finally {
+        session.close();
+    }
+}
+/* ------------------------------------------------------------------ */
+/* Production transport                                               */
+/* ------------------------------------------------------------------ */
+function createProductionTransport() {
+    return {
+        async createSession({ apiUrl, apiKey }) {
+            const response = await fetch(joinUrl(apiUrl, '/api/pugi/sessions'), {
+                method: 'POST',
+                headers: jsonHeaders(apiKey),
+                body: JSON.stringify({}),
+            });
+            const json = await readJson(response);
+            const sessionId = json.sessionId;
+            if (typeof sessionId !== 'string' || sessionId.length === 0) {
+                throw new Error('admin-api did not return a sessionId');
+            }
+            return { sessionId };
+        },
+        async postBrief({ apiUrl, apiKey, sessionId, brief }) {
+            const response = await fetch(joinUrl(apiUrl, `/api/pugi/sessions/${encodeURIComponent(sessionId)}/brief`), {
+                method: 'POST',
+                headers: jsonHeaders(apiKey),
+                body: JSON.stringify({ brief }),
+            });
+            const json = await readJson(response);
+            const dispatchId = json.dispatchId;
+            if (typeof dispatchId !== 'string' || dispatchId.length === 0) {
+                throw new Error('admin-api did not return a dispatchId');
+            }
+            return { dispatchId };
+        },
+        async postStop({ apiUrl, apiKey, sessionId, persona }) {
+            const response = await fetch(joinUrl(apiUrl, `/api/pugi/sessions/${encodeURIComponent(sessionId)}/stop`), {
+                method: 'POST',
+                headers: jsonHeaders(apiKey),
+                body: JSON.stringify({ persona }),
+            });
+            const json = await readJson(response);
+            const stopped = Boolean(json.stopped);
+            return { stopped };
+        },
+        subscribe({ apiUrl, apiKey, sessionId, lastEventId, onEvent, onError, onOpen }) {
+            const controller = new AbortController();
+            const url = joinUrl(apiUrl, `/api/pugi/sessions/${encodeURIComponent(sessionId)}/stream`);
+            const headers = {
+                Accept: 'text/event-stream',
+                Authorization: `Bearer ${apiKey}`,
+            };
+            if (lastEventId) {
+                headers['Last-Event-ID'] = lastEventId;
+            }
+            void (async () => {
+                try {
+                    const response = await fetch(url, {
+                        method: 'GET',
+                        headers,
+                        signal: controller.signal,
+                    });
+                    if (!response.ok) {
+                        throw new Error(`HTTP ${response.status} on SSE stream`);
+                    }
+                    if (!response.body) {
+                        throw new Error('SSE response has no body');
+                    }
+                    onOpen();
+                    await consumeSseStream(response.body, onEvent);
+                    // Server closed the stream cleanly. Treat as an error so
+                    // the session reconnects (the spec says "transient
+                    // disconnect" - a clean close from the server side is also
+                    // transient because the operator may have toggled wifi).
+                    onError(new Error('SSE stream ended'));
+                }
+                catch (error) {
+                    if (controller.signal.aborted)
+                        return;
+                    onError(error instanceof Error ? error : new Error(String(error)));
+                }
+            })();
+            return {
+                close: () => controller.abort(),
+            };
+        },
+    };
+}
+/* ------------------------------------------------------------------ */
+/* SSE parser                                                         */
+/* ------------------------------------------------------------------ */
+/**
+ * Minimal SSE parser. Reads a UTF-8 stream of `id:` / `event:` / `data:`
+ * lines separated by blank lines. We only need the `data` payload (a
+ * JSON object) and the `id` field (so we can replay on reconnect via
+ * Last-Event-ID).
+ */
+async function consumeSseStream(body, onEvent) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let buffer = '';
+    let currentId = '';
+    let currentData = '';
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        let newlineIndex;
+        while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+            const rawLine = buffer.slice(0, newlineIndex).replace(/\r$/, '');
+            buffer = buffer.slice(newlineIndex + 1);
+            if (rawLine.length === 0) {
+                // Dispatch - only if we have a data payload.
+                if (currentData.length > 0) {
+                    try {
+                        const parsed = JSON.parse(currentData);
+                        onEvent(parsed, currentId);
+                    }
+                    catch {
+                        // Drop malformed frames silently - protocol-level
+                        // robustness is the controller's job, not the client's.
+                    }
+                }
+                currentData = '';
+                currentId = '';
+                continue;
+            }
+            if (rawLine.startsWith(':'))
+                continue; // Comment / keepalive.
+            const colonIndex = rawLine.indexOf(':');
+            const field = colonIndex === -1 ? rawLine : rawLine.slice(0, colonIndex);
+            const value = colonIndex === -1 ? '' : rawLine.slice(colonIndex + 1).replace(/^ /, '');
+            switch (field) {
+                case 'id':
+                    currentId = value;
+                    break;
+                case 'data':
+                    currentData = currentData.length === 0 ? value : `${currentData}\n${value}`;
+                    break;
+                case 'event':
+                case 'retry':
+                default:
+                    // We do not surface the `event:` name to the consumer - the
+                    // payload itself carries `type`. Future events that need
+                    // dispatcher-side routing without parsing JSON can wire
+                    // through this branch.
+                    break;
+            }
+        }
+    }
+}
+/* ------------------------------------------------------------------ */
+/* Small helpers                                                      */
+/* ------------------------------------------------------------------ */
+function jsonHeaders(apiKey) {
+    return {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+        Authorization: `Bearer ${apiKey}`,
+    };
+}
+async function readJson(response) {
+    if (!response.ok) {
+        const detail = await response.text().catch(() => '');
+        throw new Error(`HTTP ${response.status}${detail ? `: ${detail.slice(0, 200)}` : ''}`);
+    }
+    return response.json();
+}
+function joinUrl(base, path) {
+    const trimmedBase = base.endsWith('/') ? base.slice(0, -1) : base;
+    const trimmedPath = path.startsWith('/') ? path : `/${path}`;
+    return `${trimmedBase}${trimmedPath}`;
+}
+//# sourceMappingURL=repl-render.js.map