@hasna/terminal 4.3.1 → 4.3.3

package/dist/App.js

@@ -0,0 +1,404 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useRef } from "react";
+import { Box, Text, useInput, useApp } from "ink";
+import { spawn } from "child_process";
+import { translateToCommand, explainCommand, fixCommand, checkPermissions, isIrreversible } from "./ai.js";
+import { loadHistory, appendHistory, loadConfig, saveConfig } from "./history.js";
+import { loadCache } from "./cache.js";
+import Onboarding from "./Onboarding.js";
+import StatusBar from "./StatusBar.js";
+import Spinner from "./Spinner.js";
+import Browse from "./Browse.js";
+import FuzzyPicker from "./FuzzyPicker.js";
+import { createSession, logInteraction, updateInteraction } from "./sessions-db.js";
+import { smartDisplay } from "./smart-display.js";
+import { processOutput, shouldProcess } from "./output-processor.js";
+loadCache();
+const MAX_LINES = 20;
+// ── helpers ───────────────────────────────────────────────────────────────────
+function insertAt(s, pos, ch) { return s.slice(0, pos) + ch + s.slice(pos); }
+function deleteAt(s, pos) { return pos <= 0 ? s : s.slice(0, pos - 1) + s.slice(pos); }
+/** Detect if output lines look like file paths */
+function extractFilePaths(lines) {
+    return lines.filter(l => /^\.?\//.test(l.trim()) || /\.(ts|tsx|js|json|md|py|sh|go|rs|txt|yaml|yml|env)$/.test(l.trim()));
+}
+/** Ghost text: find the best NL match that starts with the current input */
+function ghostText(input, history) {
+    if (!input.trim())
+        return "";
+    const lower = input.toLowerCase();
+    const match = [...history].reverse().find(h => h.toLowerCase().startsWith(lower) && h.length > input.length);
+    return match ? match.slice(input.length) : "";
+}
+/** Detect cd and change process cwd */
+function maybeCd(command) {
+    const m = command.match(/^\s*cd\s+(.+)\s*$/);
+    if (!m)
+        return null;
+    let target = m[1].trim().replace(/^['"]|['"]$/g, "");
+    if (target.startsWith("~"))
+        target = target.replace("~", process.env.HOME ?? "");
+    return target;
+}
+function newTab(id, cwd) {
+    return {
+        id, cwd,
+        scroll: [], sessionEntries: [], sessionNl: [],
+        phase: { type: "input", value: "", cursor: 0, histIdx: -1, raw: false },
+        streamLines: [],
+    };
+}
+function runCommand(command, cwd, onLine, onDone, signal) {
+    const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    const handle = (d) => d.toString().split("\n").forEach(l => { if (l)
+        onLine(l); });
+    proc.stdout?.on("data", handle);
+    proc.stderr?.on("data", handle);
+    proc.on("close", code => onDone(code ?? 0));
+    signal.addEventListener("abort", () => { try {
+        proc.kill("SIGTERM");
+    }
+    catch { } });
+}
+// ── App ───────────────────────────────────────────────────────────────────────
+export default function App() {
+    const { exit } = useApp();
+    const [config, setConfig] = useState(() => loadConfig());
+    const [nlHistory] = useState(() => loadHistory().map(h => h.nl).filter(Boolean));
+    const [tabs, setTabs] = useState([newTab(1, process.cwd())]);
+    const [activeTab, setActiveTab] = useState(0);
+    const abortRef = useRef(null);
+    let nextTabId = useRef(2);
+    const sessionIdRef = useRef("");
+    const interactionIdRef = useRef(0);
+    const tab = tabs[activeTab];
+    const allNl = [...nlHistory, ...tab.sessionNl];
+    // ── tab helpers ─────────────────────────────────────────────────────────────
+    const updateTab = (updater) => setTabs(ts => ts.map((t, i) => i === activeTab ? updater(t) : t));
+    const setPhase = (phase) => updateTab(t => ({ ...t, phase }));
+    const setStreamLines = (lines) => updateTab(t => ({ ...t, streamLines: lines }));
+    const inputPhase = (overrides = {}) => {
+        updateTab(t => ({
+            ...t,
+            streamLines: [],
+            phase: { type: "input", value: "", cursor: 0, histIdx: -1, raw: false, ...overrides },
+        }));
+    };
+    const pushScroll = (entry) => updateTab(t => ({ ...t, scroll: [...t.scroll, { ...entry, expanded: false }] }));
+    const commitStream = async (nl, cmd, lines, error) => {
+        const filePaths = !error ? extractFilePaths(lines) : [];
+        // Smart display: first try pattern-based compression, then AI if still large
+        let displayLines = !error && lines.length > 5 ? smartDisplay(lines) : lines;
+        // AI-powered processing for large outputs (no hardcoded patterns)
+        if (!error && shouldProcess(lines.join("\n"))) {
+            try {
+                const processed = await processOutput(cmd, lines.join("\n"));
+                if (processed.aiProcessed && processed.tokensSaved > 50) {
+                    displayLines = processed.summary.split("\n");
+                }
+            }
+            catch { /* fallback to smartDisplay result */ }
+        }
+        const truncated = displayLines.length > MAX_LINES;
+        // Build short output summary for session context (first 10 lines of ORIGINAL output)
+        const shortOutput = lines.slice(0, 10).join("\n") + (lines.length > 10 ? `\n... (${lines.length} lines total)` : "");
+        const entry = { nl, cmd, output: shortOutput, error: error || undefined };
+        updateTab(t => ({
+            ...t,
+            streamLines: [],
+            sessionEntries: [...t.sessionEntries.slice(-9), entry],
+            scroll: [...t.scroll, {
+                    nl, cmd,
+                    lines: truncated ? displayLines.slice(0, MAX_LINES) : displayLines,
+                    truncated, expanded: false,
+                    error: error || undefined,
+                    filePaths: filePaths.length ? filePaths : undefined,
+                }],
+        }));
+        appendHistory({ nl, cmd, output: lines.join("\n"), ts: Date.now(), error });
+        // Log to SQLite session
+        if (interactionIdRef.current) {
+            updateInteraction(interactionIdRef.current, { output: shortOutput, exitCode: error ? 1 : 0 });
+        }
+    };
+    // ── run command ─────────────────────────────────────────────────────────────
+    const runPhase = async (nl, command, raw) => {
+        setPhase({ type: "running", nl, command });
+        updateTab(t => ({ ...t, streamLines: [] }));
+        const abort = new AbortController();
+        abortRef.current = abort;
+        const lines = [];
+        const cwd = tabs[activeTab].cwd;
+        await new Promise(resolve => {
+            runCommand(command, cwd, line => { lines.push(line); setStreamLines([...lines]); }, code => {
+                // handle cd — update tab cwd
+                const cdTarget = maybeCd(command);
+                if (cdTarget) {
+                    try {
+                        const { resolve: resolvePath } = require("path");
+                        const newCwd = require("path").resolve(cwd, cdTarget);
+                        process.chdir(newCwd);
+                        updateTab(t => ({ ...t, cwd: newCwd }));
+                    }
+                    catch { }
+                }
+                commitStream(nl, command, lines, code !== 0).then(() => {
+                    abortRef.current = null;
+                    if (code !== 0 && !raw) {
+                        setPhase({ type: "autofix", nl, command, errorOutput: lines.join("\n") });
+                    }
+                    else {
+                        inputPhase({ raw });
+                    }
+                    resolve();
+                });
+            }, abort.signal);
+        });
+    };
+    // ── translate + run ─────────────────────────────────────────────────────────
+    const translateAndRun = async (nl, raw) => {
+        updateTab(t => ({ ...t, sessionNl: [...t.sessionNl, nl] }));
+        // Lazy session creation — only when user actually types something
+        if (!sessionIdRef.current) {
+            sessionIdRef.current = createSession(process.cwd());
+        }
+        // Log interaction start
+        const startTime = Date.now();
+        interactionIdRef.current = logInteraction(sessionIdRef.current, { nl });
+        if (raw) {
+            await runPhase(nl, nl, true);
+            return;
+        }
+        const sessionEntries = tabs[activeTab].sessionEntries;
+        setPhase({ type: "thinking", nl, partial: "" });
+        try {
+            const command = await translateToCommand(nl, config.permissions, sessionEntries, partial => setPhase({ type: "thinking", nl, partial }));
+            // Update interaction with generated command
+            updateInteraction(interactionIdRef.current, { command });
+            const blocked = checkPermissions(command, config.permissions);
+            if (blocked) {
+                pushScroll({ nl, cmd: command, lines: [`blocked: ${blocked}`], truncated: false, error: true });
+                inputPhase();
+                return;
+            }
+            const danger = isIrreversible(command);
+            if (!config.confirm && !danger) {
+                await runPhase(nl, command, false);
+                return;
+            }
+            setPhase({ type: "confirm", nl, command, danger });
+        }
+        catch (e) {
+            setPhase({ type: "error", message: e.message });
+        }
+    };
+    // ── input handler ───────────────────────────────────────────────────────────
+    useInput(useCallback(async (input, key) => {
+        const phase = tabs[activeTab].phase;
+        // ── global: ctrl+c always exits ─────────────────────────────────────────
+        if (key.ctrl && input === "c" && phase.type !== "running") {
+            exit();
+            return;
+        }
+        // ── running: ctrl+c cancels ──────────────────────────────────────────────
+        if (phase.type === "running") {
+            if (key.ctrl && input === "c") {
+                abortRef.current?.abort();
+                inputPhase();
+            }
+            return;
+        }
+        // ── browse ───────────────────────────────────────────────────────────────
+        if (phase.type === "browse")
+            return; // handled by Browse component
+        // ── fuzzy ────────────────────────────────────────────────────────────────
+        if (phase.type === "fuzzy")
+            return; // handled by FuzzyPicker component
+        // ── input ────────────────────────────────────────────────────────────────
+        if (phase.type === "input") {
+            // global shortcuts
+            if (key.ctrl && input === "l") {
+                updateTab(t => ({ ...t, scroll: [] }));
+                return;
+            }
+            if (key.ctrl && input === "b") {
+                setPhase({ type: "browse", cwd: tab.cwd });
+                return;
+            }
+            if (key.ctrl && input === "r") {
+                setPhase({ type: "fuzzy" });
+                return;
+            }
+            // tab management
+            if (key.ctrl && input === "t") {
+                const id = nextTabId.current++;
+                setTabs(ts => [...ts, newTab(id, tab.cwd)]);
+                setActiveTab(tabs.length); // new tab index
+                return;
+            }
+            if (key.ctrl && input === "w") {
+                if (tabs.length > 1) {
+                    setTabs(ts => ts.filter((_, i) => i !== activeTab));
+                    setActiveTab(i => Math.min(i, tabs.length - 2));
+                }
+                return;
+            }
+            if (key.tab) {
+                setActiveTab(i => (i + 1) % tabs.length);
+                return;
+            }
+            // history nav
+            if (key.upArrow) {
+                const idx = Math.min(phase.histIdx + 1, allNl.length - 1);
+                const val = allNl[allNl.length - 1 - idx] ?? "";
+                setPhase({ ...phase, value: val, cursor: val.length, histIdx: idx });
+                return;
+            }
+            if (key.downArrow) {
+                const idx = Math.max(phase.histIdx - 1, -1);
+                const val = idx === -1 ? "" : allNl[allNl.length - 1 - idx] ?? "";
+                setPhase({ ...phase, value: val, cursor: val.length, histIdx: idx });
+                return;
+            }
+            // cursor movement
+            if (key.leftArrow) {
+                setPhase({ ...phase, cursor: Math.max(0, phase.cursor - 1) });
+                return;
+            }
+            if (key.rightArrow) {
+                // right arrow at end → accept ghost text
+                const ghost = ghostText(phase.value, allNl);
+                if (phase.cursor === phase.value.length && ghost) {
+                    const full = phase.value + ghost;
+                    setPhase({ ...phase, value: full, cursor: full.length });
+                }
+                else {
+                    setPhase({ ...phase, cursor: Math.min(phase.value.length, phase.cursor + 1) });
+                }
+                return;
+            }
+            if (key.tab) {
+                // tab → accept ghost text
+                const ghost = ghostText(phase.value, allNl);
+                if (ghost) {
+                    const full = phase.value + ghost;
+                    setPhase({ ...phase, value: full, cursor: full.length });
+                    return;
+                }
+            }
+            if (key.return) {
+                const nl = phase.value.trim();
+                if (!nl)
+                    return;
+                await translateAndRun(nl, phase.raw);
+                return;
+            }
+            if (key.backspace || key.delete) {
+                const val = deleteAt(phase.value, phase.cursor);
+                setPhase({ ...phase, value: val, cursor: Math.max(0, phase.cursor - 1), histIdx: -1 });
+                return;
+            }
+            if (input && !key.ctrl && !key.meta) {
+                const val = insertAt(phase.value, phase.cursor, input);
+                setPhase({ ...phase, value: val, cursor: phase.cursor + 1, histIdx: -1 });
+            }
+            return;
+        }
+        // ── confirm ──────────────────────────────────────────────────────────────
+        if (phase.type === "confirm") {
+            if (input === "?") {
+                const { nl, command } = phase;
+                setPhase({ type: "thinking", nl, partial: "" });
+                try {
+                    const explanation = await explainCommand(command);
+                    setPhase({ type: "explain", nl, command, explanation });
+                }
+                catch {
+                    setPhase({ type: "confirm", nl, command, danger: phase.danger });
+                }
+                return;
+            }
+            if (input === "y" || input === "Y" || key.return) {
+                await runPhase(phase.nl, phase.command, false);
+                return;
+            }
+            if (input === "n" || input === "N" || key.escape) {
+                inputPhase();
+                return;
+            }
+            if (input === "e" || input === "E") {
+                setPhase({ type: "input", value: phase.command, cursor: phase.command.length, histIdx: -1, raw: false });
+                return;
+            }
+            return;
+        }
+        // ── explain ──────────────────────────────────────────────────────────────
+        if (phase.type === "explain") {
+            setPhase({ type: "confirm", nl: phase.nl, command: phase.command, danger: isIrreversible(phase.command) });
+            return;
+        }
+        // ── autofix ──────────────────────────────────────────────────────────────
+        if (phase.type === "autofix") {
+            if (input === "y" || input === "Y" || key.return) {
+                const { nl, command, errorOutput } = phase;
+                setPhase({ type: "thinking", nl, partial: "" });
+                try {
+                    const fixed = await fixCommand(nl, command, errorOutput, config.permissions, tab.sessionEntries);
+                    const danger = isIrreversible(fixed);
+                    if (!config.confirm && !danger) {
+                        await runPhase(nl, fixed, false);
+                        return;
+                    }
+                    setPhase({ type: "confirm", nl, command: fixed, danger });
+                }
+                catch (e) {
+                    setPhase({ type: "error", message: e.message });
+                }
+                return;
+            }
+            inputPhase();
+            return;
+        }
+        // ── error ────────────────────────────────────────────────────────────────
+        if (phase.type === "error") {
+            inputPhase();
+            return;
+        }
+    }, [tabs, activeTab, allNl, config, exit]));
+    // ── onboarding ───────────────────────────────────────────────────────────────
+    if (!config.onboarded) {
+        return _jsx(Onboarding, { onDone: (perms) => {
+                const next = { onboarded: true, confirm: false, permissions: perms };
+                setConfig(next);
+                saveConfig(next);
+            } });
+    }
+    const phase = tab.phase;
+    const isRaw = phase.type === "input" && phase.raw;
+    const ghost = phase.type === "input" ? ghostText(phase.value, allNl) : "";
+    // ── browse overlay ────────────────────────────────────────────────────────
+    if (phase.type === "browse") {
+        return (_jsxs(Box, { flexDirection: "column", children: [tabs.length > 1 && _jsx(TabBar, { tabs: tabs, active: activeTab }), _jsx(Browse, { cwd: phase.cwd, onCd: path => setPhase({ type: "browse", cwd: path }), onSelect: path => {
+                        // fill input with the path
+                        setPhase({ type: "input", value: path, cursor: path.length, histIdx: -1, raw: false });
+                    }, onExit: () => inputPhase() }), _jsx(StatusBar, { permissions: config.permissions })] }));
+    }
+    // ── fuzzy overlay ──────────────────────────────────────────────────────────
+    if (phase.type === "fuzzy") {
+        return (_jsxs(Box, { flexDirection: "column", children: [tabs.length > 1 && _jsx(TabBar, { tabs: tabs, active: activeTab }), _jsx(FuzzyPicker, { history: allNl, onSelect: nl => {
+                        setPhase({ type: "input", value: nl, cursor: nl.length, histIdx: -1, raw: false });
+                    }, onExit: () => inputPhase() }), _jsx(StatusBar, { permissions: config.permissions })] }));
+    }
+    // ── main render ───────────────────────────────────────────────────────────
+    return (_jsxs(Box, { flexDirection: "column", children: [tabs.length > 1 && _jsx(TabBar, { tabs: tabs, active: activeTab }), tab.scroll.map((entry, i) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, paddingLeft: 2, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { dimColor: true, children: "\u203A" }), _jsx(Text, { dimColor: true, children: entry.nl })] }), entry.nl !== entry.cmd && (_jsxs(Box, { gap: 2, paddingLeft: 2, children: [_jsx(Text, { dimColor: true, children: "$" }), _jsx(Text, { dimColor: true, children: entry.cmd })] })), entry.lines.length > 0 && (_jsxs(Box, { flexDirection: "column", paddingLeft: 4, children: [(entry.expanded ? entry.lines : entry.lines).map((line, j) => (_jsx(Text, { color: entry.error ? "red" : undefined, children: line }, j))), entry.truncated && !entry.expanded && (_jsx(Text, { dimColor: true, children: "  \u2026 more lines" }))] }))] }, i))), phase.type === "confirm" && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, paddingLeft: 2, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { dimColor: true, children: "\u203A" }), _jsx(Text, { dimColor: true, children: phase.nl })] }), _jsxs(Box, { gap: 2, paddingLeft: 2, children: [_jsx(Text, { dimColor: true, children: "$" }), _jsx(Text, { children: phase.command }), phase.danger && _jsx(Text, { color: "red", children: "  \u26A0 irreversible" })] }), _jsx(Box, { paddingLeft: 4, children: _jsx(Text, { dimColor: true, children: "enter  n  e  ?" }) })] })), phase.type === "explain" && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, paddingLeft: 2, children: [_jsxs(Box, { gap: 2, paddingLeft: 2, children: [_jsx(Text, { dimColor: true, children: "$" }), _jsx(Text, { children: phase.command })] }), _jsx(Box, { paddingLeft: 4, children: _jsx(Text, { dimColor: true, children: phase.explanation }) }), _jsx(Box, { paddingLeft: 4, children: _jsx(Text, { dimColor: true, children: "any key \u2192" }) })] })), phase.type === "autofix" && (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { dimColor: true, children: "failed \u2014 retry with fix?  [enter / n]" }) })), phase.type === "thinking" && (phase.partial ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { dimColor: true, children: "\u203A" }), _jsx(Text, { dimColor: true, children: phase.nl })] }), _jsxs(Box, { gap: 2, paddingLeft: 2, children: [_jsx(Text, { dimColor: true, children: "$" }), _jsx(Text, { dimColor: true, children: phase.partial })] })] })) : _jsx(Spinner, { label: "translating" })), phase.type === "running" && (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { dimColor: true, children: "$" }), _jsx(Text, { dimColor: true, children: phase.command })] }), _jsx(Box, { flexDirection: "column", paddingLeft: 2, children: tab.streamLines.slice(-MAX_LINES).map((l, i) => _jsx(Text, { children: l }, i)) }), _jsx(Spinner, { label: "ctrl+c to cancel" })] })), phase.type === "error" && (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: "red", children: phase.message }) })), phase.type === "input" && (_jsxs(Box, { gap: 2, paddingLeft: 2, children: [_jsx(Text, { dimColor: true, children: isRaw ? "$" : "›" }), _jsxs(Box, { children: [_jsx(Text, { children: phase.value.slice(0, phase.cursor) }), _jsx(Text, { inverse: true, children: phase.value[phase.cursor] ?? " " }), _jsx(Text, { children: phase.value.slice(phase.cursor + 1) }), ghost && phase.cursor === phase.value.length && (_jsx(Text, { dimColor: true, children: ghost }))] })] })), _jsx(StatusBar, { permissions: config.permissions, cwd: tab.cwd })] }));
+}
+// ── TabBar ────────────────────────────────────────────────────────────────────
+function TabBar({ tabs, active }) {
+    return (_jsxs(Box, { gap: 1, paddingLeft: 2, marginBottom: 1, children: [tabs.map((t, i) => {
+                const label = ` ${i + 1} `;
+                const cwd = t.cwd.split("/").pop() || t.cwd;
+                return (_jsx(Box, { children: i === active
+                        ? _jsxs(Text, { inverse: true, children: [label, cwd] })
+                        : _jsxs(Text, { dimColor: true, children: [label, cwd] }) }, t.id));
+            }), _jsx(Text, { dimColor: true, children: "  ctrl+t new  tab switch  ctrl+w close" })] }));
+}

