gent-cli 1.6.0 → 1.7.0

package/src/utils/diff.js

@@ -0,0 +1,121 @@
+/**
+ * Myers Diff Algorithm Implementation
+ * Calculates the difference between two sequences of text
+ */
+
+/**
+ * Compare two strings and return the differences using Myers algorithm
+ * @param {String} oldText - The original text
+ * @param {String} newText - The new text
+ * @returns {Array} Array of changes [{ type: 'equal'|'insert'|'delete', value: string }]
+ */
+function computeDiff(oldText, newText) {
+    // Split into lines for line-by-line diff
+    const oldLines = oldText.split('\n');
+    const newLines = newText.split('\n');
+
+    // If both are empty or identical
+    if (oldText === newText) {
+        return oldLines.map(line => ({ type: 'equal', value: line }));
+    }
+
+    const path = exploreEditGraph(oldLines, newLines);
+    return backtrack(path, oldLines, newLines);
+}
+
+/**
+ * Explore the edit graph to find the shortest path (shortest edit script)
+ * @param {Array} oldLines 
+ * @param {Array} newLines 
+ * @returns {Array} Trace of the path
+ */
+function exploreEditGraph(oldLines, newLines) {
+    const n = oldLines.length;
+    const m = newLines.length;
+    const max = n + m;
+
+    // v array stores the x-coordinate of the furthest reaching D-path
+    // using object/map to handle negative indices (-max to +max)
+    const v = { 1: 0 };
+    const trace = [];
+
+    for (let d = 0; d <= max; d++) {
+        trace.push({ ...v });
+
+        for (let k = -d; k <= d; k += 2) {
+            let x;
+
+            // Choose move: down (insertion) or right (deletion)
+            if (k === -d || (k !== d && (v[k - 1] || 0) < (v[k + 1] || 0))) {
+                x = v[k + 1] || 0; // Move down
+            } else {
+                x = (v[k - 1] || 0) + 1; // Move right
+            }
+
+            let y = x - k;
+
+            // Follow diagonal (equal lines)
+            while (x < n && y < m && oldLines[x] === newLines[y]) {
+                x++;
+                y++;
+            }
+
+            v[k] = x;
+
+            if (x >= n && y >= m) {
+                return trace;
+            }
+        }
+    }
+    return trace;
+}
+
+/**
+ * Backtrack from the end to generate the diff
+ * @param {Array} trace 
+ * @param {Array} oldLines 
+ * @param {Array} newLines 
+ * @returns {Array}
+ */
+function backtrack(trace, oldLines, newLines) {
+    let x = oldLines.length;
+    let y = newLines.length;
+    const diff = [];
+
+    for (let d = trace.length - 1; d >= 0; d--) {
+        const v = trace[d];
+        const k = x - y;
+
+        let prevK;
+        if (k === -d || (k !== d && (v[k - 1] || 0) < (v[k + 1] || 0))) {
+            prevK = k + 1;
+        } else {
+            prevK = k - 1;
+        }
+
+        const prevX = v[prevK] || 0;
+        const prevY = prevX - prevK;
+
+        while (x > prevX && y > prevY) {
+            diff.unshift({ type: 'equal', value: oldLines[x - 1] });
+            x--;
+            y--;
+        }
+
+        if (d > 0) {
+            if (x === prevX) {
+                diff.unshift({ type: 'insert', value: newLines[y - 1] });
+                y--;
+            } else {
+                diff.unshift({ type: 'delete', value: oldLines[x - 1] });
+                x--;
+            }
+        }
+    }
+
+    return diff;
+}
+
+module.exports = {
+    computeDiff
+};

package/src/utils/fileSystem.js

@@ -5,7 +5,7 @@
 
 const fs = require('fs').promises;
 const path = require('path');
-const { GENT_DIR, DEFAULT_IGNORE_PATTERNS, IGNORE_FILE } = require('./constants');
+const { GENT_DIR, DEFAULT_IGNORE_PATTERNS, IGNORE_FILE, OBJECTS_DIR } = require('./constants');
 
 /**
  * Check if a path exists
@@ -175,6 +175,48 @@ async function getTrackedFiles(gentPath, commitHash) {
     return commit ? commit.files : [];
 }
 
+/**
+ * Get path to the objects directory
+ * @returns {Promise<String>}
+ */
+async function getObjectsPath() {
+    const gentPath = await getGentPath();
+    const objectsPath = path.join(gentPath, OBJECTS_DIR);
+    await ensureDir(objectsPath);
+    return objectsPath;
+}
+
+/**
+ * Save file content as a blob
+ * @param {String} content - File content
+ * @param {String} hash - Content hash
+ */
+async function saveBlob(content, hash) {
+    const objectsPath = await getObjectsPath();
+    const blobPath = path.join(objectsPath, hash);
+
+    // Only write if it doesn't exist (content-addressable, immutable)
+    if (!await pathExists(blobPath)) {
+        await fs.writeFile(blobPath, content, 'utf-8');
+    }
+}
+
+/**
+ * Get file content from blob
+ * @param {String} hash - Content hash
+ * @returns {Promise<String>}
+ */
+async function getBlob(hash) {
+    const objectsPath = await getObjectsPath();
+    const blobPath = path.join(objectsPath, hash);
+
+    if (!await pathExists(blobPath)) {
+        return ''; // Return empty string if blob missing (shouldn't happen in healthy repo)
+    }
+
+    return fs.readFile(blobPath, 'utf-8');
+}
+
 module.exports = {
     pathExists,
     ensureDir,
@@ -184,5 +226,7 @@ module.exports = {
     getAllFiles,
     shouldIgnore,
     getIgnorePatterns,
-    getTrackedFiles
+    getTrackedFiles,
+    saveBlob,
+    getBlob
 };