@tianmucreations/jeeves 0.2.0

package/dist/components/ProjectPicker.js

@@ -0,0 +1,334 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import Fuse from 'fuse.js';
+import { existsSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import { session, useSession } from '../state/session.js';
+import { setRecentProjects } from '../platform/config.js';
+import { homeLocations, listSubfolders, displayPath, projectNameProblem } from '../platform/paths.js';
+import { hasCredentials } from '../providers/index.js';
+// The cursor skips header lines; every other row is selectable.
+function resolveIndex(items, cursor) {
+    const start = cursor < 0 ? 0 : cursor;
+    for (let i = start; i < items.length; i++) {
+        if (items[i].kind !== 'header')
+            return i;
+    }
+    for (let i = Math.min(start, items.length - 1); i >= 0; i--) {
+        if (items[i].kind !== 'header')
+            return i;
+    }
+    return -1;
+}
+function stepItem(items, from, delta) {
+    let i = from;
+    do {
+        i += delta;
+    } while (i >= 0 && i < items.length && items[i].kind === 'header');
+    return i >= 0 && i < items.length ? i : from;
+}
+function fuzzyFolders(pool, query) {
+    if (!query)
+        return pool;
+    const fuse = new Fuse(pool, { keys: ['name'], threshold: 0.4 });
+    return fuse.search(query).map((result) => result.item);
+}
+export function ProjectPicker({ rows, columns }) {
+    const s = useSession();
+    const [mode, setMode] = useState('list');
+    const [purpose, setPurpose] = useState('open');
+    const [stack, setStack] = useState([]);
+    const [filter, setFilter] = useState('');
+    const [cursor, setCursor] = useState(0);
+    const [createName, setCreateName] = useState('');
+    const [createTarget, setCreateTarget] = useState(null);
+    const [note, setNote] = useState('');
+    const listHeight = Math.max(1, rows - 4);
+    const current = stack.length > 0 ? stack[stack.length - 1] : null;
+    // Reading a folder is synchronous and fast, so both the listing and the menu are pure calculations.
+    const listing = useMemo(() => {
+        if (mode !== 'browse' || current === null)
+            return { folders: [], error: '' };
+        return listSubfolders(current);
+    }, [mode, current]);
+    const items = useMemo(() => {
+        if (mode === 'list') {
+            const recents = s.recentProjects.filter((folder) => existsSync(folder));
+            const out = [];
+            if (recents.length > 0) {
+                out.push({ kind: 'header', label: 'Recent projects' });
+                for (const folder of recents)
+                    out.push({ kind: 'recent', folder });
+            }
+            else {
+                out.push({ kind: 'header', label: 'No recent projects yet - pick Browse below' });
+            }
+            out.push({ kind: 'browse' }, { kind: 'create' });
+            return out;
+        }
+        if (mode === 'browse') {
+            const out = [];
+            if (current !== null) {
+                out.push({ kind: 'back' });
+                out.push(purpose === 'create' ? { kind: 'create-here' } : { kind: 'choose' });
+                for (const entry of fuzzyFolders(listing.folders, filter))
+                    out.push({ kind: 'folder', entry });
+            }
+            else {
+                for (const entry of fuzzyFolders(homeLocations(), filter))
+                    out.push({ kind: 'folder', entry });
+            }
+            return out;
+        }
+        if (mode === 'create-location') {
+            const out = [];
+            for (const entry of homeLocations())
+                out.push({ kind: 'location', entry });
+            out.push({ kind: 'browse' });
+            return out;
+        }
+        return [];
+    }, [mode, purpose, current, listing, filter, s.recentProjects]);
+    const resolved = resolveIndex(items, cursor);
+    const half = Math.floor(listHeight / 2);
+    const start = Math.max(0, Math.min(items.length - listHeight, resolved - half));
+    const visible = items.slice(start, start + listHeight);
+    function startProject(folder) {
+        try {
+            process.chdir(folder);
+        }
+        catch {
+            // Staying in the current folder is the safe fallback.
+        }
+        const updated = [folder, ...session.recentProjects.filter((p) => p !== folder)].slice(0, 10);
+        session.setRecentProjects(updated);
+        setRecentProjects(updated);
+        session.launchComplete();
+        session.addNotice(`Now working in ${displayPath(folder)}.`);
+        if (!hasCredentials()) {
+            session.startWizard(true);
+        }
+        else {
+            session.openPicker();
+        }
+    }
+    async function createProject(folder) {
+        try {
+            await mkdir(folder, { recursive: true });
+            startProject(folder);
+        }
+        catch {
+            setNote('That location could not be written to - pick another.');
+            setMode('create-location');
+        }
+    }
+    function goBack() {
+        setFilter('');
+        setCursor(0);
+        setNote('');
+        if (stack.length > 1) {
+            setStack(stack.slice(0, -1));
+            return;
+        }
+        if (stack.length === 1) {
+            setStack([]);
+            return;
+        }
+        if (mode === 'browse' && purpose === 'create') {
+            setMode('create-location');
+            setPurpose('open');
+            return;
+        }
+        setMode('list');
+    }
+    function openFolder(folder) {
+        setFilter('');
+        setCursor(0);
+        setStack([...stack, folder]);
+    }
+    function startCreate() {
+        setCreateName('');
+        setNote('');
+        setCursor(0);
+        setMode('create-name');
+    }
+    function clip(text) {
+        const width = Math.max(10, columns - 2);
+        return text.length > width ? text.slice(0, width - 1) + '…' : text;
+    }
+    useInput((input, key) => {
+        if (mode === 'create-name') {
+            if (key.escape) {
+                setMode('list');
+                setNote('');
+                return;
+            }
+            if (key.return) {
+                const problem = projectNameProblem(createName);
+                if (problem) {
+                    setNote(problem);
+                    return;
+                }
+                setNote('');
+                setCursor(0);
+                setMode('create-location');
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setCreateName((name) => name.slice(0, -1));
+                return;
+            }
+            if (!input || key.ctrl || key.meta)
+                return;
+            setCreateName((name) => (name.length >= 60 ? name : name + input));
+            return;
+        }
+        if (mode === 'create-confirm') {
+            if (key.return && createTarget !== null) {
+                void createProject(path.join(createTarget.path, createName.trim()));
+                return;
+            }
+            if (key.escape) {
+                setMode('create-location');
+                setCursor(0);
+            }
+            return;
+        }
+        if (key.upArrow) {
+            setCursor(stepItem(items, resolved, -1));
+            return;
+        }
+        if (key.downArrow) {
+            setCursor(stepItem(items, resolved, 1));
+            return;
+        }
+        if (key.escape) {
+            if (mode === 'list') {
+                startProject(process.cwd());
+                return;
+            }
+            if (mode === 'create-location') {
+                setMode('create-name');
+                setCursor(0);
+                return;
+            }
+            goBack();
+            return;
+        }
+        if (mode === 'create-location' && key.return) {
+            const item = items[resolved];
+            if (!item)
+                return;
+            if (item.kind === 'location') {
+                setCreateTarget(item.entry);
+                setMode('create-confirm');
+            }
+            if (item.kind === 'browse') {
+                setPurpose('create');
+                setMode('browse');
+                setStack([]);
+                setFilter('');
+                setCursor(0);
+            }
+            return;
+        }
+        if (mode === 'list' && key.return) {
+            const item = items[resolved];
+            if (!item)
+                return;
+            if (item.kind === 'recent')
+                startProject(item.folder);
+            if (item.kind === 'browse') {
+                setPurpose('open');
+                setMode('browse');
+                setStack([]);
+                setFilter('');
+                setCursor(0);
+            }
+            if (item.kind === 'create')
+                startCreate();
+            return;
+        }
+        if (mode === 'browse') {
+            if (key.return) {
+                const item = items[resolved];
+                if (!item)
+                    return;
+                if (item.kind === 'back')
+                    goBack();
+                if (item.kind === 'choose' && current !== null)
+                    startProject(current);
+                if (item.kind === 'create-here' && current !== null) {
+                    void createProject(path.join(current, createName.trim()));
+                }
+                if (item.kind === 'folder')
+                    openFolder(item.entry.path);
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setFilter((currentFilter) => currentFilter.slice(0, -1));
+                setCursor(0);
+                return;
+            }
+            if (!input || key.ctrl || key.meta)
+                return;
+            setFilter((currentFilter) => currentFilter + input);
+            setCursor(0);
+            return;
+        }
+    });
+    const title = mode === 'list'
+        ? 'Choose a project'
+        : mode === 'create-name'
+            ? 'Create a new project'
+            : mode === 'create-location'
+                ? `Where should "${createName.trim()}" live?`
+                : mode === 'create-confirm'
+                    ? 'Create the project?'
+                    : purpose === 'create'
+                        ? `Where should "${createName.trim()}" live? - now in ${current !== null ? displayPath(current) : 'your standard folders'}`
+                        : current !== null
+                            ? `Open a folder - now in ${displayPath(current)}`
+                            : 'Open a folder - where do you keep your projects?';
+    const hint = mode === 'list'
+        ? '↑↓ move · Enter choose · Esc current folder'
+        : mode === 'create-name'
+            ? 'type a name · Enter continue · Esc cancel'
+            : mode === 'create-location'
+                ? '↑↓ move · Enter choose · Esc back'
+                : mode === 'create-confirm'
+                    ? 'Enter create · Esc back'
+                    : '↑↓ move · Enter open · type to filter · Esc back';
+    return (_jsxs(Box, { flexDirection: "column", height: rows, children: [_jsx(Text, { dimColor: true, children: title }), mode === 'browse' ? (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "filter: " }), _jsx(Text, { children: filter }), _jsx(Text, { dimColor: true, children: filter ? '' : 'optional' })] })) : null, _jsxs(Box, { flexDirection: "column", flexGrow: 1, justifyContent: "center", minHeight: listHeight, children: [mode === 'create-name' ? (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Name: " }), _jsx(Text, { children: createName }), _jsx(Text, { inverse: true, children: " " })] })) : null, mode === 'create-confirm' && createTarget !== null ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: clip(`Create ${createName.trim()} in ${createTarget.name} →`) }), _jsx(Text, { dimColor: true, children: displayPath(createTarget.path) })] })) : null, visible.map((item, index) => {
+                        const absoluteIndex = start + index;
+                        const selected = absoluteIndex === resolved;
+                        if (item.kind === 'header') {
+                            return (_jsx(Text, { dimColor: true, children: item.label }, `h${absoluteIndex}`));
+                        }
+                        if (item.kind === 'recent') {
+                            const name = path.basename(item.folder);
+                            return (_jsxs(Text, { inverse: selected, children: [` ${name}`.padEnd(26), _jsx(Text, { dimColor: true, children: displayPath(item.folder) })] }, `r${item.folder}`));
+                        }
+                        if (item.kind === 'browse') {
+                            return (_jsx(Text, { inverse: selected, children: ' Browse for a folder →' }, `b${absoluteIndex}`));
+                        }
+                        if (item.kind === 'create') {
+                            return (_jsx(Text, { inverse: selected, children: ' Create a new project →' }, "create"));
+                        }
+                        if (item.kind === 'back') {
+                            return (_jsx(Text, { inverse: selected, dimColor: !selected, children: '← Back' }, "back"));
+                        }
+                        if (item.kind === 'choose') {
+                            return (_jsx(Text, { inverse: selected, children: '✓ Choose this folder' }, "choose"));
+                        }
+                        if (item.kind === 'create-here') {
+                            return current !== null ? (_jsx(Text, { inverse: selected, children: clip(`Create ${createName.trim()} in ${displayPath(current)} →`) }, "create-here")) : null;
+                        }
+                        if (item.kind === 'location') {
+                            return (_jsx(Text, { inverse: selected, children: ` ${item.entry.name}` }, `l${item.entry.path}`));
+                        }
+                        return (_jsx(Text, { inverse: selected, children: ` ${item.entry.name}` }, `f${item.entry.path}`));
+                    }), mode === 'browse' && current !== null && listing.folders.length === 0 && !listing.error ? (_jsx(Text, { dimColor: true, children: "(no folders inside - this one may be your project)" })) : null, mode === 'browse' && listing.error ? _jsxs(Text, { dimColor: true, children: ["(", listing.error, ")"] }) : null] }), note ? _jsx(Text, { color: "yellow", children: note }) : _jsx(Text, { dimColor: true, children: hint })] }));
+}

