@tianmucreations/jeeves 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tianmucreations
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# Jeeves
+
+A plain-English terminal assistant: describe what you need in ordinary words and it reads files, writes files, lists folders, and runs commands for you - asking permission before anything that changes your computer.
+
+## Platforms
+
+Designed and built for **macOS, Windows, and Linux** from a single codebase.
+
+- macOS is fully verified.
+- Windows and Linux will be verified on those machines after the MVP, with any fixes applied to this same codebase - no platform forks.
+
+## Quick start (local development)
+
+1. Install Node.js 20 or later.
+2. `npm install`
+3. `npm run dev`
+
+On first launch you are asked for an OpenRouter API key, which is stored securely in your operating system's credential store (macOS Keychain, Windows Credential Vault, Linux Secret Service) - never in a plain file.
+
+## Keyboard
+
+Everything is visible on screen: arrow keys move, Enter selects, Esc goes back. `Tab` zooms a footer metric. `Ctrl+R` reveals the model's last reasoning. Slash commands: `/model`, `/keys`, `/verbose`.
+
+Jeeves takes over the whole terminal window (the same way vim does). The shell's own scrollback is unavailable while it runs, so the up and down arrows scroll the conversation instead - `Page Up` / `Page Down` jump a whole screen. When you quit, the terminal returns exactly as it was.
+
+## Providers
+
+- **OpenRouter (default).** One key unlocks 400+ models from every major provider. Get a key at [openrouter.ai/settings/keys](https://openrouter.ai/settings/keys). Repeat conversation context is cached (sticky routing), so long conversations cost a fraction of the fresh-token price.
+- **Z.ai — GLM Coding Plan.** A flat-rate option for heavy daily use: from $18/month, no per-token billing. Z.ai's endpoint speaks the Anthropic protocol and Jeeves connects to it directly. To use it: subscribe at [z.ai](https://z.ai) if you want the plan, copy your Z.ai API key, then in Jeeves type `/keys`, choose Z.ai, and paste the key. Pick Z.ai in `/model` and choose a GLM model (for example GLM-5.3). Subscribing is optional - Jeeves works fine with OpenRouter alone; this is simply a money-saving option for daily drivers.
+- **Ollama.** Local models, no key needed. Start the Ollama app first.
+
+API keys are stored in your operating system's credential store - never in a plain file.

package/bin/jeeves

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/agent/context.js

@@ -0,0 +1,50 @@
+import { session } from '../state/session.js';
+import { getActiveProvider } from '../providers/index.js';
+// Builds the message list for one turn; automatic summarisation of older turns (spec 3.3)
+// is deferred until long-conversation handling lands.
+export function buildTurnMessages(history, userText) {
+    const userMessage = { role: 'user', content: userText };
+    return [...history, userMessage];
+}
+// Condenses the whole conversation into a single summary message so a newly
+// selected model can continue without re-reading every turn.
+export async function summariseHistory() {
+    if (session.history.length === 0)
+        return;
+    session.setStatus('working');
+    try {
+        const provider = getActiveProvider();
+        const messages = [
+            ...session.history,
+            {
+                role: 'user',
+                content: 'Summarise this conversation so far as compact context a model can continue from. Reply with only the summary.',
+            },
+        ];
+        const result = await provider.stream({
+            modelId: session.model,
+            messages,
+            tools: {},
+            onToken: () => { },
+            onReasoning: () => { },
+            onToolCall: () => { },
+        });
+        const summary = result.text.trim();
+        if (summary) {
+            session.setHistory([
+                {
+                    role: 'user',
+                    content: `A summary of the conversation so far:\n\n${summary}\n\nContinue helping from this point.`,
+                },
+            ]);
+            session.addNotice('Conversation summarised for the new model.');
+        }
+        else {
+            session.addNotice('Could not summarise - kept the conversation as-is.');
+        }
+    }
+    catch {
+        session.addNotice('Could not summarise - kept the conversation as-is.');
+    }
+    session.setStatus('idle');
+}

package/dist/agent/errors.js

@@ -0,0 +1,41 @@
+function firstLine(text) {
+    const line = text.split('\n')[0].trim();
+    return line.length > 0 ? line : 'Something went wrong - please ask again.';
+}
+// Turns technical failures into plain English (Phase 9 polish).
+export function plainError(error) {
+    const raw = error instanceof Error ? error.message : String(error);
+    const text = raw.toLowerCase();
+    if (text.includes('no openrouter api key')) {
+        return { message: "There's no key yet - type /keys to add one.", kind: 'auth' };
+    }
+    if (text.includes('401') || text.includes('unauthorized') || text.includes('invalid api key') || text.includes('not authenticated')) {
+        return { message: "That key wasn't accepted - type /keys to check or replace it.", kind: 'auth' };
+    }
+    if (text.includes('402') || text.includes('insufficient') || text.includes('out of credit') || text.includes('quota')) {
+        return { message: 'OpenRouter credit ran out - top up at openrouter.ai/credits, then ask again.', kind: 'payment' };
+    }
+    if (text.includes('429') || text.includes('rate limit') || text.includes('rate_limit') || text.includes('too many requests')) {
+        return { message: 'OpenRouter is asking us to slow down - wait a few seconds and ask again.', kind: 'rate-limit' };
+    }
+    if (text.includes('fetch failed') ||
+        text.includes('network') ||
+        text.includes('enotfound') ||
+        text.includes('econnrefused') ||
+        text.includes('etimedout') ||
+        text.includes('timeout') ||
+        text.includes('eai_again') ||
+        text.includes('socket hang up')) {
+        return { message: 'Lost connection - please ask again in a moment.', kind: 'network' };
+    }
+    if (text.includes('model') && (text.includes('not found') || text.includes('404'))) {
+        return { message: "That model isn't available any more - type /model to pick another.", kind: 'model' };
+    }
+    if (text.includes('context') && (text.includes('length') || text.includes('too long'))) {
+        return {
+            message: 'This conversation grew too long for the model - type /model to switch, or /clear to start fresh.',
+            kind: 'context',
+        };
+    }
+    return { message: firstLine(raw), kind: 'other' };
+}

package/dist/agent/loop.js

@@ -0,0 +1,84 @@
+import { session } from '../state/session.js';
+import { getActiveProvider, refreshCredit } from '../providers/index.js';
+import { getTools } from '../tools/index.js';
+import { buildTurnMessages } from './context.js';
+import { plainError } from './errors.js';
+import { toggleVerbose } from '../commands/verbose.js';
+import { openModelPicker } from '../commands/model.js';
+import { clearConversation } from '../commands/clear.js';
+import { isToolCapable } from '../models/filter.js';
+const DISCONNECTING = new Set(['auth', 'network', 'payment']);
+export async function runTurn(input) {
+    if (input.startsWith('/') && input.length > 1 && !input.startsWith('/ ')) {
+        if (input === '/help') {
+            session.openHelp();
+        }
+        else if (input === '/model') {
+            openModelPicker();
+        }
+        else if (input === '/keys') {
+            session.openKeys();
+        }
+        else if (input === '/verbose') {
+            session.addNotice(toggleVerbose());
+        }
+        else if (input === '/clear') {
+            clearConversation();
+        }
+        else if (input === '/exit') {
+            session.requestExit();
+        }
+        else {
+            session.addNotice('Unknown command. Try /help.');
+        }
+        return;
+    }
+    session.addUser(input);
+    session.beginTurn();
+    session.setStatus('working');
+    let assistantId = null;
+    try {
+        const provider = getActiveProvider();
+        const messages = buildTurnMessages(session.history, input);
+        // Models without tool support get a tool-free chat mode automatically (spec 4.2).
+        const currentModel = session.models.find((model) => model.id === session.model);
+        const tools = !currentModel || isToolCapable(currentModel) ? getTools() : {};
+        const result = await provider.stream({
+            modelId: session.model,
+            messages,
+            tools,
+            onToken: (token) => {
+                if (assistantId === null)
+                    assistantId = session.startAssistant();
+                session.appendToken(assistantId, token);
+            },
+            onReasoning: (delta) => {
+                if (session.verbose)
+                    session.appendReasoning(delta);
+            },
+            onToolCall: () => {
+                // Hide pre-tool chatter so only the final answer stays visible (spec 2.3).
+                if (assistantId !== null)
+                    session.setAssistantText(assistantId, '');
+                session.closeReasoningEntry();
+            },
+        });
+        if (assistantId === null)
+            assistantId = session.startAssistant();
+        session.setAssistantText(assistantId, result.text);
+        session.finishAssistant(assistantId);
+        session.setHistory([...messages, ...result.messages]);
+        session.setLastReasoning(result.reasoning);
+        session.addUsage(result.usage.input, result.usage.output, result.cost, result.usage.cached ?? 0);
+        session.setRateLimit(result.rateLimit);
+        void refreshCredit();
+        session.setStatus('idle');
+    }
+    catch (error) {
+        const plain = plainError(error);
+        if (assistantId !== null)
+            session.finishAssistant(assistantId);
+        session.addError(plain.message);
+        session.setStatus(DISCONNECTING.has(plain.kind) ? 'disconnected' : 'idle');
+    }
+}

package/dist/agent/permissions.js

@@ -0,0 +1,27 @@
+import { session } from '../state/session.js';
+// Approvals are queued so that parallel tool calls never overwrite each other's prompt.
+// The amber transcript prompt itself is rendered by the tool line in 'awaiting' state.
+const queue = [];
+export function hasPendingApproval() {
+    return queue.length > 0;
+}
+export function requestApproval() {
+    return new Promise((resolve) => {
+        queue.push({ resolve });
+        if (queue.length === 1) {
+            session.setActiveApproval();
+        }
+    });
+}
+export function answerApproval(approved) {
+    const current = queue.shift();
+    if (!current)
+        return;
+    current.resolve(approved);
+    if (queue.length > 0) {
+        session.setActiveApproval();
+    }
+    else {
+        session.clearActiveApproval();
+    }
+}

package/dist/app.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect } from 'react';
+import { Box, Text, useStdout } from 'ink';
+import { Header } from './components/Header.js';
+import { Transcript } from './components/Transcript.js';
+import { Input } from './components/Input.js';
+import { Footer } from './components/Footer.js';
+import { session, useSession } from './state/session.js';
+import { initKeys, hasCredentials, refreshCredit } from './providers/index.js';
+import { getHiddenMetrics, getFavorites, getRecents, getRecentProjects, getDefaultModel, getDefaultProvider, getVerbosePreference } from './platform/config.js';
+import { loadModels } from './models/registry.js';
+import { ModelPicker } from './components/ModelPicker.js';
+import { KeysManager } from './components/KeysManager.js';
+import { HelpView } from './components/HelpView.js';
+import { ProjectPicker } from './components/ProjectPicker.js';
+// The whole frame is exactly the height of the terminal window, so nothing ever
+// scrolls away: the header is pinned at the top, the footer and input at the bottom,
+// and only the fixed-height transcript area in the middle re-clips its content.
+export function App() {
+    const s = useSession();
+    const { stdout } = useStdout();
+    const rows = Math.max(stdout.rows ?? 24, 8);
+    const columns = Math.max(stdout.columns ?? 80, 40);
+    const transcriptHeight = Math.max(1, rows - 7);
+    const innerWidth = columns - 4;
+    const separator = '─'.repeat(innerWidth);
+    useEffect(() => {
+        session.setHiddenMetrics(getHiddenMetrics());
+        session.setFavorites(getFavorites());
+        session.setRecents(getRecents());
+        session.setRecentProjects(getRecentProjects());
+        if (getVerbosePreference())
+            session.setVerbose(true);
+        const defaultModel = getDefaultModel();
+        if (defaultModel)
+            session.setModel(defaultModel);
+        const defaultProvider = getDefaultProvider();
+        if (defaultProvider)
+            session.setProvider(defaultProvider);
+        void loadModels().then(({ models, error }) => session.setModels(models, error));
+        // Keys resolve from the Mac keychain first; the first-run wizard now starts
+        // after the project is chosen (the project list always shows first).
+        void initKeys().then(() => {
+            if (hasCredentials()) {
+                void refreshCredit();
+            }
+            else {
+                session.setStatus('disconnected');
+            }
+        });
+    }, []);
+    if (s.wizardActive) {
+        return _jsx(KeysManager, { mode: "wizard", rows: rows, columns: columns });
+    }
+    if (s.keysOpen) {
+        return _jsx(KeysManager, { mode: "manage", rows: rows, columns: columns });
+    }
+    if (s.pickerOpen) {
+        return _jsx(ModelPicker, { rows: rows, columns: columns });
+    }
+    if (s.helpOpen) {
+        return _jsx(HelpView, { rows: rows });
+    }
+    if (s.launchStage === 'project') {
+        return _jsx(ProjectPicker, { rows: rows, columns: columns });
+    }
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", paddingX: 1, height: rows, children: [_jsx(Header, {}), _jsx(Transcript, { height: transcriptHeight, width: innerWidth }), _jsx(Text, { dimColor: true, children: separator }), _jsx(Input, { scrollPage: transcriptHeight }), _jsx(Text, { dimColor: true, children: separator }), _jsx(Footer, {})] }));
+}

