@truss-harness/tui 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Truss contributors
+
+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,34 @@
+# Truss TUI
+
+<p align="center"><img src="./logo.png" width="96" alt="Truss logo"></p>
+
+The Truss TUI is a full-screen terminal workspace for local coding models. It includes a collapsible directory-first file tree, fuzzy file search, syntax-highlighted editor and Git diff preview, agent chat, shell output, tool approvals, local-model selection, and workspace commands.
+
+## Install and run
+
+```sh
+npm install -g @truss-harness/tui
+truss-tui
+```
+
+The TUI reads the same `.truss-harness/config.json` profiles as `@truss-harness/cli`, or lets you select a detected Ollama, LM Studio, llama.cpp, or custom compatible endpoint at startup.
+
+Configured MCP stdio servers are connected when an Agent session starts, and their connection status appears in the Terminal pane. Plan mode loads only servers explicitly marked `readOnly`. Run `truss-cli config path` to locate the shared user and workspace configuration files.
+
+## Controls
+
+| Key | Action |
+| --- | --- |
+| `Tab` / `Shift+Tab` | Move forward or backward between panes. |
+| `Ctrl+Left` / `Ctrl+Right` | Move to the adjacent pane without cycling forward through every pane. |
+| `/` | Fuzzy-search workspace files from the Files pane. |
+| `Enter` | Send the chat input or open the selected file. |
+| `Left` / `Right` | Collapse or expand the selected directory. |
+| `m` | Open local model settings outside the chat pane. |
+| `d` | Toggle the selected file's Git diff. |
+| Type directly | Enter a command while the terminal pane has focus. |
+| `?` | Open workspace command help. |
+| `Esc` | Stop generation. |
+| `Ctrl+C` | Stop generation, or exit while idle. |
+
+Type `/init`, `/update [note]`, `/status`, `/clear-memory`, or `/help` into the Agent pane. They run locally without a model call. Approvals for model-initiated tools still respect the selected permission policy.

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,759 @@
+#!/usr/bin/env node
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { spawn } from "node:child_process";
+import { execFile as execFileCallback } from "node:child_process";
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { cwd } from "node:process";
+import { promisify } from "node:util";
+import { Box, render, Text, useApp, useInput } from "ink";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { detectLocalEndpoints, listLocalModels } from "@truss-harness/provider-openai-compatible";
+import { brand } from "@truss-harness/branding";
+import { resolveConfiguration } from "@truss-harness/cli/config";
+import { createClientRuntime } from "@truss-harness/cli/runtime";
+import { executeWorkspaceCommand, FileWorkspacePlanStore, workspaceCommandHelp } from "@truss-harness/runtime";
+import { buildFileTree, fuzzyFiles, syntaxTokens, wrapSyntaxTokens } from "./file-browser.js";
+const execFile = promisify(execFileCallback);
+const ignoredDirectories = new Set([".git", ".next", ".truss-harness", "node_modules", "dist", "coverage"]);
+const focusOrder = ["files", "editor", "chat", "terminal"];
+function truncate(value, length) {
+    return value.length <= length ? value : `${value.slice(0, Math.max(0, length - 3))}...`;
+}
+function clamp(value, minimum, maximum) {
+    return Math.min(Math.max(value, minimum), Math.max(minimum, maximum));
+}
+function visibleLines(items, count, offset) {
+    const end = Math.max(0, items.length - clamp(offset, 0, Math.max(0, items.length - count)));
+    return items.slice(Math.max(0, end - count), end);
+}
+function estimateTokens(value) {
+    const trimmed = value.trim();
+    return trimmed ? Math.ceil(trimmed.length / 4) : 0;
+}
+function formatTokenCount(value) {
+    if (value < 1_000)
+        return String(Math.round(value));
+    return `${(value / 1_000).toFixed(value >= 10_000 ? 0 : 1).replace(/\.0$/, "")}k`;
+}
+function wrapText(value, width) {
+    const result = [];
+    for (const sourceLine of value.split(/\r?\n/)) {
+        let remaining = sourceLine || " ";
+        while (remaining.length > width) {
+            const breakAt = Math.max(1, remaining.lastIndexOf(" ", width));
+            result.push(remaining.slice(0, breakAt).trimEnd());
+            remaining = remaining.slice(breakAt).trimStart();
+        }
+        result.push(remaining);
+    }
+    return result;
+}
+function chatDisplayLines(messages, busy, width) {
+    const transcript = messages.flatMap((message) => {
+        const content = message.content || (busy && message.role === "assistant" ? "Thinking..." : "");
+        return [
+            { role: message.role, text: message.role === "user" ? "YOU" : "AGENT", header: true },
+            ...wrapText(content, width).map((text) => ({ role: message.role, text, header: false }))
+        ];
+    });
+    return transcript;
+}
+function configuredContextWindow() {
+    const configured = Number.parseInt(process.env.TRUSS_HARNESS_CONTEXT_WINDOW ?? "8192", 10);
+    return Number.isFinite(configured) ? Math.max(512, Math.min(1_000_000, configured)) : 8_192;
+}
+async function collectFiles(root, current = root, result = []) {
+    if (result.length >= 2_000)
+        return result;
+    for (const entry of await readdir(current, { withFileTypes: true })) {
+        if (result.length >= 2_000)
+            break;
+        if (entry.isDirectory() && !ignoredDirectories.has(entry.name))
+            await collectFiles(root, join(current, entry.name), result);
+        if (entry.isFile())
+            result.push({ path: relative(root, join(current, entry.name)) });
+    }
+    return result.sort((left, right) => left.path.localeCompare(right.path));
+}
+async function runTrackedCommand(command, workspaceRoot, onOutput, onProcess) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, { cwd: workspaceRoot, shell: true, windowsHide: true });
+        onProcess?.(child);
+        child.stdout.on("data", (data) => onOutput(data.toString()));
+        child.stderr.on("data", (data) => onOutput(data.toString()));
+        child.on("error", reject);
+        child.on("close", (code) => {
+            onProcess?.(undefined);
+            onOutput(`\n[process exited: ${code ?? "unknown"}]\n`);
+            resolve();
+        });
+    });
+}
+function detectedPreviewUrl(output) {
+    const match = output.match(/https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])(?::\d+)?(?:\/[^\s]*)?/i);
+    return match?.[0].replace(/[),.;]+$/, "").replace("0.0.0.0", "127.0.0.1");
+}
+function normalizedPreviewUrl(value) {
+    const normalized = /^[a-z][a-z\d+.-]*:\/\//i.test(value.trim()) ? value.trim() : `http://${value.trim()}`;
+    const url = new URL(normalized);
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+        throw new Error("Preview URLs must use HTTP or HTTPS.");
+    return url.toString();
+}
+function openExternalPreview(value) {
+    const url = normalizedPreviewUrl(value);
+    const [command, arguments_] = process.platform === "win32"
+        ? ["rundll32.exe", ["url.dll,FileProtocolHandler", url]]
+        : process.platform === "darwin"
+            ? ["open", [url]]
+            : ["xdg-open", [url]];
+    const child = spawn(command, arguments_, { detached: true, stdio: "ignore", windowsHide: true });
+    child.once("error", () => undefined);
+    child.unref();
+}
+async function stopProcessTree(child) {
+    if (process.platform === "win32" && child.pid) {
+        try {
+            await execFile("taskkill", ["/PID", String(child.pid), "/T", "/F"]);
+            return;
+        }
+        catch {
+            // Fall back to the Node process handle if taskkill is unavailable.
+        }
+    }
+    child.kill();
+}
+function Panel({ title, active, children }) {
+    return _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: active ? "cyan" : "gray", paddingX: 1, width: "100%", height: "100%", overflow: "hidden", children: [_jsx(Text, { color: active ? "cyan" : "gray", bold: true, children: title }), children] });
+}
+function App({ initialConfiguration }) {
+    const { exit } = useApp();
+    const [viewport, setViewport] = useState(() => ({ columns: process.stdout.columns || 120, rows: process.stdout.rows || 36 }));
+    const workspaceRoot = useMemo(() => cwd(), []);
+    const [configuration, setConfiguration] = useState(initialConfiguration);
+    const [client, setClient] = useState();
+    const [sessionId, setSessionId] = useState();
+    const [files, setFiles] = useState([]);
+    const [fileIndex, setFileIndex] = useState(0);
+    const [collapsedDirectories, setCollapsedDirectories] = useState(() => new Set());
+    const [fileSearchInput, setFileSearchInput] = useState("");
+    const [fileSearchIndex, setFileSearchIndex] = useState(0);
+    const [openFilePath, setOpenFilePath] = useState();
+    const [editor, setEditor] = useState("Select a file from the workspace tree.");
+    const [editorTitle, setEditorTitle] = useState("Preview");
+    const [isDiff, setIsDiff] = useState(false);
+    const [focus, setFocus] = useState("chat");
+    const [screen, setScreen] = useState(initialConfiguration ? "workspace" : "settings");
+    const [chatInput, setChatInput] = useState("");
+    const [chat, setChat] = useState([]);
+    const [chatScroll, setChatScroll] = useState(0);
+    const [streamMetrics, setStreamMetrics] = useState({ startedAt: 0, generatedTokens: 0 });
+    const [terminalLines, setTerminalLines] = useState(["Terminal ready. Shell commands run in the workspace root; slash commands run locally."]);
+    const [terminalScroll, setTerminalScroll] = useState(0);
+    const [previewUrl, setPreviewUrl] = useState();
+    const [editorScroll, setEditorScroll] = useState(0);
+    const [busy, setBusy] = useState(false);
+    const [runStatus, setRunStatus] = useState("ready");
+    const [activePlan, setActivePlan] = useState();
+    const [pendingTool, setPendingTool] = useState();
+    const [commandInput, setCommandInput] = useState("");
+    const [endpoints, setEndpoints] = useState([]);
+    const [serverIndex, setServerIndex] = useState(0);
+    const [models, setModels] = useState([]);
+    const [modelIndex, setModelIndex] = useState(0);
+    const [settingsField, setSettingsField] = useState("server");
+    const [endpointInput, setEndpointInput] = useState(initialConfiguration?.baseUrl ?? "http://127.0.0.1:11434");
+    const [modelInput, setModelInput] = useState(initialConfiguration?.model ?? "");
+    const [providerKind, setProviderKind] = useState(initialConfiguration?.provider ?? "ollama");
+    const [agentMode] = useState(initialConfiguration?.mode ?? "chat");
+    const [permissionMode] = useState(initialConfiguration?.permission ?? "ask");
+    const [internetAccess, setInternetAccess] = useState(initialConfiguration?.internetAccess ?? false);
+    const approvalResolvers = useRef(new Map());
+    const abortController = useRef(undefined);
+    const terminalProcess = useRef(undefined);
+    const contextWindow = useMemo(configuredContextWindow, []);
+    const contextTokens = useMemo(() => chat.reduce((total, message) => total + estimateTokens(message.content), 400), [chat]);
+    const tokensPerSecond = streamMetrics.startedAt && streamMetrics.generatedTokens
+        ? streamMetrics.generatedTokens / Math.max((Date.now() - streamMetrics.startedAt) / 1_000, 0.1)
+        : undefined;
+    const appendTerminal = (output) => {
+        const next = output.replace(/\r/g, "").split("\n").filter(Boolean);
+        if (!next.length)
+            return;
+        const detected = detectedPreviewUrl(output);
+        if (detected)
+            setPreviewUrl(detected);
+        setTerminalScroll(0);
+        setTerminalLines((current) => [...current, ...next].slice(-110));
+    };
+    const candidates = useMemo(() => [
+        ...endpoints,
+        { id: "custom", label: "Custom compatible endpoint", kind: "openai-compatible", baseUrl: "" }
+    ], [endpoints]);
+    const selectedEndpoint = candidates[Math.min(serverIndex, Math.max(candidates.length - 1, 0))];
+    const fileTree = useMemo(() => buildFileTree(files, collapsedDirectories), [files, collapsedDirectories]);
+    const selectedFileTreeEntry = fileTree[Math.min(fileIndex, Math.max(0, fileTree.length - 1))];
+    const fileSearchResults = useMemo(() => fuzzyFiles(files, fileSearchInput, Math.max(6, Math.min(14, viewport.rows - 10))), [files, fileSearchInput, viewport.rows]);
+    const compactLayout = viewport.columns < 106;
+    const terminalHeight = clamp(Math.floor(viewport.rows * 0.24), 7, 11);
+    const workspaceHeight = Math.max(compactLayout ? 14 : 9, viewport.rows - terminalHeight - 6);
+    const filesWidth = Math.max(20, Math.min(36, Math.floor(viewport.columns * 0.24)));
+    const chatWidth = compactLayout ? Math.max(40, viewport.columns - 4) : Math.max(28, Math.min(48, Math.floor(viewport.columns * 0.31)));
+    const editorWidth = compactLayout ? Math.max(30, viewport.columns - filesWidth - 4) : Math.max(30, viewport.columns - filesWidth - chatWidth - 4);
+    const compactChatHeight = compactLayout ? clamp(Math.floor(workspaceHeight * 0.4), 6, 10) : workspaceHeight;
+    const editorHeight = compactLayout ? Math.max(6, workspaceHeight - compactChatHeight - 1) : workspaceHeight;
+    const editorLineCount = Math.max(2, editorHeight - 3);
+    const chatLineCount = Math.max(2, compactChatHeight - (activePlan ? 7 : 0) - 4);
+    const chatTranscript = chatDisplayLines(chat, busy, Math.max(12, chatWidth - 5));
+    const chatLines = visibleLines(chatTranscript, chatLineCount, chatScroll);
+    const editorRows = useMemo(() => {
+        const maximumCharacters = Math.max(12, editorWidth - 7);
+        return editor.split(/\r?\n/).flatMap((line, sourceIndex) => {
+            const color = isDiff
+                ? line.startsWith("+") && !line.startsWith("+++")
+                    ? "green"
+                    : line.startsWith("-") && !line.startsWith("---")
+                        ? "red"
+                        : undefined
+                : undefined;
+            const tokens = isDiff ? [{ text: line, color }] : syntaxTokens(line, openFilePath ?? "");
+            return wrapSyntaxTokens(tokens, maximumCharacters).map((row, rowIndex) => ({
+                sourceLine: sourceIndex + 1,
+                continuation: rowIndex > 0,
+                tokens: row
+            }));
+        });
+    }, [editor, editorWidth, isDiff, openFilePath]);
+    const visibleEditorRows = editorRows.slice(editorScroll, editorScroll + editorLineCount);
+    const visibleTerminalLines = visibleLines(terminalLines, Math.max(1, terminalHeight - 4), terminalScroll);
+    const fileTreeStart = clamp(fileIndex - Math.floor(editorLineCount / 2), 0, Math.max(0, fileTree.length - editorLineCount));
+    const visibleFileTree = fileTree.slice(fileTreeStart, fileTreeStart + editorLineCount);
+    const overlayWidth = clamp(viewport.columns - 4, 42, 90);
+    useEffect(() => {
+        void collectFiles(workspaceRoot).then(setFiles).catch((error) => setEditor(`Unable to list workspace files: ${String(error)}`));
+        void new FileWorkspacePlanStore(workspaceRoot).load().then(setActivePlan).catch(() => undefined);
+        void detectLocalEndpoints().then((detected) => {
+            setEndpoints(detected);
+            const preferred = configuration ? detected.findIndex((endpoint) => endpoint.kind === configuration.provider && endpoint.baseUrl === configuration.baseUrl) : -1;
+            if (preferred >= 0)
+                setServerIndex(preferred);
+        });
+    }, [workspaceRoot]);
+    useEffect(() => {
+        setFileIndex((current) => clamp(current, 0, Math.max(0, fileTree.length - 1)));
+    }, [fileTree.length]);
+    useEffect(() => {
+        setEditorScroll((current) => clamp(current, 0, Math.max(0, editorRows.length - editorLineCount)));
+    }, [editorRows.length, editorLineCount]);
+    useEffect(() => {
+        if (!openFilePath)
+            return;
+        const index = fileTree.findIndex((entry) => entry.kind === "file" && entry.path === openFilePath);
+        if (index >= 0)
+            setFileIndex(index);
+    }, [fileTree, openFilePath]);
+    useEffect(() => {
+        const refreshViewport = () => setViewport({ columns: process.stdout.columns || 120, rows: process.stdout.rows || 36 });
+        process.stdout.on("resize", refreshViewport);
+        return () => { process.stdout.off("resize", refreshViewport); };
+    }, []);
+    useEffect(() => {
+        if (!selectedEndpoint || !endpointInput)
+            return;
+        const endpoint = { ...selectedEndpoint, kind: providerKind, baseUrl: endpointInput };
+        void listLocalModels(endpoint).then((available) => {
+            setModels(available.map((model) => model.name));
+            const selected = available.findIndex((model) => model.name === modelInput);
+            setModelIndex(Math.max(0, selected));
+        }).catch(() => setModels([]));
+    }, [selectedEndpoint?.id, endpointInput, providerKind]);
+    useEffect(() => {
+        if (!client)
+            return;
+        const unsubscribe = client.events.subscribe((event) => {
+            if (event.type === "text_delta") {
+                setRunStatus("thinking");
+                setChatScroll(0);
+                setStreamMetrics((current) => current.startedAt
+                    ? { ...current, generatedTokens: current.generatedTokens + estimateTokens(event.text) }
+                    : current);
+                setChat((current) => {
+                    const last = current.at(-1);
+                    if (!last || last.role !== "assistant")
+                        return [...current, { role: "assistant", content: event.text }];
+                    return [...current.slice(0, -1), { role: "assistant", content: last.content + event.text }];
+                });
+            }
+            if (event.type === "tool_call_requested") {
+                setRunStatus("tool");
+                appendTerminal(`[tool requested] ${event.tool} ${JSON.stringify(event.input)}`);
+            }
+            if (event.type === "tool_completed") {
+                setRunStatus("thinking");
+                appendTerminal(`[tool completed] ${event.tool}: ${truncate(event.result.content, 160)}`);
+            }
+            if (event.type === "plan_updated")
+                setActivePlan(event.plan);
+            if (event.type === "run_failed") {
+                setRunStatus("ready");
+                appendTerminal(`[agent error] ${event.error.message}`);
+            }
+        });
+        return () => {
+            unsubscribe();
+            void client.dispose();
+        };
+    }, [client]);
+    const loadFile = async (entry) => {
+        try {
+            setIsDiff(false);
+            setEditorScroll(0);
+            setOpenFilePath(entry.path);
+            setEditorTitle(entry.path);
+            setEditor(await readFile(join(workspaceRoot, entry.path), "utf8"));
+            setFocus("editor");
+        }
+        catch (error) {
+            setEditor(`Unable to read ${entry.path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    const toggleDirectory = (path, expand) => {
+        setCollapsedDirectories((current) => {
+            const next = new Set(current);
+            const currentlyExpanded = !next.has(path);
+            const shouldExpand = expand ?? !currentlyExpanded;
+            if (shouldExpand)
+                next.delete(path);
+            else
+                next.add(path);
+            return next;
+        });
+    };
+    const openSearchResult = (entry) => {
+        const parts = entry.path.replaceAll("\\", "/").split("/");
+        parts.pop();
+        setCollapsedDirectories((current) => {
+            const next = new Set(current);
+            let path = "";
+            for (const part of parts) {
+                path = path ? `${path}/${part}` : part;
+                next.delete(path);
+            }
+            return next;
+        });
+        setFileSearchInput("");
+        setFileSearchIndex(0);
+        setScreen("workspace");
+        void loadFile(entry);
+    };
+    const toggleDiff = async () => {
+        if (!openFilePath)
+            return;
+        const entry = { path: openFilePath };
+        if (isDiff)
+            return void loadFile(entry);
+        try {
+            setOpenFilePath(entry.path);
+            const { stdout } = await execFile("git", ["diff", "--no-ext-diff", "--", entry.path], { cwd: workspaceRoot, maxBuffer: 1_000_000 });
+            setEditorTitle(`Diff: ${entry.path}`);
+            setEditor(stdout || "No working-tree diff for this file.");
+            setIsDiff(true);
+            setEditorScroll(0);
+        }
+        catch (error) {
+            setEditor(`Unable to load Git diff: ${error instanceof Error ? error.message : String(error)}`);
+            setIsDiff(true);
+        }
+    };
+    const configureRuntime = async () => {
+        if (!endpointInput.trim() || !modelInput.trim()) {
+            appendTerminal("[configuration] An endpoint and model are required.");
+            return;
+        }
+        const nextConfiguration = {
+            workspaceRoot,
+            provider: providerKind,
+            baseUrl: endpointInput.trim(),
+            model: modelInput.trim(),
+            apiKey: process.env.TRUSS_HARNESS_API_KEY,
+            systemPrompt: process.env.TRUSS_HARNESS_SYSTEM_PROMPT,
+            mode: agentMode,
+            internetAccess,
+            approval: {
+                approve: async (call) => {
+                    const readOnly = ["read_file", "list_directory", "search_files", "grep"].includes(call.name);
+                    if (permissionMode === "auto-all" || (permissionMode === "auto-read" && readOnly))
+                        return true;
+                    return new Promise((resolve) => {
+                        approvalResolvers.current.set(call.id, resolve);
+                        setPendingTool(call);
+                        setRunStatus("waiting");
+                        setScreen("approval");
+                    });
+                }
+            }
+        };
+        setConfiguration(nextConfiguration);
+        setRunStatus("thinking");
+        try {
+            const nextClient = await createClientRuntime(nextConfiguration);
+            setClient(nextClient);
+            for (const server of nextClient.mcpServers) {
+                appendTerminal(`[mcp] ${server.name}: ${server.state}${server.error ? ` (${server.error})` : ` (${server.toolCount} tools)`}`);
+            }
+        }
+        catch (error) {
+            appendTerminal(`[mcp] Unable to configure runtime: ${error instanceof Error ? error.message : String(error)}`);
+            setRunStatus("ready");
+            return;
+        }
+        setSessionId(undefined);
+        setChat([]);
+        setChatScroll(0);
+        setStreamMetrics({ startedAt: 0, generatedTokens: 0 });
+        setScreen("workspace");
+        appendTerminal(`[configuration] ${nextConfiguration.provider} ${nextConfiguration.model} at ${nextConfiguration.baseUrl}`);
+        setRunStatus("ready");
+    };
+    useEffect(() => {
+        if (initialConfiguration && !client)
+            void configureRuntime();
+    }, []);
+    const openFileContext = async () => {
+        if (!openFilePath)
+            return [];
+        try {
+            // Keep the active file useful on small local context windows without crowding out the request and history.
+            const maximumCharacters = Math.max(2_000, Math.min(20_000, contextWindow));
+            const content = await readFile(join(workspaceRoot, openFilePath), "utf8");
+            const clipped = content.slice(0, maximumCharacters);
+            return [{
+                    source: `active-file:${openFilePath}`,
+                    content: `This is the currently open workspace file and the primary context for this request. Tool results produced later in the run take precedence over this request-start snapshot.\n\n${clipped}`,
+                    priority: 1_000
+                }];
+        }
+        catch {
+            return [];
+        }
+    };
+    const sendPrompt = async () => {
+        const prompt = chatInput.trim();
+        if (!prompt || busy)
+            return;
+        const command = await executeWorkspaceCommand({ workspaceRoot, input: prompt });
+        if (command.handled) {
+            setChatInput("");
+            setChat((current) => [...current, { role: "user", content: prompt }, { role: "assistant", content: command.message }]);
+            appendTerminal(`[workspace command] ${command.command ?? prompt}: ${command.ok ? "completed" : "failed"}`);
+            return;
+        }
+        if (!client) {
+            setScreen("settings");
+            appendTerminal("[configuration] Select a local model before sending a prompt.");
+            return;
+        }
+        setChatInput("");
+        setChatScroll(0);
+        setBusy(true);
+        setRunStatus("thinking");
+        setStreamMetrics({ startedAt: Date.now(), generatedTokens: 0 });
+        setChat((current) => [...current, { role: "user", content: prompt }, { role: "assistant", content: "" }]);
+        const controller = new AbortController();
+        abortController.current = controller;
+        try {
+            const session = sessionId ? await client.runtime.getSession(sessionId) : await client.runtime.createSession();
+            if (!session)
+                throw new Error("Conversation is unavailable.");
+            setSessionId(session.id);
+            await client.runtime.run(session.id, prompt, controller.signal, await openFileContext());
+        }
+        catch (error) {
+            if (!controller.signal.aborted)
+                appendTerminal(`[agent error] ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            setBusy(false);
+            setRunStatus("ready");
+            abortController.current = undefined;
+        }
+    };
+    const resolveApproval = (approved) => {
+        if (pendingTool)
+            approvalResolvers.current.get(pendingTool.id)?.(approved);
+        setPendingTool(undefined);
+        setRunStatus(approved ? "thinking" : "ready");
+        setScreen("workspace");
+    };
+    const startNewConversation = () => {
+        if (busy) {
+            appendTerminal("[conversation] Stop the active run before starting a new conversation.");
+            return;
+        }
+        setSessionId(undefined);
+        setChat([]);
+        setChatInput("");
+        setChatScroll(0);
+        setStreamMetrics({ startedAt: 0, generatedTokens: 0 });
+        appendTerminal("[conversation] Started a new conversation.");
+    };
+    const runTerminalInput = async (input) => {
+        const command = await executeWorkspaceCommand({ workspaceRoot, input });
+        if (command.handled) {
+            appendTerminal(`[workspace command] ${command.command ?? input}: ${command.ok ? "completed" : "failed"}`);
+            appendTerminal(command.message);
+            return;
+        }
+        await runTrackedCommand(input, workspaceRoot, appendTerminal, (process) => { terminalProcess.current = process; });
+    };
+    const moveFocus = (direction) => {
+        setFocus((current) => {
+            const currentIndex = focusOrder.indexOf(current);
+            return focusOrder[(currentIndex + direction + focusOrder.length) % focusOrder.length];
+        });
+    };
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            if (terminalProcess.current) {
+                const process = terminalProcess.current;
+                terminalProcess.current = undefined;
+                void stopProcessTree(process).then(() => appendTerminal("[terminal] Process stopped."));
+            }
+            else if (busy) {
+                abortController.current?.abort();
+                setRunStatus("ready");
+                appendTerminal("[agent] Cancellation requested.");
+            }
+            else
+                exit();
+            return;
+        }
+        if (screen === "approval") {
+            if (input.toLowerCase() === "y" || key.return)
+                resolveApproval(true);
+            if (input.toLowerCase() === "n" || key.escape)
+                resolveApproval(false);
+            return;
+        }
+        if (screen === "file-search") {
+            if (key.escape) {
+                setFileSearchInput("");
+                setFileSearchIndex(0);
+                setScreen("workspace");
+                return;
+            }
+            if (key.upArrow) {
+                setFileSearchIndex((current) => Math.max(0, current - 1));
+                return;
+            }
+            if (key.downArrow) {
+                setFileSearchIndex((current) => Math.min(Math.max(0, fileSearchResults.length - 1), current + 1));
+                return;
+            }
+            if (key.return) {
+                const result = fileSearchResults[Math.min(fileSearchIndex, Math.max(0, fileSearchResults.length - 1))];
+                if (result)
+                    openSearchResult(result);
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setFileSearchInput((current) => current.slice(0, -1));
+                setFileSearchIndex(0);
+            }
+            else if (input) {
+                setFileSearchInput((current) => current + input);
+                setFileSearchIndex(0);
+            }
+            return;
+        }
+        if (screen === "help") {
+            setScreen("workspace");
+            return;
+        }
+        if (screen === "settings") {
+            if (key.escape) {
+                setScreen("workspace");
+                return;
+            }
+            if (key.tab) {
+                const fields = ["server", "endpoint", "model", "internet"];
+                setSettingsField((current) => {
+                    const index = fields.indexOf(current);
+                    return fields[(index + (key.shift ? -1 : 1) + fields.length) % fields.length];
+                });
+                return;
+            }
+            if (settingsField === "server") {
+                if (key.upArrow)
+                    setServerIndex((current) => Math.max(0, current - 1));
+                if (key.downArrow)
+                    setServerIndex((current) => Math.min(candidates.length - 1, current + 1));
+                if (key.return && selectedEndpoint) {
+                    setProviderKind(selectedEndpoint.kind);
+                    setEndpointInput(selectedEndpoint.baseUrl);
+                    setSettingsField("model");
+                }
+                return;
+            }
+            if (settingsField === "model") {
+                if (key.upArrow)
+                    setModelIndex((current) => Math.max(0, current - 1));
+                if (key.downArrow)
+                    setModelIndex((current) => Math.min(models.length - 1, current + 1));
+                if (models[modelIndex] && (key.return || key.rightArrow))
+                    setModelInput(models[modelIndex]);
+            }
+            if (settingsField === "internet") {
+                if (input === " " || key.leftArrow || key.rightArrow)
+                    setInternetAccess((current) => !current);
+                if (key.return && endpointInput && modelInput)
+                    void configureRuntime();
+                return;
+            }
+            if (key.return && endpointInput && modelInput) {
+                void configureRuntime();
+                return;
+            }
+            const setter = settingsField === "endpoint" ? setEndpointInput : setModelInput;
+            if (key.backspace || key.delete)
+                setter((current) => current.slice(0, -1));
+            else if (!key.return && input)
+                setter((current) => current + input);
+            return;
+        }
+        if (key.ctrl && (key.leftArrow || key.rightArrow)) {
+            moveFocus(key.leftArrow ? -1 : 1);
+            return;
+        }
+        if (key.tab) {
+            moveFocus(key.shift ? -1 : 1);
+            return;
+        }
+        if (key.escape && busy) {
+            abortController.current?.abort();
+            setRunStatus("ready");
+            appendTerminal("[agent] Cancellation requested.");
+            return;
+        }
+        if (input === "o" && focus !== "chat" && focus !== "terminal" && previewUrl) {
+            try {
+                openExternalPreview(previewUrl);
+                appendTerminal(`[preview] Opened ${previewUrl}`);
+            }
+            catch (error) {
+                appendTerminal(`[preview error] ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return;
+        }
+        if (focus === "terminal") {
+            if (key.upArrow) {
+                setTerminalScroll((current) => clamp(current + 1, 0, Math.max(0, terminalLines.length - Math.max(1, terminalHeight - 4))));
+                return;
+            }
+            if (key.downArrow) {
+                setTerminalScroll((current) => clamp(current - 1, 0, Math.max(0, terminalLines.length - Math.max(1, terminalHeight - 4))));
+                return;
+            }
+            if (key.return) {
+                const command = commandInput.trim();
+                setCommandInput("");
+                if (command)
+                    void runTerminalInput(command).catch((error) => appendTerminal(`[terminal error] ${String(error)}`));
+                return;
+            }
+            if (key.backspace || key.delete)
+                setCommandInput((current) => current.slice(0, -1));
+            else if (input)
+                setCommandInput((current) => current + input);
+            return;
+        }
+        if (input === "?" && focus !== "chat") {
+            setScreen("help");
+            return;
+        }
+        if (input === "m" && focus !== "chat") {
+            setScreen("settings");
+            return;
+        }
+        if (input === "n" && focus !== "chat") {
+            startNewConversation();
+            return;
+        }
+        if (focus === "files") {
+            if (input === "/") {
+                setFileSearchInput("");
+                setFileSearchIndex(0);
+                setScreen("file-search");
+                return;
+            }
+            if (key.upArrow)
+                setFileIndex((current) => Math.max(0, current - 1));
+            if (key.downArrow)
+                setFileIndex((current) => Math.min(Math.max(fileTree.length - 1, 0), current + 1));
+            if (key.leftArrow && selectedFileTreeEntry?.kind === "directory")
+                toggleDirectory(selectedFileTreeEntry.path, false);
+            if (key.rightArrow && selectedFileTreeEntry?.kind === "directory")
+                toggleDirectory(selectedFileTreeEntry.path, true);
+            if (key.return && selectedFileTreeEntry?.kind === "directory")
+                toggleDirectory(selectedFileTreeEntry.path);
+            if (key.return && selectedFileTreeEntry?.kind === "file")
+                void loadFile(selectedFileTreeEntry);
+            return;
+        }
+        if (focus === "editor") {
+            if (key.upArrow) {
+                setEditorScroll((current) => clamp(current - 1, 0, Math.max(0, editorRows.length - editorLineCount)));
+                return;
+            }
+            if (key.downArrow) {
+                setEditorScroll((current) => clamp(current + 1, 0, Math.max(0, editorRows.length - editorLineCount)));
+                return;
+            }
+            if (input === "d")
+                void toggleDiff();
+            return;
+        }
+        if (key.upArrow) {
+            setChatScroll((current) => clamp(current + 1, 0, Math.max(0, chatTranscript.length - chatLineCount)));
+            return;
+        }
+        if (key.downArrow) {
+            setChatScroll((current) => clamp(current - 1, 0, Math.max(0, chatTranscript.length - chatLineCount)));
+            return;
+        }
+        if (key.return) {
+            void sendPrompt();
+            return;
+        }
+        if (key.backspace || key.delete)
+            setChatInput((current) => current.slice(0, -1));
+        else if (input)
+            setChatInput((current) => current + input);
+    });
+    const filesPanel = _jsxs(Panel, { title: "FILES  [/] find", active: focus === "files", children: [visibleFileTree.map((entry, visibleIndex) => {
+                const selected = fileTreeStart + visibleIndex === fileIndex;
+                const marker = entry.kind === "directory" ? (entry.expanded ? "v " : "> ") : "  ";
+                const indentation = " ".repeat(entry.depth * 2);
+                const width = Math.max(6, filesWidth - indentation.length - 7);
+                return _jsxs(Text, { wrap: "truncate-end", color: selected ? "cyan" : entry.kind === "directory" ? "blue" : entry.path === openFilePath ? "green" : undefined, bold: selected || entry.kind === "directory", children: [selected ? "> " : "  ", indentation, marker, truncate(entry.name, width)] }, `${entry.kind}:${entry.path}`);
+            }), !fileTree.length && _jsx(Text, { color: "gray", children: "No workspace files found." })] });
+    const editorPanel = _jsx(Panel, { title: `${editorTitle}  [up/down] scroll  [d] diff${previewUrl ? "  [o] browser" : ""}`, active: focus === "editor", children: visibleEditorRows.map((row, index) => {
+            const lineLabel = row.continuation ? "  |" : String(row.sourceLine).padStart(3);
+            return _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: "gray", children: lineLabel }), " ", row.tokens.map((token, tokenIndex) => _jsx(Text, { color: token.color, dimColor: token.dim, children: token.text }, `${tokenIndex}-${token.text}`))] }, `${editorScroll + index}-${row.sourceLine}-${row.continuation}`);
+        }) });
+    const agentPanel = _jsxs(Panel, { title: chatScroll ? `AGENT  [${chatScroll} lines above]` : "AGENT  [Enter] send", active: focus === "chat", children: [activePlan && _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { bold: true, color: "cyan", wrap: "truncate-end", children: ["PLAN: ", truncate(activePlan.title, Math.max(8, chatWidth - 9))] }), activePlan.steps.slice(0, 3).map((step) => _jsxs(Text, { wrap: "truncate-end", color: step.status === "completed" ? "green" : step.status === "in_progress" ? "yellow" : "gray", children: [step.status === "completed" ? "[x]" : step.status === "in_progress" ? "[..]" : "[ ]", " ", truncate(step.content, Math.max(8, chatWidth - 7))] }, step.id))] }), chatLines.map((line, index) => _jsx(Text, { color: line.role === "user" ? "cyan" : "green", bold: line.header, children: line.text }, `${line.role}-${line.header}-${index}-${line.text}`)), _jsx(Box, { flexGrow: 1 }), _jsxs(Text, { wrap: "truncate-end", color: focus === "chat" ? "cyan" : "gray", children: [focus === "chat" ? "> " : "  ", truncate(chatInput || (busy ? "Working... Escape cancels" : "Ask about this workspace"), Math.max(12, chatWidth - 5))] })] });
+    return _jsxs(Box, { flexDirection: "column", height: viewport.rows, paddingX: 1, overflow: "hidden", children: [_jsxs(Box, { height: 1, justifyContent: "space-between", marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: brand.productName.toUpperCase() }), _jsx(Text, { color: "gray", children: configuration ? `${configuration.provider} / ${configuration.model}` : "No model selected" }), _jsx(Text, { color: runStatus === "waiting" ? "yellow" : busy ? "cyan" : "green", children: runStatus === "waiting" ? "APPROVAL" : runStatus === "tool" ? "TOOL" : busy ? "WORKING" : "READY" })] }), _jsxs(Box, { height: 1, justifyContent: "space-between", marginBottom: 1, children: [_jsxs(Text, { color: "gray", children: ["CONTEXT ", _jsxs(Text, { color: contextTokens / contextWindow >= 0.9 ? "red" : contextTokens / contextWindow >= 0.7 ? "yellow" : "cyan", children: [formatTokenCount(contextTokens), " / ", formatTokenCount(contextWindow)] }), " estimated"] }), _jsxs(Text, { color: "gray", children: ["SPEED ", _jsx(Text, { color: busy ? "green" : "gray", children: tokensPerSecond ? `${tokensPerSecond.toFixed(1)} tok/s` : "-- tok/s" }), previewUrl ? `  PREVIEW ${truncate(previewUrl, Math.max(16, Math.floor(viewport.columns * 0.3)))}` : ""] })] }), compactLayout ? _jsxs(Box, { height: workspaceHeight, flexDirection: "column", gap: 1, overflow: "hidden", children: [_jsxs(Box, { height: editorHeight, flexDirection: "row", gap: 1, overflow: "hidden", children: [_jsx(Box, { width: filesWidth, height: "100%", children: filesPanel }), _jsx(Box, { width: editorWidth, height: "100%", children: editorPanel })] }), _jsx(Box, { height: compactChatHeight, width: "100%", children: agentPanel })] }) : _jsxs(Box, { height: workspaceHeight, flexDirection: "row", gap: 1, overflow: "hidden", children: [_jsx(Box, { width: filesWidth, height: "100%", children: filesPanel }), _jsx(Box, { width: editorWidth, height: "100%", children: editorPanel }), _jsx(Box, { width: chatWidth, height: "100%", children: agentPanel })] }), _jsx(Box, { height: terminalHeight, marginTop: 1, children: _jsxs(Panel, { title: "TERMINAL  [Enter] run", active: focus === "terminal", children: [visibleTerminalLines.map((line, index) => _jsx(Text, { wrap: "truncate-end", color: line.startsWith("[agent error]") || line.startsWith("[terminal error]") ? "red" : line.startsWith("[tool") ? "yellow" : "gray", children: truncate(line, Math.max(20, viewport.columns - 8)) }, `${index}-${line}`)), _jsx(Box, { flexGrow: 1 }), _jsxs(Text, { wrap: "truncate-end", color: focus === "terminal" ? "cyan" : "gray", children: [focus === "terminal" ? "> " : "  ", truncate(commandInput || "Type a workspace command", Math.max(16, viewport.columns - 10))] })] }) }), _jsxs(Box, { height: 1, marginTop: 1, justifyContent: "space-between", children: [_jsx(Text, { color: "gray", wrap: "truncate-end", children: "Tab/Shift+Tab focus  |  Ctrl+Left/Right pane  |  / find  |  m model  |  Esc stop" }), _jsx(Text, { color: "gray", children: sessionId ? `session ${sessionId.slice(0, 8)}` : "new session" })] }), screen === "file-search" && _jsxs(Box, { position: "absolute", flexDirection: "column", borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1, width: overlayWidth, marginLeft: 2, marginTop: 3, backgroundColor: "black", children: [_jsx(Text, { bold: true, color: "cyan", children: "FIND FILE" }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "> " }), fileSearchInput || _jsx(Text, { color: "gray", children: "Type part of a file name or path" })] }), _jsx(Text, { color: "gray", children: "Up/Down select  Enter open  Escape close" }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [fileSearchResults.map((entry, index) => {
+                                const selected = index === Math.min(fileSearchIndex, Math.max(0, fileSearchResults.length - 1));
+                                const fileName = entry.path.split("/").at(-1) ?? entry.path;
+                                return _jsxs(Text, { color: selected ? "cyan" : undefined, bold: selected, children: [selected ? "> " : "  ", fileName, _jsxs(Text, { color: "gray", children: ["  ", truncate(entry.path, Math.max(12, overlayWidth - fileName.length - 10))] })] }, entry.path);
+                            }), !fileSearchResults.length && _jsx(Text, { color: "yellow", children: "No matching files." })] })] }), screen === "settings" && _jsxs(Box, { position: "absolute", flexDirection: "column", borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1, width: overlayWidth, marginLeft: 2, marginTop: 3, backgroundColor: "black", children: [_jsx(Text, { bold: true, color: "cyan", children: "LOCAL MODEL CONFIGURATION" }), _jsx(Text, { color: "gray", children: "Tab changes fields. Enter selects an item or saves when endpoint and model are set." }), _jsxs(Text, { color: settingsField === "server" ? "cyan" : undefined, children: ["SERVER: ", selectedEndpoint?.label ?? "Scanning local servers..."] }), _jsxs(Text, { color: settingsField === "endpoint" ? "cyan" : undefined, children: ["ENDPOINT: ", endpointInput] }), _jsxs(Text, { color: settingsField === "model" ? "cyan" : undefined, children: ["MODEL: ", modelInput || models[modelIndex] || "Choose or type a model"] }), _jsxs(Text, { color: settingsField === "internet" ? "cyan" : undefined, children: ["INTERNET RESEARCH: ", internetAccess ? "enabled" : "disabled", " ", settingsField === "internet" ? "[Space toggles]" : ""] }), _jsxs(Text, { color: "gray", children: ["Detected models: ", models.slice(0, 5).join(", ") || "none; type one manually"] }), _jsxs(Text, { color: "yellow", children: ["Provider: ", providerKind, ". Use the server selector for Ollama or compatible endpoints."] })] }), screen === "approval" && _jsxs(Box, { position: "absolute", flexDirection: "column", borderStyle: "double", borderColor: "yellow", paddingX: 2, paddingY: 1, width: overlayWidth, marginLeft: 2, marginTop: 8, backgroundColor: "black", children: [_jsx(Text, { bold: true, color: "yellow", children: "TOOL APPROVAL REQUIRED" }), _jsxs(Text, { children: [pendingTool?.name, " ", JSON.stringify(pendingTool?.input)] }), _jsx(Text, { color: "gray", children: "Press Y or Enter to allow. Press N or Escape to deny." })] }), screen === "help" && _jsxs(Box, { position: "absolute", flexDirection: "column", borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1, width: overlayWidth, marginLeft: 2, marginTop: 7, backgroundColor: "black", children: [_jsx(Text, { bold: true, color: "cyan", children: "WORKSPACE COMMANDS" }), workspaceCommandHelp().split("\n").slice(1).map((line) => _jsx(Text, { children: line }, line)), _jsx(Text, { color: "gray", children: "Type slash commands in the Agent or Terminal pane. Press any key to close." })] })] });
+}
+const initialConfiguration = await resolveConfiguration({ workspaceRoot: cwd() }).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.startsWith("Set a model"))
+        return undefined;
+    throw error;
+});
+const application = render(_jsx(App, { initialConfiguration: initialConfiguration }));
+await application.waitUntilExit();

package/dist/file-browser.d.ts

@@ -0,0 +1,21 @@
+export interface FileEntry {
+    readonly path: string;
+}
+export interface FileTreeEntry {
+    readonly kind: "directory" | "file";
+    readonly path: string;
+    readonly name: string;
+    readonly depth: number;
+    readonly expanded?: boolean;
+}
+export interface SyntaxToken {
+    readonly text: string;
+    readonly color?: "blue" | "cyan" | "gray" | "green" | "magenta" | "red" | "yellow";
+    readonly dim?: boolean;
+}
+export declare function buildFileTree(files: readonly FileEntry[], collapsed: ReadonlySet<string>): readonly FileTreeEntry[];
+export declare function fuzzyScore(path: string, query: string): number | undefined;
+export declare function fuzzyFiles(files: readonly FileEntry[], query: string, limit?: number): readonly FileEntry[];
+export declare function syntaxTokens(line: string, path: string): readonly SyntaxToken[];
+export declare function clipSyntaxTokens(tokens: readonly SyntaxToken[], maximumCharacters: number): readonly SyntaxToken[];
+export declare function wrapSyntaxTokens(tokens: readonly SyntaxToken[], maximumCharacters: number): readonly (readonly SyntaxToken[])[];

package/dist/file-browser.js

@@ -0,0 +1,147 @@
+import { extname } from "node:path";
+export function buildFileTree(files, collapsed) {
+    const root = { directories: new Map(), files: [] };
+    for (const file of files) {
+        const parts = file.path.replaceAll("\\", "/").split("/").filter(Boolean);
+        const fileName = parts.pop();
+        if (!fileName)
+            continue;
+        let node = root;
+        for (const part of parts) {
+            let child = node.directories.get(part);
+            if (!child) {
+                child = { directories: new Map(), files: [] };
+                node.directories.set(part, child);
+            }
+            node = child;
+        }
+        node.files.push({ path: [...parts, fileName].join("/") });
+    }
+    const result = [];
+    const append = (node, parentPath, depth) => {
+        const directories = [...node.directories.entries()].sort(([left], [right]) => left.localeCompare(right));
+        for (const [name, child] of directories) {
+            const path = parentPath ? `${parentPath}/${name}` : name;
+            const expanded = !collapsed.has(path);
+            result.push({ kind: "directory", path, name, depth, expanded });
+            if (expanded)
+                append(child, path, depth + 1);
+        }
+        for (const file of [...node.files].sort((left, right) => left.path.localeCompare(right.path))) {
+            result.push({
+                kind: "file",
+                path: file.path,
+                name: file.path.split("/").at(-1) ?? file.path,
+                depth
+            });
+        }
+    };
+    append(root, "", 0);
+    return result;
+}
+export function fuzzyScore(path, query) {
+    const target = path.toLocaleLowerCase();
+    const needle = query.trim().toLocaleLowerCase();
+    if (!needle)
+        return 0;
+    let position = 0;
+    let score = 0;
+    for (const character of needle) {
+        const next = target.indexOf(character, position);
+        if (next === -1)
+            return undefined;
+        score += next - position;
+        position = next + 1;
+    }
+    const fileName = target.split("/").at(-1) ?? target;
+    if (fileName.startsWith(needle))
+        score -= 60;
+    else if (fileName.includes(needle))
+        score -= 35;
+    else if (target.includes(needle))
+        score -= 20;
+    return score + path.length / 1_000;
+}
+export function fuzzyFiles(files, query, limit = 12) {
+    return files
+        .flatMap((file) => {
+        const score = fuzzyScore(file.path, query);
+        return score === undefined ? [] : [{ file, score }];
+    })
+        .sort((left, right) => left.score - right.score || left.file.path.localeCompare(right.file.path))
+        .slice(0, limit)
+        .map(({ file }) => file);
+}
+const codeExtensions = new Set([".c", ".cc", ".cpp", ".cs", ".go", ".java", ".js", ".jsx", ".kt", ".mjs", ".php", ".py", ".rb", ".rs", ".sh", ".ts", ".tsx"]);
+const markupExtensions = new Set([".html", ".htm", ".svg", ".vue", ".svelte", ".xml"]);
+const dataExtensions = new Set([".json", ".jsonc", ".yaml", ".yml", ".toml"]);
+function tokenize(line, pattern, colors) {
+    const result = [];
+    let cursor = 0;
+    for (const match of line.matchAll(pattern)) {
+        const index = match.index ?? 0;
+        if (index > cursor)
+            result.push({ text: line.slice(cursor, index) });
+        const group = match.slice(1).findIndex((value) => value !== undefined);
+        result.push({ text: match[0], color: colors[Math.max(0, group)], dim: group === 0 });
+        cursor = index + match[0].length;
+    }
+    if (cursor < line.length)
+        result.push({ text: line.slice(cursor) });
+    return result.length ? result : [{ text: line }];
+}
+export function syntaxTokens(line, path) {
+    const extension = extname(path).toLowerCase();
+    if (markupExtensions.has(extension)) {
+        return tokenize(line, /(<!--.*?-->)|(<\/?[A-Za-z][^>]*>)|("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')/g, ["gray", "cyan", "green"]);
+    }
+    if (extension === ".md" || extension === ".mdx") {
+        return tokenize(line, /(^\s*#{1,6}\s.*$)|(`[^`]*`)|(\*\*[^*]+\*\*)|(\[[^\]]+\]\([^)]+\))/g, ["cyan", "green", "yellow", "blue"]);
+    }
+    if (dataExtensions.has(extension)) {
+        return tokenize(line, /(^\s*(?:#|\/\/).*$)|("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')|\b(true|false|null)\b|(-?\b\d+(?:\.\d+)?\b)|([{}[\],:=])/g, ["gray", "green", "magenta", "yellow", "cyan"]);
+    }
+    if (codeExtensions.has(extension)) {
+        const comment = extension === ".py" || extension === ".rb" || extension === ".sh"
+            ? /(#.*$)|("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`)|(\b(?:as|async|await|break|case|catch|class|const|continue|def|default|delete|do|else|enum|export|extends|false|finally|fn|for|from|function|if|implements|import|in|instanceof|interface|let|match|new|null|package|private|protected|public|return|static|struct|super|switch|this|throw|true|try|type|typeof|undefined|use|var|void|while|yield)\b)|(\b(?:0x[\da-f]+|\d+(?:\.\d+)?)\b)|([{}()[\].,:;=+\-*/<>!?&|]+)/gi
+            : /(\/\/.*$)|("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`)|(\b(?:as|async|await|break|case|catch|class|const|continue|def|default|delete|do|else|enum|export|extends|false|finally|fn|for|from|function|if|implements|import|in|instanceof|interface|let|match|new|null|package|private|protected|public|return|static|struct|super|switch|this|throw|true|try|type|typeof|undefined|use|var|void|while|yield)\b)|(\b(?:0x[\da-f]+|\d+(?:\.\d+)?)\b)|([{}()[\].,:;=+\-*/<>!?&|]+)/gi;
+        return tokenize(line, comment, ["gray", "green", "magenta", "yellow", "cyan"]);
+    }
+    return [{ text: line }];
+}
+export function clipSyntaxTokens(tokens, maximumCharacters) {
+    const result = [];
+    let remaining = Math.max(0, maximumCharacters);
+    for (const token of tokens) {
+        if (!remaining)
+            break;
+        const text = token.text.slice(0, remaining);
+        if (text)
+            result.push({ ...token, text });
+        remaining -= text.length;
+    }
+    return result;
+}
+export function wrapSyntaxTokens(tokens, maximumCharacters) {
+    const width = Math.max(1, maximumCharacters);
+    const rows = [[]];
+    let rowLength = 0;
+    for (const token of tokens) {
+        let remaining = token.text;
+        if (!remaining && rows.length === 1 && !rows[0].length)
+            rows[0].push(token);
+        while (remaining) {
+            const available = width - rowLength;
+            if (!available) {
+                rows.push([]);
+                rowLength = 0;
+                continue;
+            }
+            const text = remaining.slice(0, available);
+            rows.at(-1)?.push({ ...token, text });
+            rowLength += text.length;
+            remaining = remaining.slice(text.length);
+        }
+    }
+    return rows;
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@truss-harness/tui",
+  "version": "0.1.0",
+  "description": "Interactive terminal client for Truss.",
+  "type": "module",
+  "bin": {
+    "truss-tui": "./dist/bin.js"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "prepack": "node ../../scripts/clean-publish-tests.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "logo.png"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/truss-agent/truss-harness.git"
+  },
+  "bugs": {
+    "url": "https://github.com/truss-agent/truss-harness/issues"
+  },
+  "homepage": "https://github.com/truss-agent/truss-harness#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "ai",
+    "coding-agent",
+    "tui",
+    "terminal",
+    "ollama",
+    "local-first"
+  ],
+  "dependencies": {
+    "ink": "^6.8.0",
+    "react": "^19.2.0",
+    "@truss-harness/branding": "0.1.0",
+    "@truss-harness/cli": "0.1.0",
+    "@truss-harness/provider-openai-compatible": "0.1.0",
+    "@truss-harness/runtime": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.0"
+  }
+}