package/dist/components/TrafficLight.js

@@ -0,0 +1,116 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { Text } from 'ink';
+import chalk from 'chalk';
+import notifier from 'node-notifier';
+import { execa } from 'execa';
+import { platform } from 'node:os';
+import { useSession } from '../state/session.js';
+const DOT = '⬤';
+// Two true-colour greens alternate roughly twice per second while working.
+const PULSE_GREENS = ['#00FF00', '#007800'];
+const PULSE_INTERVAL_MS = 500;
+const STATIC_COLORS = {
+    idle: '#FF0000',
+    'awaiting-approval': '#FFB000',
+    disconnected: '#808080',
+};
+const TITLE_LABELS = {
+    working: 'working',
+    idle: 'done',
+    'awaiting-approval': 'approval',
+    disconnected: 'offline',
+};
+const TERMINAL_APP_NAMES = {
+    appleterminal: 'Terminal',
+    itermapp: 'iTerm2',
+    iterm: 'iTerm2',
+    vscode: 'Code',
+    warpterminal: 'Warp',
+    ghostty: 'Ghostty',
+    tmux: 'Terminal',
+};
+function expectedTerminalApp() {
+    const raw = (process.env.TERM_PROGRAM ?? '').toLowerCase().replace(/[^a-z]/g, '');
+    return TERMINAL_APP_NAMES[raw] ?? 'Terminal';
+}
+// Mirror the state in the terminal tab title (OSC 0). Terminals without OSC support
+// ignore the sequence; non-TTY streams and dumb terminals are skipped so no escape
+// bytes ever reach output they would corrupt.
+function setTabTitle(label) {
+    if (!process.stdout.isTTY || process.env.TERM === 'dumb')
+        return;
+    try {
+        process.stdout.write(`\x1b]0;${label}\x07`);
+    }
+    catch {
+        // A closed stream must never crash the app.
+    }
+}
+// Best-effort focus check via AppleScript, intentionally macOS-only (spec Phase 8
+// allows per-platform checks); other platforms simply always deliver the notification.
+async function isTerminalFocused() {
+    if (platform() !== 'darwin')
+        return false;
+    try {
+        const front = await execa('osascript', [
+            '-e',
+            'tell application "System Events" to get name of first process whose frontmost is true',
+        ]);
+        const expected = expectedTerminalApp().toLowerCase();
+        return front.stdout.toLowerCase().includes(expected);
+    }
+    catch {
+        return false;
+    }
+}
+async function notifyJobFinished(seconds) {
+    try {
+        if (await isTerminalFocused())
+            return;
+        notifier.notify({
+            title: 'Done',
+            message: `The task finished after ${Math.round(seconds)} seconds.`,
+        });
+    }
+    catch {
+        // Notifications are best-effort and must never surface errors.
+    }
+}
+export function TrafficLight() {
+    const s = useSession();
+    const [pulseTick, setPulseTick] = useState(0);
+    const jobStartRef = useRef(null);
+    // Pulse only while working; the interval is always cleaned up on change and unmount.
+    useEffect(() => {
+        if (s.status !== 'working') {
+            setPulseTick(0);
+            return;
+        }
+        const timer = setInterval(() => setPulseTick((tick) => (tick + 1) % 2), PULSE_INTERVAL_MS);
+        return () => clearInterval(timer);
+    }, [s.status]);
+    // Mirror the state in the terminal tab title; degrades silently where unsupported.
+    useEffect(() => {
+        setTabTitle(TITLE_LABELS[s.status]);
+    }, [s.status]);
+    // Watch for long jobs completing; notify when the terminal is not focused.
+    useEffect(() => {
+        if (s.status === 'working') {
+            if (jobStartRef.current === null)
+                jobStartRef.current = Date.now();
+            return;
+        }
+        if (s.status !== 'idle')
+            return;
+        const started = jobStartRef.current;
+        jobStartRef.current = null;
+        if (started !== null) {
+            const seconds = (Date.now() - started) / 1000;
+            if (seconds >= 20)
+                void notifyJobFinished(seconds);
+        }
+    }, [s.status]);
+    const color = s.status === 'working' ? PULSE_GREENS[pulseTick] : STATIC_COLORS[s.status];
+    return _jsx(Text, { children: chalk.hex(color)(DOT) });
+}