package/dist/Browse.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { Box, Text, useInput } from "ink";
+import { readdirSync, statSync } from "fs";
+import { join, dirname } from "path";
+function readDir(dir) {
+    try {
+        const names = readdirSync(dir);
+        const entries = [];
+        for (const name of names) {
+            try {
+                const stat = statSync(join(dir, name));
+                entries.push({ name, isDir: stat.isDirectory() });
+            }
+            catch {
+                entries.push({ name, isDir: false });
+            }
+        }
+        entries.sort((a, b) => {
+            if (a.isDir !== b.isDir)
+                return a.isDir ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+const PAGE = 20;
+export default function Browse({ cwd, onCd, onSelect, onExit }) {
+    const [cursor, setCursor] = useState(0);
+    const entries = readDir(cwd);
+    const total = entries.length;
+    const safeIndex = Math.min(cursor, Math.max(0, total - 1));
+    const start = Math.max(0, Math.min(safeIndex - Math.floor(PAGE / 2), total - PAGE));
+    const slice = entries.slice(Math.max(0, start), Math.max(0, start) + PAGE);
+    useInput(useCallback((_input, key) => {
+        if (key.upArrow) {
+            setCursor(c => (c <= 0 ? Math.max(0, total - 1) : c - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setCursor(c => (total === 0 ? 0 : (c >= total - 1 ? 0 : c + 1)));
+            return;
+        }
+        if (key.return) {
+            if (total === 0)
+                return;
+            const entry = entries[safeIndex];
+            if (!entry)
+                return;
+            const full = join(cwd, entry.name);
+            if (entry.isDir) {
+                setCursor(0);
+                onCd(full);
+            }
+            else {
+                onSelect(full);
+            }
+            return;
+        }
+        if (key.backspace || key.delete || key.leftArrow) {
+            setCursor(0);
+            onCd(dirname(cwd));
+            return;
+        }
+        if (key.escape) {
+            onExit();
+            return;
+        }
+    }, [cwd, entries, safeIndex, total, onCd, onSelect, onExit]));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: cwd }), total === 0 && _jsx(Text, { dimColor: true, children: "  (empty)" }), slice.map((entry, i) => {
+                const absIdx = Math.max(0, start) + i;
+                const selected = absIdx === safeIndex;
+                const icon = entry.isDir ? "▸" : "·";
+                return (_jsx(Box, { children: _jsx(Text, { inverse: selected, children: ` ${icon} ${entry.name}${entry.isDir ? "/" : ""} ` }) }, entry.name));
+            }), _jsx(Text, { dimColor: true, children: "  enter  backspace  esc" })] }));
+}

