whale-code 6.4.0

package/dist/cli/chat/hooks/useSlashCommands.js

@@ -0,0 +1,387 @@
+/**
+ * useSlashCommands — slash command handler extracted from ChatApp
+ *
+ * All consumers should import from ChatApp (re-export facade).
+ */
+import { useCallback } from "react";
+import { execSync } from "child_process";
+import { setModel, getModel, getModelShortName, loadClaudeMd, getSessionTokens, resetSessionState, saveSession, loadSession, listSessions, addMemory, removeMemory, listMemories, setPermissionMode, getPermissionMode, getServerStatus, mcpClientManager, } from "../../services/agent-loop.js";
+import { setConversationId } from "../../services/telemetry.js";
+import { getAllServerToolDefinitions, resetServerToolClient } from "../../services/server-tools.js";
+import { LOCAL_TOOL_DEFINITIONS, loadTodos, setTodoSessionId } from "../../services/local-tools.js";
+import { loadAgentDefinitions } from "../../services/agent-definitions.js";
+import { SLASH_COMMANDS } from "../ChatInput.js";
+import { MODEL_OPTIONS } from "../ModelSelector.js";
+import { symbols } from "../../shared/Theme.js";
+import { loadKeybindings } from "../../services/keybinding-manager.js";
+import { loadConfig, updateConfig } from "../../services/config-store.js";
+import { getStoresForUser, getValidToken, selectStore } from "../../services/auth-service.js";
+import { getServerToolCount } from "../../services/agent-loop.js";
+export function useSlashCommands(deps) {
+    const { exit, toolsExpanded, serverToolsAvailable, sessionId, thinkingEnabled, conversationRef, setMessages, setStreamingText, setActiveTools, setTeamState, setStoreList, setStoreSelectMode, setModelSelectMode, setCurrentModel, setSessionId, setThinkingEnabled, setUserLabel, setServerToolsAvailable, setShowRewind, rewindCheckpointCount, PKG_NAME, PKG_VERSION, } = deps;
+    const handleCommand = useCallback(async (command) => {
+        const parts = command.trim().split(/\s+/);
+        const cmd = parts[0];
+        const args = parts.slice(1).join(" ");
+        switch (cmd) {
+            case "/help": {
+                const helpLines = SLASH_COMMANDS
+                    .map((c) => `  ${c.name.padEnd(14)}${c.description}`)
+                    .join("\n");
+                const kb = loadKeybindings();
+                setMessages((prev) => [...prev, {
+                        role: "assistant",
+                        text: helpLines + `\n\n  ${kb.exit} exit  ${kb.cancel_stream} cancel  ${kb.toggle_expand} expand tools`,
+                    }]);
+                break;
+            }
+            case "/clear":
+                setMessages([]);
+                setStreamingText("");
+                setActiveTools([]);
+                setTeamState(null);
+                conversationRef.current = [];
+                resetSessionState();
+                break;
+            case "/exit":
+                exit();
+                break;
+            case "/status": {
+                const config = loadConfig();
+                const localCount = LOCAL_TOOL_DEFINITIONS.length;
+                const toolsLine = serverToolsAvailable > 0
+                    ? `  tools     ${localCount} local + ${serverToolsAvailable} server`
+                    : `  tools     ${localCount} local`;
+                const claudeMd = loadClaudeMd();
+                const tokens = getSessionTokens();
+                const tokenLine = tokens.input > 0
+                    ? `  tokens    ${(tokens.input / 1000).toFixed(1)}K in / ${(tokens.output / 1000).toFixed(1)}K out`
+                    : `  tokens    (no usage yet)`;
+                const lines = [
+                    `  version   v${PKG_VERSION}`,
+                    `  user      ${config.email || "—"}`,
+                    `  store     ${config.store_name || "—"}`,
+                    `  model     ${getModelShortName()}  (${getModel()})`,
+                    `  output    16384 max tokens`,
+                    toolsLine,
+                    tokenLine,
+                    `  session   ${sessionId || "(unsaved)"}`,
+                    `  CLAUDE.md ${claudeMd ? claudeMd.path : "not found"}`,
+                    `  mode      ${getPermissionMode()}`,
+                    `  thinking  ${thinkingEnabled ? "on" : "off"}  (^T)`,
+                    `  context   ${conversationRef.current.length} messages`,
+                    `  expand    ${toolsExpanded ? "on" : "off"}  (^E)`,
+                ];
+                setMessages((prev) => [...prev, { role: "assistant", text: lines.join("\n") }]);
+                break;
+            }
+            case "/mcp": {
+                getServerStatus().then((status) => {
+                    const lines = [];
+                    if (status.connected) {
+                        lines.push(`  Server tools:`);
+                        lines.push(`    ● Connected  (${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(`  Server tools:`);
+                        lines.push(`    ○ Disconnected — run: whale login`);
+                    }
+                    const mcpStatus = mcpClientManager.getStatus();
+                    if (mcpStatus.length > 0) {
+                        lines.push("");
+                        lines.push(`  External MCP servers:`);
+                        for (const s of mcpStatus) {
+                            lines.push(`    ● ${s.name}  (${s.toolCount} tool${s.toolCount !== 1 ? "s" : ""})`);
+                        }
+                    }
+                    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 {
+                            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 "/model": {
+                const match = args && MODEL_OPTIONS.find((m) => m.value === args);
+                if (match) {
+                    setModel(match.value);
+                    setCurrentModel(match.value);
+                    setMessages((prev) => [...prev, {
+                            role: "assistant",
+                            text: `  ${symbols.check} Model: ${match.label}  (${match.modelId})`,
+                        }]);
+                }
+                else {
+                    setModelSelectMode(true);
+                }
+                break;
+            }
+            case "/compact": {
+                setMessages((prev) => [...prev, {
+                        role: "assistant",
+                        text: `  Context management is now handled server-side by the Anthropic API. Compaction fires automatically when context exceeds 150K tokens.`,
+                    }]);
+                break;
+            }
+            case "/save": {
+                if (conversationRef.current.length === 0) {
+                    setMessages((prev) => [...prev, { role: "assistant", text: "  Nothing to save." }]);
+                }
+                else {
+                    const id = saveSession(conversationRef.current, sessionId || undefined);
+                    setSessionId(id);
+                    setTodoSessionId(id);
+                    setMessages((prev) => [...prev, {
+                            role: "assistant",
+                            text: `  ${symbols.check} Session saved: ${id}`,
+                        }]);
+                }
+                break;
+            }
+            case "/sessions": {
+                const sessions = listSessions();
+                if (sessions.length === 0) {
+                    setMessages((prev) => [...prev, { role: "assistant", text: "  No saved sessions." }]);
+                }
+                else {
+                    const lines = sessions.map((s, i) => `  ${String(i + 1).padStart(2)}. ${s.title.slice(0, 40).padEnd(42)} ${s.messageCount} msgs  ${s.updatedAt.slice(0, 10)}`);
+                    setMessages((prev) => [...prev, {
+                            role: "assistant",
+                            text: `  Saved sessions:\n${lines.join("\n")}\n\n  Use /resume to load a session.`,
+                        }]);
+                }
+                break;
+            }
+            case "/resume": {
+                const sessions = listSessions();
+                if (sessions.length === 0) {
+                    setMessages((prev) => [...prev, { role: "assistant", text: "  No saved sessions." }]);
+                }
+                else {
+                    const latest = sessions[0];
+                    const loaded = loadSession(latest.id);
+                    if (loaded) {
+                        conversationRef.current = loaded.messages;
+                        setSessionId(latest.id);
+                        setConversationId(latest.id);
+                        setTodoSessionId(latest.id);
+                        loadTodos(latest.id);
+                        if (loaded.meta.model)
+                            setModel(loaded.meta.model);
+                        setMessages((prev) => [...prev, {
+                                role: "assistant",
+                                text: `  ${symbols.check} Resumed: ${latest.title}\n  ${latest.messageCount} messages, model: ${getModelShortName()}`,
+                            }]);
+                    }
+                    else {
+                        setMessages((prev) => [...prev, { role: "assistant", text: "  Failed to load session." }]);
+                    }
+                }
+                break;
+            }
+            case "/agents": {
+                const builtIn = ["explore", "plan", "general-purpose", "research"];
+                const custom = loadAgentDefinitions();
+                const lines = [];
+                lines.push("  Built-in:");
+                for (const a of builtIn)
+                    lines.push(`    ${a.padEnd(20)} (built-in)`);
+                if (custom.length > 0) {
+                    lines.push("");
+                    lines.push("  Custom:");
+                    for (const a of custom) {
+                        lines.push(`    ${a.name.padEnd(20)} ${a.description || `(${a.source})`}`);
+                    }
+                }
+                else {
+                    lines.push("");
+                    lines.push("  No custom agents. Add .md files to .whale/agents/ or ~/.swagmanager/agents/");
+                }
+                setMessages((prev) => [...prev, { role: "assistant", text: lines.join("\n") }]);
+                break;
+            }
+            case "/remember": {
+                if (!args) {
+                    setMessages((prev) => [...prev, { role: "assistant", text: "  Usage: /remember <fact to remember>" }]);
+                }
+                else {
+                    const result = addMemory(args);
+                    setMessages((prev) => [...prev, {
+                            role: "assistant",
+                            text: `  ${result.success ? symbols.check : symbols.cross} ${result.message}`,
+                        }]);
+                }
+                break;
+            }
+            case "/forget": {
+                if (!args) {
+                    setMessages((prev) => [...prev, { role: "assistant", text: "  Usage: /forget <pattern to match>" }]);
+                }
+                else {
+                    const result = removeMemory(args);
+                    setMessages((prev) => [...prev, {
+                            role: "assistant",
+                            text: `  ${result.success ? symbols.check : symbols.cross} ${result.message}`,
+                        }]);
+                }
+                break;
+            }
+            case "/memory": {
+                const memories = listMemories();
+                if (memories.length === 0) {
+                    setMessages((prev) => [...prev, { role: "assistant", text: "  No memories stored. Use /remember <fact> to add one." }]);
+                }
+                else {
+                    const lines = memories.map((m, i) => `  ${i + 1}. ${m}`);
+                    setMessages((prev) => [...prev, {
+                            role: "assistant",
+                            text: `  ${memories.length} remembered fact${memories.length !== 1 ? "s" : ""}:\n${lines.join("\n")}`,
+                        }]);
+                }
+                break;
+            }
+            case "/mode": {
+                const modeDesc = {
+                    default: "all tools, normal operation",
+                    plan: "read-only tools only (no writes, no commands)",
+                    yolo: "all tools, no confirmation",
+                };
+                const modes = ["default", "plan", "yolo"];
+                if (args && modes.includes(args)) {
+                    setPermissionMode(args);
+                    setMessages((prev) => [...prev, {
+                            role: "assistant",
+                            text: `  ${symbols.check} Mode: ${args}  (${modeDesc[args]})`,
+                        }]);
+                }
+                else {
+                    const current = getPermissionMode();
+                    const nextIdx = (modes.indexOf(current) + 1) % modes.length;
+                    const next = modes[nextIdx];
+                    setPermissionMode(next);
+                    setMessages((prev) => [...prev, {
+                            role: "assistant",
+                            text: `  ${symbols.check} Mode: ${next}  (${modeDesc[next]})`,
+                        }]);
+                }
+                break;
+            }
+            case "/thinking": {
+                setThinkingEnabled(prev => {
+                    const next = !prev;
+                    try {
+                        updateConfig({ thinking_enabled: next });
+                    }
+                    catch { /* best effort */ }
+                    setMessages(msgs => [...msgs, {
+                            role: "assistant",
+                            text: `  Thinking: ${next ? "on" : "off"}`,
+                        }]);
+                    return next;
+                });
+                break;
+            }
+            case "/init": {
+                const { runInitInline } = await import("../../commands/init.js");
+                const result = await runInitInline();
+                setMessages(prev => [...prev, { role: "assistant", text: result }]);
+                break;
+            }
+            case "/rewind": {
+                if (rewindCheckpointCount === 0) {
+                    setMessages((prev) => [...prev, { role: "assistant", text: "  Nothing to rewind to." }]);
+                }
+                else {
+                    setShowRewind(true);
+                }
+                break;
+            }
+            case "/tools": {
+                const lines = [];
+                lines.push(`  Local (${LOCAL_TOOL_DEFINITIONS.length})`);
+                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, sessionId, thinkingEnabled, rewindCheckpointCount]);
+    // Store select handlers
+    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}`,
+            }]);
+        getServerToolCount().then((count) => setServerToolsAvailable(count));
+    }, []);
+    const handleStoreCancel = useCallback(() => {
+        setStoreSelectMode(false);
+        setStoreList([]);
+    }, []);
+    return { handleCommand, handleStoreSelect, handleStoreCancel };
+}

package/dist/cli/commands/config-cmd.d.ts

@@ -0,0 +1,10 @@
+/**
+ * whale config — View and set configuration from the CLI
+ *
+ * Usage:
+ *   whale config                Show all settings
+ *   whale config <key>          Read single key
+ *   whale config <key> <value>  Write single key
+ *   whale config --reset        Reset to defaults
+ */
+export declare function runConfigCommand(args: string[], flags: Record<string, unknown>): Promise<void>;

package/dist/cli/commands/config-cmd.js

@@ -0,0 +1,99 @@
+/**
+ * whale config — View and set configuration from the CLI
+ *
+ * Usage:
+ *   whale config                Show all settings
+ *   whale config <key>          Read single key
+ *   whale config <key> <value>  Write single key
+ *   whale config --reset        Reset to defaults
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const CONFIG_PATH = join(homedir(), ".swagmanager", "config.json");
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+function loadConfig() {
+    if (!existsSync(CONFIG_PATH))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function saveConfig(config) {
+    const dir = join(homedir(), ".swagmanager");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+function maskSecret(key, value) {
+    if (key.includes("key") || key.includes("token") || key.includes("secret")) {
+        if (value.length > 8) {
+            return value.slice(0, 4) + "..." + value.slice(-4);
+        }
+        return "***";
+    }
+    return value;
+}
+export async function runConfigCommand(args, flags) {
+    if (flags.reset) {
+        const dir = join(homedir(), ".swagmanager");
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(CONFIG_PATH, JSON.stringify({}, null, 2), { mode: 0o600 });
+        console.log("Configuration reset to defaults.");
+        return;
+    }
+    const key = args[0];
+    const value = args[1];
+    if (!key) {
+        // Show all settings
+        const config = loadConfig();
+        console.log(`\n  ${BOLD}whale config${RESET} ${DIM}(${CONFIG_PATH})${RESET}\n`);
+        if (Object.keys(config).length === 0) {
+            console.log("  No configuration set.");
+            console.log(`  ${DIM}Set a value: whale config <key> <value>${RESET}`);
+        }
+        else {
+            for (const [k, v] of Object.entries(config)) {
+                if (typeof v === "object" && v !== null) {
+                    console.log(`  ${k}:`);
+                    for (const [sk, sv] of Object.entries(v)) {
+                        const display = typeof sv === "string" ? maskSecret(sk, sv) : JSON.stringify(sv);
+                        console.log(`    ${sk}: ${DIM}${display}${RESET}`);
+                    }
+                }
+                else {
+                    const display = typeof v === "string" ? maskSecret(k, v) : String(v);
+                    console.log(`  ${k}: ${DIM}${display}${RESET}`);
+                }
+            }
+        }
+        console.log();
+        return;
+    }
+    if (!value) {
+        // Read single key
+        const config = loadConfig();
+        const v = config[key];
+        if (v === undefined) {
+            console.log(`${key}: (not set)`);
+        }
+        else if (typeof v === "object") {
+            console.log(JSON.stringify(v, null, 2));
+        }
+        else {
+            console.log(typeof v === "string" ? maskSecret(key, v) : String(v));
+        }
+        return;
+    }
+    // Write single key
+    const config = loadConfig();
+    config[key] = value;
+    saveConfig(config);
+    console.log(`${key} = ${value}`);
+}

package/dist/cli/commands/doctor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * whale doctor — Run diagnostics
+ *
+ * Checks:
+ *   - Node.js version (>=20)
+ *   - ripgrep availability
+ *   - Supabase connection
+ *   - Auth status
+ *   - Server tools loadable
+ *   - MCP servers configured
+ *   - Disk space
+ *   - Package version vs latest
+ */
+export declare function runDoctor(): Promise<void>;

package/dist/cli/commands/doctor.js

@@ -0,0 +1,172 @@
+/**
+ * whale doctor — Run diagnostics
+ *
+ * Checks:
+ *   - Node.js version (>=20)
+ *   - ripgrep availability
+ *   - Supabase connection
+ *   - Auth status
+ *   - Server tools loadable
+ *   - MCP servers configured
+ *   - Disk space
+ *   - Package version vs latest
+ */
+import { execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const CHECK = "\x1b[32m✓\x1b[0m";
+const CROSS = "\x1b[31m✗\x1b[0m";
+const WARN = "\x1b[33m!\x1b[0m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+function icon(status) {
+    if (status === "ok")
+        return CHECK;
+    if (status === "warn")
+        return WARN;
+    return CROSS;
+}
+async function checkNodeVersion() {
+    const version = process.version;
+    const major = parseInt(version.slice(1).split(".")[0], 10);
+    if (major >= 20) {
+        return { status: "ok", label: "Node.js", detail: version };
+    }
+    return { status: "error", label: "Node.js", detail: `${version} (need >=20)` };
+}
+async function checkRipgrep() {
+    try {
+        const version = execSync("rg --version 2>/dev/null", { encoding: "utf-8", timeout: 3000 }).trim().split("\n")[0];
+        return { status: "ok", label: "ripgrep", detail: version };
+    }
+    catch {
+        // Check if @vscode/ripgrep is available
+        try {
+            const { rgPath } = await import("@vscode/ripgrep");
+            return { status: "ok", label: "ripgrep", detail: `@vscode/ripgrep (${rgPath})` };
+        }
+        catch {
+            return { status: "warn", label: "ripgrep", detail: "not found (search will use fallback)" };
+        }
+    }
+}
+async function checkSupabase() {
+    try {
+        const { SUPABASE_URL } = await import("../services/auth-service.js");
+        const resp = await fetch(`${SUPABASE_URL}/rest/v1/`, {
+            method: "HEAD",
+            signal: AbortSignal.timeout(5000),
+        });
+        if (resp.ok || resp.status === 401) {
+            return { status: "ok", label: "Supabase", detail: "reachable" };
+        }
+        return { status: "warn", label: "Supabase", detail: `status ${resp.status}` };
+    }
+    catch (err) {
+        return { status: "error", label: "Supabase", detail: err.message?.slice(0, 60) || "unreachable" };
+    }
+}
+async function checkAuth() {
+    try {
+        const { isLoggedIn, getValidToken } = await import("../services/auth-service.js");
+        if (!isLoggedIn()) {
+            // Check for API key
+            const { loadConfig } = await import("../services/config-store.js");
+            const config = loadConfig();
+            if (process.env.ANTHROPIC_API_KEY || config.anthropic_api_key) {
+                return { status: "ok", label: "Auth", detail: "API key configured" };
+            }
+            return { status: "warn", label: "Auth", detail: "not logged in (run: whale login)" };
+        }
+        const token = await getValidToken();
+        return token
+            ? { status: "ok", label: "Auth", detail: "valid JWT" }
+            : { status: "warn", label: "Auth", detail: "token expired" };
+    }
+    catch {
+        return { status: "error", label: "Auth", detail: "check failed" };
+    }
+}
+async function checkServerTools() {
+    try {
+        const { loadServerToolDefinitions } = await import("../services/server-tools.js");
+        const tools = await loadServerToolDefinitions();
+        return { status: "ok", label: "Server tools", detail: `${tools.length} tools loaded` };
+    }
+    catch (err) {
+        return { status: "warn", label: "Server tools", detail: err.message?.slice(0, 60) || "unavailable" };
+    }
+}
+async function checkMcpServers() {
+    const configPath = join(homedir(), ".swagmanager", "config.json");
+    if (!existsSync(configPath)) {
+        return { status: "warn", label: "MCP servers", detail: "none configured" };
+    }
+    try {
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        const servers = config.mcpServers || {};
+        const count = Object.keys(servers).length;
+        if (count === 0) {
+            return { status: "warn", label: "MCP servers", detail: "none configured" };
+        }
+        return { status: "ok", label: "MCP servers", detail: `${count} configured` };
+    }
+    catch {
+        return { status: "warn", label: "MCP servers", detail: "config parse error" };
+    }
+}
+async function checkDiskSpace() {
+    const dir = join(homedir(), ".swagmanager");
+    if (!existsSync(dir)) {
+        return { status: "ok", label: "Data dir", detail: "~/.swagmanager/ (not created yet)" };
+    }
+    try {
+        // Get total size
+        const output = execSync(`du -sh "${dir}" 2>/dev/null`, { encoding: "utf-8", timeout: 5000 }).trim();
+        const size = output.split("\t")[0];
+        return { status: "ok", label: "Data dir", detail: `~/.swagmanager/ (${size})` };
+    }
+    catch {
+        return { status: "ok", label: "Data dir", detail: "~/.swagmanager/" };
+    }
+}
+async function checkVersion() {
+    try {
+        const pkgPath = join(new URL("../../..", import.meta.url).pathname, "package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        return { status: "ok", label: "Version", detail: `v${pkg.version}` };
+    }
+    catch {
+        return { status: "ok", label: "Version", detail: "unknown" };
+    }
+}
+export async function runDoctor() {
+    console.log("\n  whale doctor\n");
+    const checks = await Promise.all([
+        checkNodeVersion(),
+        checkRipgrep(),
+        checkSupabase(),
+        checkAuth(),
+        checkServerTools(),
+        checkMcpServers(),
+        checkDiskSpace(),
+        checkVersion(),
+    ]);
+    for (const check of checks) {
+        console.log(`  ${icon(check.status)} ${check.label.padEnd(16)} ${DIM}${check.detail}${RESET}`);
+    }
+    const errors = checks.filter(c => c.status === "error").length;
+    const warnings = checks.filter(c => c.status === "warn").length;
+    console.log();
+    if (errors > 0) {
+        console.log(`  ${CROSS} ${errors} error${errors > 1 ? "s" : ""}, ${warnings} warning${warnings !== 1 ? "s" : ""}`);
+    }
+    else if (warnings > 0) {
+        console.log(`  ${WARN} All good, ${warnings} warning${warnings !== 1 ? "s" : ""}`);
+    }
+    else {
+        console.log(`  ${CHECK} All checks passed`);
+    }
+    console.log();
+}