@currentjs/gen 0.1.1

package/dist/utils/generationRegistry.js

@@ -0,0 +1,192 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initGenerationRegistry = initGenerationRegistry;
+exports.computeContentHash = computeContentHash;
+exports.loadRegistry = loadRegistry;
+exports.saveRegistry = saveRegistry;
+exports.getStoredHash = getStoredHash;
+exports.updateStoredHash = updateStoredHash;
+exports.updateStoredHunks = updateStoredHunks;
+exports.writeGeneratedFile = writeGeneratedFile;
+exports.ensureCommitsDir = ensureCommitsDir;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const constants_1 = require("./constants");
+const crypto = __importStar(require("crypto"));
+const readline = __importStar(require("readline"));
+const commitUtils_1 = require("./commitUtils");
+const colors_1 = require("./colors");
+let projectRootDir = null;
+function initGenerationRegistry(rootDir) {
+    projectRootDir = rootDir;
+}
+function getRegistryFilePath() {
+    if (!projectRootDir) {
+        throw new Error('Generation registry is not initialized. Call initGenerationRegistry(rootDir) first.');
+    }
+    // Store at project root as registry.json
+    return path.join(projectRootDir, constants_1.COMMON_FILES.REGISTRY_JSON);
+}
+function computeContentHash(contents) {
+    return crypto.createHash('sha256').update(contents).digest('hex');
+}
+function loadRegistry() {
+    const file = getRegistryFilePath();
+    if (!fs.existsSync(file))
+        return {};
+    try {
+        const raw = fs.readFileSync(file, 'utf8');
+        const data = JSON.parse(raw);
+        return data || {};
+    }
+    catch {
+        return {};
+    }
+}
+function saveRegistry(data) {
+    const file = getRegistryFilePath();
+    fs.writeFileSync(file, JSON.stringify(data, null, 2));
+}
+function getStoredHash(filePath) {
+    var _a, _b, _c;
+    const registry = loadRegistry();
+    const root = projectRootDir || process.cwd();
+    const abs = path.resolve(filePath);
+    const rel = path.relative(root, abs);
+    // Prefer relative key; fall back to absolute for backward compatibility
+    return (_b = (_a = registry[rel]) === null || _a === void 0 ? void 0 : _a.hash) !== null && _b !== void 0 ? _b : (_c = registry[abs]) === null || _c === void 0 ? void 0 : _c.hash;
+}
+function updateStoredHash(filePath, hash) {
+    const registry = loadRegistry();
+    const root = projectRootDir || process.cwd();
+    const abs = path.resolve(filePath);
+    const rel = path.relative(root, abs);
+    // Write only relative key
+    const prev = registry[rel] || {};
+    registry[rel] = { ...prev, hash, updatedAt: new Date().toISOString() };
+    // Clean old absolute key if present
+    if (registry[abs]) {
+        delete registry[abs];
+    }
+    saveRegistry(registry);
+}
+function updateStoredHunks(filePath, hunks, baseHash, resultHash) {
+    const registry = loadRegistry();
+    const root = projectRootDir || process.cwd();
+    const abs = path.resolve(filePath);
+    const rel = path.relative(root, abs);
+    const prev = registry[rel] || {};
+    registry[rel] = {
+        ...prev,
+        diffFormat: 'hunks-v1',
+        diffHunks: hunks,
+        diffBaseHash: baseHash,
+        diffResultHash: resultHash,
+        diffUpdatedAt: new Date().toISOString()
+    };
+    // cleanup old absolute key if present
+    if (registry[abs])
+        delete registry[abs];
+    saveRegistry(registry);
+}
+async function promptYesNo(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise(resolve => rl.question(`${question} [y/N]: `, resolve));
+    rl.close();
+    return ['y', 'yes'].includes(answer.trim().toLowerCase());
+}
+async function writeGeneratedFile(filePath, contents, options) {
+    const force = (options === null || options === void 0 ? void 0 : options.force) === true;
+    const silent = (options === null || options === void 0 ? void 0 : options.silent) === true;
+    const skipOnConflict = (options === null || options === void 0 ? void 0 : options.skipOnConflict) === true;
+    const abs = path.resolve(filePath);
+    const newHash = computeContentHash(contents);
+    const exists = fs.existsSync(abs);
+    if (!exists) {
+        fs.mkdirSync(path.dirname(abs), { recursive: true });
+        fs.writeFileSync(abs, contents);
+        updateStoredHash(abs, newHash);
+        if (!silent)
+            console.log(colors_1.colors.blue(`[V] Generated ${path.relative(projectRootDir || process.cwd(), abs)}`));
+        return 'written';
+    }
+    const storedHash = getStoredHash(abs);
+    const currentContent = fs.readFileSync(abs, 'utf8');
+    const currentHash = computeContentHash(currentContent);
+    if (currentHash === newHash) {
+        // Nothing to do
+        return 'unchanged';
+    }
+    // If we have a stored hash and it matches current, safe to overwrite
+    const isUserModified = !storedHash || storedHash !== currentHash;
+    if (isUserModified && !force) {
+        const rel = path.relative(projectRootDir || process.cwd(), abs);
+        // Try commits auto-apply path
+        const applied = (0, commitUtils_1.tryApplyCommitsToGenerated)(abs, contents);
+        if (applied.applied) {
+            fs.writeFileSync(abs, applied.content);
+            updateStoredHash(abs, computeContentHash(applied.content));
+            if (!silent)
+                console.log(colors_1.colors.cyan(`Updated (with commits) ${rel}`));
+            return 'written';
+        }
+        if (skipOnConflict) {
+            if (!silent)
+                console.log(colors_1.colors.yellow(`Skipped ${rel}`));
+            return 'skipped';
+        }
+        const overwrite = await promptYesNo(`File modified since last generation: ${rel}. Overwrite?`);
+        if (!overwrite) {
+            if (!silent)
+                console.log(colors_1.colors.yellow(`Skipped ${rel}`));
+            return 'skipped';
+        }
+    }
+    fs.writeFileSync(abs, contents);
+    updateStoredHash(abs, newHash);
+    if (!silent)
+        console.log(colors_1.colors.blue(`Updated ${path.relative(projectRootDir || process.cwd(), abs)}`));
+    return 'written';
+}
+function ensureCommitsDir() {
+    if (!projectRootDir) {
+        throw new Error('Generation registry is not initialized. Call initGenerationRegistry(rootDir) first.');
+    }
+    // Store commits at project root/commits
+    const commitsDir = path.join(projectRootDir, 'commits');
+    fs.mkdirSync(commitsDir, { recursive: true });
+    return commitsDir;
+}