whale-code 6.4.0

package/dist/cli/services/mcp-client.d.ts

@@ -0,0 +1,48 @@
+/**
+ * MCP Client Manager — connect to external MCP servers
+ *
+ * Reads mcpServers from ~/.swagmanager/config.json, spawns/connects each,
+ * and exposes their tools with mcp__{server}__{tool} naming convention.
+ * Non-fatal: if a server fails to connect, it's skipped with a warning.
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+declare class McpClientManager {
+    private servers;
+    private connectPromise;
+    /**
+     * Connect to all configured MCP servers.
+     * Non-blocking: failures are logged but don't prevent startup.
+     */
+    connectAll(): Promise<void>;
+    private _connectAll;
+    private connectServer;
+    /**
+     * Get all tools from all connected MCP servers.
+     */
+    getTools(): Anthropic.Tool[];
+    /**
+     * Call a tool on a connected MCP server.
+     * Tool name format: mcp__{serverName}__{toolName}
+     */
+    callTool(fullToolName: string, args: Record<string, unknown>): Promise<{
+        success: boolean;
+        output: string;
+    }>;
+    /**
+     * Check if a tool name is an MCP tool.
+     */
+    isMcpTool(name: string): boolean;
+    /**
+     * Get status info about connected servers.
+     */
+    getStatus(): {
+        name: string;
+        toolCount: number;
+    }[];
+    /**
+     * Disconnect all servers gracefully.
+     */
+    disconnectAll(): Promise<void>;
+}
+export declare const mcpClientManager: McpClientManager;
+export {};

package/dist/cli/services/mcp-client.js

@@ -0,0 +1,157 @@
+/**
+ * MCP Client Manager — connect to external MCP servers
+ *
+ * Reads mcpServers from ~/.swagmanager/config.json, spawns/connects each,
+ * and exposes their tools with mcp__{server}__{tool} naming convention.
+ * Non-fatal: if a server fails to connect, it's skipped with a warning.
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { loadConfig } from "./config-store.js";
+// ============================================================================
+// MCP CLIENT MANAGER
+// ============================================================================
+class McpClientManager {
+    servers = new Map();
+    connectPromise = null;
+    /**
+     * Connect to all configured MCP servers.
+     * Non-blocking: failures are logged but don't prevent startup.
+     */
+    async connectAll() {
+        if (this.connectPromise)
+            return this.connectPromise;
+        this.connectPromise = this._connectAll();
+        return this.connectPromise;
+    }
+    async _connectAll() {
+        const config = loadConfig();
+        const mcpServers = (config.mcpServers || {});
+        const serverNames = Object.keys(mcpServers);
+        if (serverNames.length === 0)
+            return;
+        const results = await Promise.allSettled(serverNames.map(name => this.connectServer(name, mcpServers[name])));
+        for (let i = 0; i < results.length; i++) {
+            if (results[i].status === "rejected") {
+                const err = results[i].reason;
+                process.stderr.write(`[mcp] Failed to connect to "${serverNames[i]}": ${err?.message || err}\n`);
+            }
+        }
+    }
+    async connectServer(name, config) {
+        const client = new Client({
+            name: "whale-code",
+            version: "5.1.0",
+        });
+        let transport;
+        if (config.transport === "http" && config.url) {
+            // Dynamically import HTTP transport — handles both new StreamableHTTP and legacy SSE
+            try {
+                const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+                transport = new StreamableHTTPClientTransport(new URL(config.url));
+            }
+            catch {
+                // Fallback to SSE for older SDK versions
+                const { SSEClientTransport } = await import("@modelcontextprotocol/sdk/client/sse.js");
+                transport = new SSEClientTransport(new URL(config.url));
+            }
+        }
+        else if (config.command) {
+            transport = new StdioClientTransport({
+                command: config.command,
+                args: config.args || [],
+                env: {
+                    ...process.env,
+                    ...(config.env || {}),
+                },
+                // Pipe stderr to avoid corrupting our UI
+                stderr: "pipe",
+            });
+        }
+        else {
+            throw new Error(`Invalid config: no command or url`);
+        }
+        // Connect with a 10s timeout
+        const connectTimeout = new Promise((_, reject) => setTimeout(() => reject(new Error("Connection timeout (10s)")), 10_000));
+        await Promise.race([client.connect(transport), connectTimeout]);
+        // Discover tools
+        const toolsResult = await client.listTools();
+        const tools = (toolsResult.tools || []).map(t => ({
+            name: `mcp__${name}__${t.name}`,
+            description: `[${name}] ${t.description || t.name}`,
+            input_schema: (t.inputSchema || { type: "object", properties: {} }),
+        }));
+        this.servers.set(name, { name, client, tools });
+    }
+    /**
+     * Get all tools from all connected MCP servers.
+     */
+    getTools() {
+        const allTools = [];
+        for (const server of this.servers.values()) {
+            allTools.push(...server.tools);
+        }
+        return allTools;
+    }
+    /**
+     * Call a tool on a connected MCP server.
+     * Tool name format: mcp__{serverName}__{toolName}
+     */
+    async callTool(fullToolName, args) {
+        // Parse mcp__{server}__{tool}
+        const parts = fullToolName.split("__");
+        if (parts.length < 3 || parts[0] !== "mcp") {
+            return { success: false, output: `Invalid MCP tool name: ${fullToolName}` };
+        }
+        const serverName = parts[1];
+        const toolName = parts.slice(2).join("__"); // Handle tool names with __ in them
+        const server = this.servers.get(serverName);
+        if (!server) {
+            return { success: false, output: `MCP server "${serverName}" not connected` };
+        }
+        try {
+            const result = await server.client.callTool({ name: toolName, arguments: args });
+            // Extract text content from the result
+            const content = result.content;
+            if (Array.isArray(content)) {
+                const texts = content
+                    .filter((c) => c.type === "text")
+                    .map((c) => c.text);
+                return { success: !result.isError, output: texts.join("\n") || JSON.stringify(content) };
+            }
+            return { success: !result.isError, output: String(content) };
+        }
+        catch (err) {
+            return { success: false, output: `MCP tool error: ${err.message || err}` };
+        }
+    }
+    /**
+     * Check if a tool name is an MCP tool.
+     */
+    isMcpTool(name) {
+        return name.startsWith("mcp__");
+    }
+    /**
+     * Get status info about connected servers.
+     */
+    getStatus() {
+        return Array.from(this.servers.values()).map(s => ({
+            name: s.name,
+            toolCount: s.tools.length,
+        }));
+    }
+    /**
+     * Disconnect all servers gracefully.
+     */
+    async disconnectAll() {
+        const closePromises = [];
+        for (const server of this.servers.values()) {
+            closePromises.push(server.client.close().catch(() => { }));
+        }
+        await Promise.allSettled(closePromises);
+        this.servers.clear();
+        this.connectPromise = null;
+    }
+}
+// Singleton instance
+export const mcpClientManager = new McpClientManager();

