@currentjs/gen 0.1.1

package/dist/utils/colors.d.ts

@@ -0,0 +1,26 @@
+export type ColorizeFn = (text: string | number) => string;
+export declare const colors: {
+    enabled: boolean;
+    dim: ColorizeFn;
+    bold: ColorizeFn;
+    italic: ColorizeFn;
+    underline: ColorizeFn;
+    inverse: ColorizeFn;
+    black: ColorizeFn;
+    red: ColorizeFn;
+    green: ColorizeFn;
+    yellow: ColorizeFn;
+    blue: ColorizeFn;
+    magenta: ColorizeFn;
+    cyan: ColorizeFn;
+    white: ColorizeFn;
+    gray: ColorizeFn;
+    brightRed: ColorizeFn;
+    brightGreen: ColorizeFn;
+    brightYellow: ColorizeFn;
+    brightBlue: ColorizeFn;
+    brightMagenta: ColorizeFn;
+    brightCyan: ColorizeFn;
+    brightWhite: ColorizeFn;
+};
+export declare function stripAnsi(input: string): string;

package/dist/utils/colors.js

@@ -0,0 +1,80 @@
+"use strict";
+/* Simple ANSI color utilities with TTY/NO_COLOR/FOREG_COLOR detection */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = void 0;
+exports.stripAnsi = stripAnsi;
+function isColorSupported() {
+    const force = process.env.FORCE_COLOR;
+    if (force && force !== '0')
+        return true;
+    if (force === '0')
+        return false;
+    if (process.env.NO_COLOR)
+        return false;
+    // Prefer stdout TTY; fall back to true in CI with FORCE_COLOR
+    return !!process.stdout && !!process.stdout.isTTY;
+}
+const enabled = isColorSupported();
+function createStyle(openCode, closeCode) {
+    const open = `\u001b[${openCode}m`;
+    const close = `\u001b[${closeCode}m`;
+    return (text) => {
+        const value = String(text);
+        if (!enabled)
+            return value;
+        return open + value + close;
+    };
+}
+const dim = createStyle(2, 22);
+const bold = createStyle(1, 22);
+const italic = createStyle(3, 23);
+const underline = createStyle(4, 24);
+const inverse = createStyle(7, 27);
+const black = createStyle(30, 39);
+const red = createStyle(31, 39);
+const green = createStyle(32, 39);
+const yellow = createStyle(33, 39);
+const blue = createStyle(34, 39);
+const magenta = createStyle(35, 39);
+const cyan = createStyle(36, 39);
+const white = createStyle(37, 39);
+const gray = createStyle(90, 39);
+const brightRed = createStyle(91, 39);
+const brightGreen = createStyle(92, 39);
+const brightYellow = createStyle(93, 39);
+const brightBlue = createStyle(94, 39);
+const brightMagenta = createStyle(95, 39);
+const brightCyan = createStyle(96, 39);
+const brightWhite = createStyle(97, 39);
+exports.colors = {
+    enabled,
+    // modifiers
+    dim,
+    bold,
+    italic,
+    underline,
+    inverse,
+    // base colors
+    black,
+    red,
+    green,
+    yellow,
+    blue,
+    magenta,
+    cyan,
+    white,
+    gray,
+    // bright variants
+    brightRed,
+    brightGreen,
+    brightYellow,
+    brightBlue,
+    brightMagenta,
+    brightCyan,
+    brightWhite
+};
+function stripAnsi(input) {
+    // eslint-disable-next-line no-control-regex
+    const ansiRegex = /[\u001b\u009b][[\]()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+    return input.replace(ansiRegex, '');
+}

package/dist/utils/commitUtils.d.ts

@@ -0,0 +1,46 @@
+export type DiffHunk = {
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    oldContent: string[];
+    newContent: string[];
+    ctxBeforeOld?: string[];
+    ctxAfterOld?: string[];
+};
+type StoredCommit = {
+    createdAt?: string;
+    files: Array<{
+        file: string;
+        status: 'modified';
+        oldHash?: string;
+        newHash?: string;
+        diff?: string;
+        format?: 'hunks-v1';
+        baseHash?: string;
+        resultHash?: string;
+        hunks?: DiffHunk[];
+        meta?: Record<string, any>;
+    }>;
+};
+export declare function loadAllCommitRecords(rootDir: string): Array<{
+    createdAt: number;
+    file: string;
+    record: StoredCommit['files'][number];
+}>;
+export declare function computeLineDiff(oldStr: string, newStr: string): string;
+export declare function applyDiffToBase(base: string, diff: string): string | null;
+export declare function computeHunks(oldStr: string, newStr: string): DiffHunk[];
+export declare function applyHunksToBase(base: string, hunks: DiffHunk[]): string | null;
+/**
+ * Try to apply hunks to an arbitrary base using contextual search.
+ * - If oldContent exists, locate it and replace by newContent.
+ * - If oldLines === 0 (pure insertion), use ctxBeforeOld/ctxAfterOld anchors to place newContent.
+ * Returns null if cannot apply cleanly.
+ */
+export declare function applyHunksToAnyBase(base: string, hunks: DiffHunk[]): string | null;
+export declare function tryApplyCommitsToGenerated(fileAbsPath: string, generatedContent: string): {
+    applied: boolean;
+    content: string;
+};
+export {};

package/dist/utils/commitUtils.js

@@ -0,0 +1,377 @@
+"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.loadAllCommitRecords = loadAllCommitRecords;
+exports.computeLineDiff = computeLineDiff;
+exports.applyDiffToBase = applyDiffToBase;
+exports.computeHunks = computeHunks;
+exports.applyHunksToBase = applyHunksToBase;
+exports.applyHunksToAnyBase = applyHunksToAnyBase;
+exports.tryApplyCommitsToGenerated = tryApplyCommitsToGenerated;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const generationRegistry_1 = require("./generationRegistry");
+function parseCommitTimestamp(name) {
+    // commit-YYYY-MM-DDTHH-MM-SS-sssZ.json
+    const match = name.match(/commit-(.*)\.json$/);
+    if (!match)
+        return 0;
+    const iso = match[1].replace(/-/g, ':');
+    // restore last hyphens: not exact; fallback to Date.parse of createdAt inside file
+    return 0;
+}
+function loadAllCommitRecords(rootDir) {
+    const commitsDir = path.join(rootDir, 'commits');
+    if (!fs.existsSync(commitsDir))
+        return [];
+    const files = fs.readdirSync(commitsDir).filter(f => f.endsWith('.json'));
+    const results = [];
+    files.forEach(f => {
+        const abs = path.join(commitsDir, f);
+        try {
+            const data = JSON.parse(fs.readFileSync(abs, 'utf8'));
+            const ts = data.createdAt ? Date.parse(data.createdAt) : parseCommitTimestamp(f);
+            data.files.forEach(rec => {
+                results.push({ createdAt: ts || 0, file: rec.file, record: rec });
+            });
+        }
+        catch {
+            // ignore broken commit files
+        }
+    });
+    // sort by createdAt ascending
+    results.sort((a, b) => a.createdAt - b.createdAt);
+    return results;
+}
+function parseDiff(diff) {
+    return diff.split(/\r?\n/).map(line => {
+        const type = line[0];
+        const content = line.length > 1 && line[1] === ' ' ? line.slice(2) : line.slice(1);
+        return { type: type === ' ' || type === '+' || type === '-' ? type : ' ', line: content };
+    });
+}
+function computeLineDiff(oldStr, newStr) {
+    const oldLines = oldStr.split(/\r?\n/);
+    const newLines = newStr.split(/\r?\n/);
+    const n = oldLines.length;
+    const m = newLines.length;
+    const dp = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i -= 1) {
+        for (let j = m - 1; j >= 0; j -= 1) {
+            if (oldLines[i] === newLines[j])
+                dp[i][j] = dp[i + 1][j + 1] + 1;
+            else
+                dp[i][j] = Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    const result = [];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (oldLines[i] === newLines[j]) {
+            result.push({ type: ' ', line: oldLines[i] });
+            i += 1;
+            j += 1;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            result.push({ type: '-', line: oldLines[i] });
+            i += 1;
+        }
+        else {
+            result.push({ type: '+', line: newLines[j] });
+            j += 1;
+        }
+    }
+    while (i < n) {
+        result.push({ type: '-', line: oldLines[i] });
+        i += 1;
+    }
+    while (j < m) {
+        result.push({ type: '+', line: newLines[j] });
+        j += 1;
+    }
+    const lines = result.map(op => `${op.type} ${op.line}`);
+    return lines.join('\n');
+}
+function applyDiffToBase(base, diff) {
+    const baseLines = base.split(/\r?\n/);
+    const ops = parseDiff(diff);
+    const result = [];
+    let i = 0;
+    for (const op of ops) {
+        if (op.type === ' ') {
+            if (baseLines[i] !== op.line) {
+                return null; // context mismatch
+            }
+            result.push(op.line);
+            i += 1;
+        }
+        else if (op.type === '+') {
+            if (baseLines[i] !== op.line) {
+                return null; // base content deviates
+            }
+            // skip this line in result (removed compared to base)
+            i += 1;
+        }
+        else if (op.type === '-') {
+            // insert user-only line
+            result.push(op.line);
+        }
+    }
+    // any remaining base lines are unexpected; consider they should have been represented
+    if (i < baseLines.length) {
+        // append remaining lines only if ops end with matching context; otherwise fail
+        result.push(...baseLines.slice(i));
+    }
+    return result.join('\n');
+}
+function lcsMatrix(a, b) {
+    const n = a.length;
+    const m = b.length;
+    const dp = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i -= 1) {
+        for (let j = m - 1; j >= 0; j -= 1) {
+            if (a[i] === b[j])
+                dp[i][j] = dp[i + 1][j + 1] + 1;
+            else
+                dp[i][j] = Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    return dp;
+}
+function computeHunks(oldStr, newStr) {
+    var _a, _b;
+    const a = oldStr.split(/\r?\n/);
+    const b = newStr.split(/\r?\n/);
+    const dp = lcsMatrix(a, b);
+    const hunks = [];
+    let i = 0;
+    let j = 0;
+    let pending = null;
+    while (i < a.length && j < b.length) {
+        if (a[i] === b[j]) {
+            if (pending) {
+                hunks.push(pending);
+                pending = null;
+            }
+            i += 1;
+            j += 1;
+        }
+        else if (((_a = dp[i + 1]) === null || _a === void 0 ? void 0 : _a[j]) >= ((_b = dp[i]) === null || _b === void 0 ? void 0 : _b[j + 1])) {
+            // deletion from old (i advanced)
+            if (!pending) {
+                pending = { oldStart: i, oldLines: 0, newStart: j, newLines: 0, oldContent: [], newContent: [] };
+            }
+            pending.oldLines += 1;
+            pending.oldContent.push(a[i]);
+            i += 1;
+        }
+        else {
+            // insertion to new (j advanced)
+            if (!pending) {
+                pending = { oldStart: i, oldLines: 0, newStart: j, newLines: 0, oldContent: [], newContent: [] };
+            }
+            pending.newLines += 1;
+            pending.newContent.push(b[j]);
+            j += 1;
+        }
+    }
+    // tail remainders
+    if (i < a.length || j < b.length) {
+        const tail = {
+            oldStart: i,
+            oldLines: a.length - i,
+            newStart: j,
+            newLines: b.length - j,
+            oldContent: a.slice(i),
+            newContent: b.slice(j)
+        };
+        if (tail.oldLines > 0 || tail.newLines > 0) {
+            if (pending) {
+                // merge if adjacent
+                if (pending.oldStart + pending.oldLines === tail.oldStart && pending.newStart + pending.newLines === tail.newStart) {
+                    pending.oldLines += tail.oldLines;
+                    pending.newLines += tail.newLines;
+                    pending.oldContent.push(...tail.oldContent);
+                    pending.newContent.push(...tail.newContent);
+                }
+                else {
+                    hunks.push(pending);
+                    hunks.push(tail);
+                    pending = null;
+                }
+            }
+            else {
+                pending = tail;
+            }
+        }
+    }
+    if (pending)
+        hunks.push(pending);
+    // Attach lightweight context (up to 3 lines) around old segments to help rebase
+    const CONTEXT = 3;
+    return hunks.map(h => {
+        const beforeStart = Math.max(0, h.oldStart - CONTEXT);
+        const before = a.slice(beforeStart, h.oldStart);
+        const afterEnd = h.oldStart + h.oldLines + CONTEXT;
+        const after = a.slice(h.oldStart + h.oldLines, Math.min(a.length, afterEnd));
+        return { ...h, ctxBeforeOld: before, ctxAfterOld: after };
+    });
+}
+function applyHunksToBase(base, hunks) {
+    const baseLines = base.split(/\r?\n/);
+    let offset = 0;
+    for (const h of hunks) {
+        const start = h.oldStart + offset;
+        const end = start + h.oldLines;
+        if (start < 0 || start > baseLines.length || end < 0 || end > baseLines.length) {
+            return null;
+        }
+        baseLines.splice(start, h.oldLines, ...h.newContent);
+        offset += h.newContent.length - h.oldLines;
+    }
+    return baseLines.join('\n');
+}
+function findSubsequence(haystack, needle, fromIndex = 0) {
+    if (needle.length === 0)
+        return fromIndex;
+    for (let i = fromIndex; i <= haystack.length - needle.length; i += 1) {
+        let ok = true;
+        for (let j = 0; j < needle.length; j += 1) {
+            if (haystack[i + j] !== needle[j]) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok)
+            return i;
+    }
+    return -1;
+}
+/**
+ * Try to apply hunks to an arbitrary base using contextual search.
+ * - If oldContent exists, locate it and replace by newContent.
+ * - If oldLines === 0 (pure insertion), use ctxBeforeOld/ctxAfterOld anchors to place newContent.
+ * Returns null if cannot apply cleanly.
+ */
+function applyHunksToAnyBase(base, hunks) {
+    let baseLines = base.split(/\r?\n/);
+    let searchFrom = 0;
+    for (const h of hunks) {
+        if (h.oldLines > 0 && h.oldContent.length > 0) {
+            // Try to find exact oldContent sequence
+            let idx = findSubsequence(baseLines, h.oldContent, searchFrom);
+            if (idx === -1 && h.ctxBeforeOld && h.ctxBeforeOld.length > 0) {
+                // Try to locate by ctxBefore then expect oldContent after
+                const beforeIdx = findSubsequence(baseLines, h.ctxBeforeOld, Math.max(0, searchFrom - h.ctxBeforeOld.length));
+                if (beforeIdx !== -1) {
+                    idx = findSubsequence(baseLines, h.oldContent, beforeIdx + h.ctxBeforeOld.length);
+                }
+            }
+            if (idx === -1 && h.ctxAfterOld && h.ctxAfterOld.length > 0) {
+                // Try to locate by ctxAfter before it
+                const afterIdx = findSubsequence(baseLines, h.ctxAfterOld, searchFrom);
+                if (afterIdx !== -1) {
+                    // Scan backwards window before afterIdx
+                    const windowStart = Math.max(0, afterIdx - h.oldLines - h.ctxBeforeOld.length);
+                    idx = findSubsequence(baseLines.slice(windowStart, afterIdx), h.oldContent);
+                    if (idx !== -1)
+                        idx += windowStart;
+                }
+            }
+            if (idx === -1)
+                return null;
+            baseLines.splice(idx, h.oldLines, ...h.newContent);
+            searchFrom = idx + h.newContent.length;
+        }
+        else {
+            // Insertion-only hunk: place using context anchors
+            let insertAt = h.newStart; // fallback
+            if (h.ctxBeforeOld && h.ctxBeforeOld.length > 0) {
+                const beforeIdx = findSubsequence(baseLines, h.ctxBeforeOld, Math.max(0, searchFrom - h.ctxBeforeOld.length));
+                if (beforeIdx !== -1)
+                    insertAt = beforeIdx + h.ctxBeforeOld.length;
+            }
+            else if (h.ctxAfterOld && h.ctxAfterOld.length > 0) {
+                const afterIdx = findSubsequence(baseLines, h.ctxAfterOld, searchFrom);
+                if (afterIdx !== -1)
+                    insertAt = afterIdx;
+            }
+            if (insertAt < 0 || insertAt > baseLines.length)
+                insertAt = baseLines.length;
+            baseLines.splice(insertAt, 0, ...h.newContent);
+            searchFrom = insertAt + h.newContent.length;
+        }
+    }
+    return baseLines.join('\n');
+}
+function tryApplyCommitsToGenerated(fileAbsPath, generatedContent) {
+    const root = process.cwd();
+    const rel = path.relative(root, path.resolve(fileAbsPath));
+    const baseHash = (0, generationRegistry_1.computeContentHash)(generatedContent);
+    // Prefer registry snapshot if present and compatible
+    const registry = (0, generationRegistry_1.loadRegistry)();
+    const regEntry = registry[rel];
+    if (regEntry && regEntry.diffFormat === 'hunks-v1' && regEntry.diffHunks) {
+        // If baseHash matches, use fast exact apply; else attempt contextual apply
+        const appliedViaRegistry = regEntry.diffBaseHash === baseHash
+            ? applyHunksToBase(generatedContent, regEntry.diffHunks)
+            : applyHunksToAnyBase(generatedContent, regEntry.diffHunks);
+        if (appliedViaRegistry != null) {
+            return { applied: true, content: appliedViaRegistry };
+        }
+    }
+    // Fallback to commit files if registry snapshot not usable
+    const all = loadAllCommitRecords(root).filter(r => r.file === rel && r.record.status === 'modified');
+    if (all.length === 0)
+        return { applied: false, content: generatedContent };
+    // Prefer hunks format
+    const hunksCandidates = all.filter(r => r.record.format === 'hunks-v1' && r.record.baseHash === baseHash && r.record.hunks);
+    if (hunksCandidates.length > 0) {
+        const latest = hunksCandidates[hunksCandidates.length - 1].record;
+        const applied = applyHunksToBase(generatedContent, latest.hunks);
+        if (applied != null)
+            return { applied: true, content: applied };
+    }
+    // Fallback to legacy line diff
+    const legacyCandidates = all.filter(r => r.record.newHash === baseHash && r.record.diff);
+    if (legacyCandidates.length > 0) {
+        const latest = legacyCandidates[legacyCandidates.length - 1].record;
+        const applied = applyDiffToBase(generatedContent, latest.diff);
+        if (applied != null)
+            return { applied: true, content: applied };
+    }
+    return { applied: false, content: generatedContent };
+}

package/dist/utils/constants.d.ts

@@ -0,0 +1,52 @@
+export declare const FILE_EXTENSIONS: {
+    readonly YAML: ".yaml";
+    readonly TYPESCRIPT: ".ts";
+    readonly JAVASCRIPT: ".js";
+    readonly JSON: ".json";
+};
+export declare const COMMON_FILES: {
+    readonly APP_YAML: "app.yaml";
+    readonly APP_TS: "app.ts";
+    readonly REGISTRY_JSON: "registry.json";
+    readonly STORE_INTERFACE: "StoreInterface.ts";
+};
+export declare const GENERATOR_MARKERS: {
+    readonly CONTROLLERS_START: "// currentjs:controllers:start";
+    readonly CONTROLLERS_END: "// currentjs:controllers:end";
+};
+export declare const PATH_PATTERNS: {
+    readonly MODULES_PREFIX: "modules/";
+    readonly MODULES_RELATIVE: "./modules/";
+    readonly MODULES_DIRECTIVE: "@modules/";
+    readonly SRC_MODULES: "src/modules/";
+    readonly INFRASTRUCTURE: "infrastructure";
+    readonly APPLICATION: "application";
+    readonly DOMAIN: "domain";
+    readonly ENTITIES: "entities";
+    readonly STORES: "stores";
+    readonly SERVICES: "services";
+    readonly CONTROLLERS: "controllers";
+};
+export declare const DEFAULTS: {
+    readonly SERVER_PORT: 3000;
+    readonly SERVER_HOST: "localhost";
+    readonly PAGINATION_LIMIT: 10;
+    readonly PAGINATION_PAGE: 1;
+};
+export declare const MODULE_STRUCTURE: {
+    readonly DOMAIN_ENTITIES: "domain/entities";
+    readonly APPLICATION_SERVICES: "application/services";
+    readonly INFRASTRUCTURE_STORES: "infrastructure/stores";
+    readonly INFRASTRUCTURE_CONTROLLERS: "infrastructure/controllers";
+};
+export declare const SERVER: {
+    readonly BASE_URL: "http://localhost:3000";
+    readonly START_MESSAGE: "Server started on http://localhost:3000";
+};
+export declare const GENERATOR_SUFFIXES: {
+    readonly STORE: "Store";
+    readonly SERVICE: "Service";
+    readonly CONTROLLER: "Controller";
+    readonly API_CONTROLLER: "ApiController";
+    readonly WEB_CONTROLLER: "WebController";
+};

package/dist/utils/constants.js

@@ -0,0 +1,64 @@
+"use strict";
+// Common constants used across the generator
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATOR_SUFFIXES = exports.SERVER = exports.MODULE_STRUCTURE = exports.DEFAULTS = exports.PATH_PATTERNS = exports.GENERATOR_MARKERS = exports.COMMON_FILES = exports.FILE_EXTENSIONS = void 0;
+// File extensions
+exports.FILE_EXTENSIONS = {
+    YAML: '.yaml',
+    TYPESCRIPT: '.ts',
+    JAVASCRIPT: '.js',
+    JSON: '.json'
+};
+// Common file names
+exports.COMMON_FILES = {
+    APP_YAML: 'app.yaml',
+    APP_TS: 'app.ts',
+    REGISTRY_JSON: 'registry.json',
+    STORE_INTERFACE: 'StoreInterface.ts'
+};
+// Generator markers
+exports.GENERATOR_MARKERS = {
+    CONTROLLERS_START: '// currentjs:controllers:start',
+    CONTROLLERS_END: '// currentjs:controllers:end'
+};
+// Path patterns
+exports.PATH_PATTERNS = {
+    MODULES_PREFIX: 'modules/',
+    MODULES_RELATIVE: './modules/',
+    MODULES_DIRECTIVE: '@modules/',
+    SRC_MODULES: 'src/modules/',
+    INFRASTRUCTURE: 'infrastructure',
+    APPLICATION: 'application',
+    DOMAIN: 'domain',
+    ENTITIES: 'entities',
+    STORES: 'stores',
+    SERVICES: 'services',
+    CONTROLLERS: 'controllers'
+};
+// Default values
+exports.DEFAULTS = {
+    SERVER_PORT: 3000,
+    SERVER_HOST: 'localhost',
+    PAGINATION_LIMIT: 10,
+    PAGINATION_PAGE: 1
+};
+// Module structure paths
+exports.MODULE_STRUCTURE = {
+    DOMAIN_ENTITIES: 'domain/entities',
+    APPLICATION_SERVICES: 'application/services',
+    INFRASTRUCTURE_STORES: 'infrastructure/stores',
+    INFRASTRUCTURE_CONTROLLERS: 'infrastructure/controllers'
+};
+// Server URLs and messages
+exports.SERVER = {
+    BASE_URL: `http://${exports.DEFAULTS.SERVER_HOST}:${exports.DEFAULTS.SERVER_PORT}`,
+    START_MESSAGE: `Server started on http://${exports.DEFAULTS.SERVER_HOST}:${exports.DEFAULTS.SERVER_PORT}`
+};
+// Generator suffixes
+exports.GENERATOR_SUFFIXES = {
+    STORE: 'Store',
+    SERVICE: 'Service',
+    CONTROLLER: 'Controller',
+    API_CONTROLLER: 'ApiController',
+    WEB_CONTROLLER: 'WebController'
+};

package/dist/utils/generationRegistry.d.ts

@@ -0,0 +1,25 @@
+import { type DiffHunk } from './commitUtils';
+type RegistryEntry = {
+    hash: string;
+    updatedAt: string;
+    diffFormat?: 'hunks-v1';
+    diffBaseHash?: string;
+    diffResultHash?: string;
+    diffHunks?: DiffHunk[];
+    diffUpdatedAt?: string;
+};
+type RegistryData = Record<string, RegistryEntry>;
+export declare function initGenerationRegistry(rootDir: string): void;
+export declare function computeContentHash(contents: string): string;
+export declare function loadRegistry(): RegistryData;
+export declare function saveRegistry(data: RegistryData): void;
+export declare function getStoredHash(filePath: string): string | undefined;
+export declare function updateStoredHash(filePath: string, hash: string): void;
+export declare function updateStoredHunks(filePath: string, hunks: DiffHunk[], baseHash?: string, resultHash?: string): void;
+export declare function writeGeneratedFile(filePath: string, contents: string, options?: {
+    force?: boolean;
+    silent?: boolean;
+    skipOnConflict?: boolean;
+}): Promise<'written' | 'skipped' | 'unchanged'>;
+export declare function ensureCommitsDir(): string;
+export {};