package/dist/FuzzyPicker.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { Box, Text, useInput } from "ink";
+const MAX_MATCHES = 10;
+export default function FuzzyPicker({ history, onSelect, onExit }) {
+    const [query, setQuery] = useState("");
+    const [cursor, setCursor] = useState(0);
+    const matches = query === ""
+        ? history.slice().reverse().slice(0, MAX_MATCHES)
+        : history.slice().reverse().filter(h => h.toLowerCase().includes(query.toLowerCase())).slice(0, MAX_MATCHES);
+    const safeCursor = Math.min(cursor, Math.max(0, matches.length - 1));
+    useInput(useCallback((_input, key) => {
+        if (key.escape || key.ctrl && _input === "c") {
+            onExit();
+            return;
+        }
+        if (key.return) {
+            if (matches.length > 0) {
+                onSelect(matches[safeCursor]);
+            }
+            return;
+        }
+        if (key.upArrow) {
+            setCursor(c => Math.max(0, c - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setCursor(c => Math.min(matches.length - 1, c + 1));
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setQuery(q => q.slice(0, -1));
+            setCursor(0);
+            return;
+        }
+        if (!key.ctrl && !key.meta && _input && _input.length === 1) {
+            setQuery(q => q + _input);
+            setCursor(0);
+        }
+    }, [matches, safeCursor, onSelect, onExit]));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: `  / ${query}_` }), matches.length === 0
+                ? _jsx(Text, { dimColor: true, children: "  no matches" })
+                : matches.map((m, i) => {
+                    const selected = i === safeCursor;
+                    return (_jsx(Box, { children: _jsx(Text, { inverse: selected, dimColor: !selected, children: `  ${m} ` }) }, i));
+                }), _jsx(Text, { dimColor: true, children: "  enter  esc" })] }));
+}