package/dist/cli/services/memory-manager.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Memory Manager — persistent /remember and /forget across sessions
+ *
+ * Extracted from agent-loop.ts for single-responsibility.
+ * All consumers should import from agent-loop.ts (re-export facade).
+ */
+export declare function loadMemory(): string;
+export declare function addMemory(fact: string): {
+    success: boolean;
+    message: string;
+};
+export declare function removeMemory(pattern: string): {
+    success: boolean;
+    message: string;
+};
+export declare function listMemories(): string[];

package/dist/cli/services/memory-manager.js

@@ -0,0 +1,57 @@
+/**
+ * Memory Manager — persistent /remember and /forget across sessions
+ *
+ * Extracted from agent-loop.ts for single-responsibility.
+ * All consumers should import from agent-loop.ts (re-export facade).
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const MEMORY_DIR = join(homedir(), ".swagmanager", "memory");
+const MEMORY_FILE = join(MEMORY_DIR, "MEMORY.md");
+function ensureMemoryDir() {
+    if (!existsSync(MEMORY_DIR))
+        mkdirSync(MEMORY_DIR, { recursive: true });
+}
+export function loadMemory() {
+    if (!existsSync(MEMORY_FILE))
+        return "";
+    try {
+        return readFileSync(MEMORY_FILE, "utf-8").trim();
+    }
+    catch {
+        return "";
+    }
+}
+export function addMemory(fact) {
+    ensureMemoryDir();
+    const existing = loadMemory();
+    const entry = `- ${fact}`;
+    // Check for duplicate
+    if (existing.includes(fact)) {
+        return { success: false, message: "Already remembered." };
+    }
+    const updated = existing ? existing + "\n" + entry : entry;
+    writeFileSync(MEMORY_FILE, updated + "\n", "utf-8");
+    return { success: true, message: `Remembered: ${fact}` };
+}
+export function removeMemory(pattern) {
+    if (!existsSync(MEMORY_FILE))
+        return { success: false, message: "No memories stored." };
+    const content = readFileSync(MEMORY_FILE, "utf-8");
+    const lines = content.split("\n");
+    const lower = pattern.toLowerCase();
+    const filtered = lines.filter(line => !line.toLowerCase().includes(lower));
+    if (filtered.length === lines.length) {
+        return { success: false, message: `No memory matching "${pattern}" found.` };
+    }
+    const removed = lines.length - filtered.length;
+    writeFileSync(MEMORY_FILE, filtered.join("\n"), "utf-8");
+    return { success: true, message: `Forgot ${removed} memor${removed === 1 ? "y" : "ies"} matching "${pattern}".` };
+}
+export function listMemories() {
+    const content = loadMemory();
+    if (!content)
+        return [];
+    return content.split("\n").filter(l => l.trim().startsWith("- ")).map(l => l.replace(/^- /, "").trim());
+}

package/dist/cli/services/model-manager.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Model Manager — CLI model selection and cost tracking
+ *
+ * Extracted from agent-loop.ts for single-responsibility.
+ * All consumers should import from agent-loop.ts (re-export facade).
+ */
+export declare function setModel(name: string, persist?: boolean): {
+    success: boolean;
+    model: string;
+    error?: string;
+};
+/** Internal: set model by full ID (used for restoring after fallback) */
+export declare function setModelById(modelId: string): void;
+export declare function getModel(): string;
+export declare function getModelShortName(): string;
+/** Check if the current model is set to auto-routing */
+export declare function isAutoRouting(): boolean;
+export declare function estimateCostUsd(inputTokens: number, outputTokens: number, model?: string, thinkingTokens?: number, cacheReadTokens?: number, cacheCreationTokens?: number): number;