package/dist/commands/clear.js

@@ -0,0 +1,9 @@
+import { session } from '../state/session.js';
+import { resetStickySession } from '../providers/openrouter.js';
+// Starts fresh: wipes the screen and the conversation the model remembers.
+export function clearConversation() {
+    session.clearTranscript();
+    session.setHistory([]);
+    session.setLastReasoning('');
+    resetStickySession();
+}

package/dist/commands/help.js

@@ -0,0 +1,17 @@
+export const COMMANDS = [
+    { command: '/help', description: 'show this list' },
+    { command: '/model', description: 'pick a different AI model' },
+    { command: '/keys', description: 'add or remove API keys' },
+    { command: '/verbose', description: "show the model's thinking on screen" },
+    { command: '/clear', description: 'start a fresh conversation and clear the screen' },
+    { command: '/exit', description: 'quit' },
+];
+export const KEY_BINDINGS = [
+    { command: 'up down', description: 'move in lists' },
+    { command: 'Enter', description: 'select' },
+    { command: 'Esc', description: 'go back' },
+    { command: 'Tab', description: 'zoom a footer bar' },
+    { command: 'Ctrl+R', description: "show the model's last thinking" },
+    { command: 'y / n', description: 'allow or deny a permission request' },
+    { command: 'arrows', description: 'scroll the conversation up and down; Page Up / Page Down jump a whole screen' },
+];