package/dist/Onboarding.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { DEFAULT_PERMISSIONS } from "./history.js";
+const PERM_KEYS = [
+    { key: "destructive", label: "destructive", hint: "rm, delete, drop…" },
+    { key: "network", label: "network", hint: "curl, wget, ssh…" },
+    { key: "sudo", label: "sudo", hint: "root-level commands" },
+    { key: "install", label: "install", hint: "brew, npm -g, pip…" },
+    { key: "write_outside_cwd", label: "write outside", hint: "files outside current dir" },
+];
+export default function Onboarding({ onDone }) {
+    const [step, setStep] = useState("welcome");
+    const [cursor, setCursor] = useState(0);
+    const [perms, setPerms] = useState({ ...DEFAULT_PERMISSIONS });
+    useInput((input, key) => {
+        if (key.ctrl && input === "c")
+            process.exit(0);
+        if (step === "welcome") {
+            setStep("permissions");
+            return;
+        }
+        if (step === "permissions") {
+            if (key.upArrow) {
+                setCursor((c) => Math.max(0, c - 1));
+                return;
+            }
+            if (key.downArrow) {
+                setCursor((c) => Math.min(PERM_KEYS.length - 1, c + 1));
+                return;
+            }
+            if (input === " ") {
+                const k = PERM_KEYS[cursor].key;
+                setPerms((p) => ({ ...p, [k]: !p[k] }));
+                return;
+            }
+            if (key.return) {
+                onDone(perms);
+                return;
+            }
+        }
+    });
+    if (step === "welcome") {
+        return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, gap: 1, paddingTop: 1, children: [_jsx(Text, { children: "terminal" }), _jsx(Text, { dimColor: true, children: "speak plain english, run commands" }), _jsxs(Box, { flexDirection: "column", marginTop: 1, gap: 0, children: [_jsx(Text, { dimColor: true, children: "\u203A  type what you want" }), _jsx(Text, { dimColor: true, children: "$  see the command before it runs" }), _jsx(Text, { dimColor: true, children: "\u2191\u2193  browse history" }), _jsx(Text, { dimColor: true, children: "?  explain a command before running" }), _jsx(Text, { dimColor: true, children: "ctrl+r  toggle raw shell mode" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "any key to set permissions \u2192" }) })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, gap: 1, paddingTop: 1, children: [_jsx(Text, { dimColor: true, children: "what can the AI run?" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: PERM_KEYS.map((p, i) => {
+                    const active = cursor === i;
+                    const on = perms[p.key];
+                    return (_jsxs(Box, { gap: 2, children: [_jsx(Text, { dimColor: true, children: active ? "›" : " " }), _jsx(Text, { color: on ? undefined : "red", children: on ? "✓" : "✗" }), _jsx(Text, { bold: active, children: p.label }), _jsx(Text, { dimColor: true, children: p.hint })] }, p.key));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "space toggle  \u00B7  enter confirm" }) }), _jsx(Text, { dimColor: true, children: "edit later: ~/.hasna/terminal/config.json" })] }));
+}