package/dist/cli/services/model-manager.js

@@ -0,0 +1,71 @@
+/**
+ * Model Manager — CLI model selection and cost tracking
+ *
+ * Extracted from agent-loop.ts for single-responsibility.
+ * All consumers should import from agent-loop.ts (re-export facade).
+ */
+import { MODEL_MAP } from "../../shared/constants.js";
+import { estimateCostUsd as coreEstimateCostUsd } from "../../shared/agent-core.js";
+import { loadConfig, updateConfig } from "./config-store.js";
+/** CLI-only: current model ID for the active session */
+let activeModel = "claude-opus-4-6";
+// Load persisted default model on import
+try {
+    const cfg = loadConfig();
+    if (cfg.default_model) {
+        const id = MODEL_MAP[cfg.default_model.toLowerCase()];
+        if (id)
+            activeModel = id;
+    }
+}
+catch { /* use default */ }
+/** Reverse map: full model ID → short key */
+const REVERSE_MAP = {};
+for (const [key, id] of Object.entries(MODEL_MAP)) {
+    REVERSE_MAP[id] = key;
+}
+export function setModel(name, persist = true) {
+    // Try direct key match first (e.g. "opus", "bedrock-sonnet", "gemini-pro")
+    const directId = MODEL_MAP[name.toLowerCase()];
+    if (directId) {
+        activeModel = directId;
+        if (persist)
+            try {
+                updateConfig({ default_model: name.toLowerCase() });
+            }
+            catch { /* best effort */ }
+        return { success: true, model: activeModel };
+    }
+    // Legacy: strip "claude-" prefix for backward compat (e.g. "claude-opus" → "opus")
+    const legacy = name.toLowerCase().replace(/^claude-?/, "").replace(/-.*/, "");
+    const legacyId = MODEL_MAP[legacy];
+    if (legacyId) {
+        activeModel = legacyId;
+        if (persist)
+            try {
+                updateConfig({ default_model: legacy });
+            }
+            catch { /* best effort */ }
+        return { success: true, model: activeModel };
+    }
+    return { success: false, model: activeModel, error: `Unknown model: "${name}". Valid: ${Object.keys(MODEL_MAP).join(", ")}` };
+}
+/** Internal: set model by full ID (used for restoring after fallback) */
+export function setModelById(modelId) {
+    activeModel = modelId;
+}
+export function getModel() {
+    return activeModel;
+}
+export function getModelShortName() {
+    if (activeModel === "auto")
+        return "auto";
+    return REVERSE_MAP[activeModel] || "sonnet";
+}
+/** Check if the current model is set to auto-routing */
+export function isAutoRouting() {
+    return activeModel === "auto";
+}
+export function estimateCostUsd(inputTokens, outputTokens, model, thinkingTokens = 0, cacheReadTokens = 0, cacheCreationTokens = 0) {
+    return coreEstimateCostUsd(inputTokens, outputTokens, model || activeModel, thinkingTokens, cacheReadTokens, cacheCreationTokens);
+}

