sparkecoder 0.1.3 → 0.1.5

package/dist/{index-BxpkHy7X.d.ts → index-Btr542-G.d.ts}

@@ -1,6 +1,7 @@
 import { ModelMessage, streamText } from 'ai';
-import { S as Session, f as ToolExecution } from './schema-EPbMMFza.js';
+import { S as Session, e as ToolExecution } from './schema-CkrIadxa.js';
 import { z } from 'zod';
+import { B as BashToolProgress } from './bash-CGAqW7HR.js';
 
 declare const ToolApprovalConfigSchema: z.ZodObject<{
     bash: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -228,6 +229,9 @@ interface AgentOptions {
 }
 interface AgentRunOptions {
     prompt: string;
+    abortSignal?: AbortSignal;
+    /** Skip saving user message (if already saved externally) */
+    skipSaveUserMessage?: boolean;
     onText?: (text: string) => void;
     onToolCall?: (toolCall: {
         toolCallId: string;
@@ -245,6 +249,14 @@ interface AgentRunOptions {
         toolCalls?: unknown[];
         usage?: unknown;
     }) => void;
+    onAbort?: (info: {
+        steps: unknown[];
+    }) => void;
+    /** Called when a tool (like bash) has progress to report (e.g., terminal started) */
+    onToolProgress?: (progress: {
+        toolName: string;
+        data: BashToolProgress;
+    }) => void;
 }
 interface AgentStreamResult {
     sessionId: string;
@@ -259,9 +271,13 @@ interface AgentStreamResult {
 declare class Agent {
     private session;
     private context;
-    private tools;
+    private baseTools;
     private pendingApprovals;
     private constructor();
+    /**
+     * Create tools with optional progress callbacks
+     */
+    private createToolsWithCallbacks;
     /**
      * Create or resume an agent session
      */

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-import { R as ResolvedConfig } from './index-BxpkHy7X.js';
-export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, S as SparkcoderConfig, T as ToolApprovalConfig } from './index-BxpkHy7X.js';
+import { R as ResolvedConfig } from './index-Btr542-G.js';
+export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, S as SparkcoderConfig, T as ToolApprovalConfig } from './index-Btr542-G.js';
 export { ServerOptions, createApp, startServer, stopServer } from './server/index.js';
-export { closeDatabase, getDb, initDatabase, messageQueries, sessionQueries, skillQueries, terminalQueries, todoQueries, toolExecutionQueries } from './db/index.js';
-export { a as Message, M as ModelMessage, S as Session, g as SessionConfig, T as Terminal, d as TodoItem, f as ToolExecution } from './schema-EPbMMFza.js';
-export { createBashTool, createLoadSkillTool, createReadFileTool, createTerminalTool, createTodoTool, createTools, createWriteFileTool } from './tools/index.js';
-import { EventEmitter } from 'events';
+export { checkpointQueries, closeDatabase, fileBackupQueries, getDb, initDatabase, messageQueries, sessionQueries, skillQueries, todoQueries, toolExecutionQueries } from './db/index.js';
+import { F as FileBackup, C as Checkpoint } from './schema-CkrIadxa.js';
+export { a as Message, M as ModelMessage, S as Session, b as SessionConfig, g as Terminal, T as TodoItem, e as ToolExecution } from './schema-CkrIadxa.js';
+export { createLoadSkillTool, createReadFileTool, createTodoTool, createTools, createWriteFileTool } from './tools/index.js';
+export { c as createBashTool } from './bash-CGAqW7HR.js';
 import 'ai';
 import 'zod';
 import 'hono/types';
@@ -18,90 +19,190 @@ import 'drizzle-orm/sqlite-core';
  */
 declare function loadConfig(configPath?: string, workingDirectory?: string): ResolvedConfig;
 
-interface SpawnOptions {
+/**
+ * Checkpoint system for session revert functionality
+ *
+ * Creates checkpoints before each user message, backs up modified files,
+ * and allows reverting to any previous checkpoint.
+ */
+
+interface CheckpointManager {
     sessionId: string;
-    command: string;
-    cwd?: string;
-    name?: string;
-    env?: Record<string, string>;
+    workingDirectory: string;
+    currentCheckpointId: string | null;
 }
-interface TerminalInfo {
+/**
+ * Get or create a checkpoint manager for a session
+ */
+declare function getCheckpointManager(sessionId: string, workingDirectory: string): CheckpointManager;
+/**
+ * Create a new checkpoint before processing a user message
+ * Called when a user message is about to be processed
+ */
+declare function createCheckpoint(sessionId: string, workingDirectory: string, messageSequence: number): Promise<Checkpoint>;
+/**
+ * Backup a file before it's modified
+ * Called by the write_file tool before writing
+ */
+declare function backupFile(sessionId: string, workingDirectory: string, filePath: string): Promise<FileBackup | null>;
+/**
+ * Revert a session to a specific checkpoint
+ * This will:
+ * 1. Restore all files to their state at that checkpoint
+ * 2. Delete all messages after the checkpoint's message sequence
+ * 3. Delete all tool executions after the checkpoint
+ * 4. Delete all checkpoints after this one
+ */
+declare function revertToCheckpoint(sessionId: string, checkpointId: string): Promise<{
+    success: boolean;
+    filesRestored: number;
+    filesDeleted: number;
+    messagesDeleted: number;
+    checkpointsDeleted: number;
+    error?: string;
+}>;
+/**
+ * Get all checkpoints for a session
+ */
+declare function getCheckpoints(sessionId: string): Checkpoint[];
+/**
+ * Get the diff for an entire session (all file changes from start to now)
+ */
+declare function getSessionDiff(sessionId: string): Promise<{
+    files: Array<{
+        path: string;
+        status: 'created' | 'modified' | 'deleted';
+        originalContent: string | null;
+        currentContent: string | null;
+    }>;
+}>;
+/**
+ * Clear the checkpoint manager for a session (called when session is deleted)
+ */
+declare function clearCheckpointManager(sessionId: string): void;
+
+/**
+ * tmux wrapper for terminal session management
+ *
+ * Provides a thin abstraction over tmux commands for:
+ * - Session creation and management
+ * - Output capture and logging
+ * - Process lifecycle management
+ */
+interface TerminalMeta {
     id: string;
-    name: string | null;
     command: string;
     cwd: string;
-    pid: number | null;
-    status: 'running' | 'stopped' | 'error';
-    exitCode: number | null;
-    error: string | null;
-    createdAt: Date;
-    stoppedAt: Date | null;
+    createdAt: string;
+    sessionId: string;
+    background: boolean;
 }
+interface TerminalResult {
+    id: string;
+    output: string;
+    exitCode: number;
+    status: 'completed' | 'running' | 'stopped' | 'error';
+}
+/**
+ * Check if tmux is installed and available
+ */
+declare function isTmuxAvailable(): Promise<boolean>;
 /**
- * Manages terminal processes for agent sessions
- * - Spawns background processes
- * - Captures stdout/stderr in ring buffers
- * - Tracks process lifecycle
- * - Provides log access
- */
-declare class TerminalManager extends EventEmitter {
-    private processes;
-    private static instance;
-    private constructor();
-    static getInstance(): TerminalManager;
-    /**
-     * Spawn a new background process
-     */
-    spawn(options: SpawnOptions): TerminalInfo;
-    /**
-     * Get logs from a terminal
-     */
-    getLogs(terminalId: string, tail?: number): {
-        logs: string;
-        lineCount: number;
-    } | null;
-    /**
-     * Get terminal status
-     */
-    getStatus(terminalId: string): TerminalInfo | null;
-    /**
-     * Kill a terminal process
-     */
-    kill(terminalId: string, signal?: 'SIGTERM' | 'SIGKILL'): boolean;
-    /**
-     * Write to a terminal's stdin
-     */
-    write(terminalId: string, input: string): boolean;
-    /**
-     * List all terminals for a session
-     */
-    list(sessionId: string): TerminalInfo[];
-    /**
-     * Get all running terminals for a session
-     */
-    getRunning(sessionId: string): TerminalInfo[];
-    /**
-     * Kill all terminals for a session (cleanup)
-     */
-    killAll(sessionId: string): number;
-    /**
-     * Clean up stopped terminals from memory (keep DB records)
-     */
-    cleanup(sessionId?: string): number;
-    /**
-     * Parse a command string into executable and arguments
-     */
-    private parseCommand;
-    private toTerminalInfo;
+ * Generate a unique terminal ID
+ * Ensure it starts with a letter (tmux session names work better this way)
+ */
+declare function generateTerminalId(): string;
+/**
+ * Get the tmux session name for a terminal ID
+ */
+declare function getSessionName(terminalId: string): string;
+/**
+ * Get the log directory for a terminal (session-scoped)
+ */
+declare function getLogDir(terminalId: string, workingDirectory: string, sessionId?: string): string;
+/**
+ * Run a command synchronously in tmux (waits for completion)
+ */
+declare function runSync(command: string, workingDirectory: string, options: {
+    sessionId: string;
+    timeout?: number;
+    terminalId?: string;
+}): Promise<TerminalResult>;
+/**
+ * Run a command in the background (returns immediately)
+ */
+declare function runBackground(command: string, workingDirectory: string, options: {
+    sessionId: string;
+    terminalId?: string;
+}): Promise<TerminalResult>;
+/**
+ * Get logs from a terminal
+ */
+declare function getLogs(terminalId: string, workingDirectory: string, options?: {
+    tail?: number;
+    sessionId?: string;
+}): Promise<{
+    output: string;
+    status: 'running' | 'stopped' | 'unknown';
+}>;
+/**
+ * Check if a terminal is running
+ */
+declare function isRunning(terminalId: string): Promise<boolean>;
+/**
+ * Kill a terminal session
+ */
+declare function killTerminal(terminalId: string): Promise<boolean>;
+/**
+ * List all sparkecoder terminal sessions
+ */
+declare function listSessions(): Promise<string[]>;
+/**
+ * Get metadata for a terminal
+ */
+declare function getMeta(terminalId: string, workingDirectory: string, sessionId?: string): Promise<TerminalMeta | null>;
+/**
+ * List all terminals for a session
+ */
+declare function listSessionTerminals(sessionId: string, workingDirectory: string): Promise<TerminalMeta[]>;
+/**
+ * Send input (keystrokes) to a running terminal
+ * Use this to respond to interactive prompts
+ */
+declare function sendInput(terminalId: string, input: string, options?: {
+    pressEnter?: boolean;
+}): Promise<boolean>;
+/**
+ * Send special keys to a terminal (like arrow keys, escape, etc.)
+ */
+declare function sendKey(terminalId: string, key: 'Enter' | 'Escape' | 'Up' | 'Down' | 'Left' | 'Right' | 'Tab' | 'C-c' | 'C-d' | 'y' | 'n'): Promise<boolean>;
+
+type tmux_TerminalMeta = TerminalMeta;
+type tmux_TerminalResult = TerminalResult;
+declare const tmux_generateTerminalId: typeof generateTerminalId;
+declare const tmux_getLogDir: typeof getLogDir;
+declare const tmux_getLogs: typeof getLogs;
+declare const tmux_getMeta: typeof getMeta;
+declare const tmux_getSessionName: typeof getSessionName;
+declare const tmux_isRunning: typeof isRunning;
+declare const tmux_isTmuxAvailable: typeof isTmuxAvailable;
+declare const tmux_killTerminal: typeof killTerminal;
+declare const tmux_listSessionTerminals: typeof listSessionTerminals;
+declare const tmux_listSessions: typeof listSessions;
+declare const tmux_runBackground: typeof runBackground;
+declare const tmux_runSync: typeof runSync;
+declare const tmux_sendInput: typeof sendInput;
+declare const tmux_sendKey: typeof sendKey;
+declare namespace tmux {
+  export { type tmux_TerminalMeta as TerminalMeta, type tmux_TerminalResult as TerminalResult, tmux_generateTerminalId as generateTerminalId, tmux_getLogDir as getLogDir, tmux_getLogs as getLogs, tmux_getMeta as getMeta, tmux_getSessionName as getSessionName, tmux_isRunning as isRunning, tmux_isTmuxAvailable as isTmuxAvailable, tmux_killTerminal as killTerminal, tmux_listSessionTerminals as listSessionTerminals, tmux_listSessions as listSessions, tmux_runBackground as runBackground, tmux_runSync as runSync, tmux_sendInput as sendInput, tmux_sendKey as sendKey };
 }
-declare function getTerminalManager(): TerminalManager;
 
 /**
- * Sparkecoder - A powerful coding agent CLI with HTTP API
+ * SparkECoder - A powerful coding agent CLI with HTTP API
  *
  * @packageDocumentation
  */
 
 declare const VERSION = "0.1.0";
 
-export { ResolvedConfig, type TerminalInfo, VERSION, getTerminalManager, loadConfig };
+export { Checkpoint, FileBackup, ResolvedConfig, VERSION, backupFile, clearCheckpointManager, createCheckpoint, getCheckpointManager, getCheckpoints, getSessionDiff, loadConfig, revertToCheckpoint, tmux };