whale-code 6.4.0

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

@@ -0,0 +1,84 @@
+/**
+ * Rewind — checkpoint tracking and file revert for conversation rewind
+ *
+ * After each assistant turn, a checkpoint is recorded with:
+ * - The turn index and message count at that point
+ * - A summary of what happened (first 80 chars of assistant text)
+ * - File changes made during that turn (with backup paths from file-history)
+ *
+ * On rewind, files are restored from their backups in reverse chronological
+ * order. Files that were CREATED (not edited) during reverted turns are deleted.
+ *
+ * Integrates with the existing file-history.ts backup system.
+ */
+export interface FileChange {
+    filePath: string;
+    backupPath: string;
+    operation: "write" | "edit" | "multi_edit";
+    isNewFile: boolean;
+}
+export interface RewindCheckpoint {
+    turnIndex: number;
+    messageCount: number;
+    timestamp: number;
+    summary: string;
+    fileChanges: FileChange[];
+}
+export interface RewindResult {
+    messageCount: number;
+    filesReverted: string[];
+    filesDeleted: string[];
+    errors: string[];
+}
+export declare class RewindManager {
+    private checkpoints;
+    private pendingFileChanges;
+    /**
+     * Record a checkpoint after an assistant turn completes.
+     */
+    addCheckpoint(turnIndex: number, messageCount: number, summary: string, fileChanges: FileChange[]): void;
+    /**
+     * Get all checkpoints for display.
+     */
+    getCheckpoints(): RewindCheckpoint[];
+    /**
+     * Get the number of recorded checkpoints.
+     */
+    getCheckpointCount(): number;
+    /**
+     * Rewind to a specific checkpoint index. All checkpoints AFTER this index
+     * are removed, and their file changes are reverted.
+     *
+     * Returns the message count to truncate to, plus lists of reverted/deleted files.
+     */
+    rewindTo(checkpointIndex: number): RewindResult;
+    /**
+     * Revert only file changes (without truncating conversation).
+     * Used when user wants to undo file changes but keep conversation history.
+     */
+    revertFilesFrom(checkpointIndex: number): Omit<RewindResult, "messageCount">;
+    /**
+     * Track a file change for the current (uncommitted) turn.
+     */
+    trackFileChange(change: FileChange): void;
+    /**
+     * Get the current turn's pending file changes.
+     */
+    getCurrentFileChanges(): FileChange[];
+    /**
+     * Clear current turn tracking (called when checkpoint is committed).
+     */
+    commitTurn(): void;
+    /**
+     * Check if there are any checkpoints with file changes that could be reverted.
+     */
+    hasFileChanges(): boolean;
+    /**
+     * Get the total number of file changes across all checkpoints after a given index.
+     */
+    getFileChangeCountAfter(checkpointIndex: number): number;
+    /**
+     * Reset all state.
+     */
+    reset(): void;
+}

package/dist/cli/services/rewind.js

