whale-code 6.4.0

package/dist/cli/services/agent-definitions.js

@@ -0,0 +1,91 @@
+/**
+ * Agent Definitions — custom agent types from markdown files
+ *
+ * Matches Claude Code's .claude/agents/ pattern:
+ *
+ *   .whale/agents/reviewer.md:
+ *     ---
+ *     description: Reviews code for security issues
+ *     tools: read_file, glob, grep
+ *     ---
+ *     You are a security review agent...
+ *
+ * Load order:
+ * 1. ~/.swagmanager/agents/*.md (global)
+ * 2. .whale/agents/*.md (local, overrides global)
+ */
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join, basename } from "path";
+import { homedir } from "os";
+// ============================================================================
+// PATHS
+// ============================================================================
+const GLOBAL_AGENTS_DIR = join(homedir(), ".swagmanager", "agents");
+const LOCAL_AGENTS_DIR = ".whale/agents";
+// ============================================================================
+// LOADING
+// ============================================================================
+function parseFrontmatter(content) {
+    if (!content.startsWith("---"))
+        return { body: content.trim() };
+    const endIndex = content.indexOf("---", 3);
+    if (endIndex === -1)
+        return { body: content.trim() };
+    const frontmatter = content.slice(3, endIndex).trim();
+    const body = content.slice(endIndex + 3).trim();
+    // Parse description
+    const descMatch = frontmatter.match(/description:\s*(.+)/i);
+    const description = descMatch?.[1]?.trim();
+    // Parse tools (comma-separated)
+    const toolsMatch = frontmatter.match(/tools:\s*(.+)/i);
+    const tools = toolsMatch?.[1]?.split(",").map(t => t.trim()).filter(Boolean);
+    return { description, tools, body };
+}
+function loadAgentsFromDir(dir, source) {
+    if (!existsSync(dir))
+        return [];
+    const agents = [];
+    try {
+        const files = readdirSync(dir).filter(f => f.endsWith(".md"));
+        for (const file of files) {
+            const name = basename(file, ".md");
+            const path = join(dir, file);
+            try {
+                const content = readFileSync(path, "utf-8");
+                const { description, tools, body } = parseFrontmatter(content);
+                agents.push({
+                    name,
+                    prompt: body,
+                    description,
+                    tools,
+                    source,
+                });
+            }
+            catch { /* skip unreadable */ }
+        }
+    }
+    catch { /* skip inaccessible */ }
+    return agents;
+}
+export function loadAgentDefinitions() {
+    const agents = [];
+    // Load global agents first
+    agents.push(...loadAgentsFromDir(GLOBAL_AGENTS_DIR, "global"));
+    // Load local agents (override global with same name)
+    const localDir = join(process.cwd(), LOCAL_AGENTS_DIR);
+    const localAgents = loadAgentsFromDir(localDir, "local");
+    for (const local of localAgents) {
+        const existingIndex = agents.findIndex(a => a.name === local.name);
+        if (existingIndex >= 0) {
+            agents[existingIndex] = local;
+        }
+        else {
+            agents.push(local);
+        }
+    }
+    return agents.sort((a, b) => a.name.localeCompare(b.name));
+}
+export function getAgentDefinition(name) {
+    const agents = loadAgentDefinitions();
+    return agents.find(a => a.name === name);
+}