package/dist/cli/services/model-router.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Model Router — auto-routing via Haiku classifier.
+ *
+ * When the user selects "auto" as their model, each user message is classified
+ * by Haiku to determine the optimal model (haiku/sonnet/opus) based on task
+ * complexity. Matches Gemini CLI's auto-routing feature.
+ */
+export type RoutedModel = "haiku" | "sonnet" | "opus";
+export interface RouteResult {
+    model: RoutedModel;
+    reasoning: string;
+    confidence: number;
+}
+/**
+ * Classify a user message to determine the best model.
+ * Uses Haiku via server proxy for fast, cheap classification.
+ */
+export declare function classifyAndRoute(userMessage: string, serverUrl: string, authToken: string): Promise<RouteResult>;
+/**
+ * Check if auto-routing is enabled for this model string.
+ */
+export declare function isAutoModel(model: string): boolean;
+/**
+ * Resolve "auto" to an actual model ID based on classification.
+ */
+export declare function resolveAutoModel(userMessage: string, serverUrl: string, authToken: string): Promise<string>;

package/dist/cli/services/model-router.js

@@ -0,0 +1,149 @@
+/**
+ * Model Router — auto-routing via Haiku classifier.
+ *
+ * When the user selects "auto" as their model, each user message is classified
+ * by Haiku to determine the optimal model (haiku/sonnet/opus) based on task
+ * complexity. Matches Gemini CLI's auto-routing feature.
+ */
+import { MODELS } from "../../shared/constants.js";
+import { callServerProxy } from "../../shared/api-client.js";
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+const CLASSIFIER_MODEL = MODELS.HAIKU;
+const CLASSIFIER_PROMPT = `Classify this user request by complexity. Respond with ONLY a JSON object.
+
+Categories:
+- "haiku": Simple lookups, single-step tasks, quick questions, status checks, simple edits (1-2 files)
+- "sonnet": Multi-step tasks, code refactoring, moderate analysis, 3-5 file changes, debugging
+- "opus": Complex architecture, large refactors, planning, creative problem solving, 5+ files, ambiguous requirements
+
+User request: {message}
+
+Respond: {"model": "haiku"|"sonnet"|"opus", "reasoning": "brief reason", "confidence": 0.0-1.0}`;
+const MODEL_ID_MAP = {
+    haiku: MODELS.HAIKU,
+    sonnet: MODELS.SONNET,
+    opus: MODELS.OPUS,
+};
+const DEFAULT_ROUTE = {
+    model: "sonnet",
+    reasoning: "default fallback",
+    confidence: 0.5,
+};
+// ============================================================================
+// CLASSIFIER
+// ============================================================================
+/**
+ * Classify a user message to determine the best model.
+ * Uses Haiku via server proxy for fast, cheap classification.
+ */
+export async function classifyAndRoute(userMessage, serverUrl, authToken) {
+    try {
+        const prompt = CLASSIFIER_PROMPT.replace("{message}", userMessage);
+        const apiConfig = {
+            betas: [],
+            contextManagement: { edits: [] },
+            maxTokens: 256,
+        };
+        const stream = await callServerProxy({
+            proxyUrl: `${serverUrl}/proxy`,
+            token: authToken,
+            model: CLASSIFIER_MODEL,
+            system: [{ type: "text", text: "You are a task complexity classifier. Respond with only valid JSON." }],
+            messages: [{ role: "user", content: prompt }],
+            tools: [],
+            apiConfig,
+            timeoutMs: 5000,
+        });
+        // Collect the full text response from the SSE stream
+        const text = await collectText(stream);
+        return parseClassifierResponse(text);
+    }
+    catch {
+        // On any error (network, timeout, parse), fall back to sonnet
+        return DEFAULT_ROUTE;
+    }
+}
+/**
+ * Check if auto-routing is enabled for this model string.
+ */
+export function isAutoModel(model) {
+    return model === "auto";
+}
+/**
+ * Resolve "auto" to an actual model ID based on classification.
+ */
+export async function resolveAutoModel(userMessage, serverUrl, authToken) {
+    const result = await classifyAndRoute(userMessage, serverUrl, authToken);
+    return MODEL_ID_MAP[result.model];
+}
+// ============================================================================
+// INTERNAL HELPERS
+// ============================================================================
+/**
+ * Collect all text from an SSE stream body.
+ * Lightweight extraction — only reads text_delta events.
+ */
+async function collectText(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let text = "";
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || !trimmed.startsWith("data: "))
+                    continue;
+                const payload = trimmed.slice(6);
+                if (payload === "[DONE]")
+                    return text;
+                try {
+                    const event = JSON.parse(payload);
+                    if (event.type === "content_block_delta" && event.delta?.type === "text_delta") {
+                        text += event.delta.text;
+                    }
+                }
+                catch { /* skip malformed JSON */ }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return text;
+}
+/**
+ * Parse the classifier's JSON response into a RouteResult.
+ * Falls back to sonnet on any parse failure or low confidence.
+ */
+function parseClassifierResponse(text) {
+    try {
+        // Extract JSON from response (handle markdown fences or extra text)
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch)
+            return DEFAULT_ROUTE;
+        const parsed = JSON.parse(jsonMatch[0]);
+        const model = parsed.model;
+        if (model !== "haiku" && model !== "sonnet" && model !== "opus") {
+            return DEFAULT_ROUTE;
+        }
+        const confidence = typeof parsed.confidence === "number" ? parsed.confidence : 0;
+        const reasoning = typeof parsed.reasoning === "string" ? parsed.reasoning : "";
+        // Low confidence defaults to sonnet (safe middle ground)
+        if (confidence < 0.3) {
+            return { model: "sonnet", reasoning: reasoning || "low confidence fallback", confidence };
+        }
+        return { model: model, reasoning, confidence };
+    }
+    catch {
+        return DEFAULT_ROUTE;
+    }
+}