package/dist/commands/keys.js

@@ -0,0 +1,15 @@
+// Plain-English key helpers; the interactive screens live in KeysManager.
+export function keyLooksValid(key, provider) {
+    const trimmed = key.trim();
+    if (provider === 'openrouter' || provider === 'openrouter-management') {
+        return trimmed.startsWith('sk-or-') && trimmed.length >= 20;
+    }
+    return trimmed.length >= 20;
+}
+export function describeKeySource(source) {
+    if (source === 'keychain')
+        return 'key stored in your Mac keychain';
+    if (source === 'env')
+        return 'key in the .env development file';
+    return 'no key';
+}

package/dist/commands/model.js

@@ -0,0 +1,4 @@
+import { session } from '../state/session.js';
+export function openModelPicker() {
+    session.openPicker();
+}

package/dist/commands/verbose.js

@@ -0,0 +1,8 @@
+import { session } from '../state/session.js';
+import { setVerbosePreference } from '../platform/config.js';
+// Toggles the permanent reasoning trace; default is off (spec 2.3).
+export function toggleVerbose() {
+    session.setVerbose(!session.verbose);
+    setVerbosePreference(session.verbose);
+    return session.verbose ? 'Verbose reasoning: on' : 'Verbose reasoning: off';
+}

package/dist/components/AlternateScreen.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useInsertionEffect } from 'react';
+import { Box, useStdout } from 'ink';
+import { createRequire } from 'node:module';
+// signal-exit is the cleanup hook the mechanism prescribes: it runs on process
+// exit AND on every termination signal, before the default signal action - so
+// the terminal is handed back on every exit path: normal exit, Ctrl+C, SIGTERM,
+// hangup. Already present in the tree as Ink's own dependency; declared ours.
+const onSignalExit = createRequire(import.meta.url)('signal-exit');
+const CLEAR_SCREEN = '\x1b[2J';
+const HOME_CURSOR = '\x1b[H';
+const ERASE_SCROLLBACK = '\x1b[3J';
+const ENTER_ALT_SCREEN = '\x1b[?1049h';
+const LEAVE_ALT_SCREEN = '\x1b[?1049l';
+const HIDE_CURSOR = '\x1b[?25l';
+const SHOW_CURSOR = '\x1b[?25h';
+let altScreenActive = false;
+let cleanupRegistered = false;
+function write(data) {
+    try {
+        process.stdout.write(data);
+    }
+    catch {
+        // A closed stream must never crash the takeover or the exit path.
+    }
+}
+// Claude Code's Ink fork exposes this on the render instance; stock Ink has no
+// such method, so the notification lives here: the flag that says the alternate
+// screen owns the terminal, consulted by every exit path below.
+export function setAltScreenActive(active, mouseTracking) {
+    altScreenActive = active;
+    // Mouse tracking is deliberately left off: it would break click-drag text
+    // selection in Terminal.app, and the app already owns scrolling by key.
+    void mouseTracking;
+}
+// Hands the terminal back. Safe to call from anywhere, any number of times.
+export function leaveAltScreen() {
+    if (!altScreenActive)
+        return;
+    altScreenActive = false;
+    // 1049l restores the shell's screen; the scrollback erase follows because
+    // macOS Terminal.app archives the app's own frames into the scrollback the
+    // moment the alternate screen is handed back, and they must not linger.
+    write(LEAVE_ALT_SCREEN + ERASE_SCROLLBACK + SHOW_CURSOR);
+}
+// The terminal must be restored on every exit path. Registered once for the
+// whole process; the callback fires after Ink's own teardown (registered
+// earlier), so frame cleanup lands on the alternate screen before we leave it.
+function registerCleanup() {
+    if (cleanupRegistered)
+        return;
+    cleanupRegistered = true;
+    onSignalExit(() => leaveAltScreen(), { alwaysLast: false });
+}
+export function AlternateScreen({ children }) {
+    const { stdout } = useStdout();
+    // Entered once, before the first frame. Claude Code's order is erase
+    // scrollback, clear, home, switch - but macOS Terminal.app implements the
+    // clear (2J) by pushing the cleared screen INTO the scrollback, so erasing
+    // first lets the shell's last screen survive as scrollable history (measured:
+    // the banner came back on scroll). Clearing first and erasing the scrollback
+    // second kills both the old history and the clear's own snapshot; on terminals
+    // that clear without archiving, both orders are equivalent. The cursor is
+    // hidden for the same reason Ink's own mode hides it.
+    useInsertionEffect(() => {
+        write(CLEAR_SCREEN + HOME_CURSOR + ERASE_SCROLLBACK + ENTER_ALT_SCREEN + HIDE_CURSOR);
+        setAltScreenActive(true, false);
+        registerCleanup();
+    }, []);
+    const rows = Math.max(stdout.rows ?? 24, 8);
+    // The alternate screen has no native scrollback, so the app owns its own
+    // scrolling: everything is constrained to the terminal's row count.
+    return (_jsx(Box, { height: rows, flexDirection: "column", overflow: "hidden", children: children }));
+}