package/dist/cli/services/agent-events.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Agent Event System — decoupled event-driven architecture for smooth UI
+ *
+ * The agent loop emits typed events; the UI subscribes and renders.
+ * This prevents tight coupling and enables proper batching.
+ */
+import { EventEmitter } from "events";
+import type Anthropic from "@anthropic-ai/sdk";
+export interface AgentTextEvent {
+    type: "text";
+    text: string;
+    accumulated: string;
+}
+export interface AgentToolStartEvent {
+    type: "tool_start";
+    id: string;
+    name: string;
+}
+export interface AgentToolEndEvent {
+    type: "tool_end";
+    id: string;
+    name: string;
+    success: boolean;
+    result?: string;
+    input?: Record<string, unknown>;
+    durationMs: number;
+}
+export interface AgentUsageEvent {
+    type: "usage";
+    inputTokens: number;
+    outputTokens: number;
+    model?: string;
+    costUsd?: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+}
+export interface AgentDoneEvent {
+    type: "done";
+    text: string;
+    messages: Anthropic.MessageParam[];
+}
+export interface AgentErrorEvent {
+    type: "error";
+    error: string;
+}
+export interface AgentCompactEvent {
+    type: "compact";
+    before: number;
+    after: number;
+    tokensSaved: number;
+}
+export interface ToolOutputEvent {
+    type: "tool_output";
+    toolName: string;
+    line: string;
+}
+export interface SubagentStartEvent {
+    type: "subagent_start";
+    id: string;
+    agentType: string;
+    model: string;
+    description: string;
+}
+export interface SubagentProgressEvent {
+    type: "subagent_progress";
+    id: string;
+    agentType: string;
+    message: string;
+    turn?: number;
+    toolName?: string;
+}
+export interface SubagentDoneEvent {
+    type: "subagent_done";
+    id: string;
+    agentType: string;
+    success: boolean;
+    output: string;
+    tokens: {
+        input: number;
+        output: number;
+    };
+    tools: string[];
+    durationMs: number;
+}
+export interface SubagentToolStartEvent {
+    type: "subagent_tool_start";
+    agentId: string;
+    toolName: string;
+    toolInput?: Record<string, unknown>;
+}
+export interface SubagentToolEndEvent {
+    type: "subagent_tool_end";
+    agentId: string;
+    toolName: string;
+    success: boolean;
+    durationMs: number;
+}
+export interface TeamStartEvent {
+    type: "team_start";
+    teamId: string;
+    name: string;
+    teammateCount: number;
+    taskCount: number;
+}
+export interface TeamProgressEvent {
+    type: "team_progress";
+    teamId: string;
+    teammateId: string;
+    teammateName: string;
+    message: string;
+    taskId?: string;
+}
+export interface TeamTaskEvent {
+    type: "team_task";
+    teamId: string;
+    teammateId: string;
+    taskId: string;
+    taskDescription: string;
+    status: "started" | "completed" | "failed";
+    result?: string;
+}
+export interface TeamDoneEvent {
+    type: "team_done";
+    teamId: string;
+    success: boolean;
+    summary: string;
+    tasksCompleted: number;
+    tasksTotal: number;
+    tokens: {
+        input: number;
+        output: number;
+    };
+    durationMs: number;
+}
+export type AgentEvent = AgentTextEvent | AgentToolStartEvent | AgentToolEndEvent | AgentUsageEvent | AgentDoneEvent | AgentErrorEvent | AgentCompactEvent | ToolOutputEvent | SubagentStartEvent | SubagentProgressEvent | SubagentDoneEvent | SubagentToolStartEvent | SubagentToolEndEvent | TeamStartEvent | TeamProgressEvent | TeamTaskEvent | TeamDoneEvent;
+export declare class AgentEventEmitter extends EventEmitter {
+    /**
+     * Emit text immediately — UI-side handles batching via single flush timer
+     */
+    emitText(text: string): void;
+    /**
+     * No-op — kept for interface compat
+     */
+    flushText(): void;
+    emitToolStart(id: string, name: string): void;
+    emitToolEnd(id: string, name: string, success: boolean, result: string | undefined, input: Record<string, unknown> | undefined, durationMs: number): void;
+    emitUsage(inputTokens: number, outputTokens: number, model?: string, costUsd?: number, cacheReadTokens?: number, cacheCreationTokens?: number): void;
+    emitDone(text: string, messages: Anthropic.MessageParam[]): void;
+    emitError(error: string): void;
+    emitCompact(before: number, after: number, tokensSaved: number): void;
+    emitToolOutput(toolName: string, line: string): void;
+    emitSubagentStart(id: string, agentType: string, model: string, description: string): void;
+    emitSubagentProgress(id: string, agentType: string, message: string, turn?: number, toolName?: string): void;
+    emitSubagentDone(id: string, agentType: string, success: boolean, output: string, tokens: {
+        input: number;
+        output: number;
+    }, tools: string[], durationMs: number): void;
+    emitSubagentToolStart(agentId: string, toolName: string, toolInput?: Record<string, unknown>): void;
+    emitSubagentToolEnd(agentId: string, toolName: string, success: boolean, durationMs: number): void;
+    emitTeamStart(teamId: string, name: string, teammateCount: number, taskCount: number): void;
+    emitTeamProgress(teamId: string, teammateId: string, teammateName: string, message: string, taskId?: string): void;
+    emitTeamTask(teamId: string, teammateId: string, taskId: string, taskDescription: string, status: "started" | "completed" | "failed", result?: string): void;
+    emitTeamDone(teamId: string, success: boolean, summary: string, tasksCompleted: number, tasksTotal: number, tokens: {
+        input: number;
+        output: number;
+    }, durationMs: number): void;
+    /**
+     * Subscribe to events with typed handler
+     */
+    onEvent(handler: (event: AgentEvent) => void): () => void;
+    /**
+     * Clean up
+     */
+    destroy(): void;
+}
+export declare function getGlobalEmitter(): AgentEventEmitter;
+export declare function setGlobalEmitter(emitter: AgentEventEmitter): void;
+export declare function clearGlobalEmitter(): void;

package/dist/cli/services/agent-events.js

