swagmanager-mcp 1.2.0 → 3.0.1

package/bin/swagmanager-mcp.js

@@ -1,16 +1,15 @@
 #!/usr/bin/env node
 
 /**
- * SwagManager MCP Server CLI
+ * whale code — local-first AI agent CLI
  *
  * Usage:
- *   npx swagmanager-mcp          — Run the MCP server (stdio)
- *   npx swagmanager-mcp setup    — Install to Claude Code, Cursor, etc.
- *
- * Environment variables:
- *   SUPABASE_URL              - Your Supabase project URL
- *   SUPABASE_SERVICE_ROLE_KEY - Your Supabase service role key
- *   STORE_ID                  - Default store ID (optional)
+ *   whale              — Start chat (default, interactive terminal)
+ *   whale login        — Log in with SwagManager credentials
+ *   whale logout       — Clear saved session
+ *   whale status       — Show connection status
+ *   whale help         — Show this help
+ *   (non-TTY stdin)    — MCP stdio server for Claude Code / Cursor
  */
 
 import { fileURLToPath } from "url";
@@ -21,9 +20,104 @@ const __dirname = dirname(__filename);
 
 const command = process.argv[2];
 
-if (command === "setup") {
-  const { runSetup } = await import(join(__dirname, "..", "dist", "setup.js"));
-  await runSetup();
-} else {
-  await import(join(__dirname, "..", "dist", "index.js"));
+// ── Help ──
+function showHelp() {
+  const d = "\x1b[2m";
+  const B = "\x1b[1m";
+  const r = "\x1b[0m";
+  const c = "\x1b[38;2;99;102;241m";
+  const g = "\x1b[38;2;100;116;139m";
+
+  console.log();
+  console.log(`  ${g}╭──────────────────────────────────────────╮${r}`);
+  console.log(`  ${g}│${r}                                          ${g}│${r}`);
+  console.log(`  ${g}│${r}   ${c}${B}◆ whale code${r}  ${d}v3.0.0${r}                    ${g}│${r}`);
+  console.log(`  ${g}│${r}   ${d}local-first AI agent CLI${r}               ${g}│${r}`);
+  console.log(`  ${g}│${r}                                          ${g}│${r}`);
+  console.log(`  ${g}╰──────────────────────────────────────────╯${r}`);
+  console.log();
+  console.log(`  ${B}Commands:${r}`);
+  console.log(`    whale${d}             Start chatting (default)${r}`);
+  console.log(`    whale login${d}       Log in to SwagManager${r}`);
+  console.log(`    whale logout${d}      Clear session${r}`);
+  console.log(`    whale stores${d}      Switch active store${r}`);
+  console.log(`    whale status${d}      Connection & tools${r}`);
+  console.log(`    whale setup${d}       Install MCP to IDEs${r}`);
+  console.log();
+  console.log(`  ${B}In chat:${r}`);
+  console.log(`    ${d}Type ${r}/${d} to open command menu${r}`);
+  console.log(`    ${d}^C to exit, esc to cancel${r}`);
+  console.log();
+}
+
+// ── Route ──
+switch (command) {
+  case "help":
+  case "--help":
+  case "-h":
+    showHelp();
+    break;
+
+  case "login": {
+    if (!process.stdin.isTTY) {
+      console.error("Error: whale login requires an interactive terminal.");
+      process.exit(1);
+    }
+    const { renderLogin } = await import(join(__dirname, "..", "dist", "cli", "app.js"));
+    await renderLogin();
+    break;
+  }
+
+  case "logout": {
+    const { renderLogout } = await import(join(__dirname, "..", "dist", "cli", "app.js"));
+    await renderLogout();
+    break;
+  }
+
+  case "chat":
+  case undefined: {
+    if (process.stdin.isTTY) {
+      const { renderChat } = await import(join(__dirname, "..", "dist", "cli", "app.js"));
+      await renderChat();
+    } else if (command === "chat") {
+      console.error("Error: whale chat requires an interactive terminal.");
+      process.exit(1);
+    } else {
+      // Non-TTY, no command → MCP stdio server
+      await import(join(__dirname, "..", "dist", "index.js"));
+    }
+    break;
+  }
+
+  case "status": {
+    const { renderStatus } = await import(join(__dirname, "..", "dist", "cli", "app.js"));
+    await renderStatus();
+    break;
+  }
+
+  case "setup": {
+    if (!process.stdin.isTTY) {
+      console.error("Error: whale setup requires an interactive terminal.");
+      process.exit(1);
+    }
+    const { renderSetup } = await import(join(__dirname, "..", "dist", "cli", "app.js"));
+    await renderSetup();
+    break;
+  }
+
+  case "stores":
+  case "store": {
+    if (!process.stdin.isTTY) {
+      console.error("Error: whale stores requires an interactive terminal.");
+      process.exit(1);
+    }
+    const { renderStores } = await import(join(__dirname, "..", "dist", "cli", "app.js"));
+    await renderStores();
+    break;
+  }
+
+  default:
+    console.error(`Unknown command: ${command}`);
+    console.error(`Run 'whale help' for usage.`);
+    process.exit(1);
 }

package/dist/cli/app.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CLI App Entry Point
+ *
+ * Dynamic imports for each mode — keeps MCP server path clean.
+ */
+export declare function renderLogin(): Promise<void>;
+export declare function renderLogout(): Promise<void>;
+export declare function renderChat(): Promise<void>;
+export declare function renderSetup(): Promise<void>;
+export declare function renderStatus(): Promise<void>;
+export declare function renderStores(): Promise<void>;

package/dist/cli/app.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+export async function renderLogin() {
+    const { LoginApp } = await import("./login/LoginApp.js");
+    const { waitUntilExit } = render(_jsx(LoginApp, {}));
+    await waitUntilExit();
+}
+export async function renderLogout() {
+    const { signOut, isLoggedIn } = await import("./services/auth-service.js");
+    if (!isLoggedIn()) {
+        console.log("Not logged in.");
+    }
+    else {
+        signOut();
+        console.log("Logged out. Tokens cleared.");
+    }
+}
+export async function renderChat() {
+    const { matrixIntro } = await import("./shared/MatrixIntro.js");
+    await matrixIntro();
+    const { ChatApp } = await import("./chat/ChatApp.js");
+    const { waitUntilExit } = render(_jsx(ChatApp, {}));
+    await waitUntilExit();
+}
+export async function renderSetup() {
+    const { SetupApp } = await import("./setup/SetupApp.js");
+    const { waitUntilExit } = render(_jsx(SetupApp, {}));
+    await waitUntilExit();
+}
+export async function renderStatus() {
+    const { StatusApp } = await import("./status/StatusApp.js");
+    const { waitUntilExit } = render(_jsx(StatusApp, {}));
+    await waitUntilExit();
+}
+export async function renderStores() {
+    const { StoreApp } = await import("./stores/StoreApp.js");
+    const { waitUntilExit } = render(_jsx(StoreApp, {}));
+    await waitUntilExit();
+}

package/dist/cli/chat/AgentSelector.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AgentSelector — polished agent picker with descriptions
+ */
+interface Agent {
+    id: string;
+    name: string;
+    model: string;
+}
+interface AgentSelectorProps {
+    agents: Agent[];
+    onSelect: (agentId: string) => void;
+}
+export declare function AgentSelector({ agents, onSelect }: AgentSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cli/chat/AgentSelector.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import SelectInput from "ink-select-input";
+import { colors, symbols } from "../shared/Theme.js";
+export function AgentSelector({ agents, onSelect }) {
+    const items = agents.map((a) => ({
+        label: `${a.name}`,
+        value: a.id,
+    }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.muted, children: "Select an agent:" }), _jsx(Box, { height: 1 }), _jsx(SelectInput, { items: items, onSelect: (item) => onSelect(item.value), indicatorComponent: ({ isSelected }) => (_jsxs(Text, { color: isSelected ? colors.brand : colors.dim, children: [isSelected ? symbols.arrowRight : " ", " "] })), itemComponent: ({ isSelected, label }) => {
+                    const agent = agents.find((a) => a.name === label);
+                    return (_jsxs(Box, { children: [_jsx(Text, { color: isSelected ? colors.brand : colors.text, bold: isSelected, children: label }), agent && (_jsxs(Text, { color: colors.dim, children: [" (", agent.model, ")"] }))] }));
+                } })] }));
+}

