sparkecoder 0.1.4 → 0.1.5

package/dist/tools/index.d.ts

@@ -32,6 +32,7 @@ declare function createReadFileTool(options: ReadFileToolOptions): ai.Tool<{
 
 interface WriteFileToolOptions {
     workingDirectory: string;
+    sessionId: string;
 }
 declare function createWriteFileTool(options: WriteFileToolOptions): ai.Tool<{
     mode: "full" | "str_replace";

package/dist/tools/index.js

@@ -37,7 +37,6 @@ async function isTmuxAvailable() {
   try {
     const { stdout } = await execAsync("tmux -V");
     tmuxAvailableCache = true;
-    console.log(`[tmux] Available: ${stdout.trim()}`);
     return true;
   } catch (error) {
     tmuxAvailableCache = false;
@@ -609,131 +608,16 @@ Use this to understand existing code, check file contents, or gather context.`,
 // src/tools/write-file.ts
 import { tool as tool3 } from "ai";
 import { z as z3 } from "zod";
-import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { resolve as resolve2, relative as relative2, isAbsolute as isAbsolute2, dirname } from "path";
-import { existsSync as existsSync3 } from "fs";
-var writeFileInputSchema = z3.object({
-  path: z3.string().describe("The path to the file. Can be relative to working directory or absolute."),
-  mode: z3.enum(["full", "str_replace"]).describe('Write mode: "full" for complete file write, "str_replace" for targeted string replacement'),
-  content: z3.string().optional().describe('For "full" mode: The complete content to write to the file'),
-  old_string: z3.string().optional().describe('For "str_replace" mode: The exact string to find and replace'),
-  new_string: z3.string().optional().describe('For "str_replace" mode: The string to replace old_string with')
-});
-function createWriteFileTool(options) {
-  return tool3({
-    description: `Write content to a file. Supports two modes:
-1. "full" - Write the entire file content (creates new file or replaces existing)
-2. "str_replace" - Replace a specific string in an existing file (for precise edits)
-
-For str_replace mode:
-- Provide the exact string to find (old_string) and its replacement (new_string)
-- The old_string must match EXACTLY (including whitespace and indentation)
-- Only the first occurrence is replaced
-- Use this for surgical edits to existing code
-
-For full mode:
-- Provide the complete file content
-- Creates parent directories if they don't exist
-- Use this for new files or complete rewrites
-
-Working directory: ${options.workingDirectory}`,
-    inputSchema: writeFileInputSchema,
-    execute: async ({ path, mode, content, old_string, new_string }) => {
-      try {
-        const absolutePath = isAbsolute2(path) ? path : resolve2(options.workingDirectory, path);
-        const relativePath = relative2(options.workingDirectory, absolutePath);
-        if (relativePath.startsWith("..") && !isAbsolute2(path)) {
-          return {
-            success: false,
-            error: "Path escapes the working directory. Use an absolute path if intentional."
-          };
-        }
-        if (mode === "full") {
-          if (content === void 0) {
-            return {
-              success: false,
-              error: 'Content is required for "full" mode'
-            };
-          }
-          const dir = dirname(absolutePath);
-          if (!existsSync3(dir)) {
-            await mkdir2(dir, { recursive: true });
-          }
-          const existed = existsSync3(absolutePath);
-          await writeFile2(absolutePath, content, "utf-8");
-          return {
-            success: true,
-            path: absolutePath,
-            relativePath: relative2(options.workingDirectory, absolutePath),
-            mode: "full",
-            action: existed ? "replaced" : "created",
-            bytesWritten: Buffer.byteLength(content, "utf-8"),
-            lineCount: content.split("\n").length
-          };
-        } else if (mode === "str_replace") {
-          if (old_string === void 0 || new_string === void 0) {
-            return {
-              success: false,
-              error: 'Both old_string and new_string are required for "str_replace" mode'
-            };
-          }
-          if (!existsSync3(absolutePath)) {
-            return {
-              success: false,
-              error: `File not found: ${path}. Use "full" mode to create new files.`
-            };
-          }
-          const currentContent = await readFile3(absolutePath, "utf-8");
-          if (!currentContent.includes(old_string)) {
-            const lines = currentContent.split("\n");
-            const preview = lines.slice(0, 20).join("\n");
-            return {
-              success: false,
-              error: "old_string not found in file. The string must match EXACTLY including whitespace.",
-              hint: "Check for differences in indentation, line endings, or invisible characters.",
-              filePreview: lines.length > 20 ? `${preview}
-... (${lines.length - 20} more lines)` : preview
-            };
-          }
-          const occurrences = currentContent.split(old_string).length - 1;
-          if (occurrences > 1) {
-            return {
-              success: false,
-              error: `Found ${occurrences} occurrences of old_string. Please provide more context to make it unique.`,
-              hint: "Include surrounding lines or more specific content in old_string."
-            };
-          }
-          const newContent = currentContent.replace(old_string, new_string);
-          await writeFile2(absolutePath, newContent, "utf-8");
-          const oldLines = old_string.split("\n").length;
-          const newLines = new_string.split("\n").length;
-          return {
-            success: true,
-            path: absolutePath,
-            relativePath: relative2(options.workingDirectory, absolutePath),
-            mode: "str_replace",
-            linesRemoved: oldLines,
-            linesAdded: newLines,
-            lineDelta: newLines - oldLines
-          };
-        }
-        return {
-          success: false,
-          error: `Invalid mode: ${mode}`
-        };
-      } catch (error) {
-        return {
-          success: false,
-          error: error.message
-        };
-      }
-    }
-  });
-}
+import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { resolve as resolve3, relative as relative3, isAbsolute as isAbsolute2, dirname as dirname2 } from "path";
+import { existsSync as existsSync4 } from "fs";
 
-// src/tools/todo.ts
-import { tool as tool4 } from "ai";
-import { z as z4 } from "zod";
+// src/checkpoints/index.ts
+import { readFile as readFile3, writeFile as writeFile2, unlink, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve2, relative as relative2, dirname } from "path";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
 
 // src/db/index.ts
 import Database from "better-sqlite3";
@@ -819,6 +703,28 @@ var activeStreams = sqliteTable("active_streams", {
   createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
   finishedAt: integer("finished_at", { mode: "timestamp" })
 });
+var checkpoints = sqliteTable("checkpoints", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  // The message sequence number this checkpoint was created BEFORE
+  // (i.e., the state before this user message was processed)
+  messageSequence: integer("message_sequence").notNull(),
+  // Optional git commit hash if in a git repo
+  gitHead: text("git_head"),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var fileBackups = sqliteTable("file_backups", {
+  id: text("id").primaryKey(),
+  checkpointId: text("checkpoint_id").notNull().references(() => checkpoints.id, { onDelete: "cascade" }),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  // Relative path from working directory
+  filePath: text("file_path").notNull(),
+  // Original content (null means file didn't exist before)
+  originalContent: text("original_content"),
+  // Whether the file existed before this checkpoint
+  existed: integer("existed", { mode: "boolean" }).notNull().default(true),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
 
 // src/db/index.ts
 var db = null;
@@ -891,8 +797,240 @@ var skillQueries = {
     return !!result;
   }
 };
+var fileBackupQueries = {
+  create(data) {
+    const id = nanoid2();
+    const result = getDb().insert(fileBackups).values({
+      id,
+      checkpointId: data.checkpointId,
+      sessionId: data.sessionId,
+      filePath: data.filePath,
+      originalContent: data.originalContent,
+      existed: data.existed,
+      createdAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getByCheckpoint(checkpointId) {
+    return getDb().select().from(fileBackups).where(eq(fileBackups.checkpointId, checkpointId)).all();
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(fileBackups).where(eq(fileBackups.sessionId, sessionId)).orderBy(fileBackups.createdAt).all();
+  },
+  /**
+   * Get all file backups from a given checkpoint sequence onwards (inclusive)
+   * (Used when reverting - need to restore these files)
+   * 
+   * When reverting to checkpoint X, we need backups from checkpoint X and all later ones
+   * because checkpoint X's backups represent the state BEFORE processing message X.
+   */
+  getFromSequence(sessionId, messageSequence) {
+    const checkpointsFrom = getDb().select().from(checkpoints).where(
+      and(
+        eq(checkpoints.sessionId, sessionId),
+        sql`message_sequence >= ${messageSequence}`
+      )
+    ).all();
+    if (checkpointsFrom.length === 0) {
+      return [];
+    }
+    const checkpointIds = checkpointsFrom.map((c) => c.id);
+    const allBackups = [];
+    for (const cpId of checkpointIds) {
+      const backups = getDb().select().from(fileBackups).where(eq(fileBackups.checkpointId, cpId)).all();
+      allBackups.push(...backups);
+    }
+    return allBackups;
+  },
+  /**
+   * Check if a file already has a backup in the current checkpoint
+   */
+  hasBackup(checkpointId, filePath) {
+    const result = getDb().select().from(fileBackups).where(
+      and(
+        eq(fileBackups.checkpointId, checkpointId),
+        eq(fileBackups.filePath, filePath)
+      )
+    ).get();
+    return !!result;
+  },
+  deleteBySession(sessionId) {
+    const result = getDb().delete(fileBackups).where(eq(fileBackups.sessionId, sessionId)).run();
+    return result.changes;
+  }
+};
+
+// src/checkpoints/index.ts
+var execAsync3 = promisify3(exec3);
+var activeManagers = /* @__PURE__ */ new Map();
+function getCheckpointManager(sessionId, workingDirectory) {
+  let manager = activeManagers.get(sessionId);
+  if (!manager) {
+    manager = {
+      sessionId,
+      workingDirectory,
+      currentCheckpointId: null
+    };
+    activeManagers.set(sessionId, manager);
+  }
+  return manager;
+}
+async function backupFile(sessionId, workingDirectory, filePath) {
+  const manager = getCheckpointManager(sessionId, workingDirectory);
+  if (!manager.currentCheckpointId) {
+    console.warn("[checkpoint] No active checkpoint, skipping file backup");
+    return null;
+  }
+  const absolutePath = resolve2(workingDirectory, filePath);
+  const relativePath = relative2(workingDirectory, absolutePath);
+  if (fileBackupQueries.hasBackup(manager.currentCheckpointId, relativePath)) {
+    return null;
+  }
+  let originalContent = null;
+  let existed = false;
+  if (existsSync3(absolutePath)) {
+    try {
+      originalContent = await readFile3(absolutePath, "utf-8");
+      existed = true;
+    } catch (error) {
+      console.warn(`[checkpoint] Failed to read file for backup: ${error.message}`);
+    }
+  }
+  const backup = fileBackupQueries.create({
+    checkpointId: manager.currentCheckpointId,
+    sessionId,
+    filePath: relativePath,
+    originalContent,
+    existed
+  });
+  return backup;
+}
+
+// src/tools/write-file.ts
+var writeFileInputSchema = z3.object({
+  path: z3.string().describe("The path to the file. Can be relative to working directory or absolute."),
+  mode: z3.enum(["full", "str_replace"]).describe('Write mode: "full" for complete file write, "str_replace" for targeted string replacement'),
+  content: z3.string().optional().describe('For "full" mode: The complete content to write to the file'),
+  old_string: z3.string().optional().describe('For "str_replace" mode: The exact string to find and replace'),
+  new_string: z3.string().optional().describe('For "str_replace" mode: The string to replace old_string with')
+});
+function createWriteFileTool(options) {
+  return tool3({
+    description: `Write content to a file. Supports two modes:
+1. "full" - Write the entire file content (creates new file or replaces existing)
+2. "str_replace" - Replace a specific string in an existing file (for precise edits)
+
+For str_replace mode:
+- Provide the exact string to find (old_string) and its replacement (new_string)
+- The old_string must match EXACTLY (including whitespace and indentation)
+- Only the first occurrence is replaced
+- Use this for surgical edits to existing code
+
+For full mode:
+- Provide the complete file content
+- Creates parent directories if they don't exist
+- Use this for new files or complete rewrites
+
+Working directory: ${options.workingDirectory}`,
+    inputSchema: writeFileInputSchema,
+    execute: async ({ path, mode, content, old_string, new_string }) => {
+      try {
+        const absolutePath = isAbsolute2(path) ? path : resolve3(options.workingDirectory, path);
+        const relativePath = relative3(options.workingDirectory, absolutePath);
+        if (relativePath.startsWith("..") && !isAbsolute2(path)) {
+          return {
+            success: false,
+            error: "Path escapes the working directory. Use an absolute path if intentional."
+          };
+        }
+        if (mode === "full") {
+          if (content === void 0) {
+            return {
+              success: false,
+              error: 'Content is required for "full" mode'
+            };
+          }
+          await backupFile(options.sessionId, options.workingDirectory, absolutePath);
+          const dir = dirname2(absolutePath);
+          if (!existsSync4(dir)) {
+            await mkdir3(dir, { recursive: true });
+          }
+          const existed = existsSync4(absolutePath);
+          await writeFile3(absolutePath, content, "utf-8");
+          return {
+            success: true,
+            path: absolutePath,
+            relativePath: relative3(options.workingDirectory, absolutePath),
+            mode: "full",
+            action: existed ? "replaced" : "created",
+            bytesWritten: Buffer.byteLength(content, "utf-8"),
+            lineCount: content.split("\n").length
+          };
+        } else if (mode === "str_replace") {
+          if (old_string === void 0 || new_string === void 0) {
+            return {
+              success: false,
+              error: 'Both old_string and new_string are required for "str_replace" mode'
+            };
+          }
+          if (!existsSync4(absolutePath)) {
+            return {
+              success: false,
+              error: `File not found: ${path}. Use "full" mode to create new files.`
+            };
+          }
+          await backupFile(options.sessionId, options.workingDirectory, absolutePath);
+          const currentContent = await readFile4(absolutePath, "utf-8");
+          if (!currentContent.includes(old_string)) {
+            const lines = currentContent.split("\n");
+            const preview = lines.slice(0, 20).join("\n");
+            return {
+              success: false,
+              error: "old_string not found in file. The string must match EXACTLY including whitespace.",
+              hint: "Check for differences in indentation, line endings, or invisible characters.",
+              filePreview: lines.length > 20 ? `${preview}
+... (${lines.length - 20} more lines)` : preview
+            };
+          }
+          const occurrences = currentContent.split(old_string).length - 1;
+          if (occurrences > 1) {
+            return {
+              success: false,
+              error: `Found ${occurrences} occurrences of old_string. Please provide more context to make it unique.`,
+              hint: "Include surrounding lines or more specific content in old_string."
+            };
+          }
+          const newContent = currentContent.replace(old_string, new_string);
+          await writeFile3(absolutePath, newContent, "utf-8");
+          const oldLines = old_string.split("\n").length;
+          const newLines = new_string.split("\n").length;
+          return {
+            success: true,
+            path: absolutePath,
+            relativePath: relative3(options.workingDirectory, absolutePath),
+            mode: "str_replace",
+            linesRemoved: oldLines,
+            linesAdded: newLines,
+            lineDelta: newLines - oldLines
+          };
+        }
+        return {
+          success: false,
+          error: `Invalid mode: ${mode}`
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
+}
 
 // src/tools/todo.ts
+import { tool as tool4 } from "ai";
+import { z as z4 } from "zod";
 var todoInputSchema = z4.object({
   action: z4.enum(["add", "list", "mark", "clear"]).describe("The action to perform on the todo list"),
   items: z4.array(
@@ -1020,9 +1158,9 @@ import { tool as tool5 } from "ai";
 import { z as z6 } from "zod";
 
 // src/skills/index.ts
-import { readFile as readFile4, readdir } from "fs/promises";
-import { resolve as resolve3, basename, extname } from "path";
-import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile5, readdir } from "fs/promises";
+import { resolve as resolve4, basename, extname } from "path";
+import { existsSync as existsSync5 } from "fs";
 
 // src/config/types.ts
 import { z as z5 } from "zod";
@@ -1108,15 +1246,15 @@ function getSkillNameFromPath(filePath) {
   return basename(filePath, extname(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
 async function loadSkillsFromDirectory(directory) {
-  if (!existsSync4(directory)) {
+  if (!existsSync5(directory)) {
     return [];
   }
   const skills = [];
   const files = await readdir(directory);
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const filePath = resolve3(directory, file);
-    const content = await readFile4(filePath, "utf-8");
+    const filePath = resolve4(directory, file);
+    const content = await readFile5(filePath, "utf-8");
     const parsed = parseSkillFrontmatter(content);
     if (parsed) {
       skills.push({
@@ -1158,7 +1296,7 @@ async function loadSkillContent(skillName, directories) {
   if (!skill) {
     return null;
   }
-  const content = await readFile4(skill.filePath, "utf-8");
+  const content = await readFile5(skill.filePath, "utf-8");
   const parsed = parseSkillFrontmatter(content);
   return {
     ...skill,
@@ -1269,7 +1407,8 @@ function createTools(options) {
       workingDirectory: options.workingDirectory
     }),
     write_file: createWriteFileTool({
-      workingDirectory: options.workingDirectory
+      workingDirectory: options.workingDirectory,
+      sessionId: options.sessionId
     }),
     todo: createTodoTool({
       sessionId: options.sessionId