package/dist/Spinner.js

@@ -0,0 +1,12 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Text } from "ink";
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export default function Spinner({ label }) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const t = setInterval(() => setFrame((f) => (f + 1) % FRAMES.length), 80);
+        return () => clearInterval(t);
+    }, []);
+    return (_jsxs(Text, { dimColor: true, children: ["  ", FRAMES[frame], " ", label] }));
+}

package/dist/StatusBar.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { execSync } from "child_process";
+import { homedir } from "os";
+function formatCwd(cwd) {
+    const home = homedir();
+    return cwd.startsWith(home) ? "~" + cwd.slice(home.length) : cwd;
+}
+function getGitBranch(cwd) {
+    try {
+        return execSync("git branch --show-current 2>/dev/null", {
+            cwd,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).toString().trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function getGitDirty(cwd) {
+    try {
+        return execSync("git status --porcelain 2>/dev/null", {
+            cwd,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).toString().trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function activePerms(perms) {
+    const labels = [
+        ["destructive", "del"],
+        ["network", "net"],
+        ["sudo", "sudo"],
+        ["install", "pkg"],
+        ["write_outside_cwd", "write"],
+    ];
+    // only show disabled ones — full access is the default so no need to clutter
+    const disabled = labels.filter(([k]) => !perms[k]).map(([, l]) => `no-${l}`);
+    return disabled;
+}
+export default function StatusBar({ permissions, cwd: cwdProp }) {
+    const cwd = cwdProp ?? process.cwd();
+    const branch = getGitBranch(cwd);
+    const dirty = branch ? getGitDirty(cwd) : false;
+    const restricted = activePerms(permissions);
+    return (_jsxs(Box, { gap: 2, paddingLeft: 2, marginTop: 1, children: [_jsx(Text, { dimColor: true, children: formatCwd(cwd) }), branch && _jsxs(Text, { dimColor: true, children: [branch, dirty ? " ●" : ""] }), restricted.length > 0 && _jsx(Text, { dimColor: true, children: restricted.join(" · ") })] }));
+}