package/dist/cli/chat/ChatApp.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ChatApp — whale code CLI
+ *
+ * Clean, Apple-polished chat interface.
+ * Minimal header, generous spacing, subtle status.
+ */
+export declare function ChatApp(): import("react/jsx-runtime").JSX.Element;

package/dist/cli/chat/ChatApp.js

@@ -0,0 +1,288 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * ChatApp — whale code CLI
+ *
+ * Clean, Apple-polished chat interface.
+ * Minimal header, generous spacing, subtle status.
+ */
+import { useState, useEffect, useCallback, useRef } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { execSync } from "child_process";
+import { runAgentLoop, canUseAgent, getServerToolCount, getServerStatus } from "../services/agent-loop.js";
+import { getAllServerToolDefinitions, resetServerToolClient } from "../services/server-tools.js";
+import { LOCAL_TOOL_DEFINITIONS } from "../services/local-tools.js";
+import { MessageList } from "./MessageList.js";
+import { ChatInput, SLASH_COMMANDS } from "./ChatInput.js";
+import { StoreSelector } from "./StoreSelector.js";
+import { colors, symbols, boxLine } from "../shared/Theme.js";
+import { loadConfig } from "../services/config-store.js";
+import { getStoresForUser, getValidToken, selectStore } from "../services/auth-service.js";
+import { createRequire } from "module";
+const PKG_NAME = "swagmanager-mcp";
+const require = createRequire(import.meta.url);
+const PKG_VERSION = require("../../package.json").version;
+export function ChatApp() {
+    const { exit } = useApp();
+    const [ready, setReady] = useState(false);
+    const [error, setError] = useState("");
+    const [messages, setMessages] = useState([]);
+    const [streamingText, setStreamingText] = useState("");
+    const [isStreaming, setIsStreaming] = useState(false);
+    const [activeTools, setActiveTools] = useState([]);
+    const [userLabel, setUserLabel] = useState("");
+    const [toolsExpanded, setToolsExpanded] = useState(false);
+    const [serverToolsAvailable, setServerToolsAvailable] = useState(0);
+    const [storeSelectMode, setStoreSelectMode] = useState(false);
+    const [storeList, setStoreList] = useState([]);
+    const conversationRef = useRef([]);
+    const abortRef = useRef(null);
+    // ── Init ──
+    useEffect(() => {
+        const check = canUseAgent();
+        if (!check.ready) {
+            setError(check.reason || "Run 'whale login' to authenticate.");
+        }
+        else {
+            const config = loadConfig();
+            if (config.email)
+                setUserLabel(config.store_name || config.email);
+            setReady(true);
+            getServerToolCount().then((count) => setServerToolsAvailable(count));
+        }
+    }, []);
+    // ── Keys ──
+    useInput((input, key) => {
+        if (input === "c" && key.ctrl) {
+            if (abortRef.current)
+                abortRef.current.abort();
+            exit();
+        }
+        if (key.escape && isStreaming && abortRef.current) {
+            abortRef.current.abort();
+        }
+        if (input === "e" && key.ctrl) {
+            setToolsExpanded((prev) => !prev);
+        }
+    });
+    // ── Commands ──
+    const handleCommand = useCallback((command) => {
+        switch (command) {
+            case "/help":
+                setMessages((prev) => [...prev, {
+                        role: "assistant",
+                        text: SLASH_COMMANDS
+                            .map((c) => `  ${c.name.padEnd(12)} ${c.description}`)
+                            .join("\n") + "\n\n  ^C exit  esc cancel  ^E expand tools",
+                    }]);
+                break;
+            case "/clear":
+                setMessages([]);
+                setStreamingText("");
+                setActiveTools([]);
+                conversationRef.current = [];
+                break;
+            case "/exit":
+                if (abortRef.current)
+                    abortRef.current.abort();
+                exit();
+                break;
+            case "/status": {
+                const config = loadConfig();
+                const toolsLine = serverToolsAvailable > 0
+                    ? `  tools     7 local + ${serverToolsAvailable} server`
+                    : `  tools     7 local`;
+                setMessages((prev) => [...prev, {
+                        role: "assistant",
+                        text: [
+                            `  version   v${PKG_VERSION}`,
+                            `  user      ${config.email || "—"}`,
+                            `  store     ${config.store_name || "—"}`,
+                            `  model     claude-sonnet-4`,
+                            toolsLine,
+                            `  expand    ${toolsExpanded ? "on" : "off"}  (^E)`,
+                        ].join("\n"),
+                    }]);
+                break;
+            }
+            case "/mcp": {
+                getServerStatus().then((status) => {
+                    const lines = [];
+                    if (status.connected) {
+                        lines.push(`  ● Connected`);
+                        lines.push(`  auth      ${status.authMethod === "service_role" ? "service role" : "user JWT"}`);
+                        lines.push(`  store     ${status.storeName || status.storeId || "—"}`);
+                        lines.push(`  tools     ${status.toolCount} active`);
+                        lines.push("");
+                        const serverDefs = getAllServerToolDefinitions();
+                        for (const t of serverDefs) {
+                            lines.push(`    ${t.name.padEnd(20)} ${(t.description || "").slice(0, 45)}`);
+                        }
+                    }
+                    else {
+                        lines.push(`  ○ Disconnected`);
+                        lines.push("");
+                        lines.push("  Run: whale login");
+                    }
+                    setMessages((prev) => [...prev, { role: "assistant", text: lines.join("\n") }]);
+                });
+                break;
+            }
+            case "/store": {
+                getValidToken().then(async (token) => {
+                    if (!token) {
+                        setMessages((prev) => [...prev, { role: "assistant", text: "  Not logged in. Run: whale login" }]);
+                        return;
+                    }
+                    const config = loadConfig();
+                    const stores = await getStoresForUser(token, config.user_id || "");
+                    if (stores.length === 0) {
+                        setMessages((prev) => [...prev, { role: "assistant", text: "  No stores found for this account." }]);
+                    }
+                    else if (stores.length === 1) {
+                        setMessages((prev) => [...prev, { role: "assistant", text: `  Only one store: ${stores[0].name}` }]);
+                    }
+                    else {
+                        setStoreList(stores);
+                        setStoreSelectMode(true);
+                    }
+                });
+                break;
+            }
+            case "/update": {
+                setMessages((prev) => [...prev, { role: "assistant", text: `  Checking for updates...` }]);
+                try {
+                    const latest = execSync(`npm view ${PKG_NAME} version 2>/dev/null`, { encoding: "utf-8" }).trim();
+                    if (latest === PKG_VERSION) {
+                        setMessages((prev) => [...prev, { role: "assistant", text: `  ${symbols.check} Already on latest  v${PKG_VERSION}` }]);
+                    }
+                    else {
+                        setMessages((prev) => [...prev, { role: "assistant", text: `  v${PKG_VERSION} → v${latest}  Installing...` }]);
+                        try {
+                            execSync(`npm install -g ${PKG_NAME}@latest 2>&1`, { encoding: "utf-8", timeout: 30000 });
+                            setMessages((prev) => [...prev, { role: "assistant", text: `  ${symbols.check} Updated to v${latest}\n  Restart whale to use the new version.` }]);
+                        }
+                        catch (installErr) {
+                            setMessages((prev) => [...prev, { role: "assistant", text: `  ${symbols.cross} Install failed. Try manually:\n  npm install -g ${PKG_NAME}@latest` }]);
+                        }
+                    }
+                }
+                catch {
+                    setMessages((prev) => [...prev, { role: "assistant", text: `  ${symbols.cross} Could not check npm. Are you online?` }]);
+                }
+                break;
+            }
+            case "/tools": {
+                const lines = [];
+                lines.push("  Local (7)");
+                for (const t of LOCAL_TOOL_DEFINITIONS) {
+                    lines.push(`    ${t.name.padEnd(20)} ${t.description.slice(0, 48)}`);
+                }
+                lines.push("");
+                if (serverToolsAvailable > 0) {
+                    lines.push(`  Server (${serverToolsAvailable})`);
+                    const serverDefs = getAllServerToolDefinitions();
+                    for (const t of serverDefs) {
+                        lines.push(`    ${t.name.padEnd(20)} ${(t.description || "").slice(0, 48)}`);
+                    }
+                }
+                else {
+                    lines.push("  Server (unavailable — /mcp for details)");
+                }
+                setMessages((prev) => [...prev, { role: "assistant", text: lines.join("\n") }]);
+                break;
+            }
+        }
+    }, [exit, toolsExpanded, serverToolsAvailable]);
+    // ── Store Select ──
+    const handleStoreSelect = useCallback((store) => {
+        selectStore(store.id, store.name);
+        resetServerToolClient();
+        setStoreSelectMode(false);
+        setStoreList([]);
+        setUserLabel(store.name);
+        setMessages((prev) => [...prev, {
+                role: "assistant",
+                text: `  ${symbols.check} Switched to ${store.name}`,
+            }]);
+        // Re-check server tools with new store
+        getServerToolCount().then((count) => setServerToolsAvailable(count));
+    }, []);
+    const handleStoreCancel = useCallback(() => {
+        setStoreSelectMode(false);
+        setStoreList([]);
+    }, []);
+    // ── Send ──
+    const handleSend = useCallback(async (userMessage) => {
+        if (isStreaming)
+            return;
+        setMessages((prev) => [...prev, { role: "user", text: userMessage }]);
+        setStreamingText("");
+        setActiveTools([]);
+        setIsStreaming(true);
+        const abort = new AbortController();
+        abortRef.current = abort;
+        let accumulatedText = "";
+        const toolCalls = [];
+        let usage;
+        await runAgentLoop({
+            message: userMessage,
+            conversationHistory: conversationRef.current,
+            abortSignal: abort.signal,
+            callbacks: {
+                onText: (text) => {
+                    accumulatedText += text;
+                    setStreamingText(accumulatedText);
+                },
+                onToolStart: (name) => {
+                    toolCalls.push({ name, status: "running" });
+                    setActiveTools([...toolCalls]);
+                },
+                onToolResult: (name, success, result, input, durationMs) => {
+                    const tc = toolCalls.find((t) => t.name === name && t.status === "running");
+                    if (tc) {
+                        tc.status = success ? "success" : "error";
+                        tc.result = typeof result === "string" ? result : JSON.stringify(result);
+                        tc.input = input;
+                        tc.durationMs = durationMs;
+                        setActiveTools([...toolCalls]);
+                    }
+                    accumulatedText = "";
+                    setStreamingText("");
+                },
+                onUsage: (input_tokens, output_tokens) => {
+                    usage = { input_tokens, output_tokens };
+                },
+                onDone: (finalMessages) => {
+                    setMessages((prev) => [...prev, {
+                            role: "assistant",
+                            text: accumulatedText,
+                            toolCalls: toolCalls.length > 0 ? [...toolCalls] : undefined,
+                            usage,
+                        }]);
+                    setStreamingText("");
+                    setActiveTools([]);
+                    setIsStreaming(false);
+                    abortRef.current = null;
+                    conversationRef.current = finalMessages;
+                },
+                onError: (err) => {
+                    if (err !== "Cancelled") {
+                        setMessages((prev) => [...prev, { role: "assistant", text: `Error: ${err}` }]);
+                    }
+                    setStreamingText("");
+                    setActiveTools([]);
+                    setIsStreaming(false);
+                    abortRef.current = null;
+                },
+            },
+        });
+    }, [isStreaming]);
+    // ── Render ──
+    if (error) {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { color: colors.brand, bold: true, children: "\u25C6 whale code" }), _jsx(Box, { height: 1 }), _jsx(Text, { color: colors.error, children: error })] }));
+    }
+    if (!ready) {
+        return (_jsx(Box, { flexDirection: "column", padding: 1, children: _jsx(Text, { color: colors.tertiary, children: "loading..." }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: colors.brand, bold: true, children: "\u25C6 whale code" }), userLabel && _jsxs(Text, { color: colors.dim, children: ["  ", userLabel] }), serverToolsAvailable > 0 && (_jsxs(Text, { color: colors.tertiary, children: ["  ", symbols.dot, " ", serverToolsAvailable, " server tools"] }))] }), _jsx(Text, { color: colors.separator, children: boxLine(56) }), _jsx(MessageList, { messages: messages, streamingText: streamingText, isStreaming: isStreaming, activeTools: activeTools, toolsExpanded: toolsExpanded }), storeSelectMode ? (_jsx(StoreSelector, { stores: storeList, currentStoreId: loadConfig().store_id || "", onSelect: handleStoreSelect, onCancel: handleStoreCancel })) : (_jsx(ChatInput, { onSubmit: handleSend, onCommand: handleCommand, disabled: isStreaming, agentName: "whale code" }))] }));
+}

