sparkecoder 0.1.4 → 0.1.5

package/dist/agent/index.d.ts

@@ -1,6 +1,6 @@
 import 'ai';
-import '../schema-cUDLVN-b.js';
-export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, C as ContextManager, d as buildSystemPrompt } from '../index-DkR9Ln_7.js';
+import '../schema-CkrIadxa.js';
+export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, C as ContextManager, d as buildSystemPrompt } from '../index-Btr542-G.js';
 import '../bash-CGAqW7HR.js';
 import 'drizzle-orm/sqlite-core';
 import 'zod';

package/dist/agent/index.js

@@ -93,6 +93,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;
@@ -202,6 +224,19 @@ var messageQueries = {
   deleteBySession(sessionId) {
     const result = getDb().delete(messages).where(eq(messages.sessionId, sessionId)).run();
     return result.changes;
+  },
+  /**
+   * Delete all messages with sequence >= the given sequence number
+   * (Used when reverting to a checkpoint)
+   */
+  deleteFromSequence(sessionId, fromSequence) {
+    const result = getDb().delete(messages).where(
+      and(
+        eq(messages.sessionId, sessionId),
+        sql`sequence >= ${fromSequence}`
+      )
+    ).run();
+    return result.changes;
   }
 };
 var toolExecutionQueries = {
@@ -245,6 +280,19 @@ var toolExecutionQueries = {
   },
   getBySession(sessionId) {
     return getDb().select().from(toolExecutions).where(eq(toolExecutions.sessionId, sessionId)).orderBy(toolExecutions.startedAt).all();
+  },
+  /**
+   * Delete all tool executions after a given timestamp
+   * (Used when reverting to a checkpoint)
+   */
+  deleteAfterTime(sessionId, afterTime) {
+    const result = getDb().delete(toolExecutions).where(
+      and(
+        eq(toolExecutions.sessionId, sessionId),
+        sql`started_at > ${afterTime.getTime()}`
+      )
+    ).run();
+    return result.changes;
   }
 };
 var todoQueries = {
@@ -310,6 +358,68 @@ var skillQueries = {
     return !!result;
   }
 };
