@vetala/vetala 0.1.0-beta

package/dist/src/ink/repl-app.js

@@ -0,0 +1,789 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import SelectInput from "ink-select-input";
+import Spinner from "ink-spinner";
+import TextInput from "ink-text-input";
+import { Agent } from "../agent.js";
+import { ApprovalManager } from "../approvals.js";
+import { clearSavedAuth, loadConfig, saveChatDefaults, savePersistentAuth, withSessionAuth, withStoredAuth } from "../config.js";
+import { PathPolicy } from "../path-policy.js";
+import { SARVAM_MODELS } from "../sarvam/models.js";
+import { SkillRuntime } from "../skills/runtime.js";
+import { createToolRegistry } from "../tools/index.js";
+import { InkTerminalUI } from "./ink-terminal-ui.js";
+import { buildSlashSuggestions } from "./command-suggestions.js";
+import { buildTranscriptCards } from "./transcript-cards.js";
+export function ReplApp({ initialConfig, initialSession, store }) {
+    const { exit } = useApp();
+    const [config, setConfig] = useState(initialConfig);
+    const [session, setSession] = useState(() => cloneSession(initialSession));
+    const [trusted, setTrusted] = useState(false);
+    const [input, setInput] = useState("");
+    const [entries, setEntries] = useState([]);
+    const [assistantBuffer, setAssistantBuffer] = useState("");
+    const [activityLabel, setActivityLabel] = useState(null);
+    const [spinnerLabel, setSpinnerLabel] = useState(null);
+    const [status, setStatus] = useState("Ready");
+    const [pendingApproval, setPendingApproval] = useState(null);
+    const [modelPickerOpen, setModelPickerOpen] = useState(false);
+    const [pendingReasoningSetup, setPendingReasoningSetup] = useState(null);
+    const [pendingAuthInput, setPendingAuthInput] = useState(null);
+    const [pendingAuthRetention, setPendingAuthRetention] = useState(null);
+    const [availableSkills, setAvailableSkills] = useState([]);
+    const [paused, setPaused] = useState(false);
+    const [pendingExitConfirm, setPendingExitConfirm] = useState(false);
+    const assistantBufferRef = useRef("");
+    const nextEntryIdRef = useRef(0);
+    const sessionRef = useRef(session);
+    const uiRef = useRef(null);
+    const skillRuntimeRef = useRef(null);
+    sessionRef.current = session;
+    const pushEntry = (kind, text) => {
+        setEntries((current) => [
+            ...current,
+            {
+                id: String(nextEntryIdRef.current++),
+                kind,
+                text
+            }
+        ]);
+    };
+    const finalizeAssistant = () => {
+        const buffered = assistantBufferRef.current.trimEnd();
+        if (!buffered) {
+            assistantBufferRef.current = "";
+            setAssistantBuffer("");
+            return;
+        }
+        assistantBufferRef.current = "";
+        setAssistantBuffer("");
+        pushEntry("assistant", buffered);
+    };
+    if (!uiRef.current) {
+        uiRef.current = new InkTerminalUI({
+            appendAssistant: (text) => {
+                assistantBufferRef.current += text;
+                setAssistantBuffer(assistantBufferRef.current);
+            },
+            finalizeAssistant,
+            pushEntry,
+            setActivity: (label) => {
+                setActivityLabel(label);
+            },
+            setSpinner: (label) => {
+                setSpinnerLabel(label);
+                setStatus(label ?? "Ready");
+            }
+        });
+    }
+    const ui = uiRef.current;
+    if (!skillRuntimeRef.current) {
+        skillRuntimeRef.current = new SkillRuntime({
+            getSession: () => sessionRef.current,
+            sessionStore: store
+        });
+    }
+    const skills = skillRuntimeRef.current;
+    const busy = spinnerLabel !== null;
+    const transcriptCards = buildTranscriptCards(entries).slice(-8);
+    const liveCardId = transcriptCards.at(-1)?.id ?? null;
+    const visibleStatus = paused ? "Paused" : status;
+    const slashSuggestions = buildSlashSuggestions(input, availableSkills).slice(0, 8);
+    const showSlashSuggestions = Boolean(trusted &&
+        !busy &&
+        !paused &&
+        !pendingExitConfirm &&
+        !pendingApproval &&
+        !modelPickerOpen &&
+        !pendingReasoningSetup &&
+        !pendingAuthInput &&
+        !pendingAuthRetention &&
+        input.startsWith("/") &&
+        slashSuggestions.length > 0);
+    const createTools = () => createToolRegistry({
+        includeWebSearch: config.searchProviderName !== "disabled",
+        skillRuntime: skills
+    });
+    useEffect(() => {
+        let cancelled = false;
+        void skills
+            .listSkills()
+            .then((listed) => {
+            if (!cancelled) {
+                setAvailableSkills(listed);
+            }
+        })
+            .catch(() => {
+            if (!cancelled) {
+                setAvailableSkills([]);
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [skills]);
+    useInput((inputValue, key) => {
+        if (showSlashSuggestions && isTabInput(inputValue, key)) {
+            const firstSuggestion = slashSuggestions[0];
+            if (firstSuggestion) {
+                setInput(firstSuggestion.completion);
+            }
+            return;
+        }
+        if (isControlInput(inputValue, key, "d", "\u0004")) {
+            setPendingExitConfirm(true);
+            return;
+        }
+        if (!trusted) {
+            return;
+        }
+        if (isControlInput(inputValue, key, "c", "\u0003")) {
+            setPendingExitConfirm(false);
+            setPaused((current) => !current);
+            return;
+        }
+    });
+    const requestApprovalDecision = (request) => new Promise((resolve) => {
+        setActivityLabel("Waiting for approval.");
+        setPendingApproval({ request, resolve });
+    });
+    const syncSession = (nextSession) => {
+        const cloned = cloneSession(nextSession);
+        setSession(cloned);
+        return cloned;
+    };
+    const resetTranscript = () => {
+        assistantBufferRef.current = "";
+        setAssistantBuffer("");
+        setActivityLabel(null);
+        nextEntryIdRef.current = 0;
+        setEntries([]);
+    };
+    const mergeLoadedConfig = (loaded) => {
+        if (config.authSource === "session" && config.authValue) {
+            return {
+                ...loaded,
+                authMode: config.authMode,
+                authValue: config.authValue,
+                authFingerprint: config.authFingerprint,
+                authSource: "session"
+            };
+        }
+        return loaded;
+    };
+    const closeCommandModals = () => {
+        setModelPickerOpen(false);
+        setPendingReasoningSetup(null);
+        setPendingAuthInput(null);
+        setPendingAuthRetention(null);
+    };
+    const runPrompt = async (prompt) => {
+        const trimmed = prompt.trim();
+        if (!trimmed) {
+            return;
+        }
+        if (trimmed.startsWith("/")) {
+            await handleCommand(trimmed);
+            return;
+        }
+        setInput("");
+        setPendingExitConfirm(false);
+        setActivityLabel(null);
+        pushEntry("user", summarizeUserPrompt(trimmed));
+        setStatus("Running agent");
+        const approvals = new ApprovalManager(session, store, null, requestApprovalDecision);
+        const agent = new Agent({
+            config,
+            session,
+            sessionStore: store,
+            approvals,
+            pathPolicy: new PathPolicy(session.workspaceRoot, approvals),
+            skills,
+            tools: createTools(),
+            ui
+        });
+        try {
+            await agent.runTurn(trimmed, true);
+            syncSession(session);
+            setActivityLabel(null);
+            setStatus("Ready");
+        }
+        catch (error) {
+            finalizeAssistant();
+            setActivityLabel(null);
+            pushEntry("error", error instanceof Error ? error.message : String(error));
+            setStatus("Failed");
+            syncSession(session);
+        }
+    };
+    const handleCommand = async (commandLine) => {
+        const [command, ...args] = commandLine.slice(1).split(/\s+/);
+        setInput("");
+        setActivityLabel(null);
+        pushEntry("user", commandLine);
+        switch (command) {
+            case "help":
+                pushEntry("info", [
+                    "/help",
+                    "/model",
+                    "/skill",
+                    "/tools",
+                    "/history",
+                    "/resume <session-id>",
+                    "/new",
+                    "/approve",
+                    "/config",
+                    "/logout",
+                    "/clear",
+                    "/exit"
+                ].join("\n"));
+                return;
+            case "model":
+                if (args.length > 0) {
+                    pushEntry("warn", "/model is interactive now. Use /model and select from the list.");
+                }
+                closeCommandModals();
+                setModelPickerOpen(true);
+                setStatus("Select a model");
+                return;
+            case "skill":
+            case "skills":
+                await handleSkillsCommand(args);
+                return;
+            case "tools":
+                pushEntry("info", createTools()
+                    .list()
+                    .map((tool) => `${tool.readOnly ? "ro" : "rw"} ${tool.name} - ${tool.description}`)
+                    .join("\n"));
+                return;
+            case "history":
+                pushEntry("info", session.messages
+                    .slice(-20)
+                    .map((message) => {
+                    const label = message.role.padEnd(9, " ");
+                    const content = (message.content ?? "[tool call]").replace(/\s+/g, " ").slice(0, 140);
+                    return `${label} ${content}`;
+                })
+                    .join("\n") || "(empty session)");
+                return;
+            case "resume": {
+                const target = args[0];
+                if (!target) {
+                    const sessions = await store.listSessions();
+                    pushEntry("info", formatSessionList(sessions));
+                    return;
+                }
+                const nextSession = await store.loadSession(target);
+                const nextCloned = syncSession(nextSession);
+                closeCommandModals();
+                resetTranscript();
+                setStatus(`Resumed ${nextCloned.id.slice(0, 8)}`);
+                return;
+            }
+            case "new": {
+                const nextSession = await store.createSession(session.workspaceRoot, session.model);
+                const nextCloned = syncSession(nextSession);
+                closeCommandModals();
+                resetTranscript();
+                setStatus(`Created ${nextCloned.id.slice(0, 8)}`);
+                return;
+            }
+            case "approve":
+                pushEntry("info", [
+                    `web access: ${session.approvals.webAccess ? "granted" : "not granted"}`,
+                    `path grants: ${session.approvals.outOfTreeRoots.join(", ") || "(none)"}`,
+                    `session grants: ${session.approvals.sessionActionKeys.join(", ") || "(none)"}`
+                ].join("\n"));
+                return;
+            case "config":
+                ui.printConfig(config);
+                return;
+            case "logout": {
+                const previousAuthSource = config.authSource;
+                await clearSavedAuth();
+                closeCommandModals();
+                const reloaded = await loadConfig();
+                setConfig(reloaded);
+                if (reloaded.authSource === "env") {
+                    pushEntry("warn", "Cleared local auth state, but environment credentials are still active for this process.");
+                }
+                else if (previousAuthSource === "stored" || previousAuthSource === "stored_hash") {
+                    pushEntry("info", "Cleared the saved API key for future launches and removed current local auth.");
+                }
+                else if (previousAuthSource === "session") {
+                    pushEntry("info", "Cleared the API key that was only active in this session.");
+                }
+                else {
+                    pushEntry("info", "No saved API key remained after logout.");
+                }
+                setStatus("Logged out");
+                return;
+            }
+            case "clear":
+                closeCommandModals();
+                resetTranscript();
+                setStatus("Ready");
+                return;
+            case "exit":
+                setPendingExitConfirm(true);
+                return;
+            default:
+                pushEntry("warn", `Unknown command: /${command}`);
+        }
+    };
+    const handleSkillsCommand = async (args) => {
+        try {
+            const [subcommand, ...rest] = args;
+            if (!subcommand) {
+                const available = await skills.listSkills();
+                const pinned = new Set((await skills.pinnedSkills()).map((skill) => skill.name));
+                pushEntry("info", available.length > 0
+                    ? available
+                        .map((skill) => `${pinned.has(skill.name) ? "*" : "-"} ${skill.name} - ${skill.description || "(no description)"}`)
+                        .join("\n")
+                    : "(no skills available)");
+                return;
+            }
+            switch (subcommand) {
+                case "use":
+                case "pin": {
+                    const name = rest[0];
+                    if (!name) {
+                        pushEntry("warn", "Usage: /skill use <name>");
+                        return;
+                    }
+                    const skill = await skills.pinSkill(name);
+                    syncSession(session);
+                    pushEntry("info", `Pinned skill: ${skill.name}`);
+                    return;
+                }
+                case "drop":
+                case "unpin": {
+                    const name = rest[0];
+                    if (!name) {
+                        pushEntry("warn", "Usage: /skill drop <name>");
+                        return;
+                    }
+                    const skill = await skills.unpinSkill(name);
+                    syncSession(session);
+                    pushEntry("info", `Unpinned skill: ${skill.name}`);
+                    return;
+                }
+                case "clear": {
+                    const cleared = await skills.clearPinnedSkills();
+                    syncSession(session);
+                    pushEntry("info", cleared > 0 ? `Cleared ${cleared} pinned skills.` : "No pinned skills were active.");
+                    return;
+                }
+                case "show":
+                case "load": {
+                    const name = rest[0];
+                    if (!name) {
+                        pushEntry("warn", "Usage: /skill show <name>");
+                        return;
+                    }
+                    const skill = await skills.loadSkill(name);
+                    pushEntry("info", skill.overview);
+                    return;
+                }
+                case "read": {
+                    const [name, ...pathParts] = rest;
+                    if (!name) {
+                        pushEntry("warn", "Usage: /skill read <name> [path]");
+                        return;
+                    }
+                    const pathArg = pathParts.join(" ") || "SKILL.md";
+                    const file = await skills.readSkillFile(name, pathArg);
+                    pushEntry("info", file.content);
+                    return;
+                }
+                default:
+                    pushEntry("warn", "Usage: /skill [use|drop|clear|show|read]");
+            }
+        }
+        catch (error) {
+            pushEntry("error", error instanceof Error ? error.message : String(error));
+        }
+    };
+    const onTrustSelect = async (value) => {
+        if (value === "exit") {
+            exit();
+            return;
+        }
+        setTrusted(true);
+        setStatus("Ready");
+    };
+    const onApprovalSelect = async (value) => {
+        const promptState = pendingApproval;
+        if (!promptState) {
+            return;
+        }
+        setActivityLabel(null);
+        setPendingApproval(null);
+        promptState.resolve(value);
+    };
+    const onModelSelect = async (value) => {
+        if (value === "cancel") {
+            setModelPickerOpen(false);
+            setStatus("Ready");
+            return;
+        }
+        setModelPickerOpen(false);
+        setPendingReasoningSetup({
+            model: value,
+            reasoningEffort: config.reasoningEffort
+        });
+        setStatus(`Select reasoning effort for ${value}`);
+    };
+    const onReasoningSelect = async (value) => {
+        const current = pendingReasoningSetup;
+        if (!current) {
+            return;
+        }
+        if (value === "cancel") {
+            setPendingReasoningSetup(null);
+            setStatus("Ready");
+            return;
+        }
+        setPendingReasoningSetup(null);
+        const nextSettings = {
+            ...current,
+            reasoningEffort: value === "none" ? null : value
+        };
+        await store.updateModel(session, nextSettings.model);
+        await saveChatDefaults(nextSettings.model, nextSettings.reasoningEffort);
+        syncSession(session);
+        const loadedConfig = await loadConfig();
+        const nextConfig = mergeLoadedConfig(loadedConfig);
+        setConfig(nextConfig);
+        if (nextConfig.authSource === "missing" || nextConfig.authSource === "stored_hash") {
+            setPendingAuthInput({
+                ...nextSettings,
+                authMode: "subscription_key",
+                value: ""
+            });
+            setStatus(`Enter API key for ${nextSettings.model}`);
+            return;
+        }
+        pushEntry("info", formatModelSetupSummary(nextSettings, nextConfig));
+        setStatus("Ready");
+    };
+    const onAuthInputChange = (value) => {
+        setPendingAuthInput((current) => (current ? { ...current, value } : current));
+    };
+    const onAuthInputSubmit = async (value) => {
+        const current = pendingAuthInput;
+        if (!current) {
+            return;
+        }
+        const trimmed = value.trim();
+        if (!trimmed) {
+            setPendingAuthInput(null);
+            pushEntry("warn", "API key entry cancelled. Model settings were saved, but no usable Sarvam credential is active.");
+            setStatus("Ready");
+            return;
+        }
+        setPendingAuthInput(null);
+        setPendingAuthRetention({
+            ...current,
+            value: trimmed
+        });
+        setStatus("Choose how long to keep this API key");
+    };
+    const onAuthRetentionSelect = async (choice) => {
+        const current = pendingAuthRetention;
+        if (!current) {
+            return;
+        }
+        if (choice === "cancel") {
+            setPendingAuthRetention(null);
+            pushEntry("warn", "API key setup cancelled.");
+            setStatus("Ready");
+            return;
+        }
+        const loadedConfig = await loadConfig();
+        const nextConfig = choice === "persist"
+            ? withStoredAuth(loadedConfig, current.authMode, current.value)
+            : withSessionAuth(loadedConfig, current.authMode, current.value);
+        if (choice === "persist") {
+            await savePersistentAuth(current.authMode, current.value);
+        }
+        setConfig(nextConfig);
+        setPendingAuthRetention(null);
+        pushEntry("info", formatModelSetupSummary(current, nextConfig, choice));
+        if (choice === "persist" && loadedConfig.authSource === "env") {
+            pushEntry("warn", "Environment credentials are still set in this shell. They may take precedence on future launches.");
+        }
+        setStatus("Ready");
+    };
+    const onExitConfirmSelect = async (value) => {
+        if (value === "exit") {
+            exit();
+            return;
+        }
+        setPendingExitConfirm(false);
+    };
+    return (_jsx(Box, { flexDirection: "column", paddingX: 1, children: !trusted ? (_jsxs(_Fragment, { children: [_jsx(TrustScreen, { workspaceRoot: session.workspaceRoot, onSelect: onTrustSelect }), pendingExitConfirm ? _jsx(ExitConfirmBox, { onSelect: onExitConfirmSelect }) : null] })) : (_jsxs(_Fragment, { children: [_jsx(Dashboard, { config: config, session: session, status: visibleStatus }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [transcriptCards.length === 0 && !assistantBuffer && !spinnerLabel ? (_jsx(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: _jsx(Text, { color: "gray", children: "New transcript. Use /history if you want earlier session messages." }) })) : null, transcriptCards.map((card) => (_jsx(TranscriptCard, { card: card, assistantBuffer: card.id === liveCardId ? assistantBuffer : "", liveLabel: card.id === liveCardId ? activityLabel ?? spinnerLabel : null }, card.id))), transcriptCards.length === 0 && (assistantBuffer || activityLabel || spinnerLabel) ? (_jsx(LiveStatusCard, { assistantBuffer: assistantBuffer, liveLabel: activityLabel ?? spinnerLabel })) : null] }), pendingExitConfirm ? (_jsx(ExitConfirmBox, { onSelect: onExitConfirmSelect })) : paused ? (_jsx(PauseBox, {})) : pendingApproval ? (_jsx(ApprovalBox, { request: pendingApproval.request, onSelect: onApprovalSelect })) : modelPickerOpen ? (_jsx(ModelPicker, { currentModel: session.model, onSelect: onModelSelect })) : pendingReasoningSetup ? (_jsx(ReasoningEffortPicker, { currentValue: pendingReasoningSetup.reasoningEffort, model: pendingReasoningSetup.model, onSelect: onReasoningSelect })) : pendingAuthInput ? (_jsx(AuthInputBox, { state: pendingAuthInput, onChange: onAuthInputChange, onSubmit: onAuthInputSubmit })) : pendingAuthRetention ? (_jsx(AuthRetentionBox, { state: pendingAuthRetention, onSelect: onAuthRetentionSelect })) : (_jsxs(_Fragment, { children: [_jsx(InputBox, { busy: busy, value: input, onChange: setInput, onSubmit: runPrompt }), showSlashSuggestions ? _jsx(SlashSuggestionBox, { suggestions: slashSuggestions }) : null] })), _jsx(Footer, { config: config, status: visibleStatus, session: session })] })) }));
+}
+function Dashboard({ config, session, status }) {
+    const infoRows = [
+        { item: "model", value: session.model },
+        { item: "directory", value: session.workspaceRoot },
+        { item: "session", value: session.id.slice(0, 8) },
+        { item: "updated", value: formatTimestamp(session.updatedAt) }
+    ];
+    const stateRows = [
+        { item: "auth", value: describeAuth(config) },
+        { item: "reasoning", value: formatReasoningEffort(config.reasoningEffort) },
+        { item: "skills", value: describeSkills(session.pinnedSkills.length) },
+        { item: "sha256", value: config.authFingerprint?.slice(0, 12) ?? "(none)" },
+        { item: "context", value: describeContext(session.messages.length) }
+    ];
+    return (_jsxs(_Fragment, { children: [_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, flexDirection: "row", children: [_jsxs(Box, { flexDirection: "column", width: "60%", paddingRight: 2, children: [_jsx(Text, { color: "yellow", children: "Vetala" }), _jsx(Text, { bold: true, children: "Ready." }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: infoRows.map((row) => (_jsx(InfoRow, { item: row.item, value: row.value }, row.item))) })] }), _jsxs(Box, { flexDirection: "column", width: "40%", children: [_jsx(Text, { color: "yellow", children: "Tips" }), _jsx(Text, { children: "/help for commands" }), _jsx(Text, { children: "/model for model + reasoning" }), _jsx(Text, { children: "/skill to inspect local skills" }), _jsx(Text, { children: "/logout to clear local auth" }), _jsx(Text, { children: "Ctrl+C to pause" }), _jsx(Text, { children: "Ctrl+D to exit" }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "gray", children: ["status: ", status] }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "yellow", children: "Context" }) }), stateRows.map((row) => (_jsx(InfoRow, { item: row.item, value: row.value }, row.item)))] })] }), _jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: "gray", paddingX: 1, children: _jsx(Text, { children: "Try \"explain this codebase\" or \"write a test for <filepath>\"" }) })] }));
+}
+function InfoRow({ item, value }) {
+    return (_jsxs(Box, { children: [_jsx(Box, { width: 12, children: _jsx(Text, { color: "gray", children: item }) }), _jsx(Text, { children: value })] }));
+}
+function TrustScreen({ workspaceRoot, onSelect }) {
+    return (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "Accessing workspace" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: workspaceRoot }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { children: "Quick safety check: is this a project you created or one you trust? If not, review it before continuing." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: "Vetala will be able to read, edit, and execute files here." }) })] }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: [
+                        { label: "Yes, I trust this folder", value: "trust" },
+                        { label: "No, exit", value: "exit" }
+                    ], onSelect: (item) => void onSelect(item.value) }) })] }));
+}
+function ApprovalBox({ request, onSelect }) {
+    return (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "magenta", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "magenta", children: "Approval required" }), request.label.split("\n").map((line) => (_jsx(Text, { children: line }, line))), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: [
+                        { label: "Allow once", value: "once" },
+                        { label: "Allow for session", value: "session" },
+                        { label: "Deny", value: "deny" }
+                    ], onSelect: (item) => void onSelect(item.value) }) })] }));
+}
+function ModelPicker({ currentModel, onSelect }) {
+    return (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "green", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "green", children: "Select model" }), _jsxs(Text, { color: "gray", children: ["Current: ", currentModel] }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: [
+                        ...SARVAM_MODELS.map((model) => ({
+                            label: model === currentModel ? `${model} (current)` : model,
+                            value: model
+                        })),
+                        { label: "Cancel", value: "cancel" }
+                    ], onSelect: (item) => void onSelect(item.value) }) })] }));
+}
+function ReasoningEffortPicker({ currentValue, model, onSelect }) {
+    return (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "green", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "green", children: "Select reasoning effort" }), _jsxs(Text, { color: "gray", children: ["Model: ", model, " \u00B7 Current: ", formatReasoningEffort(currentValue)] }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: [
+                        { label: "None (null / let Sarvam decide)", value: "none" },
+                        { label: "Low", value: "low" },
+                        { label: "Medium", value: "medium" },
+                        { label: "High", value: "high" },
+                        { label: "Cancel", value: "cancel" }
+                    ], onSelect: (item) => void onSelect(item.value) }) })] }));
+}
+function AuthInputBox({ state, onChange, onSubmit }) {
+    return (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "green", paddingX: 1, flexDirection: "column", children: [_jsxs(Text, { color: "green", children: ["Enter API key for ", state.model] }), _jsx(Text, { color: "gray", children: "This will be used as Sarvam's `apiSubscriptionKey`. After you press Enter, choose whether Vetala keeps it for all sessions or only for this session." }), _jsxs(Text, { color: "gray", children: ["Reasoning: ", formatReasoningEffort(state.reasoningEffort)] }), _jsx(Text, { color: "gray", children: "Press Enter on an empty field to cancel." }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "cyan", children: "key " }), _jsx(TextInput, { mask: "*", highlightPastedText: false, value: state.value, onChange: onChange, onSubmit: (value) => void onSubmit(value) })] })] }));
+}
+function AuthRetentionBox({ state, onSelect }) {
+    return (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "green", paddingX: 1, flexDirection: "column", children: [_jsxs(Text, { color: "green", children: ["Keep API key for ", state.model] }), _jsxs(Text, { color: "gray", children: ["Key preview: ", maskSecretPreview(state.value)] }), _jsxs(Text, { color: "gray", children: ["Reasoning: ", formatReasoningEffort(state.reasoningEffort)] }), _jsx(Text, { color: "gray", children: "Future-session mode stores the raw key locally until you run /logout." }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Text, { children: "Choose how long Vetala should keep this key:" }) }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: [
+                        {
+                            label: "Keep for all sessions until /logout",
+                            value: "persist"
+                        },
+                        {
+                            label: "This session only",
+                            value: "session"
+                        },
+                        {
+                            label: "Cancel",
+                            value: "cancel"
+                        }
+                    ], onSelect: (item) => void onSelect(item.value) }) })] }));
+}
+function InputBox({ busy, value, onChange, onSubmit }) {
+    return (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "white", paddingX: 1, children: [_jsx(Text, { color: "cyan", children: "\u276F " }), busy ? (_jsx(Text, { color: "gray", children: "Agent is busy. Wait for the current turn to finish." })) : (_jsx(TextInput, { highlightPastedText: false, value: value, onChange: onChange, onSubmit: (nextValue) => void onSubmit(nextValue) }))] }));
+}
+function SlashSuggestionBox({ suggestions }) {
+    return (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "blue", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "blue", children: "Commands" }), _jsx(Text, { color: "gray", children: "Tab autocompletes the first match." }), suggestions.map((suggestion, index) => (_jsxs(Box, { children: [_jsx(Box, { width: "45%", children: _jsxs(Text, { color: index === 0 ? "cyan" : "white", children: [index === 0 ? "❯ " : "  ", suggestion.label] }) }), _jsx(Text, { color: "gray", children: suggestion.detail })] }, suggestion.label)))] }));
+}
+function PauseBox() {
+    return (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "yellow", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "Paused" }), _jsx(Text, { children: "Press Ctrl+C again to resume." }), _jsx(Text, { children: "Press Ctrl+D if you want to exit." })] }));
+}
+function ExitConfirmBox({ onSelect }) {
+    return (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "red", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: "red", children: "Exit Vetala?" }), _jsx(Text, { color: "gray", children: "Current session state is already written to disk as it changes." }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: [
+                        { label: "Exit", value: "exit" },
+                        { label: "Stay", value: "stay" }
+                    ], onSelect: (item) => void onSelect(item.value) }) })] }));
+}
+function Footer({ config, status, session }) {
+    return (_jsxs(Box, { marginTop: 1, justifyContent: "space-between", children: [_jsx(Text, { color: "gray", children: "/help for commands \u00B7 Ctrl+C pause \u00B7 Ctrl+D exit" }), _jsxs(Text, { color: "gray", children: [status, " \u00B7 ", describeAuth(config), " \u00B7 ", describeContext(session.messages.length)] })] }));
+}
+function TranscriptCard({ card, assistantBuffer, liveLabel }) {
+    const borderColor = transcriptCardBorder(card.entries);
+    return (_jsxs(Box, { marginBottom: 1, borderStyle: "round", borderColor: borderColor, paddingX: 1, flexDirection: "column", children: [card.entries.map((entry) => (_jsx(TranscriptSection, { entry: entry }, entry.id))), liveLabel ? _jsx(LiveActivitySection, { label: liveLabel }) : null, assistantBuffer ? (_jsx(TranscriptSection, { entry: { id: `${card.id}:stream`, kind: "assistant", text: assistantBuffer } })) : null] }));
+}
+function LiveStatusCard({ assistantBuffer, liveLabel }) {
+    return (_jsxs(Box, { marginBottom: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1, flexDirection: "column", children: [liveLabel ? _jsx(LiveActivitySection, { label: liveLabel }) : null, assistantBuffer ? (_jsx(TranscriptSection, { entry: { id: "live:assistant", kind: "assistant", text: assistantBuffer } })) : null] }));
+}
+function TranscriptSection({ entry }) {
+    const isActivity = entry.kind === "activity";
+    return (_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsx(Text, { color: entryColor(entry.kind), children: entryLabel(entry.kind) }), entry.text.split("\n").map((line, index) => isActivity ? (_jsx(Text, { color: "gray", children: line.length > 0 ? line : " " }, `${entry.id}:${index}`)) : (_jsx(Text, { children: line.length > 0 ? line : " " }, `${entry.id}:${index}`)))] }));
+}
+function LiveActivitySection({ label }) {
+    return (_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsx(Text, { color: "gray", children: "doing" }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { color: "gray", children: [" ", label] })] })] }));
+}
+function cloneSession(session) {
+    return {
+        ...session,
+        approvals: {
+            sessionActionKeys: [...session.approvals.sessionActionKeys],
+            outOfTreeRoots: [...session.approvals.outOfTreeRoots],
+            webAccess: session.approvals.webAccess
+        },
+        messages: [...session.messages],
+        referencedFiles: [...session.referencedFiles],
+        readFiles: [...session.readFiles],
+        pinnedSkills: [...session.pinnedSkills]
+    };
+}
+function formatSessionList(sessions) {
+    return sessions.length > 0
+        ? sessions
+            .slice(0, 10)
+            .map((item) => `${item.id}  ${item.updatedAt}  ${item.workspaceRoot}`)
+            .join("\n")
+        : "(no sessions)";
+}
+function formatTimestamp(value) {
+    const date = new Date(value);
+    return Number.isNaN(date.valueOf()) ? value : date.toLocaleString();
+}
+function describeAuth(config) {
+    switch (config.authSource) {
+        case "env":
+            return `${renderAuthMode(config.authMode)} from env`;
+        case "session":
+            return `${renderAuthMode(config.authMode)} in session`;
+        case "stored":
+            return `${renderAuthMode(config.authMode)} saved locally`;
+        case "stored_hash":
+            return `${renderAuthMode(config.authMode)} fingerprint only`;
+        case "missing":
+            return "missing";
+    }
+}
+function formatReasoningEffort(value) {
+    return value ?? "(none)";
+}
+function describeSkills(pinnedCount) {
+    return pinnedCount > 0 ? `${pinnedCount} pinned` : "none pinned";
+}
+function formatModelSetupSummary(state, config, authRetention) {
+    const lines = [
+        `Model: ${state.model}`,
+        `Reasoning effort: ${formatReasoningEffort(state.reasoningEffort)}`,
+        `Credential: ${describeAuth(config)}`,
+        `Stored SHA-256: ${config.authFingerprint?.slice(0, 16) ?? "(none)"}`
+    ];
+    if (authRetention === "persist") {
+        lines.push("Raw key is stored locally for all future sessions until /logout.");
+    }
+    else if (authRetention === "session") {
+        lines.push("Raw key is kept only in memory for this session.");
+    }
+    return lines.join("\n");
+}
+function describeContext(messageCount) {
+    if (messageCount <= 12) {
+        return `${messageCount} live messages`;
+    }
+    return `${messageCount - 12} compacted, 12 live`;
+}
+function summarizeUserPrompt(prompt) {
+    const lineCount = prompt.split("\n").length;
+    const hasLargePaste = prompt.length > 260 || lineCount > 6;
+    if (!hasLargePaste) {
+        return prompt;
+    }
+    const preview = prompt.replace(/\s+/g, " ").trim().slice(0, 120);
+    return [
+        `Pasted content: ${prompt.length} chars, ${lineCount} lines`,
+        `Preview: ${preview}${preview.length < prompt.replace(/\s+/g, " ").trim().length ? "..." : ""}`
+    ].join("\n");
+}
+function renderAuthMode(authMode) {
+    switch (authMode) {
+        case "bearer":
+            return "bearer token";
+        case "subscription_key":
+            return "API key";
+        case "missing":
+            return "missing";
+    }
+}
+function isControlInput(inputValue, key, expectedKey, rawControlChar) {
+    return (key.ctrl && inputValue.toLowerCase() === expectedKey) || inputValue === rawControlChar;
+}
+function isTabInput(inputValue, key) {
+    return key.tab === true || inputValue === "\t";
+}
+function maskSecretPreview(value) {
+    const compact = value.trim();
+    if (compact.length <= 8) {
+        return compact;
+    }
+    return `${compact.slice(0, 4)}...${compact.slice(-4)}`;
+}
+function entryColor(kind) {
+    switch (kind) {
+        case "assistant":
+            return "cyan";
+        case "user":
+            return "green";
+        case "tool":
+            return "magenta";
+        case "activity":
+            return "gray";
+        case "info":
+            return "blue";
+        case "warn":
+            return "yellow";
+        case "error":
+            return "red";
+    }
+}
+function entryLabel(kind) {
+    switch (kind) {
+        case "assistant":
+            return "assistant";
+        case "user":
+            return "user";
+        case "tool":
+            return "tool";
+        case "activity":
+            return "doing";
+        case "info":
+            return "info";
+        case "warn":
+            return "warn";
+        case "error":
+            return "error";
+    }
+}
+function transcriptCardBorder(entries) {
+    if (entries.some((entry) => entry.kind === "error")) {
+        return "red";
+    }
+    if (entries.some((entry) => entry.kind === "warn")) {
+        return "yellow";
+    }
+    if (entries.some((entry) => entry.kind === "tool")) {
+        return "magenta";
+    }
+    if (entries.some((entry) => entry.kind === "assistant")) {
+        return "white";
+    }
+    if (entries.some((entry) => entry.kind === "info")) {
+        return "blue";
+    }
+    if (entries.some((entry) => entry.kind === "activity")) {
+        return "gray";
+    }
+    return "white";
+}
+//# sourceMappingURL=repl-app.js.map