package/dist/cli/chat/ChatInput.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ChatInput — clean input with slash command menu
+ *
+ * "/" triggers a select menu. Esc/backspace dismisses.
+ * Minimal chrome, Apple-style focus states.
+ */
+export interface SlashCommand {
+    name: string;
+    description: string;
+}
+export declare const SLASH_COMMANDS: SlashCommand[];
+interface ChatInputProps {
+    onSubmit: (message: string) => void;
+    onCommand: (command: string) => void;
+    disabled: boolean;
+    agentName?: string;
+}
+export declare function ChatInput({ onSubmit, onCommand, disabled, agentName }: ChatInputProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cli/chat/ChatInput.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * ChatInput — clean input with slash command menu
+ *
+ * "/" triggers a select menu. Esc/backspace dismisses.
+ * Minimal chrome, Apple-style focus states.
+ */
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+import SelectInput from "ink-select-input";
+import Spinner from "ink-spinner";
+import { colors, symbols } from "../shared/Theme.js";
+export const SLASH_COMMANDS = [
+    { name: "/help", description: "Show available commands" },
+    { name: "/tools", description: "List all tools" },
+    { name: "/mcp", description: "Server connection status" },
+    { name: "/store", description: "Switch active store" },
+    { name: "/status", description: "Show session info" },
+    { name: "/update", description: "Check for updates & install" },
+    { name: "/clear", description: "Clear conversation" },
+    { name: "/exit", description: "Exit" },
+];
+export function ChatInput({ onSubmit, onCommand, disabled, agentName }) {
+    const [value, setValue] = useState("");
+    const [menuMode, setMenuMode] = useState(false);
+    const handleChange = (newValue) => {
+        if (newValue === "/") {
+            setMenuMode(true);
+            setValue("");
+            return;
+        }
+        setValue(newValue);
+    };
+    useInput((input, key) => {
+        if (!menuMode || disabled)
+            return;
+        if (key.escape || key.delete || key.backspace) {
+            setMenuMode(false);
+        }
+    }, { isActive: menuMode });
+    const handleMenuSelect = (item) => {
+        setMenuMode(false);
+        setValue("");
+        onCommand(item.value);
+    };
+    const handleSubmit = (text) => {
+        const trimmed = text.trim();
+        if (!trimmed || disabled)
+            return;
+        onSubmit(trimmed);
+        setValue("");
+    };
+    // Thinking state — smooth spinner
+    if (disabled) {
+        return (_jsx(Box, { children: _jsx(Text, { color: colors.brand, children: _jsx(Spinner, { type: "dots" }) }) }));
+    }
+    // Slash command menu
+    if (menuMode) {
+        const items = SLASH_COMMANDS.map((c) => ({
+            label: c.name,
+            value: c.name,
+        }));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(SelectInput, { items: items, onSelect: handleMenuSelect, indicatorComponent: ({ isSelected }) => (_jsxs(Text, { color: isSelected ? colors.brand : colors.quaternary, children: [isSelected ? "›" : " ", " "] })), itemComponent: ({ isSelected, label }) => {
+                        const cmd = SLASH_COMMANDS.find((c) => c.name === label);
+                        return (_jsxs(Box, { children: [_jsx(Text, { color: isSelected ? colors.brand : colors.secondary, bold: isSelected, children: label }), _jsxs(Text, { color: colors.tertiary, children: ["  ", cmd?.description] })] }));
+                    } }), _jsx(Text, { color: colors.quaternary, children: "  esc to dismiss" })] }));
+    }
+    // Normal input
+    return (_jsxs(Box, { children: [_jsxs(Text, { color: colors.brand, bold: true, children: [symbols.user, " "] }), _jsx(TextInput, { value: value, onChange: handleChange, onSubmit: handleSubmit, placeholder: `Message ${agentName || "whale"}, or /` })] }));
+}