package/dist/components/Transcript.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { Box, Text } from 'ink';
+import { useSession } from '../state/session.js';
+import { buildDisplayLines, visibleWindow } from './transcript-layout.js';
+// The transcript is clipped to a fixed height so the frame never grows past the
+// terminal window - this is what keeps the header and footer permanently in place.
+// The terminal's native scrollback is unavailable in alternate-screen mode, so
+// the region scrolls itself: arrow and page keys move the view, and 0 offset
+// keeps it pinned to the newest line while answers stream in.
+export function Transcript({ height, width }) {
+    const s = useSession();
+    const entries = useMemo(() => {
+        if (s.showLastReasoning && s.lastReasoning) {
+            return [...s.transcript, { id: -1, kind: 'reasoning', text: s.lastReasoning }];
+        }
+        return s.transcript;
+    }, [s.transcript, s.showLastReasoning, s.lastReasoning]);
+    const lines = useMemo(() => buildDisplayLines(entries, width), [entries, width]);
+    const { visible, linesAbove, linesBelow } = useMemo(() => visibleWindow(lines, height, s.transcriptScrollUp), [lines, height, s.transcriptScrollUp]);
+    const showPosition = linesAbove > 0 || linesBelow > 0;
+    return (_jsxs(Box, { flexDirection: "column", justifyContent: "flex-end", height: height, children: [showPosition && (_jsxs(Text, { dimColor: true, children: ["\u2191 ", linesAbove, " line", linesAbove === 1 ? '' : 's', " above \u00B7 newest \u2193", linesBelow > 0 ? ` (+${linesBelow} below)` : ''] })), visible.map((line, index) => (_jsx(Text, { color: line.color, dimColor: line.dim, children: line.text }, index)))] }));
+}

