amai 0.0.4 → 0.0.5

package/dist/cli.cjs

@@ -9,6 +9,7 @@ var promises = require('fs/promises');
 var path9 = require('path');
 var fs3 = require('fs');
 var os2 = require('os');
+var crypto = require('crypto');
 var child_process = require('child_process');
 var util = require('util');
 var hono = require('hono');
@@ -612,15 +613,133 @@ function calculateDiffStats(oldContent, newContent) {
   }
   return { linesAdded, linesRemoved };
 }
-
-// src/tools/apply-patch.ts
+var CheckpointStore = class {
+  checkpoints = /* @__PURE__ */ new Map();
+  fileCheckpoints = /* @__PURE__ */ new Map();
+  // filePath -> checkpointIds
+  /**
+   * Compute SHA-256 hash of content
+   */
+  computeHash(content) {
+    return crypto.createHash("sha256").update(content, "utf8").digest("hex");
+  }
+  /**
+   * Create a new checkpoint before an edit operation
+   */
+  createCheckpoint(id, filePath, beforeContent, afterContent) {
+    const checkpoint = {
+      id,
+      filePath,
+      beforeContent,
+      afterContent,
+      beforeHash: this.computeHash(beforeContent),
+      afterHash: this.computeHash(afterContent),
+      timestamp: Date.now()
+    };
+    this.checkpoints.set(id, checkpoint);
+    const fileCheckpointIds = this.fileCheckpoints.get(filePath) || [];
+    fileCheckpointIds.push(id);
+    this.fileCheckpoints.set(filePath, fileCheckpointIds);
+    return checkpoint;
+  }
+  /**
+   * Get a checkpoint by ID
+   */
+  getCheckpoint(id) {
+    return this.checkpoints.get(id);
+  }
+  /**
+   * Get all checkpoints for a file (ordered by timestamp)
+   */
+  getCheckpointsForFile(filePath) {
+    const ids = this.fileCheckpoints.get(filePath) || [];
+    return ids.map((id) => this.checkpoints.get(id)).filter((cp) => cp !== void 0).sort((a, b) => a.timestamp - b.timestamp);
+  }
+  /**
+   * Verify if current file content matches expected state
+   * Returns true if safe to revert
+   */
+  verifyFileState(checkpointId, currentContent) {
+    const checkpoint = this.checkpoints.get(checkpointId);
+    if (!checkpoint) {
+      return {
+        safe: false,
+        reason: "Checkpoint not found"
+      };
+    }
+    const currentHash = this.computeHash(currentContent);
+    if (currentHash === checkpoint.afterHash) {
+      return {
+        safe: true,
+        checkpoint,
+        currentHash
+      };
+    }
+    if (currentHash === checkpoint.beforeHash) {
+      return {
+        safe: false,
+        reason: "File appears to already be reverted",
+        checkpoint,
+        currentHash
+      };
+    }
+    return {
+      safe: false,
+      reason: "File was modified after this edit. Current content does not match expected state.",
+      checkpoint,
+      currentHash
+    };
+  }
+  /**
+   * Remove a checkpoint after successful revert or accept
+   */
+  removeCheckpoint(id) {
+    const checkpoint = this.checkpoints.get(id);
+    if (!checkpoint) return false;
+    this.checkpoints.delete(id);
+    const fileCheckpointIds = this.fileCheckpoints.get(checkpoint.filePath);
+    if (fileCheckpointIds) {
+      const filtered = fileCheckpointIds.filter((cpId) => cpId !== id);
+      if (filtered.length === 0) {
+        this.fileCheckpoints.delete(checkpoint.filePath);
+      } else {
+        this.fileCheckpoints.set(checkpoint.filePath, filtered);
+      }
+    }
+    return true;
+  }
+  /**
+   * Get all checkpoints (for debugging/listing)
+   */
+  getAllCheckpoints() {
+    return Array.from(this.checkpoints.values()).sort((a, b) => b.timestamp - a.timestamp);
+  }
+  /**
+   * Clear all checkpoints (for cleanup)
+   */
+  clear() {
+    this.checkpoints.clear();
+    this.fileCheckpoints.clear();
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      totalCheckpoints: this.checkpoints.size,
+      filesTracked: this.fileCheckpoints.size
+    };
+  }
+};
+var checkpointStore = new CheckpointStore();
 zod.z.object({
   file_path: zod.z.string().describe("The path to the file you want to search and replace in. You can use either a relative path in the workspace or an absolute path. If an absolute path is provided, it will be preserved as is"),
   new_string: zod.z.string().describe("The edited text to replace the old_string (must be different from the old_string)"),
-  old_string: zod.z.string().describe("The text to replace (must be unique within the file, and must match the file contents exactly, including all whitespace and indentation)")
+  old_string: zod.z.string().describe("The text to replace (must be unique within the file, and must match the file contents exactly, including all whitespace and indentation)"),
+  toolCallId: zod.z.string().optional().describe("Optional tool call ID for checkpoint tracking")
 });
 var apply_patch = async function(input, projectCwd) {
-  const { file_path, new_string, old_string } = input;
+  const { file_path, new_string, old_string, toolCallId } = input;
   try {
     if (!file_path) {
       return {
@@ -695,6 +814,13 @@ var apply_patch = async function(input, projectCwd) {
       };
     }
     const newContent = fileContent.replace(old_string, new_string);
+    const checkpointId = toolCallId || crypto.randomUUID();
+    const checkpoint = checkpointStore.createCheckpoint(
+      checkpointId,
+      absolute_file_path,
+      fileContent,
+      newContent
+    );
     try {
       await promises.writeFile(absolute_file_path, newContent, "utf-8");
       const diffStats = calculateDiffStats(fileContent, newContent);
@@ -704,9 +830,14 @@ var apply_patch = async function(input, projectCwd) {
         new_string,
         linesAdded: diffStats.linesAdded,
         linesRemoved: diffStats.linesRemoved,
-        message: `Successfully replaced string in file: ${file_path}`
+        message: `Successfully replaced string in file: ${file_path}`,
+        // Include checkpoint info for frontend
+        checkpointId: checkpoint.id,
+        beforeHash: checkpoint.beforeHash,
+        afterHash: checkpoint.afterHash
       };
     } catch (error) {
+      checkpointStore.removeCheckpoint(checkpointId);
       return {
         success: false,
         message: `Failed to write to file: ${file_path}`,
@@ -724,10 +855,11 @@ var apply_patch = async function(input, projectCwd) {
 zod.z.object({
   target_file: zod.z.string().describe("The relative path to the file to modify. The tool will create any directories in the path that don't exist"),
   content: zod.z.string().describe("The content to write to the file"),
-  providedNewFile: zod.z.boolean().describe("The new file content to write to the file").optional()
+  providedNewFile: zod.z.boolean().describe("The new file content to write to the file").optional(),
+  toolCallId: zod.z.string().optional().describe("Optional tool call ID for checkpoint tracking")
 });
 var editFiles = async function(input, projectCwd) {
-  const { target_file, content, providedNewFile } = input;
+  const { target_file, content, providedNewFile, toolCallId } = input;
   try {
     if (projectCwd) {
       const validation = validatePath(target_file, projectCwd);
@@ -759,7 +891,19 @@ var editFiles = async function(input, projectCwd) {
         isNewFile = true;
       }
     }
-    await fs3__default.default.promises.writeFile(filePath, content);
+    const checkpointId = toolCallId || crypto.randomUUID();
+    const checkpoint = checkpointStore.createCheckpoint(
+      checkpointId,
+      filePath,
+      existingContent,
+      content
+    );
+    try {
+      await fs3__default.default.promises.writeFile(filePath, content);
+    } catch (writeError) {
+      checkpointStore.removeCheckpoint(checkpointId);
+      throw writeError;
+    }
     const diffStats = calculateDiffStats(existingContent, content);
     if (isNewFile) {
       return {
@@ -769,7 +913,11 @@ var editFiles = async function(input, projectCwd) {
         new_string: content,
         message: `Created new file: ${target_file}`,
         linesAdded: diffStats.linesAdded,
-        linesRemoved: diffStats.linesRemoved
+        linesRemoved: diffStats.linesRemoved,
+        // Include checkpoint info for frontend
+        checkpointId: checkpoint.id,
+        beforeHash: checkpoint.beforeHash,
+        afterHash: checkpoint.afterHash
       };
     } else {
       return {
@@ -779,7 +927,11 @@ var editFiles = async function(input, projectCwd) {
         new_string: content,
         message: `Modified file: ${target_file}`,
         linesAdded: diffStats.linesAdded,
-        linesRemoved: diffStats.linesRemoved
+        linesRemoved: diffStats.linesRemoved,
+        // Include checkpoint info for frontend
+        checkpointId: checkpoint.id,
+        beforeHash: checkpoint.beforeHash,
+        afterHash: checkpoint.afterHash
       };
     }
   } catch (error) {
@@ -1335,7 +1487,15 @@ var startHttpServer = (connection) => {
   });
   app.post("/revert", async (c) => {
     try {
-      const { filePath, oldString, newString, projectCwd } = await c.req.json();
+      const {
+        filePath,
+        oldString,
+        newString,
+        projectCwd,
+        checkpointId,
+        expectedAfterHash,
+        force = false
+      } = await c.req.json();
       if (!filePath || oldString === void 0) {
         return c.json({ error: "filePath and oldString required" }, 400);
       }
@@ -1359,25 +1519,127 @@ var startHttpServer = (connection) => {
         }
         return c.json({ error: `Failed to read file: ${error.message}` }, 500);
       }
+      if (checkpointId) {
+        const verification = checkpointStore.verifyFileState(checkpointId, currentContent);
+        if (!verification.safe && !force) {
+          return c.json({
+            success: false,
+            conflict: true,
+            error: verification.reason,
+            currentHash: verification.currentHash,
+            expectedHash: verification.checkpoint?.afterHash,
+            checkpointId
+          }, 409);
+        }
+        if (verification.checkpoint) {
+          try {
+            await promises.writeFile(resolved, verification.checkpoint.beforeContent, "utf-8");
+            checkpointStore.removeCheckpoint(checkpointId);
+            return c.json({ success: true, usedCheckpoint: true });
+          } catch (writeError) {
+            return c.json({ error: `Failed to write file: ${writeError.message}` }, 500);
+          }
+        }
+      }
+      if (expectedAfterHash && !force) {
+        const currentHash = checkpointStore.computeHash(currentContent);
+        if (currentHash !== expectedAfterHash) {
+          return c.json({
+            success: false,
+            conflict: true,
+            error: "File was modified after this edit. Current content does not match expected state.",
+            currentHash,
+            expectedHash: expectedAfterHash
+          }, 409);
+        }
+      }
       let finalContent;
       if (newString && newString !== oldString) {
         if (!currentContent.includes(newString)) {
-          return c.json({ error: "Cannot revert: the new content is not found in the current file. The file may have been modified." }, 400);
+          return c.json({
+            success: false,
+            conflict: true,
+            error: "Cannot revert: the new content is not found in the current file. The file may have been modified."
+          }, 409);
         }
         const occurrences = currentContent.split(newString).length - 1;
         if (occurrences > 1) {
-          return c.json({ error: "Cannot revert: the new content appears multiple times in the file" }, 400);
+          return c.json({
+            success: false,
+            conflict: true,
+            error: "Cannot revert: the new content appears multiple times in the file"
+          }, 409);
         }
         finalContent = currentContent.replace(newString, oldString);
       } else {
         finalContent = oldString;
       }
       await promises.writeFile(resolved, finalContent, "utf-8");
+      if (checkpointId) {
+        checkpointStore.removeCheckpoint(checkpointId);
+      }
       return c.json({ success: true });
     } catch (error) {
       return c.json({ error: error.message }, 500);
     }
   });
+  app.post("/revert/force", async (c) => {
+    try {
+      const { filePath, checkpointId, projectCwd } = await c.req.json();
+      if (!checkpointId) {
+        return c.json({ error: "checkpointId is required for force revert" }, 400);
+      }
+      const checkpoint = checkpointStore.getCheckpoint(checkpointId);
+      if (!checkpoint) {
+        return c.json({ error: "Checkpoint not found" }, 404);
+      }
+      let resolved;
+      if (projectCwd) {
+        resolved = path9__default.default.isAbsolute(filePath || checkpoint.filePath) ? filePath || checkpoint.filePath : path9__default.default.resolve(projectCwd, filePath || checkpoint.filePath);
+        const normalizedResolved = path9__default.default.normalize(resolved);
+        const normalizedCwd = path9__default.default.normalize(projectCwd);
+        if (!normalizedResolved.startsWith(normalizedCwd)) {
+          return c.json({ error: "Path is outside project directory" }, 403);
+        }
+      } else {
+        resolved = checkpoint.filePath;
+      }
+      try {
+        await promises.writeFile(resolved, checkpoint.beforeContent, "utf-8");
+        checkpointStore.removeCheckpoint(checkpointId);
+        return c.json({ success: true, forced: true });
+      } catch (writeError) {
+        return c.json({ error: `Failed to write file: ${writeError.message}` }, 500);
+      }
+    } catch (error) {
+      return c.json({ error: error.message }, 500);
+    }
+  });
+  app.get("/checkpoints/:checkpointId", (c) => {
+    const checkpointId = c.req.param("checkpointId");
+    const checkpoint = checkpointStore.getCheckpoint(checkpointId);
+    if (!checkpoint) {
+      return c.json({ error: "Checkpoint not found" }, 404);
+    }
+    return c.json({
+      id: checkpoint.id,
+      filePath: checkpoint.filePath,
+      beforeHash: checkpoint.beforeHash,
+      afterHash: checkpoint.afterHash,
+      timestamp: checkpoint.timestamp
+    });
+  });
+  app.get("/checkpoints", (c) => {
+    const stats = checkpointStore.getStats();
+    const checkpoints = checkpointStore.getAllCheckpoints().map((cp) => ({
+      id: cp.id,
+      filePath: cp.filePath,
+      beforeHash: cp.beforeHash,
+      afterHash: cp.afterHash,
+      timestamp: cp.timestamp
+    }));
+    return c.json({ stats, checkpoints });
+  });
   app.get("/projects", (c) => {
     const projects = projectRegistry.list();
     return c.json({ projects });
@@ -1895,7 +2157,7 @@ function getDaemonPid() {
     return null;
   }
 }
-var VERSION = "0.0.4";
+var VERSION = "0.0.5";
 var PROJECT_DIR = process.cwd();
 function promptUser(question) {
   const rl = readline__default.default.createInterface({