package/dist/cli/chat/MarkdownText.d.ts

@@ -0,0 +1,9 @@
+/**
+ * MarkdownText — renders markdown as ANSI-styled terminal output
+ */
+interface MarkdownTextProps {
+    text: string;
+    streaming?: boolean;
+}
+export declare function MarkdownText({ text, streaming }: MarkdownTextProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cli/chat/MarkdownText.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * MarkdownText — renders markdown as ANSI-styled terminal output
+ */
+import { useMemo } from "react";
+import { Text } from "ink";
+import { renderMarkdown } from "../shared/markdown.js";
+/**
+ * During streaming, an odd number of ``` fences means a code block is unclosed.
+ * Append a closing fence so marked renders it properly mid-stream.
+ */
+function closeIncompleteFences(text) {
+    const fenceCount = (text.match(/^```/gm) || []).length;
+    if (fenceCount % 2 !== 0) {
+        return text + "\n```";
+    }
+    return text;
+}
+export function MarkdownText({ text, streaming = false }) {
+    const rendered = useMemo(() => {
+        if (!text)
+            return "";
+        try {
+            const safeText = streaming ? closeIncompleteFences(text) : text;
+            return renderMarkdown(safeText);
+        }
+        catch {
+            return text;
+        }
+    }, [text, streaming]);
+    return _jsx(Text, { children: rendered });
+}