package/dist/components/UsageBar.js

@@ -0,0 +1,35 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from 'ink';
+export function usageFraction(value, max) {
+    if (!Number.isFinite(value) || !Number.isFinite(max) || max <= 0)
+        return 0;
+    return Math.min(1, Math.max(0, value / max));
+}
+// Green below 70%, amber 70-89%, red 90% and above.
+export function usageColor(fraction) {
+    if (fraction >= 0.9)
+        return '#FF0000';
+    if (fraction >= 0.7)
+        return '#FFB000';
+    return '#00CC00';
+}
+// Colours for "higher is better" bars such as the cache hit rate: a full bar is
+// the good outcome, so green at 70%+, amber 20-69%, red below 20%.
+export function benefitColor(fraction) {
+    if (fraction >= 0.7)
+        return '#00CC00';
+    if (fraction >= 0.2)
+        return '#FFB000';
+    return '#FF0000';
+}
+export function renderBar(fraction, width) {
+    const filled = Math.round(fraction * width);
+    return '█'.repeat(filled) + '░'.repeat(Math.max(0, width - filled));
+}
+// A filled bar followed by a percentage, coloured by how full the limit is.
+export function UsageBar({ label, value, max, unit, width = 10, goodWhenFull = false, }) {
+    const fraction = usageFraction(value, max);
+    const color = goodWhenFull ? benefitColor(fraction) : usageColor(fraction);
+    const percent = Math.round(fraction * 100);
+    return (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [label, " "] }), _jsxs(Text, { color: color, children: [renderBar(fraction, width), " ", percent, "%"] }), unit ? _jsxs(Text, { dimColor: true, children: [" ", unit] }) : null] }));
+}

