gnosys 5.5.0 → 5.6.0

package/dist/lib/chat/render.js

@@ -0,0 +1,737 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Chat TUI — ink-based React components.
+ *
+ * Layout:
+ *   ┌────────────────────────────────────────┐
+ *   │ Header: project | provider/model | tokens │
+ *   ├────────────────────────────────────────┤
+ *   │ Conversation                           │
+ *   │   user / assistant turns scroll        │
+ *   │   system messages in dim text          │
+ *   ├────────────────────────────────────────┤
+ *   │ Status: idle | thinking… | error       │
+ *   ├────────────────────────────────────────┤
+ *   │ > input prompt                         │
+ *   └────────────────────────────────────────┘
+ */
+import { useState, useEffect, useRef } from "react";
+import { Box, Text, useApp } from "ink";
+import TextInput from "ink-text-input";
+import SelectInput from "ink-select-input";
+import Spinner from "ink-spinner";
+import { dispatchCommand } from "./commands.js";
+import { appendEvent } from "./session.js";
+import { runTurn, buildProvider } from "./llmTurn.js";
+import { runRecall, reinforceMemory, buildRecallQuery } from "./recall.js";
+import { promoteToMemory, lastExchange, formatExchange, detectAutoPromote } from "./write.js";
+import { inferIntent, describeIntent, isDestructive, shouldAutoAccept, recordAcceptance, newAcceptanceLog, } from "./intent.js";
+import { extractChooseFence, formatSelection } from "./choose.js";
+import { newFocusState, applyFocus, applyBranch, applyResumeFocus, popBranch, } from "./focus.js";
+import { GnosysDB } from "../db.js";
+export const ChatApp = ({ initialHeader, initialBuffer, config, projectId, onExit }) => {
+    const { exit } = useApp();
+    const [header, setHeader] = useState(initialHeader);
+    const [buffer, setBuffer] = useState(initialBuffer);
+    const [status, setStatus] = useState({ kind: "idle" });
+    const [input, setInput] = useState("");
+    const [systemNotice, setSystemNotice] = useState([]);
+    const configRef = useRef(config);
+    // Recall state — pinned IDs, scope, threshold
+    const [pinnedIds, setPinnedIds] = useState([]);
+    const [scope, setScope] = useState("federated");
+    const [threshold, setThreshold] = useState(0);
+    // Intent detection — inferred-but-not-yet-confirmed action
+    const [pendingIntent, setPendingIntent] = useState(null);
+    const acceptanceLogRef = useRef(newAcceptanceLog());
+    // Multiple-choice — when the LLM emits a gnosys-choose fence, capture
+    // the block here and render a SelectInput in place of the regular text input.
+    const [pendingChoice, setPendingChoice] = useState(null);
+    // Focus boundaries — declared topic + saved snapshots + branch stack
+    const [focusState, setFocusState] = useState(newFocusState());
+    function nowIso() {
+        return new Date().toISOString();
+    }
+    function pushSystem(lines) {
+        const arr = Array.isArray(lines) ? lines : [lines];
+        setSystemNotice(arr);
+        // Auto-clear after a few seconds so the buffer doesn't grow with stale notices
+        setTimeout(() => setSystemNotice([]), 5000);
+    }
+    /** Run an inferred intent as if the user had typed the equivalent slash command. */
+    async function executeIntent(intent) {
+        const cmdText = describeIntent(intent);
+        appendEvent(header.sessionId, {
+            type: "intent_inferred",
+            ts: nowIso(),
+            pattern: intent.matchedPattern ?? "(llm)",
+            intent: intent.command,
+            accepted: true,
+        });
+        // Re-enter handleSubmit with the slash form — reuses the existing dispatch path
+        await handleSubmit(cmdText);
+    }
+    async function handleSubmit(raw) {
+        const text = raw.trim();
+        if (!text) {
+            // Empty submit while a pending intent is shown → accept
+            if (pendingIntent) {
+                const intent = pendingIntent;
+                recordAcceptance(acceptanceLogRef.current, intent.matchedPattern);
+                setPendingIntent(null);
+                setInput("");
+                await executeIntent(intent);
+                return;
+            }
+            return;
+        }
+        setInput("");
+        // Pending-intent confirm step ──────────────────────────────────────
+        if (pendingIntent) {
+            const lower = text.toLowerCase();
+            if (lower === "y" || lower === "yes") {
+                const intent = pendingIntent;
+                recordAcceptance(acceptanceLogRef.current, intent.matchedPattern);
+                setPendingIntent(null);
+                await executeIntent(intent);
+                return;
+            }
+            if (lower === "n" || lower === "no") {
+                appendEvent(header.sessionId, {
+                    type: "intent_inferred",
+                    ts: nowIso(),
+                    pattern: pendingIntent.matchedPattern ?? "(llm)",
+                    intent: pendingIntent.command,
+                    accepted: false,
+                });
+                setPendingIntent(null);
+                pushSystem("Intent declined. Type your message normally.");
+                return;
+            }
+            if (lower === "e" || lower === "edit") {
+                // Drop the intent into the input box for tweaking
+                const cmdText = describeIntent(pendingIntent);
+                setPendingIntent(null);
+                setInput(cmdText);
+                return;
+            }
+            // Anything else cancels the pending intent and is treated as the new input
+            setPendingIntent(null);
+            pushSystem("Intent declined.");
+            // Fall through to normal handling of `text`
+        }
+        // Slash command path
+        if (text.startsWith("/")) {
+            const ctx = {
+                sessionId: header.sessionId,
+                buffer,
+                provider: header.provider,
+                model: header.model,
+            };
+            appendEvent(header.sessionId, {
+                type: "command",
+                ts: nowIso(),
+                name: text.split(/\s+/)[0],
+                args: text.split(/\s+/).slice(1),
+            });
+            const result = await dispatchCommand(text, ctx);
+            if (!result)
+                return; // not a command, fall through (shouldn't happen since we checked /)
+            switch (result.kind) {
+                case "ok":
+                    if (result.message)
+                        pushSystem(result.message);
+                    break;
+                case "show":
+                    pushSystem(result.lines);
+                    break;
+                case "clear-buffer":
+                    setBuffer([]);
+                    pushSystem("Buffer cleared (session log preserved).");
+                    break;
+                case "switch-provider": {
+                    try {
+                        const p = buildProvider(configRef.current, result.provider, result.model);
+                        setHeader((h) => ({ ...h, provider: p.name, model: p.model }));
+                        pushSystem(`Switched to ${p.name} / ${p.model}`);
+                    }
+                    catch (err) {
+                        pushSystem(`Failed to switch provider: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    break;
+                }
+                case "exit":
+                    appendEvent(header.sessionId, { type: "session_end", ts: nowIso(), reason: "quit" });
+                    if (onExit)
+                        onExit();
+                    exit();
+                    break;
+                case "pin":
+                    if (pinnedIds.includes(result.memoryId)) {
+                        pushSystem(`Already pinned: ${result.memoryId}`);
+                    }
+                    else {
+                        setPinnedIds((p) => [...p, result.memoryId]);
+                        appendEvent(header.sessionId, { type: "pin", ts: nowIso(), memory_id: result.memoryId });
+                        pushSystem(`Pinned ${result.memoryId} — included in every turn until /unpin`);
+                    }
+                    break;
+                case "unpin":
+                    if (!pinnedIds.includes(result.memoryId)) {
+                        pushSystem(`Not pinned: ${result.memoryId}`);
+                    }
+                    else {
+                        setPinnedIds((p) => p.filter((id) => id !== result.memoryId));
+                        appendEvent(header.sessionId, { type: "unpin", ts: nowIso(), memory_id: result.memoryId });
+                        pushSystem(`Unpinned ${result.memoryId}`);
+                    }
+                    break;
+                case "scope":
+                    setScope(result.scope);
+                    pushSystem(`Recall scope set to ${result.scope}`);
+                    break;
+                case "threshold":
+                    setThreshold(result.value);
+                    pushSystem(`Confidence threshold set to ${result.value}`);
+                    break;
+                case "preview-recall": {
+                    const db = GnosysDB.openCentral();
+                    if (!db.isAvailable()) {
+                        pushSystem("Central DB unavailable");
+                        db.close();
+                        break;
+                    }
+                    try {
+                        const recalled = runRecall(db, {
+                            query: result.query,
+                            scope,
+                            projectId,
+                            threshold,
+                            pinnedIds,
+                        });
+                        if (recalled.memories.length === 0) {
+                            pushSystem(`No memories matched "${result.query}"`);
+                        }
+                        else {
+                            const lines = [`Recall preview (${recalled.memories.length} match${recalled.memories.length === 1 ? "" : "es"}):`];
+                            for (const m of recalled.memories) {
+                                const tag = m.pinned ? " [pinned]" : "";
+                                lines.push(`  ${m.id.padEnd(14)} ${m.confidence.toFixed(2)}  ${m.title}${tag}`);
+                            }
+                            pushSystem(lines);
+                        }
+                    }
+                    finally {
+                        db.close();
+                    }
+                    break;
+                }
+                case "reinforce": {
+                    const db = GnosysDB.openCentral();
+                    if (!db.isAvailable()) {
+                        pushSystem("Central DB unavailable");
+                        db.close();
+                        break;
+                    }
+                    try {
+                        const ok = reinforceMemory(db, result.memoryId);
+                        pushSystem(ok ? `Reinforced ${result.memoryId}` : `Memory not found: ${result.memoryId}`);
+                    }
+                    finally {
+                        db.close();
+                    }
+                    break;
+                }
+                case "remember": {
+                    const db = GnosysDB.openCentral();
+                    if (!db.isAvailable()) {
+                        pushSystem("Central DB unavailable");
+                        db.close();
+                        break;
+                    }
+                    try {
+                        const promoted = await promoteToMemory(db, {
+                            content: result.text,
+                            source: "remember",
+                            sessionId: header.sessionId,
+                            projectId,
+                            config: configRef.current,
+                        });
+                        appendEvent(header.sessionId, {
+                            type: "memory_promoted",
+                            ts: nowIso(),
+                            memory_id: promoted.id,
+                            source: "remember",
+                        });
+                        pushSystem(`Saved as ${promoted.id} — "${promoted.title}" [${promoted.category}]`);
+                    }
+                    catch (err) {
+                        pushSystem(`Failed to save: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    finally {
+                        db.close();
+                    }
+                    break;
+                }
+                case "save-turn": {
+                    const pair = lastExchange(buffer);
+                    if (!pair) {
+                        pushSystem("No recent user+assistant exchange to save.");
+                        break;
+                    }
+                    const db = GnosysDB.openCentral();
+                    if (!db.isAvailable()) {
+                        pushSystem("Central DB unavailable");
+                        db.close();
+                        break;
+                    }
+                    try {
+                        const promoted = await promoteToMemory(db, {
+                            content: formatExchange(pair),
+                            source: "save-turn",
+                            sessionId: header.sessionId,
+                            projectId,
+                            config: configRef.current,
+                        });
+                        appendEvent(header.sessionId, {
+                            type: "memory_promoted",
+                            ts: nowIso(),
+                            memory_id: promoted.id,
+                            source: "save-turn",
+                        });
+                        pushSystem(`Saved exchange as ${promoted.id} — "${promoted.title}" [${promoted.category}]`);
+                    }
+                    catch (err) {
+                        pushSystem(`Failed to save: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    finally {
+                        db.close();
+                    }
+                    break;
+                }
+                case "attach": {
+                    // Ingest the file via the existing multimodal pipeline, then pin
+                    // any resulting memories so they're injected into the next turn.
+                    pushSystem(`Ingesting ${result.filePath}…`);
+                    try {
+                        const { ingestFile } = await import("../multimodalIngest.js");
+                        const { GnosysResolver } = await import("../resolver.js");
+                        const r = new GnosysResolver();
+                        await r.resolve();
+                        const stores = r.getStores();
+                        if (stores.length === 0) {
+                            pushSystem("No store found — run 'gnosys init' first.");
+                            break;
+                        }
+                        const ingestResult = await ingestFile({
+                            filePath: result.filePath,
+                            storePath: stores[0].path,
+                        });
+                        const newIds = ingestResult.memories.map((m) => m.id).slice(0, 10);
+                        for (const id of newIds) {
+                            if (!pinnedIds.includes(id)) {
+                                setPinnedIds((p) => [...p, id]);
+                                appendEvent(header.sessionId, { type: "memory_promoted", ts: nowIso(), memory_id: id, source: "attach" });
+                                appendEvent(header.sessionId, { type: "pin", ts: nowIso(), memory_id: id });
+                            }
+                        }
+                        pushSystem(`Ingested ${newIds.length} memor${newIds.length === 1 ? "y" : "ies"} from ${result.filePath} — pinned for this session.`);
+                    }
+                    catch (err) {
+                        pushSystem(`Attach failed: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    break;
+                }
+                case "focus": {
+                    const updated = applyFocus(focusState, buffer, result.topic, nowIso());
+                    setFocusState(updated.state);
+                    setBuffer(updated.buffer);
+                    appendEvent(header.sessionId, {
+                        type: "focus",
+                        ts: nowIso(),
+                        topic: result.topic,
+                        previous_topic: updated.previousTopic ?? undefined,
+                    });
+                    pushSystem(updated.previousTopic
+                        ? `Focus: ${result.topic} (${updated.previousTopic} stashed — /resume-focus ${updated.previousTopic})`
+                        : `Focus: ${result.topic}`);
+                    break;
+                }
+                case "branch": {
+                    if (buffer.length === 0) {
+                        pushSystem("Nothing to branch — buffer is empty.");
+                        break;
+                    }
+                    setFocusState(applyBranch(focusState, buffer, nowIso()));
+                    appendEvent(header.sessionId, {
+                        type: "branch",
+                        ts: nowIso(),
+                        from_session: header.sessionId,
+                        new_session: header.sessionId, // Phase 7 keeps the same session log
+                    });
+                    pushSystem(`Branch saved (${focusState.branches.length + 1} on stack — /resume-focus to pop the latest).`);
+                    break;
+                }
+                case "resume-focus": {
+                    if (result.topic) {
+                        const restored = applyResumeFocus(focusState, buffer, result.topic, nowIso());
+                        if (!restored) {
+                            pushSystem(`No saved focus named "${result.topic}".`);
+                            break;
+                        }
+                        setFocusState(restored.state);
+                        setBuffer(restored.buffer);
+                        pushSystem(`Resumed focus: ${result.topic}`);
+                    }
+                    else {
+                        // No arg → pop most recent branch
+                        const popped = popBranch(focusState);
+                        if (!popped) {
+                            pushSystem("No branches on the stack and no topic given.");
+                            break;
+                        }
+                        setFocusState(popped.state);
+                        setBuffer(popped.buffer);
+                        pushSystem(`Restored branch (focus: ${popped.topic})`);
+                    }
+                    break;
+                }
+                case "export-session": {
+                    try {
+                        const { writeFileSync } = await import("fs");
+                        const path = await import("path");
+                        const md = renderSessionAsMarkdown(buffer, header.sessionId);
+                        const targetPath = path.resolve(result.filePath);
+                        writeFileSync(targetPath, md, "utf-8");
+                        pushSystem(`Exported ${buffer.length} turn(s) to ${targetPath}`);
+                    }
+                    catch (err) {
+                        pushSystem(`Export failed: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    break;
+                }
+                case "search-chats": {
+                    const { searchSessions } = await import("./session.js");
+                    const matches = searchSessions(result.query, 20);
+                    if (matches.length === 0) {
+                        pushSystem(`No matches for: ${result.query}`);
+                        break;
+                    }
+                    const lines = [`${matches.length} match(es):`];
+                    for (const m of matches.slice(0, 15)) {
+                        const text = (() => {
+                            const e = m.event;
+                            switch (e.type) {
+                                case "user":
+                                case "assistant":
+                                    return e.text;
+                                case "command":
+                                    return `${e.name} ${e.args.join(" ")}`;
+                                case "focus":
+                                    return e.topic;
+                                case "recall":
+                                    return e.query;
+                                default:
+                                    return "";
+                            }
+                        })();
+                        const preview = text.length > 80 ? text.slice(0, 77) + "..." : text;
+                        lines.push(`  ${m.sessionId.slice(0, 12)}…  [${m.event.type}]  ${preview}`);
+                    }
+                    pushSystem(lines);
+                    break;
+                }
+                case "dream-here": {
+                    // Run a focused dream cycle scoped to the memories surfaced in this session.
+                    // Pulls the cited_memory_ids from the session log and uses them as the
+                    // workset for the dream engine.
+                    pushSystem("Starting dream cycle for this session…");
+                    try {
+                        const { GnosysDB } = await import("../db.js");
+                        const { GnosysDreamEngine } = await import("../dream.js");
+                        const { readSession } = await import("./session.js");
+                        const db = GnosysDB.openCentral();
+                        if (!db.isAvailable()) {
+                            pushSystem("Central DB unavailable");
+                            db.close();
+                            break;
+                        }
+                        try {
+                            const events = readSession(header.sessionId);
+                            const cited = new Set();
+                            for (const e of events) {
+                                if (e.type === "assistant" && e.cited_memory_ids) {
+                                    for (const id of e.cited_memory_ids)
+                                        cited.add(id);
+                                }
+                                if (e.type === "recall") {
+                                    for (const id of e.memory_ids)
+                                        cited.add(id);
+                                }
+                            }
+                            if (cited.size === 0) {
+                                pushSystem("No memories surfaced this session yet — nothing to dream on.");
+                                db.close();
+                                break;
+                            }
+                            const engine = new GnosysDreamEngine(db, configRef.current, {
+                                enabled: true,
+                                idleMinutes: 0,
+                                maxRuntimeMinutes: 5,
+                                selfCritique: true,
+                                generateSummaries: false,
+                                discoverRelationships: true,
+                                minMemories: 1,
+                                provider: configRef.current.dream?.provider ?? "ollama",
+                                model: configRef.current.dream?.model,
+                            });
+                            const report = await engine.dream();
+                            pushSystem(`Dream complete — duration ${report.durationMs}ms; surfaced ${cited.size} session memories.`);
+                        }
+                        finally {
+                            db.close();
+                        }
+                    }
+                    catch (err) {
+                        pushSystem(`Dream-here failed: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    break;
+                }
+                case "error":
+                    pushSystem(`Error: ${result.message}`);
+                    break;
+            }
+            return;
+        }
+        // Free-text intent detection ──────────────────────────────────────
+        // Try to map the user's natural-language input to a slash command.
+        // If we find a match: auto-accept when the user has confirmed this
+        // pattern N times before, or render a [Y/n/edit] confirm prompt.
+        {
+            const intent = await inferIntent(text, configRef.current);
+            if (intent) {
+                const auto = shouldAutoAccept(acceptanceLogRef.current, intent.matchedPattern);
+                if (auto && !isDestructive(intent.command)) {
+                    await executeIntent(intent);
+                    return;
+                }
+                setPendingIntent(intent);
+                appendEvent(header.sessionId, {
+                    type: "intent_inferred",
+                    ts: nowIso(),
+                    pattern: intent.matchedPattern ?? "(llm)",
+                    intent: intent.command,
+                    accepted: false, // not yet
+                });
+                return;
+            }
+        }
+        // Chat turn path
+        const userTurn = { role: "user", text, ts: nowIso() };
+        setBuffer((b) => [...b, userTurn]);
+        appendEvent(header.sessionId, { type: "user", ts: userTurn.ts, text });
+        // Auto-promote heuristic — non-blocking hint; user can /save-turn
+        // explicitly or ignore. We don't auto-write without consent.
+        const hint = detectAutoPromote(text);
+        if (hint) {
+            pushSystem(`hint: that looks like a ${hint.reason} — type /save-turn after the response to capture it.`);
+        }
+        // File-path detection — suggest /attach if the user pasted a path
+        const detectedPath = detectFilePath(text);
+        if (detectedPath) {
+            pushSystem(`hint: detected file path "${detectedPath}" — type "/attach ${detectedPath}" to ingest it.`);
+        }
+        setStatus({ kind: "thinking" });
+        // Run recall before the LLM call so the model sees relevant memories.
+        let recalled = [];
+        try {
+            const db = GnosysDB.openCentral();
+            if (db.isAvailable()) {
+                const query = buildRecallQuery(text, [...buffer, userTurn]);
+                const result = runRecall(db, {
+                    query,
+                    scope,
+                    projectId,
+                    threshold,
+                    pinnedIds,
+                });
+                recalled = result.memories;
+                appendEvent(header.sessionId, {
+                    type: "recall",
+                    ts: nowIso(),
+                    query,
+                    memory_ids: recalled.map((m) => m.id),
+                    scope,
+                });
+            }
+            db.close();
+        }
+        catch {
+            // Recall errors shouldn't block the chat — proceed without recall
+        }
+        setStatus({ kind: "streaming", partial: "" });
+        try {
+            let partial = "";
+            const result = await runTurn(configRef.current, {
+                buffer: [...buffer, userTurn],
+                userInput: text,
+                recalled,
+                onToken: (tok) => {
+                    partial += tok;
+                    setStatus({ kind: "streaming", partial });
+                },
+            });
+            // Check for gnosys-choose fence — if present, strip it from the
+            // visible turn and surface as an interactive picker.
+            const fence = extractChooseFence(result.text);
+            let visibleText = result.text;
+            let pendingBlock = null;
+            if (fence?.kind === "ok") {
+                visibleText = [fence.before, fence.after].filter((s) => s.length > 0).join("\n\n");
+                pendingBlock = fence.block;
+                appendEvent(header.sessionId, {
+                    type: "choice_offered",
+                    ts: nowIso(),
+                    prompt: fence.block.prompt,
+                    option_ids: fence.block.options.map((o) => o.id),
+                });
+            }
+            else if (fence?.kind === "parse-error") {
+                // Fail-soft: leave the raw fence in the visible text so the user can
+                // see what the LLM tried to emit. Log the parse error for debugging.
+                pushSystem(`malformed gnosys-choose fence: ${fence.reason}`);
+                appendEvent(header.sessionId, {
+                    type: "error",
+                    ts: nowIso(),
+                    message: `gnosys-choose parse error: ${fence.reason}`,
+                });
+            }
+            const assistantTurn = {
+                role: "assistant",
+                text: visibleText,
+                ts: nowIso(),
+                provider: result.provider,
+                model: result.model,
+                citedMemoryIds: result.recalledIds,
+            };
+            setBuffer((b) => [...b, assistantTurn]);
+            appendEvent(header.sessionId, {
+                type: "assistant",
+                ts: assistantTurn.ts,
+                text: result.text, // log the FULL text (including fence) for fidelity
+                provider: result.provider,
+                model: result.model,
+                cited_memory_ids: result.recalledIds,
+            });
+            if (pendingBlock) {
+                setPendingChoice(pendingBlock);
+            }
+            setStatus({ kind: "idle" });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            setStatus({ kind: "error", message });
+            appendEvent(header.sessionId, { type: "error", ts: nowIso(), message });
+        }
+    }
+    // Trap Ctrl-C → graceful exit, mirroring /quit
+    useEffect(() => {
+        const handler = () => {
+            appendEvent(header.sessionId, { type: "session_end", ts: nowIso(), reason: "quit" });
+            if (onExit)
+                onExit();
+            exit();
+        };
+        process.on("SIGINT", handler);
+        return () => {
+            process.off("SIGINT", handler);
+        };
+    }, []);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ChatHeader, { info: header, recallScope: scope, threshold: threshold, pinnedCount: pinnedIds.length, focus: focusState.current, branchCount: focusState.branches.length }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [buffer.map((turn, i) => (_jsx(ConversationTurn, { turn: turn }, i))), status.kind === "streaming" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: "assistant:" }), _jsx(Text, { children: status.partial })] }))] }), systemNotice.length > 0 && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: systemNotice.map((line, i) => (_jsx(Text, { dimColor: true, children: line }, i))) })), _jsx(Box, { marginTop: 1, children: _jsx(StatusLine, { status: status }) }), pendingIntent && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: "magenta", children: ["inferred: ", describeIntent(pendingIntent), isDestructive(pendingIntent.command) ? " (destructive)" : ""] }), _jsx(Text, { dimColor: true, children: "[Y]es \u00B7 [N]o \u00B7 [E]dit \u00B7 or type a new message" })] })), pendingChoice ? (_jsx(ChoosePicker, { block: pendingChoice, onSelect: async (option) => {
+                    const selectionText = formatSelection(option);
+                    appendEvent(header.sessionId, {
+                        type: "choice_made",
+                        ts: nowIso(),
+                        option_id: option.id,
+                        label: option.label,
+                    });
+                    setPendingChoice(null);
+                    // Fire the selection as a synthetic user turn — runs through
+                    // the normal handleSubmit path so recall + LLM happen.
+                    await handleSubmit(selectionText);
+                } })) : (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { children: "> " }), _jsx(TextInput, { value: input, onChange: setInput, onSubmit: handleSubmit })] }))] }));
+};
+/** Render the conversation buffer as a human-readable markdown transcript for /export. */
+function renderSessionAsMarkdown(buffer, sessionId) {
+    const lines = [
+        `# Gnosys chat session ${sessionId}`,
+        ``,
+        `_Exported ${new Date().toISOString()}_`,
+        ``,
+        `---`,
+        ``,
+    ];
+    for (const turn of buffer) {
+        if (turn.role === "user") {
+            lines.push(`## You`);
+            lines.push(turn.text);
+            lines.push(``);
+        }
+        else if (turn.role === "assistant") {
+            const provider = turn.provider ? ` (${turn.provider}/${turn.model})` : "";
+            lines.push(`## Assistant${provider}`);
+            lines.push(turn.text);
+            if (turn.citedMemoryIds && turn.citedMemoryIds.length > 0) {
+                lines.push(``);
+                lines.push(`_cited: ${turn.citedMemoryIds.map((id) => `\`${id}\``).join(", ")}_`);
+            }
+            lines.push(``);
+        }
+        else if (turn.role === "system") {
+            lines.push(`> ${turn.text}`);
+            lines.push(``);
+        }
+    }
+    return lines.join("\n");
+}
+/** Detect a file path in user input — returns the path if found, null otherwise. */
+function detectFilePath(text) {
+    // Match common file path formats — absolute, ~, or ./relative — with extensions
+    const m = text.match(/(?<![\w/])((?:~|\.{1,2})?\/[^\s]+\.(?:pdf|md|txt|docx|png|jpg|jpeg|gif|mp3|wav|m4a|mp4|mov|webm))/i);
+    return m ? m[1] : null;
+}
+const ChoosePicker = ({ block, onSelect }) => {
+    const items = block.options.map((opt) => ({
+        label: opt.detail ? `${opt.label}  —  ${opt.detail}` : opt.label,
+        value: opt.id,
+    }));
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "magenta", children: block.prompt }), _jsx(SelectInput, { items: items, onSelect: (item) => {
+                    const picked = block.options.find((o) => o.id === item.value);
+                    if (picked)
+                        onSelect(picked);
+                } })] }));
+};
+const ChatHeader = ({ info, recallScope, threshold, pinnedCount, focus, branchCount }) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "green", children: "gnosys chat" }), _jsx(Text, { children: "  " }), _jsxs(Text, { dimColor: true, children: ["session=", info.sessionId.slice(0, 8), "\u2026"] }), _jsx(Text, { children: "  " }), info.projectName && (_jsxs(_Fragment, { children: [_jsxs(Text, { dimColor: true, children: ["project=", info.projectName] }), _jsx(Text, { children: "  " })] })), _jsxs(Text, { dimColor: true, children: [info.provider, "/", info.model] })] }), _jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: ["recall: scope=", recallScope] }), _jsx(Text, { children: "  " }), _jsxs(Text, { dimColor: true, children: ["threshold=", threshold.toFixed(2)] }), _jsx(Text, { children: "  " }), _jsxs(Text, { dimColor: true, children: ["pinned=", pinnedCount] }), focus && (_jsxs(_Fragment, { children: [_jsx(Text, { children: "  " }), _jsxs(Text, { dimColor: true, children: ["focus=", focus] })] })), branchCount > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { children: "  " }), _jsxs(Text, { dimColor: true, children: ["branches=", branchCount] })] }))] })] }));
+const ConversationTurn = ({ turn }) => {
+    if (turn.role === "user") {
+        return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: "yellow", children: "you:" }), _jsx(Text, { children: turn.text })] }));
+    }
+    if (turn.role === "assistant") {
+        const cited = turn.citedMemoryIds ?? [];
+        return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: "cyan", children: "assistant:" }), _jsx(Text, { children: turn.text }), cited.length > 0 && (_jsxs(Text, { dimColor: true, children: ["cited: ", cited.map((id) => `[${id}]`).join(" ")] }))] }));
+    }
+    return (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: ["\u00B7 ", turn.text] }) }));
+};
+const StatusLine = ({ status }) => {
+    switch (status.kind) {
+        case "idle":
+            return _jsx(Text, { dimColor: true, children: "ready \u2014 type /help for commands, /quit to exit" });
+        case "thinking":
+            return (_jsxs(Text, { color: "cyan", children: [_jsx(Spinner, { type: "dots" }), " thinking\u2026"] }));
+        case "streaming":
+            return (_jsxs(Text, { color: "cyan", children: [_jsx(Spinner, { type: "dots" }), " streaming\u2026"] }));
+        case "error":
+            return _jsxs(Text, { color: "red", children: ["error: ", status.message] });
+    }
+};
+//# sourceMappingURL=render.js.map