whale-code 6.4.0 → 6.5.0

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

@@ -4,7 +4,11 @@
  * All consumers should import from ChatApp (re-export facade).
  */
 import { useCallback } from "react";
-import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { execSync, spawn } from "child_process";
+import { createConnection } from "net";
 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";
@@ -13,12 +17,58 @@ 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 { switchTheme, getThemePresets } from "../../shared/theme-manager.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 { getStoresForUser, getValidToken, selectStore, signOut } from "../../services/auth-service.js";
 import { getServerToolCount } from "../../services/agent-loop.js";
+// ── Module-level helpers ──
+function readNodeConfig() {
+    const p = join(homedir(), ".whaletools", "config.json");
+    if (!existsSync(p))
+        return { registered: false };
+    try {
+        const cfg = JSON.parse(readFileSync(p, "utf-8"));
+        return { registered: true, nodeId: cfg.node_id };
+    }
+    catch {
+        return { registered: false };
+    }
+}
+// ── Port helpers for node auto-start ──
+function checkPort(port) {
+    return new Promise((resolve) => {
+        const sock = createConnection({ port, host: "127.0.0.1" }, () => {
+            sock.destroy();
+            resolve(true);
+        });
+        sock.on("error", () => resolve(false));
+        sock.setTimeout(1000, () => {
+            sock.destroy();
+            resolve(false);
+        });
+    });
+}
+function waitForPort(port, timeout) {
+    const start = Date.now();
+    return new Promise((resolve) => {
+        const poll = () => {
+            if (Date.now() - start > timeout) {
+                resolve(false);
+                return;
+            }
+            checkPort(port).then((up) => {
+                if (up)
+                    resolve(true);
+                else
+                    setTimeout(poll, 500);
+            });
+        };
+        poll();
+    });
+}
 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 { exit, toolsExpanded, serverToolsAvailable, sessionId, thinkingEnabled, conversationRef, setMessages, setStreamingText, setActiveTools, setTeamState, setStoreList, setStoreSelectMode, setModelSelectMode, setCurrentModel, setSessionId, setThinkingEnabled, setUserLabel, setServerToolsAvailable, setShowRewind, rewindCheckpointCount, setNodeSelectMode, setNodeList, setSessionManagerMode, setSessionList, setMemoryManagerMode, setMemoryList, setThemeSelectMode, setNodeManagerMode, setNodeManagerStatus, PKG_NAME, PKG_VERSION, } = deps;
     const handleCommand = useCallback(async (command) => {
         const parts = command.trim().split(/\s+/);
         const cmd = parts[0];
@@ -70,7 +120,7 @@ export function useSlashCommands(deps) {
                     `  mode      ${getPermissionMode()}`,
                     `  thinking  ${thinkingEnabled ? "on" : "off"}  (^T)`,
                     `  context   ${conversationRef.current.length} messages`,
-                    `  expand    ${toolsExpanded ? "on" : "off"}  (^E)`,
+                    `  expand    ${toolsExpanded ? "on" : "off"}  (^O)`,
                 ];
                 setMessages((prev) => [...prev, { role: "assistant", text: lines.join("\n") }]);
                 break;
@@ -192,11 +242,8 @@ export function useSlashCommands(deps) {
                     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.`,
-                        }]);
+                    setSessionList(sessions);
+                    setSessionManagerMode(true);
                 }
                 break;
             }
@@ -280,11 +327,8 @@ export function useSlashCommands(deps) {
                     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")}`,
-                        }]);
+                    setMemoryList(memories);
+                    setMemoryManagerMode(true);
                 }
                 break;
             }
@@ -344,6 +388,15 @@ export function useSlashCommands(deps) {
                 }
                 break;
             }
