whale-code 6.4.0

package/dist/cli/services/telemetry.d.ts

@@ -0,0 +1,61 @@
+/**
+ * CLI Telemetry — fire-and-forget span logging to audit_logs
+ *
+ * Session-scoped conversationId + auto-incrementing turnNumber.
+ * Uses same column schema as executor.ts telemetry (trace_id, span_id, etc).
+ * Never blocks or crashes the chat.
+ */
+export interface ExecutionContext {
+    source: string;
+    userId?: string;
+    userEmail?: string;
+    traceId?: string;
+    spanId?: string;
+    parentSpanId?: string;
+    traceFlags?: number;
+    requestId?: string;
+    parentId?: string;
+    rowId?: string;
+    serviceName?: string;
+    serviceVersion?: string;
+    agentId?: string;
+    agentName?: string;
+    conversationId?: string;
+    turnNumber?: number;
+    model?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    totalCost?: number;
+    costBefore?: number;
+    turnCost?: number;
+    iteration?: number;
+    toolType?: string;
+}
+/**
+ * Set the conversation ID (used by worker threads to share parent's conversation)
+ */
+export declare function setConversationId(id: string): void;
+/**
+ * Get the current conversation ID
+ */
+export declare function getConversationId(): string;
+/**
+ * Initialize the telemetry client with a specific auth token.
+ * Used by worker threads that receive the token from the parent.
+ */
+export declare function initializeTelemetryClient(authToken: string): void;
+export declare function generateTraceId(): string;
+export declare function generateSpanId(): string;
+export declare function nextTurn(): number;
+export declare function createTurnContext(overrides?: Partial<ExecutionContext>): ExecutionContext;
+export declare function getTurnNumber(): number;
+export interface SpanOptions {
+    action: string;
+    severity?: "info" | "warn" | "error";
+    durationMs: number;
+    context: ExecutionContext;
+    storeId?: string;
+    error?: string;
+    details?: Record<string, unknown>;
+}
+export declare function logSpan(opts: SpanOptions): void;

package/dist/cli/services/telemetry.js