@@ -0,0 +1,175 @@
+/**
+ * Agent Event System — decoupled event-driven architecture for smooth UI
+ *
+ * The agent loop emits typed events; the UI subscribes and renders.
+ * This prevents tight coupling and enables proper batching.
+ */
+import { EventEmitter } from "events";
+// ============================================================================
+// TYPED EVENT EMITTER
+// ============================================================================
+export class AgentEventEmitter extends EventEmitter {
+    /**
+     * Emit text immediately — UI-side handles batching via single flush timer
+     */
+    emitText(text) {
+        this.emit("event", {
+            type: "text",
+            text,
+            accumulated: "", // Set by consumer
+        });
+    }
+    /**
+     * No-op — kept for interface compat
+     */
+    flushText() { }
+    emitToolStart(id, name) {
+        this.flushText(); // Flush pending text before tool
+        this.emit("event", { type: "tool_start", id, name });
+    }
+    emitToolEnd(id, name, success, result, input, durationMs) {
+        this.emit("event", {
+            type: "tool_end",
+            id,
+            name,
+            success,
+            result,
+            input,
+            durationMs,
+        });
+    }
+    emitUsage(inputTokens, outputTokens, model, costUsd, cacheReadTokens, cacheCreationTokens) {
+        this.emit("event", { type: "usage", inputTokens, outputTokens, model, costUsd, cacheReadTokens, cacheCreationTokens });
+    }
+    emitDone(text, messages) {
+        this.flushText();
+        this.emit("event", { type: "done", text, messages });
+    }
+    emitError(error) {
+        this.flushText();
+        this.emit("event", { type: "error", error });
+    }
+    emitCompact(before, after, tokensSaved) {
+        this.emit("event", { type: "compact", before, after, tokensSaved });
+    }
+    emitToolOutput(toolName, line) {
+        this.emit("event", { type: "tool_output", toolName, line });
+    }
+    emitSubagentStart(id, agentType, model, description) {
+        this.emit("event", { type: "subagent_start", id, agentType, model, description });
+    }
+    emitSubagentProgress(id, agentType, message, turn, toolName) {
+        this.emit("event", {
+            type: "subagent_progress",
+            id,
+            agentType,
+            message,
+            turn,
+            toolName,
+        });
+    }
+    emitSubagentDone(id, agentType, success, output, tokens, tools, durationMs) {
+        this.emit("event", {
+            type: "subagent_done",
+            id,
+            agentType,
+            success,
+            output,
+            tokens,
+            tools,
+            durationMs,
+        });
+    }
+    emitSubagentToolStart(agentId, toolName, toolInput) {
+        this.emit("event", {
+            type: "subagent_tool_start",
+            agentId,
+            toolName,
+            toolInput,
+        });
+    }
+    emitSubagentToolEnd(agentId, toolName, success, durationMs) {
+        this.emit("event", {
+            type: "subagent_tool_end",
+            agentId,
+            toolName,
+            success,
+            durationMs,
+        });
+    }
+    // ── Team Events ──
+    emitTeamStart(teamId, name, teammateCount, taskCount) {
+        this.emit("event", {
+            type: "team_start",
+            teamId,
+            name,
+            teammateCount,
+            taskCount,
+        });
+    }
+    emitTeamProgress(teamId, teammateId, teammateName, message, taskId) {
+        this.emit("event", {
+            type: "team_progress",
+            teamId,
+            teammateId,
+            teammateName,
+            message,
+            taskId,
+        });
+    }
+    emitTeamTask(teamId, teammateId, taskId, taskDescription, status, result) {
+        this.emit("event", {
+            type: "team_task",
+            teamId,
+            teammateId,
+            taskId,
+            taskDescription,
+            status,
+            result,
+        });
+    }
+    emitTeamDone(teamId, success, summary, tasksCompleted, tasksTotal, tokens, durationMs) {
+        this.emit("event", {
+            type: "team_done",
+            teamId,
+            success,
+            summary,
+            tasksCompleted,
+            tasksTotal,
+            tokens,
+            durationMs,
+        });
+    }
+    /**
+     * Subscribe to events with typed handler
+     */
+    onEvent(handler) {
+        this.on("event", handler);
+        return () => this.off("event", handler);
+    }
+    /**
+     * Clean up
+     */
+    destroy() {
+        this.removeAllListeners();
+    }
+}
+// ============================================================================
+// GLOBAL EMITTER (for subagents to report progress)
+// ============================================================================
+let globalEmitter = null;
+export function getGlobalEmitter() {
+    if (!globalEmitter) {
+        globalEmitter = new AgentEventEmitter();
+    }
+    return globalEmitter;
+}
+export function setGlobalEmitter(emitter) {
+    globalEmitter = emitter;
+}
+export function clearGlobalEmitter() {
+    if (globalEmitter) {
+        globalEmitter.destroy();
+        globalEmitter = null;
+    }
+}

