gent-cli 2.0.0 → 5.0.0

package/src/utils/diff-engine.js

@@ -0,0 +1,236 @@
+/**
+ * ============================================================================
+ * Diff Engine - Line-level LCS diff with hunk generation and unified format
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   Compute minimal edit scripts between two text files, classify each line
+ *   as insert / delete / equal, generate unified diff output.
+ *
+ * ALGORITHM: Longest Common Subsequence (LCS)
+ *   - Build M×N dynamic programming matrix where M,N = line counts
+ *   - dp[i][j] = length of LCS of first i lines of A and first j lines of B
+ *   - Recurrence:
+ *       if A[i] == B[j]:  dp[i][j] = dp[i-1][j-1] + 1
+ *       else:             dp[i][j] = max(dp[i-1][j], dp[i][j-1])
+ *   - Backtrack from dp[M][N] to produce edit operations
+ *   - Time: O(M*N), Space: O(M*N) — uses Uint32Array for memory efficiency
+ *
+ * INSERTION/DELETION CLASSIFICATION:
+ *   During backtrack:
+ *   - A[i]==B[j] → EQUAL (line unchanged)
+ *   - Move up (i-1) → DELETE (line only in old version)
+ *   - Move left (j-1) → INSERT (line only in new version)
+ *
+ * HUNK GENERATION:
+ *   Groups adjacent changes with N context lines (default 3) into hunks.
+ *   Changes within 2*N+1 lines of each other merge into one hunk.
+ *   Output format matches unified diff:
+ *     @@ -oldStart,oldCount +newStart,newCount @@
+ *
+ * BACKEND EXPECTATIONS:
+ *   Diffs are computed locally. Backend does NOT need diff support.
+ *   Backend stores blob objects; clients compute diffs on demand.
+ *
+ * ============================================================================
+ */
+
+const { splitLines } = require('./hash-engine');
+
+// ─── Core LCS / Diff ────────────────────────────────────
+
+/**
+ * Build LCS length matrix.
+ * @param {String[]} a
+ * @param {String[]} b
+ * @returns {Array<Uint32Array>}
+ */
+function buildLcsMatrix(a, b) {
+    const rows = a.length + 1;
+    const cols = b.length + 1;
+    const matrix = Array.from({ length: rows }, () => new Uint32Array(cols));
+
+    for (let i = 1; i < rows; i++) {
+        for (let j = 1; j < cols; j++) {
+            if (a[i - 1] === b[j - 1]) {
+                matrix[i][j] = matrix[i - 1][j - 1] + 1;
+            } else {
+                matrix[i][j] = Math.max(matrix[i - 1][j], matrix[i][j - 1]);
+            }
+        }
+    }
+    return matrix;
+}
+
+/**
+ * Backtrack LCS matrix → line operations.
+ * @param {String[]} oldLines
+ * @param {String[]} newLines
+ * @returns {Array<{type: 'equal'|'insert'|'delete', oldLine: number, newLine: number, content: String}>}
+ */
+function buildLineOperations(oldLines, newLines) {
+    const matrix = buildLcsMatrix(oldLines, newLines);
+    const ops = [];
+    let i = oldLines.length;
+    let j = newLines.length;
+
+    while (i > 0 || j > 0) {
+        if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+            ops.push({ type: 'equal', oldLine: i, newLine: j, content: oldLines[i - 1] });
+            i--; j--;
+        } else if (j > 0 && (i === 0 || matrix[i][j - 1] >= matrix[i - 1][j])) {
+            ops.push({ type: 'insert', oldLine: i, newLine: j, content: newLines[j - 1] });
+            j--;
+        } else {
+            ops.push({ type: 'delete', oldLine: i, newLine: j, content: oldLines[i - 1] });
+            i--;
+        }
+    }
+
+    return ops.reverse();
+}
+
+/**
+ * Diff two texts → operations + stats.
+ * @param {String} oldText
+ * @param {String} newText
+ * @returns {{ algorithm: string, operations: Array, stats: Object }}
+ */
+function diffText(oldText, newText) {
+    const oldLines = splitLines(oldText);
+    const newLines = splitLines(newText);
+    const operations = buildLineOperations(oldLines, newLines);
+    const stats = summarizeOperations(operations);
+    return { algorithm: 'lcs-line-v1', operations, stats };
+}
+
+/**
+ * Count insert/delete/equal ops.
+ * @param {Array} operations
+ * @returns {{insertions, deletions, unchanged, changes}}
+ */
+function summarizeOperations(operations) {
+    let insertions = 0, deletions = 0, unchanged = 0;
+    for (const op of operations) {
+        if (op.type === 'insert') insertions++;
+        else if (op.type === 'delete') deletions++;
+        else unchanged++;
+    }
+    return { insertions, deletions, unchanged, changes: insertions + deletions };
+}
+
+// ─── Hunk Generation ────────────────────────────────────
+
+/**
+ * Group diff ops into hunks with context lines (like git diff).
+ * @param {Array} ops - From buildLineOperations
+ * @param {Number} contextLines - Context around changes (default 3)
+ * @returns {Array<{oldStart, oldCount, newStart, newCount, lines: String[]}>}
+ */
+function generateHunks(ops, contextLines = 3) {
+    const changeIndices = [];
+    for (let i = 0; i < ops.length; i++) {
+        if (ops[i].type !== 'equal') changeIndices.push(i);
+    }
+    if (changeIndices.length === 0) return [];
+
+    // Group changes within contextLines*2 of each other
+    const groups = [];
+    let group = [changeIndices[0]];
+    for (let i = 1; i < changeIndices.length; i++) {
+        if (changeIndices[i] - changeIndices[i - 1] <= contextLines * 2 + 1) {
+            group.push(changeIndices[i]);
+        } else {
+            groups.push(group);
+            group = [changeIndices[i]];
+        }
+    }
+    groups.push(group);
+
+    const hunks = [];
+    for (const g of groups) {
+        const first = g[0];
+        const last = g[g.length - 1];
+        const start = Math.max(0, first - contextLines);
+        const end = Math.min(ops.length - 1, last + contextLines);
+
+        let oldLine = 0, newLine = 0;
+        for (let i = 0; i < start; i++) {
+            if (ops[i].type === 'equal' || ops[i].type === 'delete') oldLine++;
+            if (ops[i].type === 'equal' || ops[i].type === 'insert') newLine++;
+        }
+
+        const hunkOldStart = oldLine + 1;
+        const hunkNewStart = newLine + 1;
+        let hunkOldCount = 0, hunkNewCount = 0;
+        const lines = [];
+
+        for (let i = start; i <= end; i++) {
+            const op = ops[i];
+            if (op.type === 'equal') {
+                lines.push(` ${op.content}`);
+                hunkOldCount++; hunkNewCount++;
+            } else if (op.type === 'delete') {
+                lines.push(`-${op.content}`);
+                hunkOldCount++;
+            } else {
+                lines.push(`+${op.content}`);
+                hunkNewCount++;
+            }
+        }
+
+        hunks.push({ oldStart: hunkOldStart, oldCount: hunkOldCount, newStart: hunkNewStart, newCount: hunkNewCount, lines });
+    }
+    return hunks;
+}
+
+// ─── Unified Diff Format ────────────────────────────────
+
+/**
+ * Format as unified diff string (like `git diff`).
+ * @param {String} filePath
+ * @param {String} oldText
+ * @param {String} newText
+ * @returns {String}
+ */
+function formatUnifiedDiff(filePath, oldText, newText) {
+    const oldLines = splitLines(oldText);
+    const newLines = splitLines(newText);
+    const ops = buildLineOperations(oldLines, newLines);
+    const hunks = generateHunks(ops);
+    if (hunks.length === 0) return '';
+
+    const out = [`--- a/${filePath}`, `+++ b/${filePath}`];
+    for (const h of hunks) {
+        out.push(`@@ -${h.oldStart},${h.oldCount} +${h.newStart},${h.newCount} @@`);
+        out.push(...h.lines);
+    }
+    return out.join('\n');
+}
+
+// ─── Patch Application ──────────────────────────────────
+
+/**
+ * Apply operations to reconstruct target from source.
+ * @param {Array} ops
+ * @returns {String[]} Reconstructed lines
+ */
+function applyOperations(ops) {
+    const result = [];
+    for (const op of ops) {
+        if (op.type === 'equal' || op.type === 'insert') {
+            result.push(op.content);
+        }
+    }
+    return result;
+}
+
+module.exports = {
+    diffText,
+    summarizeOperations,
+    buildLcsMatrix,
+    buildLineOperations,
+    generateHunks,
+    formatUnifiedDiff,
+    applyOperations
+};

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, OBJECTS_DIR } = require('./constants');
+const { GENT_DIR, DEFAULT_IGNORE_PATTERNS, IGNORE_FILE } = require('./constants');
 
 /**
  * Check if a path exists
@@ -113,31 +113,23 @@ async function getAllFiles(dir, ignorePatterns = []) {
  */
 function shouldIgnore(filePath, patterns) {
     const normalizedPath = filePath.replace(/\\/g, '/');
-    const segments = normalizedPath.split('/');
 
     for (const pattern of patterns) {
-        const normalizedPattern = pattern.replace(/\/$/, '');
-
-        // Check if any segment matches the pattern (for directory-level ignores like node_modules)
-        if (segments.some(segment => segment === normalizedPattern)) {
-            return true;
-        }
-
-        // Exact match or starts with pattern
-        if (normalizedPath === normalizedPattern || normalizedPath.startsWith(normalizedPattern + '/')) {
+        // Exact match
+        if (normalizedPath === pattern || normalizedPath.startsWith(pattern + '/')) {
             return true;
         }
 
         // Wildcard match
-        if (normalizedPattern.includes('*')) {
-            const regex = new RegExp('^' + normalizedPattern.replace(/\*/g, '.*') + '$');
+        if (pattern.includes('*')) {
+            const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
             if (regex.test(normalizedPath)) {
                 return true;
             }
         }
 
         // Extension match
-        if (normalizedPattern.startsWith('*.') && normalizedPath.endsWith(normalizedPattern.substring(1))) {
+        if (pattern.startsWith('*.') && normalizedPath.endsWith(pattern.substring(1))) {
             return true;
         }
     }
@@ -178,53 +170,11 @@ async function getTrackedFiles(gentPath, commitHash) {
     }
 
     const repository = await readJSON(path.join(gentPath, 'commits.json'));
-    const commit = repository.commits.find(c => c.sha === commitHash);
+    const commit = repository.commits.find(c => c.hash === 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,
@@ -234,7 +184,5 @@ module.exports = {
     getAllFiles,
     shouldIgnore,
     getIgnorePatterns,
-    getTrackedFiles,
-    saveBlob,
-    getBlob
+    getTrackedFiles
 };

package/src/utils/hash-engine.js

@@ -0,0 +1,337 @@
+/**
+ * ============================================================================
+ * Hash Engine - Content-Addressable Object Store
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   Git-like blob/tree storage using SHA-256 content addressing.
+ *   Files are stored once (deduplicated) and retrieved by hash.
+ *
+ * STORAGE LAYOUT:
+ *   .gent/objects/<2-char-prefix>/<remaining-hash>
+ *   Example: .gent/objects/ab/cdef1234567890...
+ *
+ * OBJECT FORMAT (on disk):
+ *   zlib-compressed( "<type> <size>\0<content>" )
+ *   Where type = "blob" | "tree"
+ *
+ * HASHING ALGORITHMS:
+ *   1. SHA-256 (crypto.createHash) — for content-addressable storage
+ *      Same approach as git but uses SHA-256 instead of SHA-1.
+ *      Input: type header + null byte + raw content
+ *      Output: 64-char hex string
+ *
+ *   2. FNV-1a 32-bit — for fast line-level fingerprinting
+ *      Used by diff engine to quickly compare lines.
+ *      Non-cryptographic, optimized for speed over collision resistance.
+ *
+ * DEDUPLICATION:
+ *   Before writing, check if object file exists → skip if so.
+ *   Identical content always produces same hash → automatic dedup.
+ *
+ * COMPRESSION:
+ *   zlib.deflate before write, zlib.inflate on read.
+ *   Typically 60-80% size reduction for text files.
+ *
+ * BACKEND EXPECTATIONS:
+ *   Backend should implement equivalent object store:
+ *   - POST /api/repos/:id/push/ receives base64-encoded blobs
+ *   - Backend computes same SHA-256 hash to verify integrity
+ *   - Store in DB or filesystem with same addressing scheme
+ *   - GET /api/repos/:id/pull/ returns base64 blob data
+ *
+ * ============================================================================
+ */
+
+const crypto = require('crypto');
+const fs = require('fs').promises;
+const path = require('path');
+const zlib = require('zlib');
+const { promisify } = require('util');
+
+const deflate = promisify(zlib.deflate);
+const inflate = promisify(zlib.inflate);
+
+// ─── Primitive Hashing ───────────────────────────────────
+
+/**
+ * SHA-256 hash of raw input.
+ * @param {Buffer|String} input
+ * @returns {String}
+ */
+function sha256(input) {
+    return crypto.createHash('sha256').update(input).digest('hex');
+}
+
+/**
+ * FNV-1a 32-bit fast non-crypto hash for line tracking.
+ * @param {String} value
+ * @returns {String}
+ */
+function fnv1a32(value) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < value.length; i++) {
+        hash ^= value.charCodeAt(i);
+        hash = (hash >>> 0) * 0x01000193;
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+
+/**
+ * Hash each line of text.
+ * @param {String} text
+ * @returns {Array<{ lineNumber: number, hash: string }>}
+ */
+function hashLines(text) {
+    const lines = splitLines(text);
+    return lines.map((line, index) => ({
+        lineNumber: index + 1,
+        hash: fnv1a32(line)
+    }));
+}
+
+/**
+ * Split text into lines (normalizes CRLF).
+ * @param {String} text
+ * @returns {Array<String>}
+ */
+function splitLines(text) {
+    if (!text) return [];
+    return text.replace(/\r\n/g, '\n').split('\n');
+}
+
+/**
+ * Check if buffer looks binary (contains null bytes).
+ * @param {Buffer} buffer
+ * @returns {Boolean}
+ */
+function isBinaryBuffer(buffer) {
+    const probeLength = Math.min(buffer.length, 8000);
+    for (let i = 0; i < probeLength; i++) {
+        if (buffer[i] === 0) return true;
+    }
+    return false;
+}
+
+// ─── Content-Addressable Object Hashing ──────────────────
+
+/**
+ * Hash content with type prefix: "<type> <size>\0<content>"
+ * @param {String} type - 'blob' | 'tree'
+ * @param {Buffer|String} content
+ * @returns {String} SHA-256 hex
+ */
+function hashObject(type, content) {
+    const buf = Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf-8');
+    const header = `${type} ${buf.length}\0`;
+    const store = Buffer.concat([Buffer.from(header), buf]);
+    return crypto.createHash('sha256').update(store).digest('hex');
+}
+
+/**
+ * Hash content as blob.
+ * @param {Buffer|String} content
+ * @returns {String}
+ */
+function hashBlob(content) {
+    return hashObject('blob', content);
+}
+
+/**
+ * Hash a tree structure.
+ * @param {Array<{mode: String, name: String, hash: String, type: String}>} entries
+ * @returns {String}
+ */
+function hashTree(entries) {
+    return hashObject('tree', serializeTree(entries));
+}
+
+// ─── Object Store (disk read/write) ─────────────────────
+
+/**
+ * Filesystem path for object: objects/ab/cdef1234...
+ */
+function objectPath(gentPath, hash) {
+    return path.join(gentPath, 'objects', hash.substring(0, 2), hash.substring(2));
+}
+
+/**
+ * Check if object exists in store.
+ * @param {String} gentPath
+ * @param {String} hash
+ * @returns {Promise<Boolean>}
+ */
+async function objectExists(gentPath, hash) {
+    try {
+        await fs.access(objectPath(gentPath, hash));
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Store blob (file content). Compressed with zlib. Deduplicates.
+ * @param {String} gentPath
+ * @param {Buffer|String} content
+ * @returns {Promise<String>} hash
+ */
+async function storeBlob(gentPath, content) {
+    const buf = Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf-8');
+    const hash = hashBlob(buf);
+
+    if (await objectExists(gentPath, hash)) return hash;
+
+    const header = `blob ${buf.length}\0`;
+    const store = Buffer.concat([Buffer.from(header), buf]);
+    const compressed = await deflate(store);
+
+    const objPath = objectPath(gentPath, hash);
+    await fs.mkdir(path.dirname(objPath), { recursive: true });
+    await fs.writeFile(objPath, compressed);
+
+    return hash;
+}
+
+/**
+ * Read blob raw content from store.
+ * @param {String} gentPath
+ * @param {String} hash
+ * @returns {Promise<Buffer>}
+ */
+async function readBlob(gentPath, hash) {
+    const objPath = objectPath(gentPath, hash);
+    const compressed = await fs.readFile(objPath);
+    const raw = await inflate(compressed);
+    const nullIndex = raw.indexOf(0);
+    return raw.slice(nullIndex + 1);
+}
+
+/**
+ * Read blob as UTF-8 string.
+ * @param {String} gentPath
+ * @param {String} hash
+ * @returns {Promise<String>}
+ */
+async function readBlobAsString(gentPath, hash) {
+    const buf = await readBlob(gentPath, hash);
+    return buf.toString('utf-8');
+}
+
+// ─── Tree Objects ────────────────────────────────────────
+
+/**
+ * Serialize tree entries to deterministic JSON (sorted by name).
+ */
+function serializeTree(entries) {
+    const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+    return JSON.stringify(sorted);
+}
+
+/**
+ * Deserialize tree JSON.
+ */
+function deserializeTree(data) {
+    return JSON.parse(data);
+}
+
+/**
+ * Store tree object. Entry: { mode, name, hash, type }
+ * @param {String} gentPath
+ * @param {Array} entries
+ * @returns {Promise<String>} tree hash
+ */
+async function storeTree(gentPath, entries) {
+    const serialized = serializeTree(entries);
+    const hash = hashObject('tree', serialized);
+
+    if (await objectExists(gentPath, hash)) return hash;
+
+    const header = `tree ${Buffer.byteLength(serialized)}\0`;
+    const store = Buffer.concat([Buffer.from(header), Buffer.from(serialized)]);
+    const compressed = await deflate(store);
+
+    const objPath = objectPath(gentPath, hash);
+    await fs.mkdir(path.dirname(objPath), { recursive: true });
+    await fs.writeFile(objPath, compressed);
+
+    return hash;
+}
+
+/**
+ * Read tree entries from store.
+ * @param {String} gentPath
+ * @param {String} hash
+ * @returns {Promise<Array>}
+ */
+async function readTree(gentPath, hash) {
+    const buf = await readBlob(gentPath, hash);
+    return deserializeTree(buf.toString('utf-8'));
+}
+
+// ─── Snapshot Helpers ────────────────────────────────────
+
+/**
+ * Snapshot single file → store blob, return tree entry.
+ * @param {String} gentPath
+ * @param {String} cwd
+ * @param {String} relativePath
+ * @returns {Promise<{mode, name, hash, type}>}
+ */
+async function snapshotFile(gentPath, cwd, relativePath) {
+    const fullPath = path.join(cwd, relativePath);
+    const content = await fs.readFile(fullPath);
+    const hash = await storeBlob(gentPath, content);
+    return { mode: '100644', name: relativePath, hash, type: 'blob' };
+}
+
+/**
+ * Snapshot multiple files → store blobs + tree.
+ * @param {String} gentPath
+ * @param {String} cwd
+ * @param {Array<String>} files
+ * @returns {Promise<{treeHash: String, entries: Array}>}
+ */
+async function snapshotFiles(gentPath, cwd, files) {
+    const entries = [];
+    for (const file of files) {
+        const entry = await snapshotFile(gentPath, cwd, file);
+        entries.push(entry);
+    }
+    const treeHash = await storeTree(gentPath, entries);
+    return { treeHash, entries };
+}
+
+/**
+ * Build lookup map: filePath → blobHash from tree entries.
+ * @param {Array} entries
+ * @returns {Map<String, String>}
+ */
+function treeToMap(entries) {
+    const map = new Map();
+    for (const e of entries) map.set(e.name, e.hash);
+    return map;
+}
+
+module.exports = {
+    // Primitives
+    sha256,
+    fnv1a32,
+    hashLines,
+    splitLines,
+    isBinaryBuffer,
+    // Content-addressable
+    hashObject,
+    hashBlob,
+    hashTree,
+    objectExists,
+    storeBlob,
+    readBlob,
+    readBlobAsString,
+    storeTree,
+    readTree,
+    // Snapshots
+    snapshotFile,
+    snapshotFiles,
+    treeToMap
+};