package/dist/components/Footer.js

@@ -0,0 +1,114 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+import { useSession, DEFAULT_CONTEXT_TOKENS } from '../state/session.js';
+import { UsageBar, usageFraction, usageColor, benefitColor } from './UsageBar.js';
+export function shortModelName(model) {
+    const short = model.split('/').pop();
+    return short && short.length > 0 ? short : model;
+}
+export function compactNumber(value) {
+    if (value >= 1_000_000)
+        return `${(value / 1_000_000).toFixed(1)}M`;
+    if (value >= 1000)
+        return `${(value / 1000).toFixed(1)}k`;
+    return `${Math.round(value)}`;
+}
+function pct(fraction) {
+    return `${Math.round(fraction * 100)}%`;
+}
+function forecastContext(contextTokens, tokensPerMinute) {
+    if (tokensPerMinute <= 0 || contextTokens <= 0)
+        return '';
+    const minutes = (DEFAULT_CONTEXT_TOKENS - contextTokens) / tokensPerMinute;
+    if (minutes <= 0 || minutes > 600)
+        return '';
+    return `~${Math.max(1, Math.round(minutes))}m left`;
+}
+function forecastRateReset(resetEpochSeconds) {
+    if (!resetEpochSeconds)
+        return '';
+    const seconds = resetEpochSeconds - Date.now() / 1000;
+    if (seconds <= 0 || seconds > 3600)
+        return '';
+    return `resets in ${Math.max(1, Math.round(seconds / 60))}m`;
+}
+export function Footer() {
+    const s = useSession();
+    const contextTokens = s.estimateContextTokens();
+    const tpm = s.tokensPerMinute();
+    const cacheRate = s.cacheHitRate();
+    if (s.footerExpanded !== null) {
+        let bar = {
+            label: 'context',
+            value: contextTokens,
+            max: DEFAULT_CONTEXT_TOKENS,
+            suffix: forecastContext(contextTokens, tpm),
+        };
+        if (s.footerExpanded === 'session') {
+            bar = { label: 'session', value: s.tokensIn + s.tokensOut, max: DEFAULT_CONTEXT_TOKENS, suffix: '' };
+        }
+        else if (s.footerExpanded === 'cache' && cacheRate !== null) {
+            bar = {
+                label: 'cache',
+                value: s.tokensCached,
+                max: s.tokensIn,
+                unit: 'of input read from cache',
+                suffix: '',
+                goodWhenFull: true,
+            };
+        }
+        else if (s.footerExpanded === 'today' && s.spend > 0 && s.creditLimit) {
+            bar = { label: 'today', value: s.spend, max: s.creditLimit, suffix: '' };
+        }
+        else if (s.footerExpanded === 'credit' && s.creditRemaining !== null && s.creditLimit) {
+            bar = {
+                label: 'credit',
+                value: s.creditLimit - s.creditRemaining,
+                max: s.creditLimit,
+                unit: 'used',
+                suffix: `· $${s.creditRemaining.toFixed(2)} ${s.creditIsAccount ? 'left' : 'key cap'}`,
+            };
+        }
+        else if (s.footerExpanded === 'speed' && s.rateLimit && s.rateLimit.limit > 0) {
+            bar = {
+                label: 'speed',
+                value: s.rateLimit.limit - s.rateLimit.remaining,
+                max: s.rateLimit.limit,
+                suffix: forecastRateReset(s.rateLimit.reset),
+            };
+        }
+        return (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { dimColor: true, children: shortModelName(s.model) }), _jsxs(Text, { dimColor: true, children: [_jsx(UsageBar, { label: bar.label, value: bar.value, max: bar.max, unit: bar.unit, width: 20, goodWhenFull: bar.goodWhenFull }), bar.suffix ? _jsxs(Text, { dimColor: true, children: [" ", bar.suffix] }) : null] })] }));
+    }
+    // The compact view shows every metric at all times - nothing needs a key press.
+    const sessionFraction = usageFraction(s.tokensIn + s.tokensOut, DEFAULT_CONTEXT_TOKENS);
+    const contextFraction = usageFraction(contextTokens, DEFAULT_CONTEXT_TOKENS);
+    const segments = [
+        {
+            key: 'session',
+            render: _jsxs(Text, { color: usageColor(sessionFraction), children: ["sess ", pct(sessionFraction)] }),
+        },
+        {
+            key: 'context',
+            render: _jsxs(Text, { color: usageColor(contextFraction), children: ["ctx ", pct(contextFraction)] }),
+        },
+        {
+            key: 'cache',
+            render: cacheRate === null ? (_jsx(Text, { children: "cache \u2014" })) : (_jsxs(Text, { color: benefitColor(cacheRate), children: ["cache ", pct(cacheRate)] })),
+        },
+        {
+            key: 'today',
+            render: _jsxs(Text, { children: ["today $", s.spend.toFixed(2)] }),
+        },
+        {
+            key: 'credit',
+            render: (_jsx(Text, { children: s.creditRemaining !== null
+                    ? s.creditIsAccount
+                        ? `$${s.creditRemaining.toFixed(2)} left`
+                        : `$${s.creditRemaining.toFixed(2)} key cap`
+                    : '$— left' })),
+        },
+    ];
+    const visible = segments.filter((segment) => !s.hiddenMetrics.includes(segment.key));
+    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { dimColor: true, children: shortModelName(s.model) }), _jsxs(Text, { dimColor: true, children: [visible.map((segment, index) => (_jsxs(React.Fragment, { children: [index > 0 ? ' · ' : null, segment.render] }, segment.key))), visible.length > 0 ? ' · ' : null, _jsxs(Text, { children: [compactNumber(tpm), " tpm"] })] })] }));
+}

