gent-cli 6.0.1 → 8.0.0

package/src/utils/diff-engine.js

@@ -22,6 +22,14 @@
  *   - Move up (i-1) → DELETE (line only in old version)
  *   - Move left (j-1) → INSERT (line only in new version)
  *
+ * COMMON PREFIX/SUFFIX TRIMMING (optimization):
+ *   Before building the O(M×N) matrix, identical leading and trailing lines are
+ *   stripped. Only the differing "middle" is run through LCS; the trimmed lines
+ *   are re-attached as `equal` ops with their original 1-based positions. For
+ *   the common case of a localized edit in a large file this turns an O(M×N)
+ *   matrix into something proportional to the size of the change — a large
+ *   memory and time win — while producing byte-identical output.
+ *
  * 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.
@@ -63,12 +71,14 @@ function buildLcsMatrix(a, b) {
 }
 
 /**
- * Backtrack LCS matrix → line operations.
+ * Backtrack the LCS matrix of two line arrays → line operations with
+ * 1-based positions local to the given arrays. Pure O(M×N) core; callers
+ * normally use buildLineOperations, which trims common prefix/suffix first.
  * @param {String[]} oldLines
  * @param {String[]} newLines
  * @returns {Array<{type: 'equal'|'insert'|'delete', oldLine: number, newLine: number, content: String}>}
  */