+            case "/logout": {
+                signOut();
+                setMessages((prev) => [...prev, {
+                        role: "assistant",
+                        text: `  ${symbols.check} Logged out. Goodbye!`,
+                    }]);
+                setTimeout(() => exit(), 500);
+                break;
+            }
             case "/tools": {
                 const lines = [];
                 lines.push(`  Local (${LOCAL_TOOL_DEFINITIONS.length})`);
@@ -364,6 +417,46 @@ export function useSlashCommands(deps) {
                 setMessages((prev) => [...prev, { role: "assistant", text: lines.join("\n") }]);
                 break;
             }
+            case "/theme": {
+                if (args) {
+                    const success = switchTheme(args);
+                    if (success) {
+                        const preset = getThemePresets().find((t) => t.id === args);
+                        setMessages((prev) => [...prev, {
+                                role: "assistant",
+                                text: `  ${symbols.check} Theme: ${preset?.label || args}`,
+                            }]);
+                    }
+                    else {
+                        const available = getThemePresets().map((t) => t.id).join(", ");
+                        setMessages((prev) => [...prev, {
+                                role: "assistant",
+                                text: `  ${symbols.cross} Unknown theme: ${args}\n  Available: ${available}`,
+                            }]);
+                    }
+                }
+                else {
+                    setThemeSelectMode(true);
+                }
+                break;
+            }
+            // ── Node Commands ──
+            case "/nodes": {
+                const nodeConfigPath = join(homedir(), ".whaletools", "config.json");
+                const registered = existsSync(nodeConfigPath);
+                let nodeId;
+                if (registered) {
+                    try {
+                        const cfg = JSON.parse(readFileSync(nodeConfigPath, "utf-8"));
+                        nodeId = cfg.node_id;
+                    }
+                    catch { /* ignore parse errors */ }
+                }
+                const running = registered ? await checkPort(7890) : false;
+                setNodeManagerStatus({ registered, running, nodeId, port: 7890 });
+                setNodeManagerMode(true);
+                break;
+            }
         }
     }, [exit, toolsExpanded, serverToolsAvailable, sessionId, thinkingEnabled, rewindCheckpointCount]);
     // Store select handlers
@@ -383,5 +476,151 @@ export function useSlashCommands(deps) {
         setStoreSelectMode(false);
         setStoreList([]);
     }, []);
-    return { handleCommand, handleStoreSelect, handleStoreCancel };
+    // Node select handlers
+    const handleNodeSelect = useCallback((node) => {
+        setNodeSelectMode(false);
+        setNodeList([]);
+    }, []);
+    const handleNodeCancel = useCallback(() => {
+        setNodeSelectMode(false);
+        setNodeList([]);
+    }, []);
+    // Session manager handler
+    const handleSessionSelect = useCallback((session) => {
+        setSessionManagerMode(false);
+        const loaded = loadSession(session.id);
+        if (loaded) {
+            conversationRef.current = loaded.messages;
+            setSessionId(session.id);
+            setConversationId(session.id);
+            setTodoSessionId(session.id);
+            loadTodos(session.id);
+            if (loaded.meta.model)
+                setModel(loaded.meta.model);
+            setMessages((prev) => [...prev, {
+                    role: "assistant",
+                    text: `  ${symbols.check} Resumed: ${session.title}\n  ${session.messageCount} messages, model: ${getModelShortName()}`,
+                }]);
+        }
+        else {
+            setMessages((prev) => [...prev, { role: "assistant", text: "  Failed to load session." }]);
+        }
+    }, []);
+    // Memory manager handler
+    const handleMemoryDelete = useCallback((index) => {
+        setMemoryList((prev) => {
+            const memory = prev[index];
+            if (memory) {
+                removeMemory(memory);
+                setMessages((msgs) => [...msgs, { role: "assistant", text: `  ${symbols.check} Forgot: ${memory}` }]);
+            }
+            const next = prev.filter((_, i) => i !== index);
+            if (next.length === 0) {
+                setMemoryManagerMode(false);
+            }
+            return next;
+        });
+    }, []);
+    // ── Node manager helpers ──
+    // Node toggle: start or stop — returns result for NodeManager to display
+    const handleNodeToggle = useCallback(async () => {
+        const { nodeId } = readNodeConfig();
+        const running = await checkPort(7890);
+        if (running) {
+            // Stop
+            try {
+                execSync("lsof -ti :7890 | xargs kill", { encoding: "utf-8" });
+                return {
+                    success: true,
+                    message: "Node stopped",
+                    newStatus: { registered: true, running: false, nodeId, port: 7890 },
+                };
+            }
+            catch {
+                return {
+                    success: false,
+                    message: "Failed to stop node",
+                    newStatus: { registered: true, running: true, nodeId, port: 7890 },
+                };
+            }
+        }
+        else {
+            // Start
+            spawn("whalenode", ["node", "start"], {
+                detached: true,
+                stdio: "ignore",
+                cwd: homedir(),
+            }).unref();
+            const ready = await waitForPort(7890, 8000);
+            return {
+                success: ready,
+                message: ready ? "Node started" : "Node failed to start",
+                newStatus: { registered: true, running: ready, nodeId, port: 7890 },
+            };
+        }
+    }, []);
+    // Node register: register this machine, returns result for NodeManager
+    const handleNodeRegister = useCallback(async () => {
+        const token = await getValidToken();
+        const config = loadConfig();
+        if (!token || !config.store_id) {
+            return {
+                success: false,
+                message: "Not logged in — run: whale login",
+                newStatus: { registered: false, running: false },
+            };
+        }
+        try {
+            const hostname = (await import("os")).hostname();
+            const res = await fetch(`https://whale-agent.fly.dev/nodes/register`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+                body: JSON.stringify({ name: hostname, store_id: config.store_id }),
+            });
+            const data = await res.json();
+            if (!data.success) {
+                return {
+                    success: false,
+                    message: `Registration failed: ${data.error || "unknown"}`,
+                    newStatus: { registered: false, running: false },
+                };
+            }
+            const nodeConfig = {
+                node_id: data.node.id,
+                api_key: data.api_key,
+                store_id: config.store_id,
+                server_url: "https://whale-agent.fly.dev",
+                channels: [],
+            };
+            const configDir = join(homedir(), ".whaletools");
+            if (!existsSync(configDir))
+                mkdirSync(configDir, { recursive: true });
+            writeFileSync(join(configDir, "config.json"), JSON.stringify(nodeConfig, null, 2));
+            return {
+                success: true,
+                message: `Registered: ${data.node.id}`,
+                newStatus: { registered: true, running: false, nodeId: data.node.id, port: 7890 },
+            };
+        }
+        catch {
+            return {
+                success: false,
+                message: "Registration failed",
+                newStatus: { registered: false, running: false },
+            };
+        }
+    }, []);
+    // Node manager close: dismiss panel + optionally show result in chat
+    const handleNodeClose = useCallback((resultMessage) => {
+        setNodeManagerMode(false);
+        if (resultMessage) {
+            setMessages((prev) => [...prev, { role: "assistant", text: `  ${resultMessage}` }]);
+        }
+    }, []);
+    return {
+        handleCommand, handleStoreSelect, handleStoreCancel,
+        handleNodeSelect, handleNodeCancel,
+        handleSessionSelect, handleMemoryDelete,
+        handleNodeToggle, handleNodeRegister, handleNodeClose,
+    };
 }

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