+var fileBackupQueries = {
+  create(data) {
+    const id = nanoid();
+    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/config/index.ts
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
@@ -445,7 +555,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;
@@ -1017,9 +1126,62 @@ 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 z4 } from "zod";
-import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { resolve as resolve3, relative as relative2, isAbsolute as isAbsolute2, dirname as dirname2 } from "path";
+import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { resolve as resolve4, relative as relative3, isAbsolute as isAbsolute2, dirname as dirname3 } from "path";
+import { existsSync as existsSync5 } from "fs";
+
+// src/checkpoints/index.ts
+import { readFile as readFile3, writeFile as writeFile2, unlink, mkdir as mkdir2 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve3, relative as relative2, dirname as dirname2 } from "path";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+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 = resolve3(workingDirectory, filePath);
+  const relativePath = relative2(workingDirectory, absolutePath);
+  if (fileBackupQueries.hasBackup(manager.currentCheckpointId, relativePath)) {
+    return null;
+  }
+  let originalContent = null;
+  let existed = false;
+  if (existsSync4(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 = z4.object({
   path: z4.string().describe("The path to the file. Can be relative to working directory or absolute."),
   mode: z4.enum(["full", "str_replace"]).describe('Write mode: "full" for complete file write, "str_replace" for targeted string replacement'),
@@ -1048,8 +1210,8 @@ 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 = relative2(options.workingDirectory, absolutePath);
+        const absolutePath = isAbsolute2(path) ? path : resolve4(options.workingDirectory, path);
+        const relativePath = relative3(options.workingDirectory, absolutePath);
         if (relativePath.startsWith("..") && !isAbsolute2(path)) {
           return {
             success: false,
@@ -1063,16 +1225,17 @@ Working directory: ${options.workingDirectory}`,
               error: 'Content is required for "full" mode'
             };
           }
-          const dir = dirname2(absolutePath);
-          if (!existsSync4(dir)) {
-            await mkdir2(dir, { recursive: true });
+          await backupFile(options.sessionId, options.workingDirectory, absolutePath);
+          const dir = dirname3(absolutePath);
+          if (!existsSync5(dir)) {
+            await mkdir3(dir, { recursive: true });
           }
-          const existed = existsSync4(absolutePath);
-          await writeFile2(absolutePath, content, "utf-8");
+          const existed = existsSync5(absolutePath);
+          await writeFile3(absolutePath, content, "utf-8");
           return {
             success: true,
             path: absolutePath,
-            relativePath: relative2(options.workingDirectory, absolutePath),
+            relativePath: relative3(options.workingDirectory, absolutePath),
             mode: "full",
             action: existed ? "replaced" : "created",
             bytesWritten: Buffer.byteLength(content, "utf-8"),
@@ -1085,13 +1248,14 @@ Working directory: ${options.workingDirectory}`,
               error: 'Both old_string and new_string are required for "str_replace" mode'
             };
           }
-          if (!existsSync4(absolutePath)) {
+          if (!existsSync5(absolutePath)) {
             return {
               success: false,
               error: `File not found: ${path}. Use "full" mode to create new files.`
             };
           }
-          const currentContent = await readFile3(absolutePath, "utf-8");
+          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");
@@ -1112,13 +1276,13 @@ Working directory: ${options.workingDirectory}`,
             };
           }
           const newContent = currentContent.replace(old_string, new_string);
-          await writeFile2(absolutePath, newContent, "utf-8");
+          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: relative2(options.workingDirectory, absolutePath),
+            relativePath: relative3(options.workingDirectory, absolutePath),
             mode: "str_replace",
             linesRemoved: oldLines,
             linesAdded: newLines,
@@ -1269,9 +1433,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 resolve4, basename, extname } from "path";
-import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile5, readdir } from "fs/promises";
+import { resolve as resolve5, basename, extname } from "path";
+import { existsSync as existsSync6 } from "fs";
 function parseSkillFrontmatter(content) {
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!frontmatterMatch) {
@@ -1302,15 +1466,15 @@ function getSkillNameFromPath(filePath) {
   return basename(filePath, extname(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
 async function loadSkillsFromDirectory(directory) {
-  if (!existsSync5(directory)) {
+  if (!existsSync6(directory)) {
     return [];
   }
   const skills = [];
   const files = await readdir(directory);
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const filePath = resolve4(directory, file);
-    const content = await readFile4(filePath, "utf-8");
+    const filePath = resolve5(directory, file);
+    const content = await readFile5(filePath, "utf-8");
     const parsed = parseSkillFrontmatter(content);
     if (parsed) {
       skills.push({
@@ -1352,7 +1516,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,
@@ -1463,7 +1627,8 @@ function createTools(options) {
       workingDirectory: options.workingDirectory
     }),
     write_file: createWriteFileTool({
-      workingDirectory: options.workingDirectory
+      workingDirectory: options.workingDirectory,
+      sessionId: options.sessionId
     }),
     todo: createTodoTool({
       sessionId: options.sessionId
@@ -1521,6 +1686,9 @@ You have access to powerful tools for:
 - **todo**: Manage your task list to track progress on complex operations
 - **load_skill**: Load specialized knowledge documents for specific tasks
 
+
+IMPORTANT: If you have zero context of where you are working, always explore it first to understand the structure before doing things for the user.
+
 Use the TODO tool to manage your task list to track progress on complex operations. Always ask the user what they want to do specifically before doing it, and make a plan. 
 Step 1 of the plan should be researching files and understanding the components/structure of what you're working on (if you don't already have context), then after u have done that, plan out the rest of the tasks u need to do. 
 You can clear the todo and restart it, and do multiple things inside of one session.
@@ -1957,8 +2125,8 @@ var Agent = class _Agent {
           this.pendingApprovals.set(toolCallId, execution);
           options.onApprovalRequired?.(execution);
           sessionQueries.updateStatus(this.session.id, "waiting");
-          const approved = await new Promise((resolve5) => {
-            approvalResolvers.set(toolCallId, { resolve: resolve5, sessionId: this.session.id });
+          const approved = await new Promise((resolve6) => {
+            approvalResolvers.set(toolCallId, { resolve: resolve6, sessionId: this.session.id });
           });
           const resolverData = approvalResolvers.get(toolCallId);
           approvalResolvers.delete(toolCallId);