package/dist/cli/services/agent-loop.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Agent Loop — local-first agentic CLI with server tool support
+ *
+ * LLM calls proxy through the `agent-proxy` edge function (server holds API key).
+ * User authenticates via Supabase JWT. Local tools execute on the client.
+ * Server tools execute via direct import of executeTool() (same codebase).
+ *
+ * Fallback: if proxy is unavailable and ANTHROPIC_API_KEY is set, calls directly.
+ *
+ * This file is the thin orchestrator + re-export facade. Domain logic lives in:
+ *   - memory-manager.ts     (loadMemory, addMemory, removeMemory, listMemories)
+ *   - git-context.ts        (gatherGitContext, refreshGitContext)
+ *   - claude-md-loader.ts   (loadClaudeMd, reloadClaudeMd)
+ *   - permission-modes.ts   (PermissionMode, set/get/isAllowed)
+ *   - model-manager.ts      (setModel, getModel, getModelShortName, estimateCostUsd)
+ *   - session-persistence.ts (SessionMeta, save/load/list/find sessions)
+ *   - system-prompt.ts      (buildSystemPrompt)
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+import { getServerStatus, type ServerStatus } from "./server-tools.js";
+import { AgentEventEmitter } from "./agent-events.js";
+import { mcpClientManager } from "./mcp-client.js";
+import { loadMemory, addMemory, removeMemory, listMemories } from "./memory-manager.js";
+import { refreshGitContext } from "./git-context.js";
+import { loadClaudeMd, reloadClaudeMd } from "./claude-md-loader.js";
+import { setPermissionMode, getPermissionMode, isToolAllowedByPermission, type PermissionMode } from "./permission-modes.js";
+import { setModel, getModel, getModelShortName, estimateCostUsd } from "./model-manager.js";
+import { saveSession, loadSession, listSessions, findLatestSessionForCwd, type SessionMeta } from "./session-persistence.js";
+export { loadMemory, addMemory, removeMemory, listMemories };
+export { refreshGitContext };
+export { loadClaudeMd, reloadClaudeMd };
+export { setPermissionMode, getPermissionMode, isToolAllowedByPermission, type PermissionMode };
+export { setModel, getModel, getModelShortName, estimateCostUsd };
+export { saveSession, loadSession, listSessions, findLatestSessionForCwd, type SessionMeta };
+export { getServerStatus, type ServerStatus };
+export { mcpClientManager };
+export { listProcesses, listBackgroundAgents } from "./background-processes.js";
+export { AgentEventEmitter, type AgentEvent } from "./agent-events.js";
+export interface AgentLoopCallbacks {
+    onText: (text: string) => void;
+    onToolStart: (name: string, input?: Record<string, unknown>) => void;
+    onToolResult: (name: string, success: boolean, result: unknown, input?: Record<string, unknown>, durationMs?: number) => void;
+    onUsage: (input_tokens: number, output_tokens: number, thinking_tokens?: number, model?: string, costUsd?: number, cacheReadTokens?: number, cacheCreationTokens?: number) => void;
+    onDone: (finalMessages: Anthropic.MessageParam[]) => void;
+    onError: (error: string, partialMessages?: Anthropic.MessageParam[]) => void;
+    onAutoCompact?: (beforeMessages: number, afterMessages: number, tokensSaved: number) => void;
+}
+export interface AgentLoopOptions {
+    message: string;
+    images?: {
+        base64: string;
+        mediaType: string;
+    }[];
+    conversationHistory: Anthropic.MessageParam[];
+    callbacks: AgentLoopCallbacks;
+    abortSignal?: AbortSignal;
+    model?: string;
+    emitter?: AgentEventEmitter;
+    maxTurns?: number;
+    maxBudgetUsd?: number;
+    effort?: "low" | "medium" | "high";
+    allowedTools?: string[];
+    disallowedTools?: string[];
+    fallbackModel?: string;
+    thinking?: boolean;
+    shellSummarization?: boolean;
+    cwd?: string;
+}
+export declare function getSessionTokens(): {
+    input: number;
+    output: number;
+};
+/**
+ * Reset all CLI-only session state. Call when starting a new conversation
+ * (e.g., /clear command, new print-mode run) to prevent stale token counts,
+ * loop detector state, and caches from leaking across sessions.
+ *
+ * Does NOT reset activeModel or permissionMode — those are user preferences
+ * that persist intentionally until explicitly changed.
+ */
+export declare function resetSessionState(): void;
+/** Exposed for /status command */
+export declare function getServerToolCount(): Promise<number>;
+export declare function runAgentLoop(opts: AgentLoopOptions): Promise<void>;
+export declare function truncateResult(output: string, maxLen: number): string;
+export declare function classifyToolError(output: string): string;
+export declare function canUseAgent(): {
+    ready: boolean;
+    reason?: string;
+};