@@ -0,0 +1,209 @@
+/**
+ * CLI Telemetry — fire-and-forget span logging to audit_logs
+ *
+ * Session-scoped conversationId + auto-incrementing turnNumber.
+ * Uses same column schema as executor.ts telemetry (trace_id, span_id, etc).
+ * Never blocks or crashes the chat.
+ */
+import { createClient } from "@supabase/supabase-js";
+import { createRequire } from "module";
+import { resolveConfig, loadConfig } from "./config-store.js";
+import { getValidToken, createAuthenticatedClient } from "./auth-service.js";
+import { captureError } from "./error-logger.js";
+const require = createRequire(import.meta.url);
+const PKG_VERSION = require("../../../package.json").version;
+// ============================================================================
+// SESSION STATE
+// ============================================================================
+let conversationId = crypto.randomUUID();
+let turnNumber = 0;
+/**
+ * Set the conversation ID (used by worker threads to share parent's conversation)
+ */
+export function setConversationId(id) {
+    conversationId = id;
+}
+/**
+ * Get the current conversation ID
+ */
+export function getConversationId() {
+    return conversationId;
+}
+let supabaseClient = null;
+/**
+ * Initialize the telemetry client with a specific auth token.
+ * Used by worker threads that receive the token from the parent.
+ */
+export function initializeTelemetryClient(authToken) {
+    if (supabaseClient)
+        return; // Already initialized
+    supabaseClient = createAuthenticatedClient(authToken);
+    if (process.env.DEBUG_TELEMETRY) {
+        process.stderr.write(`[telemetry] initialized client with provided auth token\n`);
+    }
+}
+// ============================================================================
+// W3C TRACE CONTEXT GENERATORS
+// ============================================================================
+export function generateTraceId() {
+    // Use proper UUID format so it's compatible with Postgres uuid columns
+    return crypto.randomUUID();
+}
+export function generateSpanId() {
+    const bytes = new Uint8Array(8);
+    crypto.getRandomValues(bytes);
+    return Array.from(bytes).map(b => b.toString(16).padStart(2, "0")).join("");
+}
+// ============================================================================
+// SUPABASE CLIENT (lazy init)
+// ============================================================================
+async function getClient() {
+    if (supabaseClient)
+        return supabaseClient;
+    const config = resolveConfig();
+    // Prefer service role key
+    if (config.supabaseUrl && config.supabaseKey) {
+        supabaseClient = createClient(config.supabaseUrl, config.supabaseKey, {
+            auth: { persistSession: false, autoRefreshToken: false },
+        });
+        if (process.env.DEBUG_TELEMETRY) {
+            process.stderr.write(`[telemetry] using service role key\n`);
+        }
+        return supabaseClient;
+    }
+    // Fallback: user JWT
+    const token = await getValidToken();
+    if (token) {
+        supabaseClient = createAuthenticatedClient(token);
+        if (process.env.DEBUG_TELEMETRY) {
+            process.stderr.write(`[telemetry] using user JWT token\n`);
+        }
+        return supabaseClient;
+    }
+    if (process.env.DEBUG_TELEMETRY) {
+        process.stderr.write(`[telemetry] NO CLIENT - no service key and no valid token\n`);
+        process.stderr.write(`[telemetry]   config.supabaseUrl: ${config.supabaseUrl}\n`);
+        process.stderr.write(`[telemetry]   config.supabaseKey: ${config.supabaseKey ? 'set' : 'not set'}\n`);
+    }
+    return null;
+}
+// ============================================================================
+// TURN CONTEXT
+// ============================================================================
+export function nextTurn() {
+    return ++turnNumber;
+}
+export function createTurnContext(overrides) {
+    // Get user info from config
+    const { user_id, email } = loadConfig();
+    return {
+        source: "whale_cli",
+        serviceName: "whale-code",
+        serviceVersion: PKG_VERSION,
+        conversationId,
+        turnNumber,
+        traceId: generateTraceId(),
+        spanId: generateSpanId(),
+        traceFlags: 1,
+        userId: user_id,
+        userEmail: email,
+        ...overrides,
+    };
+}
+export function getTurnNumber() {
+    return turnNumber;
+}
+export function logSpan(opts) {
+    // Fire-and-forget — don't await, log errors in debug mode
+    _logSpan(opts).catch((err) => {
+        if (process.env.DEBUG_TELEMETRY) {
+            process.stderr.write(`[telemetry error] ${opts.action}: ${err.message}\n`);
+        }
+    });
+}
+async function _logSpan(opts) {
+    if (process.env.DEBUG_TELEMETRY) {
+        process.stderr.write(`[telemetry] _logSpan called for ${opts.action}\n`);
+    }
+    const client = await getClient();
+    if (!client) {
+        if (process.env.DEBUG_TELEMETRY) {
+            process.stderr.write(`[telemetry] no client for ${opts.action}\n`);
+        }
+        return;
+    }
+    const now = new Date();
+    const startTime = new Date(now.getTime() - opts.durationMs);
+    const ctx = opts.context;
+    // Debug: log team-related spans (only when DEBUG_TELEMETRY is set)
+    if (process.env.DEBUG_TELEMETRY && (opts.action.startsWith("team.") || opts.details?.parent_conversation_id)) {
+        process.stderr.write(`[telemetry:team] action=${opts.action}\n`);
+        process.stderr.write(`[telemetry:team]   conversation_id=${ctx.conversationId}\n`);
+        process.stderr.write(`[telemetry:team]   parent_conversation_id=${opts.details?.parent_conversation_id}\n`);
+    }
+    const row = {
+        action: opts.action,
+        severity: opts.severity || (opts.error ? "error" : "info"),
+        store_id: opts.storeId || resolveConfig().storeId || null,
+        user_id: ctx.userId || null,
+        user_email: ctx.userEmail || null,
+        resource_type: "cli_span",
+        resource_id: opts.action,
+        request_id: ctx.traceId,
+        parent_id: ctx.parentId || null,
+        duration_ms: opts.durationMs,
+        error_message: opts.error || null,
+        // OTEL columns
+        trace_id: ctx.traceId,
+        span_id: ctx.spanId,
+        trace_flags: ctx.traceFlags ?? 1,
+        span_kind: "INTERNAL",
+        service_name: ctx.serviceName || "whale-code",
+        service_version: ctx.serviceVersion || PKG_VERSION,
+        status_code: opts.error ? "ERROR" : "OK",
+        start_time: startTime.toISOString(),
+        end_time: now.toISOString(),
+        // AI telemetry — use ?? to handle 0 correctly
+        model: ctx.model || null,
+        input_tokens: ctx.inputTokens ?? null,
+        output_tokens: ctx.outputTokens ?? null,
+        total_cost: ctx.totalCost ?? null,
+        turn_number: ctx.turnNumber ?? null,
+        conversation_id: ctx.conversationId || null,
+        details: {
+            source: ctx.source || "whale_cli",
+            conversation_id: ctx.conversationId || conversationId,
+            turn_number: ctx.turnNumber ?? turnNumber,
+            parent_span_id: ctx.parentSpanId || null,
+            ...opts.details,
+        },
+    };
+    // Allow caller to control row ID so children can reference it via parent_id
+    if (ctx.rowId)
+        row.id = ctx.rowId;
+    const { error } = await client.from("audit_logs").insert(row);
+    if (error) {
+        if (process.env.DEBUG_TELEMETRY) {
+            process.stderr.write(`[telemetry db error] ${opts.action}: ${error.message}\n`);
+            process.stderr.write(`[telemetry db error]   code: ${error.code}\n`);
+            process.stderr.write(`[telemetry db error]   hint: ${error.hint}\n`);
+        }
+    }
+    else if (opts.details?.is_teammate && process.env.DEBUG_TELEMETRY) {
+        process.stderr.write(`[telemetry] teammate span logged: ${opts.action}\n`);
+    }
+    // Bridge errors to the error logging system
+    if (opts.error) {
+        captureError({
+            errorType: opts.action,
+            errorMessage: opts.error,
+            severity: "error",
+            traceId: ctx.traceId,
+            spanId: ctx.spanId,
+            storeId: opts.storeId || resolveConfig().storeId,
+            userId: ctx.userId,
+            userEmail: ctx.userEmail,
+            tags: { action: opts.action },
+        });
+    }
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Agent Tools — task, team_create, task_output, task_stop, config, ask_user, lsp, skill
+ *
+ * Extracted from local-tools.ts for single-responsibility.
+ */
+import { ToolResult } from "../../../shared/types.js";
+export declare function configTool(input: Record<string, unknown>): ToolResult;
+export declare function askUser(input: Record<string, unknown>): ToolResult;
+export declare function lspTool(input: Record<string, unknown>): Promise<ToolResult>;
+export declare function skillTool(input: Record<string, unknown>): ToolResult;
+export declare function taskTool(input: Record<string, unknown>): Promise<ToolResult>;
+export declare function taskOutput(input: Record<string, unknown>): Promise<ToolResult>;
+export declare function taskStop(input: Record<string, unknown>): ToolResult;
+export declare function teamCreateTool(input: Record<string, unknown>): Promise<ToolResult>;

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

@@ -0,0 +1,347 @@
+/**
+ * Agent Tools — task, team_create, task_output, task_stop, config, ask_user, lsp, skill
+ *
+ * Extracted from local-tools.ts for single-responsibility.
+ */
+import { readFileSync, existsSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+import { runSubagent, runSubagentBackground, } from "../subagent.js";
+import { createTurnContext, getTurnNumber, } from "../telemetry.js";
+import { runAgentTeam, } from "../team-lead.js";
+import { readAgentOutput, stopBackgroundAgent } from "../background-processes.js";
+import { readProcessOutput, killProcess } from "../background-processes.js";
+import { getGlobalEmitter } from "../agent-events.js";
+import { executeLSP } from "../lsp-manager.js";
+import { debugLog } from "../debug-log.js";
+import { setPermissionMode, getPermissionMode } from "../permission-modes.js";
+import { getModel, setModel } from "../model-manager.js";
+// ============================================================================
+// CONFIG TOOL
+// ============================================================================
+export function configTool(input) {
+    const setting = input.setting;
+    const value = input.value;
+    switch (setting) {
+        case "model": {
+            if (!value)
+                return { success: true, output: `Current model: ${getModel()}` };
+            const result = setModel(value);
+            if (!result.success) {
+                return { success: false, output: result.error || `Unknown model: ${value}` };
+            }
+            return { success: true, output: `Model set to: ${result.model}` };
+        }
+        case "mode":
+        case "permission_mode": {
+            if (!value)
+                return { success: true, output: `Current mode: ${getPermissionMode()}` };
+            if (!["default", "plan", "yolo"].includes(value)) {
+                return { success: false, output: `Invalid mode: ${value}. Use: default, plan, yolo` };
+            }
+            const result = setPermissionMode(value);
+            return { success: result.success, output: result.message };
+        }
+        case "memory": {
+            if (!value) {
+                const memPath = join(homedir(), ".swagmanager", "memory", "MEMORY.md");
+                if (!existsSync(memPath))
+                    return { success: true, output: "No memory file found." };
+                const content = readFileSync(memPath, "utf-8");
+                return { success: true, output: `Memory (${content.length} chars):\n${content.slice(0, 20_000)}` };
+            }
+            return { success: false, output: "Use read_file/write_file to edit memory directly." };
+        }
+        default:
+            return { success: false, output: `Unknown setting: ${setting}. Available: model, mode, memory` };
+    }
+}
+// ============================================================================
+// ASK USER
+// ============================================================================
+export function askUser(input) {
+    const question = input.question;
+    const options = input.options;
+    if (!question)
+        return { success: false, output: "question is required" };
+    if (!options || options.length < 2)
+        return { success: false, output: "at least 2 options required" };
+    // Emit the question via the global event emitter for the UI to render
+    const emitter = getGlobalEmitter();
+    if (emitter) {
+        emitter.emit("ask_user", { question, options });
+    }
+    // Format question as text for the model to see in the response
+    const optionLines = options.map((o, i) => `  ${i + 1}. **${o.label}** — ${o.description}`).join("\n");
+    return {
+        success: true,
+        output: `Question presented to user:\n${question}\n\nOptions:\n${optionLines}\n\n(Waiting for user response...)`,
+    };
+}
+// ============================================================================
+// LSP TOOL
+// ============================================================================
+export async function lspTool(input) {
+    const operation = input.operation;
+    if (!operation)
+        return { success: false, output: "operation is required" };
+    return await executeLSP(operation, input);
+}
+// ============================================================================
+// SKILL TOOL
+// ============================================================================
+export function skillTool(input) {
+    const skillName = input.skill;
+    if (!skillName)
+        return { success: false, output: "skill name is required" };
+    const args = (input.args || "").split(/\s+/).filter(Boolean);
+    // Resolution order:
+    // 1. .whale/commands/{skill}.md (project-local)
+    // 2. ~/.swagmanager/commands/{skill}.md (user global)
+    // 3. Built-in skills bundled with package
+    const localPath = join(process.cwd(), ".whale", "commands", `${skillName}.md`);
+    const globalPath = join(homedir(), ".swagmanager", "commands", `${skillName}.md`);
+    // Built-in skills: check both dist/ and src/ locations
+    const thisFileDir = dirname(new URL(import.meta.url).pathname);
+    const builtinPaths = [
+        join(thisFileDir, "..", "builtin-skills", `${skillName}.md`), // dist/cli/services/tools/../builtin-skills/
+        join(thisFileDir, "..", "..", "..", "..", "src", "cli", "services", "builtin-skills", `${skillName}.md`), // src/ from dist/
+    ];
+    let template = null;
+    let source = "";
+    // Check local -> global -> builtin (multiple paths)
+    const candidates = [
+        [localPath, "local"],
+        [globalPath, "global"],
+        ...builtinPaths.map(p => [p, "builtin"]),
+    ];
+    for (const [path, src] of candidates) {
+        if (existsSync(path)) {
+            try {
+                let content = readFileSync(path, "utf-8");
+                // Strip frontmatter
+                if (content.startsWith("---")) {
+                    const endIdx = content.indexOf("---", 3);
+                    if (endIdx !== -1) {
+                        content = content.slice(endIdx + 3).trim();
+                    }
+                }
+                template = content;
+                source = src;
+                break;
+            }
+            catch { /* skip */ }
+        }
+    }
+    if (!template) {
+        return {
+            success: false,
+            output: `Skill not found: ${skillName}. Available locations:\n  .whale/commands/${skillName}.md\n  ~/.swagmanager/commands/${skillName}.md\n\nBuilt-in skills: commit, review, review-pr`,
+        };
+    }
+    // Expand arguments ($1, $2, $ARGS)
+    let expanded = template;
+    for (let i = 0; i < args.length; i++) {
+        expanded = expanded.replace(new RegExp(`\\$${i + 1}`, "g"), args[i]);
+    }
+    expanded = expanded.replace(/\$ARGS/g, args.join(" "));
+    expanded = expanded.replace(/\$\d+/g, ""); // Clean up unused
+    return {
+        success: true,
+        output: `[Skill: ${skillName} (${source})]\n\n${expanded.trim()}`,
+    };
+}
+// ============================================================================
+// TASK TOOL — subagent execution
+// ============================================================================
+/** Create parent trace context for subagent hierarchy */
+function getParentTraceContext() {
+    const ctx = createTurnContext();
+    return {
+        traceId: ctx.traceId,
+        spanId: ctx.spanId,
+        conversationId: ctx.conversationId,
+        turnNumber: getTurnNumber(),
+        userId: ctx.userId,
+        userEmail: ctx.userEmail,
+    };
+}
+export async function taskTool(input) {
+    const prompt = input.prompt;
+    const subagent_type = input.subagent_type;
+    const model = input.model || "haiku";
+    const runInBackground = input.run_in_background;
+    const maxTurns = input.max_turns;
+    const agentName = input.name;
+    const teamName = input.team_name;
+    const mode = input.mode;
+    if (!prompt)
+        return { success: false, output: "prompt is required" };
+    if (!subagent_type)
+        return { success: false, output: "subagent_type is required" };
+    // Apply permission mode for subagent if specified
+    if (mode) {
+        setPermissionMode(mode);
+        // Note: mode resets are handled by subagent isolation
+    }
+    debugLog("tools", `task: ${agentName || subagent_type}`, { model, maxTurns, teamName, mode });
+    try {
+        // Background mode: start agent, return output file path immediately
+        if (runInBackground) {
+            const { agentId, outputFile } = await runSubagentBackground({
+                prompt,
+                subagent_type,
+                model,
+                max_turns: maxTurns,
+                name: agentName,
+                run_in_background: true,
+                parentTraceContext: getParentTraceContext(),
+            });
+            return {
+                success: true,
+                output: `Background agent started.\n  agent_id: ${agentId}\n  output_file: ${outputFile}\n\nUse task_output with task_id="${agentId}" to check progress.`,
+            };
+        }
+        // Foreground mode: run agent synchronously
+        const result = await runSubagent({
+            prompt,
+            subagent_type,
+            model,
+            max_turns: maxTurns,
+            name: agentName,
+            parentTraceContext: getParentTraceContext(),
+        });
+        return {
+            success: result.success,
+            output: result.output,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            output: `Task failed: ${err.message || err}`,
+        };
+    }
+}
+// ============================================================================
+// TASK OUTPUT / TASK STOP
+// ============================================================================
+export async function taskOutput(input) {
+    const taskId = input.task_id;
+    const block = input.block ?? true;
+    const timeout = Math.min(input.timeout || 30000, 120000);
+    if (!taskId)
+        return { success: false, output: "task_id is required" };
+    // Check if it's a background agent (agent-xxx prefix)
+    if (taskId.startsWith("agent-")) {
+        const agentResult = readAgentOutput(taskId);
+        if (!agentResult)
+            return { success: false, output: `Agent not found: ${taskId}. Use list_shells to see available tasks.` };
+        // If blocking and still running, poll until done or timeout
+        if (block && agentResult.status === "running") {
+            const start = Date.now();
+            while (Date.now() - start < timeout) {
+                await new Promise(r => setTimeout(r, 1000));
+                const updated = readAgentOutput(taskId);
+                if (updated && updated.status !== "running") {
+                    return { success: true, output: `[${updated.status}]\n${updated.output}` };
+                }
+            }
+            const final = readAgentOutput(taskId);
+            return { success: true, output: `[${final?.status || "running"} — timed out waiting]\n${final?.output || ""}` };
+        }
+        return { success: true, output: `[${agentResult.status}]\n${agentResult.output}` };
+    }
+    // Fall back to shell process output (bash_output behavior)
+    const result = readProcessOutput(taskId, {});
+    if ("error" in result)
+        return { success: false, output: result.error };
+    const statusIcon = result.status === "running" ? "\u25CF" : result.status === "completed" ? "\u2713" : "\u2715";
+    const lines = [];
+    lines.push(`${statusIcon} Task ${taskId} — ${result.status}`);
+    if (result.exitCode !== undefined)
+        lines.push(`  Exit code: ${result.exitCode}`);
+    if (result.newOutput) {
+        lines.push(`  Output:`);
+        lines.push(result.newOutput);
+    }
+    if (result.newErrors) {
+        lines.push(`  Errors:`);
+        lines.push(result.newErrors);
+    }
+    if (!result.newOutput && !result.newErrors)
+        lines.push("  (no new output since last check)");
+    return { success: true, output: lines.join("\n") };
+}
+export function taskStop(input) {
+    const taskId = input.task_id;
+    if (!taskId)
+        return { success: false, output: "task_id is required" };
+    // Check if it's a background agent
+    if (taskId.startsWith("agent-")) {
+        const result = stopBackgroundAgent(taskId);
+        return { success: result.success, output: result.message };
+    }
+    // Fall back to shell kill
+    const result = killProcess(taskId);
+    return { success: result.success, output: result.message };
+}
+// ============================================================================
+// TEAM CREATE
+// ============================================================================
+export async function teamCreateTool(input) {
+    const name = input.name;
+    const teammateCount = input.teammate_count;
+    const model = input.model || "sonnet";
+    const tasksInput = input.tasks;
+    if (!name)
+        return { success: false, output: "name is required" };
+    if (!teammateCount || teammateCount < 1) {
+        return { success: false, output: "teammate_count must be at least 1" };
+    }
+    if (!tasksInput || tasksInput.length === 0) {
+        return { success: false, output: "tasks array is required and must not be empty" };
+    }
+    // Validate task count vs teammate count
+    if (tasksInput.length < teammateCount) {
+        return {
+            success: false,
+            output: `Not enough tasks (${tasksInput.length}) for ${teammateCount} teammates. Add more tasks or reduce teammates.`,
+        };
+    }
+    const config = {
+        name,
+        teammateCount,
+        model,
+        tasks: tasksInput,
+    };
+    try {
+        const result = await runAgentTeam(config);
+        // Build summary output
+        const lines = [
+            `## Team: ${name}`,
+            `Status: ${result.success ? "SUCCESS" : "PARTIAL"}`,
+            `Duration: ${(result.durationMs / 1000).toFixed(1)}s`,
+            `Tokens: ${result.tokensUsed.input} in, ${result.tokensUsed.output} out`,
+            "",
+            "### Task Results",
+        ];
+        for (const task of result.taskResults) {
+            const icon = task.status === "completed" ? "[done]" : "[fail]";
+            lines.push(`${icon} ${task.description}`);
+            if (task.result) {
+                lines.push(`    ${task.result.slice(0, 200)}${task.result.length > 200 ? "..." : ""}`);
+            }
+        }
+        return {
+            success: result.success,
+            output: lines.join("\n"),
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            output: `Team failed: ${err.message || err}`,
+        };
+    }
+}

package/dist/cli/services/tools/file-ops.d.ts

@@ -0,0 +1,15 @@
+/**
+ * File Operations — read, write, edit, multi-edit, notebook, list, search
+ *
+ * Extracted from local-tools.ts for single-responsibility.
+ */
+import { ToolResult } from "../../../shared/types.js";
+export declare function resolvePath(p: string): string;
+export declare function readFile(input: Record<string, unknown>): Promise<ToolResult>;
+export declare function writeFile(input: Record<string, unknown>): ToolResult;
+export declare function editFile(input: Record<string, unknown>): ToolResult;
+export declare function multiEdit(input: Record<string, unknown>): ToolResult;
+export declare function notebookEdit(input: Record<string, unknown>): ToolResult;
+export declare function listDirectory(input: Record<string, unknown>): ToolResult;
+export declare function searchFiles(input: Record<string, unknown>): ToolResult;
+export declare function searchContent(input: Record<string, unknown>): ToolResult;