package/dist/components/transcript-layout.js

@@ -0,0 +1,103 @@
+// Greedy word-wrap for plain text. Long unbreakable words are hard-broken at the width.
+export function wrapParagraph(s, max) {
+    if (max <= 0)
+        return [s];
+    if (s.length <= max)
+        return [s];
+    const lines = [];
+    let start = 0;
+    while (start < s.length) {
+        if (s.length - start <= max) {
+            lines.push(s.slice(start).trimEnd());
+            break;
+        }
+        let cut = s.lastIndexOf(' ', start + max);
+        if (cut <= start)
+            cut = start + max;
+        lines.push(s.slice(start, cut).trimEnd());
+        start = s[cut] === ' ' ? cut + 1 : cut;
+    }
+    return lines;
+}
+// Clip to a single physical line - used for tool actions so they can never wrap.
+export function clipLine(s, width) {
+    if (width <= 1)
+        return s.slice(0, width);
+    return s.length <= width ? s : s.slice(0, width - 1) + '…';
+}
+// Wraps an entry's text across multiple physical lines; the first line gets the
+// prefix, continuation lines get the indent. Prefix and indent must be the same width.
+function wrapWithPrefix(s, width, prefix, indent) {
+    const max = width - prefix.length;
+    const paragraphs = s.split('\n');
+    const raw = [];
+    for (let i = 0; i < paragraphs.length; i++) {
+        if (i > 0)
+            raw.push('');
+        if (paragraphs[i])
+            raw.push(...wrapParagraph(paragraphs[i], max));
+    }
+    return raw.map((line, index) => (index === 0 ? prefix + line : indent + line));
+}
+function toolLineText(d) {
+    if (d.state === 'awaiting') {
+        return { text: `? ${d.tool} ${d.summary} — allow? (y/n)`, color: 'yellow' };
+    }
+    if (d.state === 'running') {
+        return { text: `… ${d.tool} ${d.summary}`, dim: true };
+    }
+    if (d.state === 'declined') {
+        return { text: `✗ ${d.tool} declined`, color: 'red' };
+    }
+    if (d.state === 'failed') {
+        return { text: `✗ ${d.tool} failed: ${clipLine(d.label, 60)}`, color: 'red' };
+    }
+    return { text: `✓ ${d.label}` };
+}
+// Picks the visible window of display lines for the transcript region. The
+// terminal's own scrollback is off in alternate-screen mode, so this is the
+// app's whole scrolling story: scrollUp counts lines above the bottom edge,
+// and 0 pins the view to the newest line (follow mode).
+export function visibleWindow(lines, height, scrollUp) {
+    const total = lines.length;
+    const maxScroll = Math.max(0, total - height);
+    const offset = Math.min(Math.max(0, scrollUp), maxScroll);
+    const end = total - offset;
+    const start = Math.max(0, end - height);
+    const visible = lines.slice(start, end);
+    return { visible, linesAbove: start, linesBelow: total - end };
+}
+// Turns transcript entries into physical display lines that fit the given width.
+export function buildDisplayLines(entries, width) {
+    const lines = [];
+    const pushWrapped = (text, prefix, indent, color, dim) => {
+        for (const line of wrapWithPrefix(text, width, prefix, indent)) {
+            lines.push({ text: line, color, dim });
+        }
+    };
+    for (const entry of entries) {
+        switch (entry.kind) {
+            case 'user':
+                pushWrapped(entry.text, '> ', '  ');
+                break;
+            case 'assistant':
+                pushWrapped(entry.text, '', '');
+                break;
+            case 'reasoning':
+                pushWrapped(entry.text, '· ', '  ', undefined, true);
+                break;
+            case 'error':
+                pushWrapped(entry.text, '', '', 'red');
+                break;
+            case 'notice':
+                pushWrapped(entry.text, '', '', 'yellow');
+                break;
+            case 'tool': {
+                const rendered = toolLineText(entry.data);
+                lines.push({ text: clipLine(rendered.text, width), color: rendered.color, dim: rendered.dim });
+                break;
+            }
+        }
+    }
+    return lines;
+}