package/dist/components/Header.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { TrafficLight } from './TrafficLight.js';
+export function Header() {
+    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: "cyan", children: "Jeeves" }), _jsx(TrafficLight, {})] }));
+}

package/dist/components/HelpView.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import { useSession } from '../state/session.js';
+import { COMMANDS, KEY_BINDINGS } from '../commands/help.js';
+// Plain-English help; every command and key is visible with a one-line description.
+export function HelpView({ rows }) {
+    const s = useSession();
+    useInput((input, key) => {
+        if (key.escape || key.return) {
+            s.closeHelp();
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", height: rows, children: [_jsx(Text, { dimColor: true, children: "Help - what you can type" }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, justifyContent: "center", children: [_jsx(Text, { children: "Commands" }), COMMANDS.map((entry) => (_jsxs(Text, { children: [_jsx(Text, { children: ' ' + entry.command.padEnd(9) }), _jsx(Text, { dimColor: true, children: entry.description })] }, entry.command))), _jsx(Text, { children: " " }), _jsx(Text, { children: "Keys" }), KEY_BINDINGS.map((entry) => (_jsxs(Text, { children: [_jsx(Text, { children: ' ' + entry.command.padEnd(9) }), _jsx(Text, { dimColor: true, children: entry.description })] }, entry.command))), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "Type anything else in plain English and press Enter - that's all you need." })] }), _jsx(Text, { dimColor: true, children: "Esc close" })] }));
+}