whale-code 6.4.0

package/dist/setup.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+/**
+ * SwagManager MCP — Interactive Setup
+ *
+ * Detects installed MCP-compatible CLIs and writes config for each.
+ * Usage: npx swagmanager-mcp setup
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { createInterface } from "readline";
+const home = homedir();
+const CLI_TARGETS = [
+    {
+        name: "Claude Code",
+        configPath: join(home, ".claude", "settings.json"),
+        configKey: "mcpServers",
+        detect: () => existsSync(join(home, ".claude")),
+        format: (servers) => servers,
+    },
+    {
+        name: "Claude Desktop",
+        configPath: process.platform === "darwin"
+            ? join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")
+            : join(home, "AppData", "Roaming", "Claude", "claude_desktop_config.json"),
+        configKey: "mcpServers",
+        detect: () => existsSync(process.platform === "darwin"
+            ? join(home, "Library", "Application Support", "Claude")
+            : join(home, "AppData", "Roaming", "Claude")),
+        format: (servers) => servers,
+    },
+    {
+        name: "Cursor",
+        configPath: join(home, ".cursor", "mcp.json"),
+        configKey: "mcpServers",
+        detect: () => existsSync(join(home, ".cursor")),
+        format: (servers) => servers,
+    },
+    {
+        name: "Windsurf",
+        configPath: join(home, ".codeium", "windsurf", "mcp_config.json"),
+        configKey: "mcpServers",
+        detect: () => existsSync(join(home, ".codeium", "windsurf")),
+        format: (servers) => servers,
+    },
+    {
+        name: "Gemini CLI",
+        configPath: join(home, ".gemini", "settings.json"),
+        configKey: "mcpServers",
+        detect: () => existsSync(join(home, ".gemini")),
+        format: (servers) => servers,
+    },
+];
+// ============================================================================
+// HELPERS
+// ============================================================================
+function readJSON(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeJSON(path, data) {
+    const dir = dirname(path);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function prompt(rl, question, defaultValue) {
+    const suffix = defaultValue ? ` (${defaultValue})` : "";
+    return new Promise((resolve) => {
+        rl.question(`${question}${suffix}: `, (answer) => {
+            resolve(answer.trim() || defaultValue || "");
+        });
+    });
+}
+function promptYN(rl, question, defaultYes = true) {
+    const hint = defaultYes ? "[Y/n]" : "[y/N]";
+    return new Promise((resolve) => {
+        rl.question(`${question} ${hint} `, (answer) => {
+            const a = answer.trim().toLowerCase();
+            if (a === "")
+                resolve(defaultYes);
+            else
+                resolve(a === "y" || a === "yes");
+        });
+    });
+}
+// ============================================================================
+// MAIN
+// ============================================================================
+export async function runSetup() {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    console.log("");
+    console.log("  SwagManager MCP — Setup");
+    console.log("  ═══════════════════════");
+    console.log("");
+    // Detect installed CLIs
+    const detected = CLI_TARGETS.filter((t) => t.detect());
+    const notDetected = CLI_TARGETS.filter((t) => !t.detect());
+    if (detected.length > 0) {
+        console.log("  Detected CLIs:");
+        detected.forEach((t) => console.log(`    + ${t.name}`));
+    }
+    if (notDetected.length > 0) {
+        console.log("  Not found:");
+        notDetected.forEach((t) => console.log(`    - ${t.name}`));
+    }
+    console.log("");
+    if (detected.length === 0) {
+        console.log("  No supported MCP clients detected.");
+        console.log("  Install Claude Code, Claude Desktop, Cursor, Windsurf, or Gemini CLI first.");
+        rl.close();
+        return;
+    }
+    // Collect credentials
+    console.log("  Enter your Supabase credentials:");
+    console.log("");
+    const supabaseUrl = await prompt(rl, "  Supabase URL");
+    if (!supabaseUrl) {
+        console.log("  Supabase URL is required. Aborting.");
+        rl.close();
+        return;
+    }
+    const supabaseKey = await prompt(rl, "  Supabase Service Role Key");
+    if (!supabaseKey) {
+        console.log("  Service Role Key is required. Aborting.");
+        rl.close();
+        return;
+    }
+    const storeId = await prompt(rl, "  Store ID (optional, press enter to skip)");
+    console.log("");
+    // Build MCP server entry
+    const serverEntry = {
+        type: "stdio",
+        command: "npx",
+        args: ["-y", "swagmanager-mcp"],
+        env: {
+            SUPABASE_URL: supabaseUrl,
+            SUPABASE_SERVICE_ROLE_KEY: supabaseKey,
+            ...(storeId ? { STORE_ID: storeId } : {}),
+        },
+    };
+    // Install to each detected CLI
+    let installed = 0;
+    for (const target of detected) {
+        const install = await promptYN(rl, `  Install to ${target.name}?`);
+        if (!install)
+            continue;
+        const config = readJSON(target.configPath);
+        if (!config[target.configKey])
+            config[target.configKey] = {};
+        // Check for existing entry
+        if (config[target.configKey].swagmanager) {
+            const overwrite = await promptYN(rl, `    swagmanager already configured in ${target.name}. Overwrite?`, false);
+            if (!overwrite)
+                continue;
+        }
+        config[target.configKey].swagmanager = target.format(serverEntry);
+        writeJSON(target.configPath, config);
+        console.log(`    Wrote ${target.configPath}`);
+        installed++;
+    }
+    console.log("");
+    if (installed > 0) {
+        console.log(`  Done! Installed to ${installed} CLI${installed > 1 ? "s" : ""}.`);
+        console.log("  Restart your CLI(s) to load the MCP server.");
+    }
+    else {
+        console.log("  No changes made.");
+    }
+    console.log("");
+    rl.close();
+}
+// Run if called directly
+const isDirectRun = process.argv[1]?.includes("setup");
+if (isDirectRun) {
+    runSetup().catch(console.error);
+}

package/dist/shared/agent-core.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Shared Agent Core — single source of truth for CLI + server agent
+ *
+ * Pure TypeScript, no runtime-specific APIs (no Deno.env, no process.env, no fs).
+ * Both the CLI (Node.js) and server (Fly container) import from here.
+ */
+export interface LoopCheckResult {
+    blocked: boolean;
+    reason?: string;
+}
+export interface BailCheckResult {
+    shouldBail: boolean;
+    message?: string;
+}
+export interface CostInfo {
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    cacheCreation: number;
+    cacheRead: number;
+}
+/**
+ * Controls which tools the model can/must use:
+ * - "auto": Model decides whether to use tools (default)
+ * - "any": Model must use at least one tool
+ * - "none": Model must not use any tools (text-only response)
+ * - { type: "tool", name: string }: Model must use the specified tool
+ */
+export type ToolChoice = "auto" | "any" | "none" | {
+    type: "tool";
+    name: string;
+};
+/**
+ * Resolve the effective tool_choice for a given turn.
+ *
+ * Priority:
+ * 1. Explicit override from caller (toolChoice option)
+ * 2. Loop detection: if last 3 turns all used the same tool, force "none"
+ * 3. Keyword detection: if user message mentions a tool name, force that tool
+ * 4. Default: "auto"
+ */
+export declare function resolveToolChoice(opts: {
+    toolChoice?: ToolChoice;
+    turnCount: number;
+    recentToolUses: string[];
+    availableToolNames: string[];
+    userMessage: string;
+}): ToolChoice;
+export interface ContextManagementConfig {
+    betas: string[];
+    config: {
+        edits: Array<Record<string, unknown>>;
+    };
+}
+/** Compaction trigger threshold — shared so agent loops can track budget */
+export declare const COMPACTION_TRIGGER_TOKENS = 120000;
+/** Max cumulative tokens before forcing wrap-up (prevents runaway compaction cost) */
+export declare const COMPACTION_TOTAL_BUDGET = 2000000;
+/** Default session cost budget in USD — Infinity = no limit (budget enforcement disabled by default) */
+export declare const DEFAULT_SESSION_COST_BUDGET_USD: number;
+/**
+ * Provider-aware compaction configuration.
+ * - Anthropic/Bedrock: native server-side compaction via compact_20260112
+ * - OpenAI/Gemini: Haiku-based summarization (same instructions, same format)
+ */
+export interface CompactionConfig {
+    triggerTokens: number;
+    totalBudget: number;
+    isNative: boolean;
+}
+export declare function getCompactionConfig(model: string): CompactionConfig;
+/**
+ * Returns Anthropic beta flags and context_management config for the given model.
+ * - Opus 4.6 / Sonnet 4.6: compact at 120K (pause after) + clear thinking + clear tools at 80K/keep 3
+ * - All other Claude models: clear thinking + clear tools at 80K/keep 3
+ * - Non-Anthropic models (Gemini, OpenAI): no betas, no context management
+ */
+export declare function getContextManagement(model: string): ContextManagementConfig;
+export declare function getMaxOutputTokens(model: string, agentMax?: number): number;
+/**
+ * Add prompt cache breakpoints to tools and messages.
+ * Uses 2 of 4 allowed breakpoints:
+ * - Last tool definition
+ * - Turn boundary (second-to-last message)
+ * System prompt caching is handled by the caller.
+ */
+export declare function addPromptCaching(tools: Array<Record<string, unknown>>, messages: Array<Record<string, unknown>>): {
+    tools: Array<Record<string, unknown>>;
+    messages: Array<Record<string, unknown>>;
+};
+export declare class LoopDetector {
+    private history;
+    private consecutiveErrors;
+    private turnErrors;
+    private turnHadErrors;
+    private sessionErrors;
+    private failedStrategies;
+    private consecutiveFailedTurns;
+    private totalSessionErrors;
+    static IDENTICAL_CALL_LIMIT: number;
+    static CONSECUTIVE_ERROR_LIMIT: number;
+    static TURN_ERROR_LIMIT: number;
+    static WINDOW: number;
+    static SESSION_TOOL_ERROR_LIMIT: number;
+    static CONSECUTIVE_FAILED_TURN_LIMIT: number;
+    /** Get the error-tracking key for a tool call. Tools with an `action` param
+     *  are tracked per-action so e.g. voice/speak failing won't block voice/music_compose. */
+    private errorKey;
+    recordCall(name: string, input: Record<string, unknown>): LoopCheckResult;
+    recordResult(name: string, success: boolean, input?: Record<string, unknown>): void;
+    endTurn(): BailCheckResult;
+    resetTurn(): void;
+    reset(): void;
+    getSessionStats(): {
+        totalErrors: number;
+        failedStrategies: number;
+        consecutiveFailedTurns: number;
+    };
+}
+export interface ThinkingConfig {
+    type: "enabled" | "disabled" | "adaptive";
+    budget_tokens?: number;
+}
+/**
+ * Returns the thinking configuration and required beta string for the given model.
+ * - Opus 4.6: adaptive thinking (no budget needed)
+ * - Sonnet/Haiku: enabled with 10000 token budget
+ * - budget_tokens must be strictly < max_tokens
+ */
+export declare function getThinkingConfig(model: string, enabled: boolean): {
+    thinking: ThinkingConfig;
+    beta: string;
+};
+export declare const MODEL_PRICING: Record<string, {
+    inputPer1M: number;
+    outputPer1M: number;
+    thinkingPer1M?: number;
+}>;
+export declare function estimateCostUsd(inputTokens: number, outputTokens: number, model: string, thinkingTokens?: number, cacheReadTokens?: number, cacheCreationTokens?: number): number;
+/**
+ * Route to cheaper model when the task is simple enough.
+ * Returns the model to actually use.
+ */
+export declare function routeModel(message: string, requestedModel: string, forceModel?: boolean): string;
+export type ErrorCategory = "RATE_LIMIT" | "TIMEOUT" | "AUTH" | "MALFORMED" | "PROVIDER_DOWN" | "NETWORK" | "UNKNOWN";
+export declare function categorizeError(err: unknown): {
+    category: ErrorCategory;
+    retryable: boolean;
+};
+export declare function isRetryableError(err: unknown): boolean;
+/** @deprecated — Anthropic context_management handles limits. Use SAFETY_MAX_CHARS in tool-dispatch instead. */
+export declare function truncateToolResult(content: string, maxChars: number): string;
+/** @deprecated — Anthropic context_management handles limits. */
+export declare function getMaxToolResultChars(contextConfig?: {
+    max_tool_result_chars?: number;
+} | null): number;
+export declare function sanitizeError(err: unknown): string;