-function buildLineOperations(oldLines, newLines) {
+function lcsOperations(oldLines, newLines) {
     const matrix = buildLcsMatrix(oldLines, newLines);
     const ops = [];
     let i = oldLines.length;
@@ -90,6 +100,61 @@ function buildLineOperations(oldLines, newLines) {
     return ops.reverse();
 }
 
+/**
+ * Diff two line arrays into operations, trimming common prefix/suffix before
+ * running LCS on the differing middle. Output is identical to running LCS on
+ * the full arrays, with `oldLine`/`newLine` as absolute 1-based positions.
+ * @param {String[]} oldLines
+ * @param {String[]} newLines
+ * @returns {Array<{type: 'equal'|'insert'|'delete', oldLine: number, newLine: number, content: String}>}
+ */
+function buildLineOperations(oldLines, newLines) {
+    const oldLen = oldLines.length;
+    const newLen = newLines.length;
+    const minLen = Math.min(oldLen, newLen);
+
+    // Common leading lines.
+    let prefix = 0;
+    while (prefix < minLen && oldLines[prefix] === newLines[prefix]) prefix++;
+
+    // Common trailing lines (not overlapping the prefix).
+    let suffix = 0;
+    while (
+        suffix < minLen - prefix &&
+        oldLines[oldLen - 1 - suffix] === newLines[newLen - 1 - suffix]
+    ) suffix++;
+
+    const ops = [];
+
+    // Prefix → equal ops at their original positions.
+    for (let k = 0; k < prefix; k++) {
+        ops.push({ type: 'equal', oldLine: k + 1, newLine: k + 1, content: oldLines[k] });
+    }
+
+    // Middle → LCS, shifted back into absolute coordinates by `prefix`.
+    const oldMid = oldLines.slice(prefix, oldLen - suffix);
+    const newMid = newLines.slice(prefix, newLen - suffix);
+    if (oldMid.length || newMid.length) {
+        for (const op of lcsOperations(oldMid, newMid)) {
+            ops.push({
+                type: op.type,
+                oldLine: op.oldLine + prefix,
+                newLine: op.newLine + prefix,
+                content: op.content
+            });
+        }
+    }
+
+    // Suffix → equal ops at their original positions.
+    for (let k = 0; k < suffix; k++) {
+        const oldIdx = oldLen - suffix + k;
+        const newIdx = newLen - suffix + k;
+        ops.push({ type: 'equal', oldLine: oldIdx + 1, newLine: newIdx + 1, content: oldLines[oldIdx] });
+    }
+
+    return ops;
+}
+
 /**
  * Diff two texts → operations + stats.
  * @param {String} oldText
@@ -229,6 +294,7 @@ module.exports = {
     diffText,
     summarizeOperations,
     buildLcsMatrix,
+    lcsOperations,
     buildLineOperations,
     generateHunks,
     formatUnifiedDiff,

package/src/utils/env-loader.js

@@ -0,0 +1,61 @@
+/**
+ * Env Loader - Load .env files into process.env before commands run.
+ *
+ * Precedence (lower wins — does NOT clobber existing env):
+ *   1. process.env (real shell vars)            ← highest, untouched
+ *   2. <cwd>/.env                                ← project-local
+ *   3. ~/.gent/.env                              ← user-global
+ *
+ * No new dependency: a tiny KEY=VALUE parser (supports quoted values + comments).
+ * Silently no-ops if files are missing or malformed.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { GENT_DIR } = require('./constants');
+
+function parse(content) {
+    const out = {};
+    const lines = content.split(/\r?\n/);
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line || line.startsWith('#')) continue;
+        const eq = line.indexOf('=');
+        if (eq < 1) continue;
+        const key = line.slice(0, eq).trim();
+        let value = line.slice(eq + 1).trim();
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
+
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        } else {
+            const hash = value.indexOf(' #');
+            if (hash !== -1) value = value.slice(0, hash).trim();
+        }
+        out[key] = value;
+    }
+    return out;
+}
+
+function loadOne(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const parsed = parse(content);
+        for (const [k, v] of Object.entries(parsed)) {
+            if (process.env[k] === undefined) {
+                process.env[k] = v;
+            }
+        }
+    } catch {
+        // Missing or unreadable — fine.
+    }
+}
+
+function load() {
+    loadOne(path.join(process.cwd(), '.env'));
+    loadOne(path.join(os.homedir(), GENT_DIR, '.env'));
+}
+
+module.exports = { load, parse };

package/src/utils/journal.js

@@ -0,0 +1,215 @@
+/**
+ * ============================================================================
+ * Operation Journal - Safety net for history-changing commands
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   Record every history-changing operation (commit, merge, reset, checkout,
+ *   branch delete, pull) so it can be reversed with a single `gent undo` and
+ *   re-applied with `gent redo`. Friendlier and more discoverable than
+ *   `git reflog`: a human-readable list and one-command undo.
+ *
+ * WHAT IS RECORDED:
+ *   Before an operation mutates `commits.json`, `recordOp()` snapshots the
+ *   parts that change — the `branches` map and `currentBranch`. That snapshot
+ *   plus a label/description/timestamp becomes one journal entry.
+ *
+ * UNDO SEMANTICS (intentionally non-destructive):
+ *   - `gent undo` restores branch pointers + current branch to their state
+ *     before the last operation.
+ *   - Working files are NEVER deleted. For operations that discard file
+ *     content (reset --hard, fast-forward merge, pull) the entry is flagged
+ *     `restoreTree`, and undo also rewrites those files from the object store.
+ *     For commit / checkout / branch-delete, undo leaves the working tree
+ *     as-is — a just-committed change simply becomes uncommitted again.
+ *   - `gent redo` re-applies the last undone operation. Any new history-
+ *     changing operation clears the redo stack.
+ *
+ * STORAGE:
+ *   .gent/journal.json → { entries: [...], redo: [...] }
+ *   History is capped to the most recent MAX_ENTRIES operations.
+ *
+ * ============================================================================
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { readJSON, writeJSON, pathExists } = require('./fileSystem');
+const { COMMITS_FILE, STAGING_FILE } = require('./constants');
+const { readBlobAsString } = require('./hash-engine');
+
+const JOURNAL_FILE = 'journal.json';
+const MAX_ENTRIES = 100;
+
+// ─── Persistence ────────────────────────────────────────
+
+async function readJournal(gentPath) {
+    const p = path.join(gentPath, JOURNAL_FILE);
+    if (!await pathExists(p)) return { entries: [], redo: [] };
+    try {
+        const j = await readJSON(p);
+        return { entries: j.entries || [], redo: j.redo || [] };
+    } catch {
+        return { entries: [], redo: [] };
+    }
+}
+
+async function writeJournal(gentPath, journal) {
+    await writeJSON(path.join(gentPath, JOURNAL_FILE), journal);
+}
+
+// ─── Helpers ────────────────────────────────────────────
+
+function snapshotState(repository) {
+    return {
+        branches: { ...(repository.branches || {}) },
+        currentBranch: repository.currentBranch || 'main'
+    };
+}
+
+function makeId() {
+    return Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+}
+
+/** Resolve a commit's tree entries (supports legacy `files` shape). */
+function treeOf(commits, hash) {
+    if (!hash) return [];
+    const c = (commits || []).find(x => x.hash === hash);
+    if (!c) return [];
+    if (Array.isArray(c.tree)) return c.tree;
+    return (c.files || []).map(f => ({ mode: '100644', name: f.path || f.name, hash: f.hash, type: 'blob' }));
+}
+
+/** Overwrite/create working files from a tree (never deletes). */
+async function restoreFiles(gentPath, cwd, tree) {
+    for (const e of tree) {
+        try {
+            const content = await readBlobAsString(gentPath, e.hash);
+            const full = path.join(cwd, e.name);
+            await fs.mkdir(path.dirname(full), { recursive: true });
+            await fs.writeFile(full, content, 'utf-8');
+        } catch {
+            // Blob may be missing for legacy commits — best effort.
+        }
+    }
+}
+
+async function clearStaging(gentPath) {
+    await writeJSON(path.join(gentPath, STAGING_FILE), { entries: [], files: [], mergeState: null });
+}
+
+// ─── Public API ─────────────────────────────────────────
+
+/**
+ * Record the pre-operation state. Call this BEFORE the command writes
+ * commits.json. Journaling must never break the underlying command, so all
+ * failures are swallowed.
+ * @param {String} gentPath
+ * @param {String} op - short op label (commit|merge|reset|checkout|branch-delete|pull)
+ * @param {String} description - human-readable detail
+ * @param {Object} [meta] - e.g. { restoreTree: true }
+ */
+async function recordOp(gentPath, op, description, meta = {}) {
+    try {
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+        const journal = await readJournal(gentPath);
+        journal.entries.push({
+            id: makeId(),
+            op,
+            description: description || '',
+            timestamp: new Date().toISOString(),
+            meta,
+            state: snapshotState(repository)
+        });
+        if (journal.entries.length > MAX_ENTRIES) {
+            journal.entries = journal.entries.slice(-MAX_ENTRIES);
+        }
+        journal.redo = []; // a fresh action invalidates the redo stack
+        await writeJournal(gentPath, journal);
+    } catch {
+        // Never let journaling failures surface to the user.
+    }
+}
+
+/** Return journal entries, most-recent first. */
+async function listEntries(gentPath) {
+    const journal = await readJournal(gentPath);
+    return [...journal.entries].reverse();
+}
+
+/**
+ * Restore commits.json pointers + (optionally) working tree to `targetState`.
+ * Shared by undo and redo.
+ */
+async function applyState(gentPath, cwd, repository, commits, targetState, restoreTree) {
+    repository.branches = { ...targetState.branches };
+    repository.currentBranch = targetState.currentBranch;
+    await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+
+    if (restoreTree) {
+        const head = targetState.branches[targetState.currentBranch];
+        await restoreFiles(gentPath, cwd, treeOf(commits, head));
+    }
+    await clearStaging(gentPath);
+}
+
+/**
+ * Reverse the last recorded operation.
+ * @returns {Promise<{ok: Boolean, reason?: String, entry?: Object, head?: String, branch?: String}>}
+ */
+async function applyUndo(gentPath, cwd) {
+    const journal = await readJournal(gentPath);
+    if (journal.entries.length === 0) return { ok: false, reason: 'nothing-to-undo' };
+
+    const entry = journal.entries.pop();
+    const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+    const commits = repository.commits || [];
+
+    // Remember the post-operation state so `redo` can re-apply it.
+    const postState = snapshotState(repository);
+    journal.redo.push({ ...entry, state: postState });
+
+    await applyState(gentPath, cwd, repository, commits, entry.state, !!(entry.meta && entry.meta.restoreTree));
+    await writeJournal(gentPath, journal);
+
+    return {
+        ok: true,
+        entry,
+        branch: entry.state.currentBranch,
+        head: entry.state.branches[entry.state.currentBranch] || null
+    };
+}
+
+/**
+ * Re-apply the last undone operation.
+ * @returns {Promise<{ok: Boolean, reason?: String, entry?: Object, head?: String, branch?: String}>}
+ */
+async function applyRedo(gentPath, cwd) {
+    const journal = await readJournal(gentPath);
+    if (journal.redo.length === 0) return { ok: false, reason: 'nothing-to-redo' };
+
+    const entry = journal.redo.pop();
+    const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+    const commits = repository.commits || [];
+
+    const preState = snapshotState(repository);
+    journal.entries.push({ ...entry, state: preState });
+
+    await applyState(gentPath, cwd, repository, commits, entry.state, !!(entry.meta && entry.meta.restoreTree));
+    await writeJournal(gentPath, journal);
+
+    return {
+        ok: true,
+        entry,
+        branch: entry.state.currentBranch,
+        head: entry.state.branches[entry.state.currentBranch] || null
+    };
+}
+
+module.exports = {
+    recordOp,
+    listEntries,
+    applyUndo,
+    applyRedo,
+    readJournal
+};