package/dist/cli/services/permission-modes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Permission Modes — control tool access levels
+ *
+ * Extracted from agent-loop.ts for single-responsibility.
+ * All consumers should import from agent-loop.ts (re-export facade).
+ */
+export type PermissionMode = "default" | "plan" | "yolo";
+export declare function setPermissionMode(mode: PermissionMode): {
+    success: boolean;
+    message: string;
+};
+export declare function getPermissionMode(): PermissionMode;
+export declare function isToolAllowedByPermission(toolName: string): boolean;

package/dist/cli/services/permission-modes.js

@@ -0,0 +1,43 @@
+/**
+ * Permission Modes — control tool access levels
+ *
+ * Extracted from agent-loop.ts for single-responsibility.
+ * All consumers should import from agent-loop.ts (re-export facade).
+ */
+import { loadConfig, updateConfig } from "./config-store.js";
+/** CLI-only: current permission mode */
+let activePermissionMode = "default";
+// Load persisted permission mode on import
+try {
+    const cfg = loadConfig();
+    if (cfg.permission_mode && ["default", "plan", "yolo"].includes(cfg.permission_mode)) {
+        activePermissionMode = cfg.permission_mode;
+    }
+}
+catch { /* use default */ }
+// Tools allowed in plan mode
+const PLAN_MODE_TOOLS = new Set([
+    "read_file", "list_directory", "search_files", "search_content",
+    "glob", "grep", "web_fetch", "web_search", "task", "task_output",
+    "bash_output", "list_shells", "tasks", "config", "ask_user",
+    // Interactive tools (read-only by nature)
+    "ask_user_question", "enter_plan_mode", "exit_plan_mode",
+]);
+export function setPermissionMode(mode) {
+    activePermissionMode = mode;
+    try {
+        updateConfig({ permission_mode: mode });
+    }
+    catch { /* best effort */ }
+    return { success: true, message: `Permission mode: ${mode}` };
+}
+export function getPermissionMode() {
+    return activePermissionMode;
+}
+export function isToolAllowedByPermission(toolName) {
+    switch (activePermissionMode) {
+        case "yolo": return true;
+        case "plan": return PLAN_MODE_TOOLS.has(toolName);
+        case "default": return true; // Default allows all — UI can prompt for confirmation
+    }
+}