@@ -0,0 +1,194 @@
+/**
+ * Rewind — checkpoint tracking and file revert for conversation rewind
+ *
+ * After each assistant turn, a checkpoint is recorded with:
+ * - The turn index and message count at that point
+ * - A summary of what happened (first 80 chars of assistant text)
+ * - File changes made during that turn (with backup paths from file-history)
+ *
+ * On rewind, files are restored from their backups in reverse chronological
+ * order. Files that were CREATED (not edited) during reverted turns are deleted.
+ *
+ * Integrates with the existing file-history.ts backup system.
+ */
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+// ============================================================================
+// REWIND MANAGER
+// ============================================================================
+export class RewindManager {
+    checkpoints = [];
+    pendingFileChanges = [];
+    /**
+     * Record a checkpoint after an assistant turn completes.
+     */
+    addCheckpoint(turnIndex, messageCount, summary, fileChanges) {
+        this.checkpoints.push({
+            turnIndex,
+            messageCount,
+            timestamp: Date.now(),
+            summary: summary.slice(0, 80),
+            fileChanges,
+        });
+    }
+    /**
+     * Get all checkpoints for display.
+     */
+    getCheckpoints() {
+        return [...this.checkpoints];
+    }
+    /**
+     * Get the number of recorded checkpoints.
+     */
+    getCheckpointCount() {
+        return this.checkpoints.length;
+    }
+    /**
+     * Rewind to a specific checkpoint index. All checkpoints AFTER this index
+     * are removed, and their file changes are reverted.
+     *
+     * Returns the message count to truncate to, plus lists of reverted/deleted files.
+     */
+    rewindTo(checkpointIndex) {
+        if (checkpointIndex < 0 || checkpointIndex >= this.checkpoints.length) {
+            return {
+                messageCount: 0,
+                filesReverted: [],
+                filesDeleted: [],
+                errors: [`Invalid checkpoint index: ${checkpointIndex}`],
+            };
+        }
+        const targetCheckpoint = this.checkpoints[checkpointIndex];
+        const removedCheckpoints = this.checkpoints.slice(checkpointIndex + 1);
+        const filesReverted = [];
+        const filesDeleted = [];
+        const errors = [];
+        // Revert file changes in reverse chronological order
+        // Process checkpoints from newest to oldest
+        for (let i = removedCheckpoints.length - 1; i >= 0; i--) {
+            const cp = removedCheckpoints[i];
+            // Process file changes within each checkpoint in reverse order
+            for (let j = cp.fileChanges.length - 1; j >= 0; j--) {
+                const change = cp.fileChanges[j];
+                try {
+                    if (change.isNewFile) {
+                        // File was created during this turn — delete it
+                        if (existsSync(change.filePath)) {
+                            unlinkSync(change.filePath);
+                            filesDeleted.push(change.filePath);
+                        }
+                    }
+                    else if (change.backupPath && existsSync(change.backupPath)) {
+                        // File was edited — restore from backup
+                        const backupContent = readFileSync(change.backupPath);
+                        writeFileSync(change.filePath, backupContent);
+                        filesReverted.push(change.filePath);
+                    }
+                    else {
+                        errors.push(`No backup found for ${change.filePath}`);
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    errors.push(`Failed to revert ${change.filePath}: ${msg}`);
+                }
+            }
+        }
+        // Truncate checkpoints to the target
+        this.checkpoints = this.checkpoints.slice(0, checkpointIndex + 1);
+        // Clear any pending file changes
+        this.pendingFileChanges = [];
+        return {
+            messageCount: targetCheckpoint.messageCount,
+            filesReverted: [...new Set(filesReverted)],
+            filesDeleted: [...new Set(filesDeleted)],
+            errors,
+        };
+    }
+    /**
+     * Revert only file changes (without truncating conversation).
+     * Used when user wants to undo file changes but keep conversation history.
+     */
+    revertFilesFrom(checkpointIndex) {
+        if (checkpointIndex < 0 || checkpointIndex >= this.checkpoints.length) {
+            return {
+                filesReverted: [],
+                filesDeleted: [],
+                errors: [`Invalid checkpoint index: ${checkpointIndex}`],
+            };
+        }
+        const removedCheckpoints = this.checkpoints.slice(checkpointIndex + 1);
+        const filesReverted = [];
+        const filesDeleted = [];
+        const errors = [];
+        for (let i = removedCheckpoints.length - 1; i >= 0; i--) {
+            const cp = removedCheckpoints[i];
+            for (let j = cp.fileChanges.length - 1; j >= 0; j--) {
+                const change = cp.fileChanges[j];
+                try {
+                    if (change.isNewFile) {
+                        if (existsSync(change.filePath)) {
+                            unlinkSync(change.filePath);
+                            filesDeleted.push(change.filePath);
+                        }
+                    }
+                    else if (change.backupPath && existsSync(change.backupPath)) {
+                        const backupContent = readFileSync(change.backupPath);
+                        writeFileSync(change.filePath, backupContent);
+                        filesReverted.push(change.filePath);
+                    }
+                    else {
+                        errors.push(`No backup found for ${change.filePath}`);
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    errors.push(`Failed to revert ${change.filePath}: ${msg}`);
+                }
+            }
+        }
+        return {
+            filesReverted: [...new Set(filesReverted)],
+            filesDeleted: [...new Set(filesDeleted)],
+            errors,
+        };
+    }
+    /**
+     * Track a file change for the current (uncommitted) turn.
+     */
+    trackFileChange(change) {
+        this.pendingFileChanges.push(change);
+    }
+    /**
+     * Get the current turn's pending file changes.
+     */
+    getCurrentFileChanges() {
+        return [...this.pendingFileChanges];
+    }
+    /**
+     * Clear current turn tracking (called when checkpoint is committed).
+     */
+    commitTurn() {
+        this.pendingFileChanges = [];
+    }
+    /**
+     * Check if there are any checkpoints with file changes that could be reverted.
+     */
+    hasFileChanges() {
+        return this.checkpoints.some(cp => cp.fileChanges.length > 0);
+    }
+    /**
+     * Get the total number of file changes across all checkpoints after a given index.
+     */
+    getFileChangeCountAfter(checkpointIndex) {
+        return this.checkpoints
+            .slice(checkpointIndex + 1)
+            .reduce((sum, cp) => sum + cp.fileChanges.length, 0);
+    }
+    /**
+     * Reset all state.
+     */
+    reset() {
+        this.checkpoints = [];
+        this.pendingFileChanges = [];
+    }
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Ripgrep Integration — fast search via `rg` binary
+ *
+ * Tries system `rg` first, then falls back to @vscode/ripgrep package.
+ * If neither available, callers fall back to grep/find.
+ */
+export declare function getRgPath(): string | null;
+export declare function isRgAvailable(): boolean;
+export interface RgGrepOptions {
+    pattern: string;
+    path: string;
+    outputMode?: "content" | "files_with_matches" | "count";
+    glob?: string;
+    type?: string;
+    caseInsensitive?: boolean;
+    multiline?: boolean;
+    context?: number;
+    before?: number;
+    after?: number;
+    headLimit?: number;
+}
+export declare function rgGrep(opts: RgGrepOptions): string | null;
+export interface RgGlobOptions {
+    pattern: string;
+    path: string;
+    headLimit?: number;
+}
+export declare function rgGlob(opts: RgGlobOptions): string | null;

package/dist/cli/services/ripgrep.js

@@ -0,0 +1,138 @@
+/**
+ * Ripgrep Integration — fast search via `rg` binary
+ *
+ * Tries system `rg` first, then falls back to @vscode/ripgrep package.
+ * If neither available, callers fall back to grep/find.
+ */
+import { execSync, execFileSync } from "child_process";
+// ============================================================================
+// RG BINARY DISCOVERY
+// ============================================================================
+let rgPathCache = undefined; // undefined = unchecked
+function findSystemRg() {
+    try {
+        const path = execSync("which rg", { encoding: "utf-8", timeout: 3000 }).trim();
+        if (path)
+            return path;
+    }
+    catch { /* not on PATH */ }
+    return null;
+}
+function findVscodeRg() {
+    try {
+        const rgModule = require("@vscode/ripgrep");
+        if (rgModule?.rgPath)
+            return rgModule.rgPath;
+    }
+    catch { /* package not installed */ }
+    return null;
+}
+export function getRgPath() {
+    if (rgPathCache !== undefined)
+        return rgPathCache;
+    rgPathCache = findSystemRg() || findVscodeRg();
+    return rgPathCache;
+}
+export function isRgAvailable() {
+    return getRgPath() !== null;
+}
+export function rgGrep(opts) {
+    const rg = getRgPath();
+    if (!rg)
+        return null;
+    const args = [];
+    // Output mode
+    switch (opts.outputMode) {
+        case "files_with_matches":
+            args.push("-l");
+            break;
+        case "count":
+            args.push("-c");
+            break;
+        case "content":
+            args.push("-n");
+            break;
+        default:
+            args.push("-l");
+            break;
+    }
+    // Case sensitivity
+    if (opts.caseInsensitive)
+        args.push("-i");
+    // Multiline
+    if (opts.multiline) {
+        args.push("-U", "--multiline-dotall");
+    }
+    // Context lines (content mode only)
+    if (opts.outputMode === "content") {
+        if (opts.context)
+            args.push("-C", String(opts.context));
+        if (opts.before)
+            args.push("-B", String(opts.before));
+        if (opts.after)
+            args.push("-A", String(opts.after));
+    }
+    // File type filter
+    if (opts.type)
+        args.push("--type", opts.type);
+    if (opts.glob)
+        args.push("--glob", opts.glob);
+    // Exclusions
+    args.push("--glob", "!node_modules", "--glob", "!.git", "--glob", "!dist");
+    // Pattern and path
+    args.push("--", opts.pattern, opts.path);
+    const limit = opts.headLimit || 200;
+    try {
+        const output = execFileSync(rg, args, {
+            encoding: "utf-8",
+            timeout: 30000,
+            maxBuffer: 2 * 1024 * 1024,
+            stdio: ["pipe", "pipe", "pipe"], // Suppress stderr from leaking to terminal
+        });
+        // Apply head limit
+        const lines = output.split("\n");
+        const limited = lines.slice(0, limit).join("\n");
+        return limited.trim() || null;
+    }
+    catch (err) {
+        // rg exits 1 for "no matches" — that's not an error
+        if (err.status === 1)
+            return null;
+        // rg exits 2 for actual errors (permission denied etc.) — don't throw, return null
+        if (err.status === 2)
+            return null;
+        throw err;
+    }
+}
+export function rgGlob(opts) {
+    const rg = getRgPath();
+    if (!rg)
+        return null;
+    const args = [
+        "--files",
+        "--glob", opts.pattern,
+        "--glob", "!node_modules",
+        "--glob", "!.git",
+        "--glob", "!dist",
+        opts.path,
+    ];
+    const limit = opts.headLimit || 200;
+    try {
+        const output = execFileSync(rg, args, {
+            encoding: "utf-8",
+            timeout: 10000,
+            maxBuffer: 2 * 1024 * 1024,
+            stdio: ["pipe", "pipe", "pipe"], // Suppress stderr from leaking to terminal
+        });
+        const files = output.trim().split("\n").filter(Boolean);
+        const limited = files.slice(0, limit);
+        return limited.length > 0 ? limited.join("\n") : null;
+    }
+    catch (err) {
+        if (err.status === 1)
+            return null;
+        if (err.status === 2)
+            return null; // Permission errors etc.
+        throw err;
+    }
+}

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

@@ -0,0 +1,29 @@
+/**
+ * Bash Sandbox — macOS sandbox-exec wrapper for shell commands
+ *
+ * Restricts file writes to:
+ *   - Current working directory (cwd)
+ *   - /tmp and /private/tmp
+ *   - ~/.swagmanager/
+ *   - /dev (for terminal I/O)
+ *   - /private/var/folders (macOS temp)
+ *
+ * Allows all reads and network access.
+ * Only active on macOS. Linux: passthrough (future work).
+ */
+/**
+ * Wrap a command with macOS sandbox-exec.
+ * Returns the original command unchanged on non-macOS platforms.
+ */
+export declare function sandboxCommand(command: string, cwd: string): {
+    wrapped: string;
+    profilePath: string | null;
+};
+/**
+ * Clean up sandbox profile after command execution.
+ */
+export declare function cleanupSandbox(profilePath: string | null): void;
+/**
+ * Check if sandbox-exec is available on this platform.
+ */
+export declare function isSandboxAvailable(): boolean;

package/dist/cli/services/sandbox.js

@@ -0,0 +1,97 @@
+/**
+ * Bash Sandbox — macOS sandbox-exec wrapper for shell commands
+ *
+ * Restricts file writes to:
+ *   - Current working directory (cwd)
+ *   - /tmp and /private/tmp
+ *   - ~/.swagmanager/
+ *   - /dev (for terminal I/O)
+ *   - /private/var/folders (macOS temp)
+ *
+ * Allows all reads and network access.
+ * Only active on macOS. Linux: passthrough (future work).
+ */
+import { writeFileSync, unlinkSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+// ============================================================================
+// SANDBOX PROFILE
+// ============================================================================
+function buildSandboxProfile(cwd) {
+    const home = homedir();
+    return `(version 1)
+(allow default)
+(deny file-write*)
+(allow file-write* (subpath "${cwd}"))
+(allow file-write* (subpath "/tmp"))
+(allow file-write* (subpath "/private/tmp"))
+(allow file-write* (subpath "${home}/.swagmanager"))
+(allow file-write* (subpath "/dev"))
+(allow file-write* (subpath "/private/var/folders"))
+`;
+}
+// ============================================================================
+// TEMP PROFILE MANAGEMENT
+// ============================================================================
+const SANDBOX_DIR = join(homedir(), ".swagmanager", "sandbox");
+let profileCounter = 0;
+function writeTempProfile(profile) {
+    if (!existsSync(SANDBOX_DIR)) {
+        mkdirSync(SANDBOX_DIR, { recursive: true });
+    }
+    const profilePath = join(SANDBOX_DIR, `profile-${process.pid}-${profileCounter++}.sb`);
+    writeFileSync(profilePath, profile, "utf-8");
+    return profilePath;
+}
+function cleanupProfile(profilePath) {
+    try {
+        if (existsSync(profilePath))
+            unlinkSync(profilePath);
+    }
+    catch { /* best effort */ }
+}
+// ============================================================================
+// SHELL ESCAPING
+// ============================================================================
+function shellEscape(s) {
+    // Use single quotes and escape any existing single quotes
+    return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+// ============================================================================
+// PUBLIC API
+// ============================================================================
+/**
+ * Wrap a command with macOS sandbox-exec.
+ * Returns the original command unchanged on non-macOS platforms.
+ */
+export function sandboxCommand(command, cwd) {
+    if (process.platform !== "darwin") {
+        return { wrapped: command, profilePath: null };
+    }
+    const profile = buildSandboxProfile(cwd);
+    const profilePath = writeTempProfile(profile);
+    const wrapped = `sandbox-exec -f ${shellEscape(profilePath)} /bin/bash -c ${shellEscape(command)}`;
+    return { wrapped, profilePath };
+}
+/**
+ * Clean up sandbox profile after command execution.
+ */
+export function cleanupSandbox(profilePath) {
+    if (profilePath)
+        cleanupProfile(profilePath);
+}
+/**
+ * Check if sandbox-exec is available on this platform.
+ */
+export function isSandboxAvailable() {
+    if (process.platform !== "darwin")
+        return false;
+    try {
+        const { execSync } = require("child_process");
+        execSync("which sandbox-exec", { stdio: "pipe", timeout: 3000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,61 @@
+/**
+ * Server Tools — loaded dynamically from ai_tool_registry
+ *
+ * Single source of truth: the database. Same as the MCP server (index.ts).
+ * No hardcoded definitions. Tools are cached for 60s after first load.
+ *
+ * Execution: proxied to the Fly.io server or Supabase edge function (mode: "tool").
+ * All business logic lives server-side — CLI is a thin client.
+ * Claude formats the JSON results for the user (no client-side formatter).
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+import type { AgentEventEmitter } from "./agent-events.js";
+import { ToolResult } from "../../shared/types.js";
+export type { ToolResult };
+interface ToolExecutionContext {
+    traceId?: string;
+    conversationId?: string;
+    userId?: string;
+    userEmail?: string;
+    source?: string;
+}
+/**
+ * Set the execution context for server tool calls.
+ * Called by agent-loop.ts before each turn so tool calls carry trace/user identity.
+ */
+export declare function setServerToolContext(ctx: ToolExecutionContext): void;
+export interface ServerStatus {
+    connected: boolean;
+    storeId: string;
+    storeName: string;
+    toolCount: number;
+    authMethod: "service_role" | "jwt" | "none";
+}
+export declare function resetServerToolClient(): void;
+export declare function checkConnection(): Promise<boolean>;
+/**
+ * Load server tool definitions from ai_tool_registry.
+ * Same query as the MCP server (index.ts). Cached for 60s.
+ * Filters out tool_mode='code' (those are local CLI tools).
+ */
+export declare function loadServerToolDefinitions(force?: boolean): Promise<Anthropic.Tool[]>;
+/**
+ * Check if a tool name is a server tool.
+ * After first load, checks against the dynamically loaded set.
+ */
+export declare function isServerTool(name: string): boolean;
+/**
+ * Get currently loaded definitions (for /tools listing).
+ * Returns whatever is cached — call loadServerToolDefinitions() first to populate.
+ */
+export declare function getAllServerToolDefinitions(): Anthropic.Tool[];
+export declare function getServerStatus(): Promise<ServerStatus>;
+/**
+ * Execute a server tool via the Fly.io server or Supabase edge function (mode: "tool").
+ * Returns the raw JSON — Claude formats it for the user.
+ * No client-side formatting: the model is the presentation layer.
+ *
+ * For tools that support live progress (kali exec), uses `mode: "tool_stream"` with NDJSON
+ * and emits `tool_output` events via the optional emitter for real-time CLI rendering.
+ */
+export declare function executeServerTool(name: string, input: Record<string, unknown>, emitter?: AgentEventEmitter): Promise<ToolResult>;