@@ -7,29 +7,10 @@
  *   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");
+import { loadConfig, saveConfig, clearConfig, getConfigPath } from "../services/config-store.js";
 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) {
@@ -41,19 +22,17 @@ function maskSecret(key, 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 });
+        clearConfig();
         console.log("Configuration reset to defaults.");
         return;
     }
+    const configPath = getConfigPath();
     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`);
+        console.log(`\n  ${BOLD}whale config${RESET} ${DIM}(${configPath})${RESET}\n`);
         if (Object.keys(config).length === 0) {
             console.log("  No configuration set.");
             console.log(`  ${DIM}Set a value: whale config <key> <value>${RESET}`);

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

@@ -0,0 +1,13 @@
+/**
+ * whale db — Local Supabase database management
+ *
+ * Subcommands:
+ *   whale db status    Check if local Supabase is running
+ *   whale db start     Start local Supabase
+ *   whale db stop      Stop local Supabase
+ *   whale db reset     Drop + recreate + seed local DB
+ *   whale db sync      Pull latest production schema, apply locally
+ *   whale db seed      Re-run seed.sql without full reset
+ *   whale db test      Run full test suite against local DB
+ */
+export declare function runDbCommand(args: string[]): Promise<void>;

package/dist/cli/commands/db.js

@@ -0,0 +1,243 @@
+/**
+ * whale db — Local Supabase database management
+ *
+ * Subcommands:
+ *   whale db status    Check if local Supabase is running
+ *   whale db start     Start local Supabase
+ *   whale db stop      Stop local Supabase
+ *   whale db reset     Drop + recreate + seed local DB
+ *   whale db sync      Pull latest production schema, apply locally
+ *   whale db seed      Re-run seed.sql without full reset
+ *   whale db test      Run full test suite against local DB
+ */
+import { execSync, spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join, resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// ── ANSI colors ──
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+const CHECK = `${GREEN}✓${RESET}`;
+const CROSS = `${RED}✗${RESET}`;
+const WARN = `${YELLOW}!${RESET}`;
+const DB_URL = "postgresql://postgres:postgres@127.0.0.1:54322/postgres";
+function findEcosystemRoot() {
+    // Walk up from __dirname to find the directory containing supabase/config.toml
+    let dir = resolve(__dirname, "..", "..", "..");
+    for (let i = 0; i < 5; i++) {
+        if (existsSync(join(dir, "supabase", "config.toml"))) {
+            return dir;
+        }
+        dir = resolve(dir, "..");
+    }
+    // Fallback
+    return resolve(__dirname, "..", "..", "..");
+}
+function isLocalRunning() {
+    try {
+        execSync(`PGPASSWORD=postgres psql "${DB_URL}" -c "SELECT 1;" 2>/dev/null`, {
+            encoding: "utf-8",
+            timeout: 5000,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function runShell(cmd, opts) {
+    return execSync(cmd, {
+        encoding: "utf-8",
+        timeout: opts?.timeout ?? 30000,
+        cwd: opts?.cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+}
+function spawnInteractive(cmd, args, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, {
+            cwd,
+            stdio: "inherit",
+            shell: true,
+        });
+        child.on("close", (code) => resolve(code ?? 1));
+    });
+}
+// ── Subcommands ──
+async function dbStatus(root) {
+    console.log(`\n  ${BOLD}whale db status${RESET}\n`);
+    const supaDir = join(root, "supabase");
+    // Check Docker
+    let dockerOk = false;
+    try {
+        runShell("docker info 2>/dev/null", { timeout: 5000 });
+        dockerOk = true;
+    }
+    catch { /* noop */ }
+    console.log(`  ${dockerOk ? CHECK : CROSS} Docker         ${DIM}${dockerOk ? "running" : "not running"}${RESET}`);
+    // Check local Supabase
+    const running = isLocalRunning();
+    console.log(`  ${running ? CHECK : CROSS} Local Supabase ${DIM}${running ? "running (127.0.0.1:54321)" : "not running"}${RESET}`);
+    // Table count
+    if (running) {
+        try {
+            const count = runShell(`PGPASSWORD=postgres psql "${DB_URL}" -t -c "SELECT count(*) FROM pg_tables WHERE schemaname='public';"`, { timeout: 5000 }).trim();
+            console.log(`  ${CHECK} Tables         ${DIM}${count} in public schema${RESET}`);
+        }
+        catch {
+            console.log(`  ${WARN} Tables         ${DIM}could not query${RESET}`);
+        }
+    }
+    // Last sync
+    const syncFile = join(supaDir, ".last-sync");
+    if (existsSync(syncFile)) {
+        const ts = readFileSync(syncFile, "utf-8").trim();
+        console.log(`  ${CHECK} Last sync      ${DIM}${ts}${RESET}`);
+    }
+    else {
+        console.log(`  ${WARN} Last sync      ${DIM}never (run: whale db sync)${RESET}`);
+    }
+    // Config
+    const configOk = existsSync(join(supaDir, "config.toml"));
+    console.log(`  ${configOk ? CHECK : CROSS} Config         ${DIM}${configOk ? "supabase/config.toml" : "missing"}${RESET}`);
+    console.log();
+}
+async function dbStart(root) {
+    const supaDir = join(root, "supabase");
+    if (!existsSync(join(supaDir, "config.toml"))) {
+        console.error(`${RED}ERROR: supabase/config.toml not found in ${root}${RESET}`);
+        process.exit(1);
+    }
+    if (isLocalRunning()) {
+        console.log(`${GREEN}Local Supabase is already running.${RESET}`);
+        return;
+    }
+    console.log(`${CYAN}Starting local Supabase...${RESET}`);
+    const code = await spawnInteractive("supabase", ["start", "--workdir", "."], supaDir);
+    if (code !== 0) {
+        console.error(`${RED}Failed to start Supabase (exit ${code})${RESET}`);
+        process.exit(1);
+    }
+}
+async function dbStop(root) {
+    const supaDir = join(root, "supabase");
+    console.log(`${CYAN}Stopping local Supabase...${RESET}`);
+    const code = await spawnInteractive("supabase", ["stop", "--workdir", "."], supaDir);
+    if (code !== 0) {
+        console.error(`${RED}Failed to stop Supabase (exit ${code})${RESET}`);
+        process.exit(1);
+    }
+    console.log(`${GREEN}Local Supabase stopped.${RESET}`);
+}
+async function dbReset(root) {
+    const script = join(root, "scripts", "reset-test-db.sh");
+    if (!existsSync(script)) {
+        console.error(`${RED}ERROR: scripts/reset-test-db.sh not found${RESET}`);
+        process.exit(1);
+    }
+    console.log(`${CYAN}Resetting local database...${RESET}`);
+    const code = await spawnInteractive("bash", [script]);
+    if (code !== 0) {
+        console.error(`${RED}Reset failed (exit ${code})${RESET}`);
+        process.exit(1);
+    }
+}
+async function dbSync(root) {
+    const script = join(root, "scripts", "sync-local-db.sh");
+    if (!existsSync(script)) {
+        console.error(`${RED}ERROR: scripts/sync-local-db.sh not found${RESET}`);
+        process.exit(1);
+    }
+    console.log(`${CYAN}Syncing production schema to local...${RESET}`);
+    const code = await spawnInteractive("bash", [script]);
+    if (code !== 0) {
+        console.error(`${RED}Sync failed (exit ${code})${RESET}`);
+        process.exit(1);
+    }
+}
+async function dbSeed(root) {
+    const seedFile = join(root, "supabase", "seed.sql");
+    if (!existsSync(seedFile)) {
+        console.error(`${RED}ERROR: supabase/seed.sql not found${RESET}`);
+        process.exit(1);
+    }
+    if (!isLocalRunning()) {
+        console.error(`${RED}ERROR: Local Supabase is not running. Run: whale db start${RESET}`);
+        process.exit(1);
+    }
+    console.log(`${CYAN}Re-seeding local database...${RESET}`);
+    try {
+        runShell(`PGPASSWORD=postgres psql "${DB_URL}" -f "${seedFile}"`, { timeout: 15000 });
+        console.log(`${GREEN}Seed data applied.${RESET}`);
+    }
+    catch (err) {
+        console.error(`${RED}Seed failed: ${err.message?.slice(0, 200)}${RESET}`);
+        process.exit(1);
+    }
+}
+async function dbTest(root) {
+    const script = join(root, "scripts", "run-all-tests.sh");
+    if (!existsSync(script)) {
+        console.error(`${RED}ERROR: scripts/run-all-tests.sh not found${RESET}`);
+        process.exit(1);
+    }
+    console.log(`${CYAN}Running full test suite against local DB...${RESET}\n`);
+    const code = await spawnInteractive("bash", [script]);
+    process.exit(code);
+}
+// ── Help ──
+function showDbHelp() {
+    console.log(`
+  ${BOLD}whale db${RESET} — Local Supabase management
+
+  ${BOLD}Subcommands:${RESET}
+    whale db status${DIM}    Check if local Supabase is running${RESET}
+    whale db start${DIM}     Start local Supabase${RESET}
+    whale db stop${DIM}      Stop local Supabase${RESET}
+    whale db reset${DIM}     Drop + recreate + seed local DB${RESET}
+    whale db sync${DIM}      Pull prod schema → apply locally${RESET}
+    whale db seed${DIM}      Re-run seed.sql without full reset${RESET}
+    whale db test${DIM}      Run full test suite against local DB${RESET}
+`);
+}
+// ── Router ──
+export async function runDbCommand(args) {
+    const sub = args[0];
+    const root = findEcosystemRoot();
+    switch (sub) {
+        case "status":
+            return dbStatus(root);
+        case "start":
+            return dbStart(root);
+        case "stop":
+            return dbStop(root);
+        case "reset":
+            return dbReset(root);
+        case "sync":
+            return dbSync(root);
+        case "seed":
+            return dbSeed(root);
+        case "test":
+            return dbTest(root);
+        case "help":
+        case "--help":
+        case "-h":
+            showDbHelp();
+            return;
+        case undefined:
+            showDbHelp();
+            return;
+        default:
+            console.error(`${RED}Unknown db subcommand: ${sub}${RESET}`);
+            showDbHelp();
+            process.exit(1);
+    }
+}

package/dist/cli/commands/doctor.js

@@ -99,12 +99,9 @@ async function checkServerTools() {
     }
 }
 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 { loadConfig } = await import("../services/config-store.js");
+        const config = loadConfig();
         const servers = config.mcpServers || {};
         const count = Object.keys(servers).length;
         if (count === 0) {
@@ -117,18 +114,18 @@ async function checkMcpServers() {
     }
 }
 async function checkDiskSpace() {
-    const dir = join(homedir(), ".swagmanager");
+    const dir = join(homedir(), ".whaletools");
     if (!existsSync(dir)) {
-        return { status: "ok", label: "Data dir", detail: "~/.swagmanager/ (not created yet)" };
+        return { status: "ok", label: "Data dir", detail: "~/.whaletools/ (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})` };
+        return { status: "ok", label: "Data dir", detail: `~/.whaletools/ (${size})` };
     }
     catch {
-        return { status: "ok", label: "Data dir", detail: "~/.swagmanager/" };
+        return { status: "ok", label: "Data dir", detail: "~/.whaletools/" };
     }
 }
 async function checkVersion() {