nou-cli 0.0.0-stage → 0.2.0

package/dist/src/ui/App.js

@@ -0,0 +1,671 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { readFileSync, writeFileSync } from "fs";
+import path from "path";
+import { Box, Text, useApp, useInput, useWindowSize } from "ink";
+import { Agent, buildSystemPrompt } from "../agent/index.js";
+import { describe, providers, resolveModel, saveModel } from "../providers/index.js";
+import { loadSettings, saveSettings } from "../config/index.js";
+import { branch as gitBranch, diffAgainstHead, isRepo, status as gitStatus, summary as gitSummary } from "../git/index.js";
+import { gitTools } from "../git/tools.js";
+import { BUILTIN_PLUGINS, discoverPlugins, isEnabled, loadPlugin, trustPatch } from "../plugins/index.js";
+import { DiagnosticsManager, formatDiagnostic, newProblems } from "../diagnostics/index.js";
+import { Timeline } from "../history/index.js";
+import { lsp } from "../lsp/index.js";
+import { onGrammarLoaded, preload } from "../syntax/index.js";
+import { checkForUpdate } from "../update/index.js";
+import { changedLines } from "./text.js";
+import { ProblemsView } from "./ProblemsView.js";
+import { C } from "./theme.js";
+import { FileTree } from "./FileTree.js";
+import { CodeView } from "./CodeView.js";
+import { Editor } from "./Editor.js";
+import { Chat } from "./Chat.js";
+import { Header } from "./Header.js";
+import { QuickOpen, listAllFiles } from "./QuickOpen.js";
+import { Settings } from "./Settings.js";
+const FOCUS_ORDER = ["tree", "code", "chat"];
+const NO_LINES = new Set();
+const HELP = `Commands:
+  /settings            models, preferences and plugins
+  /model               show providers and the current model
+  /model <provider[:model]>  switch, e.g. /model anthropic  /model ollama:qwen3:8b
+  /models [provider]   list models a provider offers
+  /clear               start a fresh conversation
+  /undo                undo Nou's last change (also: u)
+  /rewind              undo everything from Nou's last turn
+  /history             recent changes
+Keys:
+  Ctrl+P  find a file      Tab  switch pane      Esc  stop / back
+  e  edit open file        v    diff (git / Nou)  f   follow mode
+  p  problems              u    undo Nou's edit   s   settings
+  c  (in files) show only changed files            Ctrl+C twice  quit
+In the editor: Ctrl+S save · Ctrl+Z/Y undo/redo · Ctrl+K info · Ctrl+G go to definition`;
+function readText(filePath) {
+    try {
+        return readFileSync(path.resolve(process.cwd(), filePath), "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+export function App({ initialModel, permContext }) {
+    const { exit } = useApp();
+    const { columns, rows } = useWindowSize();
+    const [settings, setSettings] = useState(loadSettings);
+    const [view, setView] = useState("main");
+    const [quickOpen, setQuickOpen] = useState(false);
+    const [focus, setFocus] = useState("chat");
+    const [follow, setFollow] = useState(settings.followMode);
+    const [entries, setEntries] = useState([]);
+    const [streaming, setStreaming] = useState("");
+    const [busy, setBusy] = useState(null);
+    const [choice, setChoice] = useState(initialModel);
+    const [approval, setApproval] = useState(null);
+    const [openFile, setOpenFile] = useState(null);
+    const [content, setContent] = useState("");
+    const [reveal, setReveal] = useState(null);
+    const [treeVersion, setTreeVersion] = useState(0);
+    // The last change Nou made per file, so we can flag edited lines and re-open the diff.
+    const [changes, setChanges] = useState(new Map());
+    const [diffMode, setDiffMode] = useState("off");
+    const [editing, setEditing] = useState(false);
+    const [git, setGit] = useState(() => gitStatus());
+    const [plugins, setPlugins] = useState([]);
+    const [viewport, setViewport] = useState(null);
+    const [editorState, setEditorState] = useState(null);
+    // Unsaved editor text survives switching to a diff and back.
+    const draft = useRef(null);
+    const [codePanel, setCodePanel] = useState("code");
+    const [, setDiagVersion] = useState(0);
+    const [syntaxVersion, setSyntaxVersion] = useState(0);
+    const [focusLine, setFocusLine] = useState(null);
+    const [editorStart, setEditorStart] = useState({ line: 1, nonce: 0 });
+    const [pendingNote, setPendingNote] = useState(null);
+    const [exitArmed, setExitArmed] = useState(false);
+    const [update, setUpdate] = useState(null);
+    const diagnosticsRef = useRef(null);
+    diagnosticsRef.current ??= new DiagnosticsManager();
+    const diagnostics = diagnosticsRef.current;
+    const timelineRef = useRef(null);
+    timelineRef.current ??= new Timeline();
+    const timeline = timelineRef.current;
+    const followRef = useRef(follow);
+    followRef.current = follow;
+    const settingsRef = useRef(settings);
+    settingsRef.current = settings;
+    const refreshGit = useCallback(() => setGit(gitStatus()), []);
+    const allFiles = useMemo(() => (quickOpen ? listAllFiles() : []), [quickOpen]);
+    const repo = useMemo(() => isRepo(), []);
+    const branch = useMemo(() => (repo ? gitBranch() : null), [repo, git]);
+    const open = useCallback((filePath) => {
+        setOpenFile(filePath);
+        setContent(readText(filePath));
+        setDiffMode("off");
+        setEditing(false);
+        setCodePanel("code");
+        preload(filePath);
+        void diagnosticsRef.current.checkFile(filePath);
+    }, []);
+    const agentRef = useRef(null);
+    if (!agentRef.current) {
+        agentRef.current = new Agent(initialModel, buildSystemPrompt(permContext), {
+            onEntry: (entry) => setEntries((prev) => [...prev, entry]),
+            onStream: setStreaming,
+            onBusy: setBusy,
+            onRead: (filePath) => {
+                if (!followRef.current)
+                    return;
+                open(filePath);
+                setReveal(filePath);
+            },
+            onChange: (change, status, turn) => {
+                if (status === "applied") {
+                    timelineRef.current.record({ path: change.path, before: change.isNew ? null : change.before, after: change.after, source: "nou", turn });
+                }
+                const lines = status === "applied" ? changedLines(change.before, change.after) : NO_LINES;
+                setChanges((prev) => new Map(prev).set(change.path, { change, status, lines }));
+                // Diffs awaiting approval are always shown, follow mode or not.
+                if (status === "pending" || followRef.current) {
+                    setOpenFile(change.path);
+                    setContent(status === "applied" ? change.after : readText(change.path));
+                    setDiffMode("off");
+                    setReveal(change.path);
+                }
+                if (status === "applied") {
+                    setTreeVersion((v) => v + 1);
+                    setGit(gitStatus());
+                    if (draft.current?.path === change.path) {
+                        setEntries((prev) => [...prev, { kind: "info", text: `Heads up: you have unsaved edits in ${change.path}; saving them will overwrite Nou's change.` }]);
+                    }
+                }
+            },
+            approve: (request) => {
+                const s = settingsRef.current;
+                if ((request.kind === "change" && s.autoApproveEdits) || (request.kind !== "change" && s.autoApproveCommands)) {
+                    return Promise.resolve(true);
+                }
+                return new Promise((resolve) => setApproval({ request, resolve }));
+            },
+            checkChange: async (change) => {
+                const introduced = await diagnosticsRef.current.introducedBy(change.path, change.before, change.after);
+                return introduced.length ? introduced.slice(0, 15).map((d) => formatDiagnostic(d)).join("\n") : null;
+            },
+        });
+    }
+    useEffect(() => diagnostics.subscribe(() => setDiagVersion((v) => v + 1)), []);
+    useEffect(() => onGrammarLoaded(() => setSyntaxVersion((v) => v + 1)), []);
+    useEffect(() => {
+        void checkForUpdate().then(setUpdate);
+    }, []);
+    // Discover plugins once and load the enabled ones.
+    useEffect(() => {
+        void (async () => {
+            const found = discoverPlugins();
+            const saved = loadSettings();
+            setPlugins(await Promise.all(found.map((p) => (isEnabled(p, saved) ? loadPlugin(p) : p))));
+        })();
+    }, []);
+    const allPlugins = useMemo(() => [...BUILTIN_PLUGINS, ...plugins], [plugins]);
+    const activePlugins = useMemo(() => allPlugins.filter((p) => isEnabled(p, settings) && p.plugin), [allPlugins, settings.plugins, settings.trustedPlugins]);
+    // Checkers come from enabled plugins (built-in ones included).
+    const firstCheck = useRef(true);
+    useEffect(() => {
+        diagnostics.setProviders(activePlugins.flatMap((p) => p.plugin.diagnostics ?? []));
+        if (firstCheck.current) {
+            firstCheck.current = false;
+            setTimeout(() => void diagnostics.checkProject(), 1500);
+        }
+    }, [activePlugins]);
+    // Keep the agent's system prompt and tools in sync with settings and plugins.
+    useEffect(() => {
+        const extras = [];
+        const extraTools = [];
+        if (settings.gitContext && repo) {
+            const summary = gitSummary();
+            if (summary)
+                extras.push(summary);
+            extraTools.push(...gitTools());
+        }
+        for (const { plugin } of activePlugins) {
+            if (plugin.systemPrompt)
+                extras.push(`Plugin ${plugin.name}: ${plugin.systemPrompt}`);
+            for (const tool of plugin.tools ?? []) {
+                extraTools.push({
+                    definition: tool.definition,
+                    readOnly: !!tool.readOnly,
+                    source: plugin.name,
+                    run: (args) => tool.run(args, { cwd: process.cwd() }),
+                });
+            }
+        }
+        extraTools.push({
+            source: "problems",
+            readOnly: true,
+            definition: {
+                name: "get_diagnostics",
+                description: "Get errors and warnings from the project's linters, type checker and language servers, for one file or the whole project.",
+                parameters: { type: "object", properties: { path: { type: "string", description: "Optional file. Omit for the whole project." } }, required: [] },
+            },
+            run: async (args) => {
+                const file = typeof args.path === "string" ? args.path : null;
+                if (file)
+                    await diagnostics.checkFile(file);
+                else
+                    await diagnostics.checkProject();
+                const list = file ? diagnostics.get(file) : diagnostics.all();
+                return list.length ? list.slice(0, 100).map((d) => formatDiagnostic(d, true)).join("\n") : "No problems found.";
+            },
+        });
+        agentRef.current.configure({ system: buildSystemPrompt(permContext, extras), extraTools, effort: settings.effort });
+    }, [settings.gitContext, settings.effort, activePlugins]);
+    // Pick up changes made outside Nou (other editors, git commands).
+    useEffect(() => {
+        if (!repo)
+            return;
+        const timer = setInterval(() => {
+            if (!busy)
+                setGit(gitStatus());
+        }, 4000);
+        return () => clearInterval(timer);
+    }, [repo, busy]);
+    useEffect(() => {
+        if (busy)
+            return;
+        refreshGit();
+        if (openFile && diffMode === "off" && !editing)
+            setContent(readText(openFile));
+    }, [busy]);
+    const updateSettings = (patch) => setSettings(saveSettings(patch));
+    const switchModel = (next) => {
+        const problem = next.provider.unavailable();
+        if (problem) {
+            setEntries((prev) => [...prev, { kind: "error", text: `${next.provider.label} isn't set up: ${problem}` }]);
+            return false;
+        }
+        agentRef.current.setModel(next);
+        setChoice(next);
+        saveModel(next);
+        setSettings(loadSettings());
+        setEntries((prev) => [...prev, { kind: "info", text: `Now using ${describe(next)}. The conversation carries over.` }]);
+        return true;
+    };
+    const togglePlugin = async (id, enabled) => {
+        const entry = allPlugins.find((p) => p.id === id);
+        if (!entry)
+            return;
+        updateSettings(trustPatch(entry, enabled, settings));
+        if (!enabled)
+            return;
+        if (!entry.plugin) {
+            const loaded = await loadPlugin(entry);
+            setPlugins((prev) => prev.map((p) => (p.id === id ? loaded : p)));
+        }
+    };
+    const answer = (ok) => {
+        approval?.resolve(ok);
+        setApproval(null);
+    };
+    const record = openFile ? changes.get(openFile) : undefined;
+    const pendingChange = approval?.request.kind === "change" ? approval.request.change : null;
+    const gitChange = useMemo(() => (diffMode === "git" && openFile ? diffAgainstHead(openFile, content) : null), [diffMode, openFile, content]);
+    const diff = pendingChange ?? (diffMode === "git" ? gitChange : diffMode === "nou" && record ? record.change : null);
+    const showEditor = editing && !!openFile && !pendingChange;
+    // Check Nou's proposed edit before you approve it: does it add problems?
+    useEffect(() => {
+        setPendingNote(null);
+        if (!pendingChange)
+            return;
+        let cancelled = false;
+        void (async () => {
+            const before = await diagnostics.checkText(pendingChange.path, pendingChange.before);
+            const after = await diagnostics.checkText(pendingChange.path, pendingChange.after);
+            if (cancelled)
+                return;
+            const added = newProblems(before, after);
+            setPendingNote(added.length
+                ? { short: `⚠ +${added.length} problem${added.length === 1 ? "" : "s"}`, detail: added.slice(0, 3).map((d) => formatDiagnostic(d)).join("\n") }
+                : { short: "✓ no new problems", detail: null });
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [pendingChange]);
+    // Live problems while you type (debounced).
+    useEffect(() => {
+        if (!showEditor || !openFile || !editorState)
+            return;
+        const timer = setTimeout(() => void diagnostics.checkFile(openFile, editorState.lines.join("\n")), 700);
+        return () => clearTimeout(timer);
+    }, [editorState?.lines]);
+    /** Quit, saving the editor's unsaved text first if auto-save is on. */
+    const quit = () => {
+        if (draft.current && settings.autoSave !== "off")
+            saveFromEditor(draft.current.text, draft.current.path);
+        exit();
+    };
+    /** Quitting always takes two presses (Ctrl+C or q) within 2 seconds, so a stray key never loses work. */
+    const requestQuit = () => {
+        if (exitArmed)
+            return quit();
+        setExitArmed(true);
+        setTimeout(() => setExitArmed(false), 2000);
+    };
+    // Ctrl+C: stop Nou if it's working; otherwise press twice to quit.
+    useInput((input, key) => {
+        if (!(key.ctrl && input === "c"))
+            return;
+        if (busy || approval) {
+            agentRef.current?.cancel();
+            approval?.resolve(false);
+            setApproval(null);
+            return;
+        }
+        requestQuit();
+    });
+    const info = (text, kind = "info") => setEntries((prev) => [...prev, { kind, text }]);
+    /** After a file changes outside the normal flow (undo), refresh everything that shows it. */
+    const reload = (file) => {
+        if (file === openFile)
+            setContent(readText(file));
+        setTreeVersion((v) => v + 1);
+        refreshGit();
+        void diagnostics.checkFile(file);
+    };
+    const undoCheckpoints = (list) => {
+        const done = [];
+        for (const cp of list) {
+            const result = timeline.undo(cp);
+            if (result.ok) {
+                done.push(cp.path);
+                info(`↶ Undid Nou's change to ${cp.path}${result.merged ? " (kept your later edits)" : ""}`);
+                reload(cp.path);
+            }
+            else {
+                info(`Couldn't undo ${cp.path}: ${result.reason}. Press v on the file to see the diff.`, "error");
+            }
+        }
+        if (done.length)
+            agentRef.current.note(`The user undid your changes to ${done.join(", ")}; those files are back to how they were before your edits.`);
+    };
+    const undoLast = () => {
+        const last = timeline.lastNouChange();
+        if (!last)
+            return info("Nothing of Nou's to undo.");
+        undoCheckpoints([last]);
+    };
+    const rewind = () => {
+        const turn = timeline.lastTurn();
+        if (!turn.length)
+            return info("Nothing of Nou's to rewind.");
+        undoCheckpoints(turn);
+    };
+    const showHistory = () => {
+        const items = timeline.all.slice(-15).reverse();
+        if (!items.length)
+            return info("No changes recorded yet.");
+        info(`Recent changes (newest first):\n${items.map((c) => {
+            const time = new Date(c.time).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+            return `  ${time}  ${c.source === "nou" ? "Nou" : "you"}  ${c.before === null ? "created " : ""}${c.path}${c.undone ? "  (undone)" : ""}`;
+        }).join("\n")}\nUndo with /undo (last) or /rewind (whole last turn).`);
+    };
+    /**
+     * Before editing another file: an unsaved draft of a different file is saved (auto-save on) or kept and
+     * the switch refused (auto-save off). Never silently dropped. Returns whether it's OK to continue.
+     */
+    const settleDraft = (target) => {
+        if (!draft.current || draft.current.path === target)
+            return true;
+        if (settings.autoSave !== "off") {
+            saveFromEditor(draft.current.text, draft.current.path);
+            return true;
+        }
+        info(`You have unsaved edits in ${draft.current.path}. Open it and save (Ctrl+S) first, or turn on auto-save in settings.`, "error");
+        return false;
+    };
+    /** Opens a file at a line, in the editor if `edit` (used by the Problems list and go-to-definition). */
+    const openAt = (file, line, edit = false) => {
+        if (!settleDraft(file))
+            return;
+        if (file !== openFile)
+            open(file);
+        setReveal(file);
+        setCodePanel("code");
+        if (edit) {
+            setEditorStart((s) => ({ line, nonce: s.nonce + 1 }));
+            setEditing(true);
+            setFocus("code");
+        }
+        else {
+            setFocusLine((f) => ({ line, nonce: (f?.nonce ?? 0) + 1 }));
+        }
+    };
+    const startEditing = () => {
+        if (!openFile || !settleDraft(openFile))
+            return;
+        setDiffMode("off");
+        setCodePanel("code");
+        setEditorStart((s) => ({ line: viewport?.top ?? 1, nonce: s.nonce + 1 }));
+        setEditing(true);
+        setFocus("code");
+    };
+    const cycleDiff = () => {
+        if (!openFile)
+            return;
+        const order = ["off"];
+        if (git.has(openFile))
+            order.push("git");
+        if (record?.status === "applied")
+            order.push("nou");
+        if (order.length === 1) {
+            setEntries((prev) => [...prev, { kind: "info", text: `${openFile} has no changes vs git HEAD.` }]);
+            return;
+        }
+        setEditing(false);
+        setDiffMode((m) => order[(order.indexOf(m) + 1) % order.length]);
+    };
+    useInput((input, key) => {
+        if (approval) {
+            if (input === "y" || input === "Y")
+                answer(true);
+            else if (input === "n" || input === "N")
+                answer(false);
+            else if (key.escape) {
+                agentRef.current?.cancel();
+                answer(false);
+            }
+            return;
+        }
+        if (key.ctrl && input === "p") {
+            setQuickOpen(true);
+            return;
+        }
+        if (showEditor && focus === "code")
+            return; // the editor owns the keyboard
+        if (key.tab) {
+            const step = key.shift ? -1 : 1;
+            setFocus((f) => FOCUS_ORDER[(FOCUS_ORDER.indexOf(f) + step + FOCUS_ORDER.length) % FOCUS_ORDER.length]);
+            return;
+        }
+        if (key.escape) {
+            if (busy)
+                agentRef.current?.cancel();
+            else if (diffMode !== "off")
+                setDiffMode("off");
+            else
+                setFocus("chat");
+            return;
+        }
+        if (focus === "chat")
+            return; // letters belong to the text box
+        if (input === "f")
+            setFollow((f) => !f);
+        else if (input === "p") {
+            setCodePanel((p) => (p === "problems" ? "code" : "problems"));
+            setEditing(false);
+            setFocus("code");
+        }
+        else if (input === "u")
+            undoLast();
+        else if (input === "v")
+            cycleDiff();
+        else if (input === "e")
+            startEditing();
+        else if (input === "s" || input === ",")
+            setView("settings");
+        else if (input === "r") {
+            refreshGit();
+            setTreeVersion((v) => v + 1);
+        }
+        else if (input === "q")
+            requestQuit();
+    }, { isActive: view === "main" && !quickOpen && !(codePanel === "problems" && focus === "code") });
+    /** What the user is looking at, attached to each message so "this file" / "here" make sense. */
+    const editorContext = () => {
+        if (!openFile)
+            return null;
+        const unsaved = showEditor && editorState?.dirty;
+        const lines = showEditor && editorState ? editorState.lines : content.replace(/\r\n/g, "\n").split("\n");
+        let from;
+        let to;
+        let where;
+        if (showEditor && editorState) {
+            from = Math.max(1, editorState.line - 15);
+            to = Math.min(lines.length, editorState.line + 15);
+            where = `cursor on line ${editorState.line}`;
+        }
+        else {
+            from = viewport?.top ?? 1;
+            to = Math.min(lines.length, viewport?.bottom ?? 40, from + 80);
+            where = `lines ${from}-${to} visible`;
+        }
+        const snippet = lines.slice(from - 1, to).map((l, i) => `${String(from + i).padStart(4)}| ${l}`).join("\n");
+        return `<editor_context>
+The user has ${openFile} open in the editor (${where}${unsaved ? "; they have unsaved edits, shown below" : ""}${git.get(openFile) ? `; git status ${git.get(openFile)}` : ""}).
+${snippet}
+</editor_context>`;
+    };
+    const contextChip = openFile
+        ? `${openFile}${showEditor && editorState ? `:${editorState.line}${editorState.dirty ? " ✎ unsaved" : ""}` : viewport ? `:${viewport.top}-${viewport.bottom}` : ""}`
+        : null;
+    const runCommand = async (input) => {
+        const [command, ...rest] = input.slice(1).split(/\s+/);
+        const arg = rest.join(" ").trim();
+        switch (command) {
+            case "undo":
+                return undoLast();
+            case "rewind":
+                return rewind();
+            case "history":
+                return showHistory();
+            case "problems":
+                setCodePanel("problems");
+                setFocus("code");
+                return;
+            case "settings":
+                setView("settings");
+                return;
+            case "model": {
+                if (!arg) {
+                    const list = providers.map((p) => {
+                        const problem = p.unavailable();
+                        return `${p.id === choice.provider.id ? "▸" : " "} ${p.id.padEnd(10)} ${p.local ? "local " : "cloud "} ${problem ? `(${problem})` : `default ${p.defaultModel}`}`;
+                    });
+                    info(`Current: ${describe(choice)}\n${list.join("\n")}\nSwitch with /model <provider[:model]> or open /settings`);
+                    return;
+                }
+                switchModel(resolveModel(arg));
+                return;
+            }
+            case "models": {
+                const provider = arg ? providers.find((p) => p.id === arg) : choice.provider;
+                if (!provider)
+                    return info(`Unknown provider "${arg}". Try /model to see them.`, "error");
+                setBusy(`Listing ${provider.id} models...`);
+                try {
+                    const models = await provider.listModels();
+                    info(models.length ? `${provider.id} models:\n${models.slice(0, 60).map((m) => `  ${provider.id}:${m}`).join("\n")}` : `${provider.id} has no models.`);
+                }
+                catch (error) {
+                    info(`Couldn't list ${provider.id} models: ${error.message}`, "error");
+                }
+                finally {
+                    setBusy(null);
+                }
+                return;
+            }
+            case "clear":
+                agentRef.current.clear();
+                setEntries([]);
+                return;
+            case "help":
+                return info(HELP);
+            default: {
+                for (const { plugin } of activePlugins) {
+                    const found = plugin.commands?.find((c) => c.name === command);
+                    if (!found)
+                        continue;
+                    try {
+                        const out = await found.run(arg, { cwd: process.cwd() });
+                        if (out)
+                            info(out);
+                    }
+                    catch (error) {
+                        info(`/${command}: ${error.message}`, "error");
+                    }
+                    return;
+                }
+                return info(`Unknown command /${command}. Type /help.`, "error");
+            }
+        }
+    };
+    const send = (text) => {
+        if (text.startsWith("/")) {
+            void runCommand(text);
+            return;
+        }
+        setEntries((prev) => [...prev, { kind: "user", text }]);
+        void agentRef.current.send(text, editorContext() ?? undefined);
+    };
+    function saveFromEditor(text, file = openFile) {
+        if (!file)
+            return;
+        try {
+            const full = path.resolve(process.cwd(), file);
+            const before = readText(file);
+            writeFileSync(full, text, "utf-8");
+            timeline.record({ path: file, before, after: text, source: "you", turn: agentRef.current.turnId });
+            if (file === openFile)
+                setContent(text);
+            if (draft.current?.path === file)
+                draft.current = null;
+            setTreeVersion((v) => v + 1);
+            refreshGit();
+            void diagnostics.checkFile(file);
+            diagnostics.scheduleProject();
+        }
+        catch (error) {
+            setEntries((prev) => [...prev, { kind: "error", text: `Couldn't save ${file}: ${error.message}` }]);
+        }
+    }
+    if (view === "settings") {
+        return (_jsx(Settings, { width: columns, height: rows, settings: settings, choice: choice, plugins: allPlugins, onModel: (next) => switchModel(next), onChange: updateSettings, onTogglePlugin: (id, enabled) => void togglePlugin(id, enabled), onRescanPlugins: () => {
+                const found = discoverPlugins();
+                setPlugins((prev) => found.map((f) => prev.find((p) => p.id === f.id && p.plugin) ?? f));
+            }, onClose: () => setView("main") }));
+    }
+    const height = Math.max(10, rows - 2);
+    const treeWidth = Math.max(24, Math.floor(columns * 0.2));
+    const chatWidth = Math.max(34, Math.floor(columns * 0.3));
+    const codeWidth = Math.max(20, columns - treeWidth - chatWidth);
+    const edited = new Set([...changes].filter(([, c]) => c.status === "applied").map(([p]) => p));
+    const fileProblems = openFile ? diagnostics.get(openFile) : [];
+    const totals = diagnostics.counts();
+    const checking = diagnostics.busy;
+    const lspEnabled = activePlugins.some((p) => p.id === "lsp");
+    const mode = approval
+        ? { label: "APPROVE", color: C.yellow }
+        : showEditor ? { label: "EDIT", color: C.green }
+            : diff ? { label: "DIFF", color: C.accent2 }
+                : busy ? { label: "WORKING", color: C.accent2 }
+                    : { label: focus.toUpperCase(), color: C.accent };
+    const hints = approval
+        ? "y accept · n reject · Esc stop"
+        : showEditor && focus === "code"
+            ? `Ctrl+S save${settings.autoSave === "off" ? "" : " (auto-save on)"} · Ctrl+Z/Y undo/redo · Ctrl+K info · Ctrl+G definition · Esc close`
+            : focus === "chat"
+                ? busy ? "Esc stop · Tab switch pane" : "Enter send · / commands · Ctrl+P find file · Tab switch pane"
+                : focus === "tree"
+                    ? "↑↓ move · Enter open · c changes · e edit · p problems · u undo · Ctrl+P find · s settings"
+                    : diff ? "n/N next/prev change · v cycle diff · Esc close diff" : "↑↓ scroll · e edit · v diff · p problems · u undo · s settings";
+    return (_jsxs(Box, { flexDirection: "column", width: columns, height: rows, children: [_jsx(Header, { width: columns, branch: branch, changes: git.size, model: describe(choice), local: choice.provider.local, busy: busy, update: update }), _jsxs(Box, { flexDirection: "row", height: height, children: [_jsx(FileTree, { width: treeWidth, height: height, focused: focus === "tree" && !approval, openFile: openFile, reveal: reveal, version: treeVersion, changed: edited, git: git, problemCounts: diagnostics.fileCounts(), onOpen: (filePath) => {
+                            open(filePath);
+                            setFocus("code");
+                        }, onHover: () => { } }), codePanel === "problems" && !pendingChange ? (_jsx(ProblemsView, { width: codeWidth, height: height, focused: focus === "code" && !approval, problems: diagnostics.all(), checking: checking, onJump: (file, line) => openAt(file, line), onClose: () => setCodePanel("code") })) : showEditor ? (_jsx(Editor, { width: codeWidth, height: height, focused: focus === "code", filePath: openFile, initial: draft.current?.path === openFile ? draft.current.text : content, baseline: draft.current?.path === openFile ? draft.current.baseline : content, startLine: editorStart.line, problems: fileProblems, autoSave: settings.autoSave, syntaxVersion: syntaxVersion, onHover: (text, line, col) => (lspEnabled ? lsp.hover(openFile, text, line, col) : Promise.resolve(null)), onDefinition: (text, line, col) => {
+                            if (!lspEnabled)
+                                return info("Go to definition needs a language server (see /settings → Plugins).", "error");
+                            void lsp.definition(openFile, text, line, col).then((target) => {
+                                if (!target)
+                                    return info("No definition found here.");
+                                // Keep unsaved text when jumping within the same file.
+                                if (target.file === openFile && draft.current)
+                                    draft.current = { ...draft.current, text };
+                                openAt(target.file, target.line, true);
+                            });
+                        }, onSave: (text) => saveFromEditor(text), onExit: () => {
+                            draft.current = null;
+                            setEditing(false);
+                        }, onState: (state) => {
+                            setEditorState(state);
+                            draft.current = state.dirty
+                                ? { path: openFile, text: state.lines.join("\n"), baseline: draft.current?.path === openFile ? draft.current.baseline : content }
+                                : null;
+                        } }, `${openFile}:${editorStart.nonce}`)) : (_jsx(CodeView, { width: codeWidth, height: height, focused: focus === "code" && !approval, filePath: openFile, content: content, diff: diff, diffLabel: diffMode === "git" ? "vs HEAD" : "Nou's edit", pending: !!pendingChange, marked: record?.lines ?? NO_LINES, problems: fileProblems, focusLine: focusLine, syntaxVersion: syntaxVersion, diffNote: pendingChange ? pendingNote?.short ?? (checking.length ? "checking…" : null) : null, onViewport: (top, bottom) => setViewport((v) => (v?.top === top && v.bottom === bottom ? v : { top, bottom })) })), _jsx(Chat, { width: chatWidth, height: height, focused: focus === "chat", entries: entries, streaming: streaming, busy: busy, approval: approval?.request ?? null, approvalNote: pendingChange ? pendingNote?.detail ?? null : null, contextChip: contextChip, onSubmit: send })] }), _jsx(Box, { children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { backgroundColor: mode.color, color: "black", bold: true, children: ` ${mode.label} ` }), _jsx(Text, { backgroundColor: C.panel, color: follow ? C.green : C.dim, children: follow ? " ◉ follow " : " ○ follow " }), _jsx(Text, { backgroundColor: C.panel, color: totals.errors ? C.red : C.dim, children: ` ✖ ${totals.errors}` }), _jsx(Text, { backgroundColor: C.panel, color: totals.warnings ? C.yellow : C.dim, children: ` ▲ ${totals.warnings} ` }), checking.length > 0 && _jsxs(Text, { color: C.accent2, children: [" \u27F3 ", checking.join(", ")] }), exitArmed
+                            ? _jsxs(Text, { color: C.yellow, bold: true, children: ["  ", "Press again to quit", draft.current && settings.autoSave === "off" ? ` (unsaved changes in ${draft.current.path} will be lost)` : ""] })
+                            : _jsxs(Text, { color: C.dim, children: ["  ", hints] })] }) }), quickOpen && (_jsx(QuickOpen, { width: columns, top: 3, files: allFiles, onPick: (file) => {
+                    setQuickOpen(false);
+                    open(file);
+                    setReveal(file);
+                    setFocus("code");
+                }, onClose: () => setQuickOpen(false) }))] }));
+}