package/dist/index.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { Command } from 'commander';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { App } from './app.js';
+import { session } from './state/session.js';
+import { AlternateScreen, leaveAltScreen } from './ink/AlternateScreen.js';
+// Local development bridge: settings such as OPENROUTER_API_KEY are loaded from a gitignored
+// .env file at the project root. Replaced by the secure OS credential store in Phase 7.
+const envPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '.env');
+if (existsSync(envPath)) {
+    try {
+        process.loadEnvFile(envPath);
+    }
+    catch {
+        // A malformed .env is non-fatal; the on-screen notice explains what is missing.
+    }
+}
+// Graceful degradation: without an interactive terminal there is nothing to draw,
+// so explain in plain English instead of crashing on raw mode.
+if (!process.stdin.isTTY) {
+    console.error('This app needs an interactive terminal window to run.');
+    process.exit(1);
+}
+const program = new Command();
+program
+    .name('jeeves')
+    .version('0.2.0')
+    .description('A plain-English terminal assistant.')
+    .argument('[prompt]', 'optional prompt to start with')
+    .action((prompt) => {
+    // The prompt argument is accepted but not auto-sent yet; a later phase wires it into the loop.
+    // The whole app - project picker, key screens, model picker, main window - runs inside a
+    // single AlternateScreen, so the terminal is taken over exactly once for the whole
+    // process and handed back only when Jeeves quits (Claude Code's mechanism).
+    const instance = render(_jsx(AlternateScreen, { children: _jsx(App, {}) }));
+    let quitting = false;
+    // /exit asks for a clean shutdown: let Ink finish its frame teardown, hand the
+    // terminal back, then leave.
+    session.subscribe(() => {
+        if (session.exitRequested && !quitting) {
+            quitting = true;
+            instance.unmount();
+            void instance.waitUntilExit().then(() => {
+                leaveAltScreen();
+                process.exit(0);
+            });
+        }
+    });
+});
+program.parse();