prodex 1.3.0 → 1.4.1

package/dist/cli/summary.js

@@ -4,23 +4,29 @@ exports.endSummary = endSummary;
 exports.introSummary = introSummary;
 exports.entrySummary = entrySummary;
 const logger_1 = require("../lib/logger");
-const helpers_1 = require("../core/helpers");
+const io_1 = require("../shared/io");
+const store_1 = require("../store");
+let CONFIG;
+let FLAGS;
 function endSummary(out, result) {
     logger_1.logger.debug(`🧩 Summary:
- • Unique imports expected: ${result.stats.expected.size}
- • Unique imports resolved: ${result.stats.resolved.size}
+ • Unique imports expected: ${result?.stats?.expected.size}
+ • Unique imports resolved: ${result?.stats?.resolved.size}
 `);
     logger_1.logger.log(`✅ ${out.norm()}`);
 }
-function introSummary({ flags, config }) {
-    logger_1.logger.log(`------- PRODEx RUN @ ${new Date().toLocaleTimeString()} — Codebase decoded -------`);
+function introSummary() {
+    CONFIG = (0, store_1.getConfig)();
+    FLAGS = (0, store_1.getFlags)();
+    logger_1.logger.log(`------- PRODEx RUN @ ${new Date().toLocaleTimeString()} — Codebase decoded -------\n`);
     // Log parse results for testing
-    logger_1.logger.debug("🧩 Parsed CLI input:", _2j({ flags }));
-    logger_1.logger.debug("Final merged config:", _2j(config));
+    logger_1.logger.debug("🧩 Parsed CLI input:", _2j({ FLAGS }));
+    logger_1.logger.debug("Final merged config:", _2j(CONFIG));
 }
 function entrySummary(entries) {
     let result = "📋 You selected:";
     for (const e of entries)
-        result += "\n   -" + (0, helpers_1.rel)(e);
-    logger_1.logger.log(result);
+        result += "\n   -" + (0, io_1.rel)(e);
+    if (entries?.length)
+        logger_1.logger.log(result);
 }

package/dist/constants/cache-keys.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CACHE_KEYS = void 0;
+exports.CACHE_KEYS = {
+    ALIASES: "aliases",
+    JS_IMPORTS: "js:imports",
+    JS_STATS: "js:stats",
+    PHP_PSR4: "php:psr4",
+    PHP_BINDINGS: "php:bindings",
+    PHP_FILECACHE: "php:fileCache",
+};

package/dist/constants/config.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VALID_GLOB_CHARS = exports.SUFFIX = exports.DTS_EXT = exports.BASE_EXTS = exports.GLOBAL_IGNORE = exports.RESOLVERS = exports.CODE_EXTS = void 0;
-exports.CODE_EXTS = [".js", ".mjs", ".ts", ".tsx", ".d.ts", ".php"];
+exports.VALID_GLOB_CHARS = exports.SUFFIX = exports.GLOBAL_IGNORE = exports.RESOLVERS = exports.DTS_EXT = exports.REAL_EXTS = exports.BASE_EXTS = exports.CODE_EXTS = void 0;
 const js_resolver_1 = require("../resolvers/js/js-resolver");
 const php_resolver_1 = require("../resolvers/php/php-resolver");
+exports.CODE_EXTS = [".js", ".mjs", ".ts", ".tsx", ".d.ts", ".php"];
+exports.BASE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
+exports.REAL_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".d.ts", ".json"]);
+exports.DTS_EXT = ".d.ts";
 exports.RESOLVERS = {
     ".php": php_resolver_1.resolvePhpImports,
     ".ts": js_resolver_1.resolveJsImports,
@@ -12,8 +15,6 @@ exports.RESOLVERS = {
     ".js": js_resolver_1.resolveJsImports,
 };
 exports.GLOBAL_IGNORE = ["**/node_modules/**", "**/vendor/**", "**/dist/**"];
-exports.BASE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".types"];
-exports.DTS_EXT = ".d.ts";
 exports.SUFFIX = "trace";
 /**
  * Normalize and sanitize pattern fields.
@@ -23,4 +24,4 @@ exports.SUFFIX = "trace";
  * - Trims and removes empty elements.
  * - Filters out invalid or unusable characters for Fast-Glob.
  */
-exports.VALID_GLOB_CHARS = /^[\w\-@./*?|!{}\[\]^$()+]+$/; // allows Fast-Glob-safe symbols
+exports.VALID_GLOB_CHARS = /^[\w\-@./*?|!{}\[\]^$()+]+$/; // allows Fast-Glob-safe symbolsexport const REAL_EXTS = new Set<string>([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".d.ts", ".json"]);

package/dist/constants/flags.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_USAGE = exports.FLAG_SHORT_MAP = exports.FLAG_MAP = void 0;
+exports.FLAG_MAP = {
+    txt: {
+        short: "t",
+        type: "boolean",
+        description: "Output as .txt instead of .md.",
+        apply: (cfg, v) => (cfg.output.format = v ? "txt" : "md"),
+    },
+    name: {
+        short: "n",
+        type: "string",
+        description: "Custom output filename (without extension).",
+        apply: (cfg, v) => (cfg.name = v),
+    },
+    limit: {
+        short: "l",
+        type: "number",
+        description: "Override traversal limit.",
+        apply: (cfg, v) => (cfg.resolve.limit = v),
+    },
+    include: {
+        short: "i",
+        type: "list",
+        description: "Comma-separated include globs.",
+        apply: (cfg, v) => (cfg.resolve.include = v),
+    },
+    exclude: {
+        short: "x",
+        type: "list",
+        description: "Comma-separated exclude globs.",
+        apply: (cfg, v) => (cfg.resolve.exclude = v),
+    },
+    files: {
+        short: "f",
+        type: "list",
+        description: "Entry files (comma-separated).",
+        apply: (cfg, v) => (cfg.entry.files = v),
+    },
+    ci: {
+        short: "c",
+        type: "boolean",
+        description: "Headless (non-interactive) mode.",
+        apply: () => { },
+    },
+    debug: {
+        short: "d",
+        type: "boolean",
+        description: "Enable debug logs.",
+        apply: () => { },
+    },
+    help: {
+        short: "h",
+        type: "boolean",
+        description: "Show CLI help and exit.",
+        apply: () => { },
+    },
+};
+// Reverse lookup for short aliases
+exports.FLAG_SHORT_MAP = Object.entries(exports.FLAG_MAP).reduce((acc, [k, v]) => {
+    //@ts-ignore
+    if (v.short)
+        acc[v.short] = k;
+    return acc;
+}, {});
+exports.CLI_USAGE = `
+Usage: prodex [options]
+
+${Object.entries(exports.FLAG_MAP)
+    .map(([k, v]) => `  --${k}${v.short ? ` | -${v.short}` : ""}\t${v.description}`)
+    .join("\n")}
+`;

package/dist/constants/index.js

@@ -0,0 +1,20 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cache-keys"), exports);
+__exportStar(require("./default-config"), exports);
+__exportStar(require("./render-constants"), exports);
+__exportStar(require("./config"), exports);

package/dist/constants/render-constants.js

@@ -4,10 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MD_FOOTER = exports.TEXT_HEADERS = exports.LANG_MAP = void 0;
-// ================================================================
-// 🧩 Prodex — Render Constants
-// Defines shared constants for renderer outDir formats.
-// ================================================================
 const package_json_1 = __importDefault(require("../../package.json"));
 exports.LANG_MAP = {
     "": "js",

package/dist/core/combine.js

@@ -3,36 +3,54 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCombine = runCombine;
 const picker_1 = require("../cli/picker");
 const summary_1 = require("../cli/summary");
-const dependency_1 = require("./dependency");
-const file_utils_1 = require("./file-utils");
+const cache_keys_1 = require("../constants/cache-keys");
+const cache_1 = require("./managers/cache");
+const config_1 = require("./managers/config");
 const logger_1 = require("../lib/logger");
+const dependency_1 = require("./dependency");
+const helpers_1 = require("./helpers");
+const helpers_2 = require("./helpers");
 const output_1 = require("./output");
 async function runCombine({ cfg, opts }) {
+    (0, summary_1.introSummary)();
     const { showUi, cliName } = opts;
     let entries = (await resolveEntries(showUi, cfg)) ?? [];
-    if (!entries.length) {
-        logger_1.logger.error("No entries selected.");
-        return;
-    }
     (0, summary_1.entrySummary)(entries);
-    const result = await (0, dependency_1.followChain)(entries, cfg);
-    const withinclude = await (0, dependency_1.applyincludes)(cfg, result.files);
-    const autoName = (0, file_utils_1.produceSmartName)(entries);
+    let result;
+    if (!entries.length)
+        logger_1.logger.info("No entries found");
+    if (entries.length)
+        result = await (0, dependency_1.followChain)(entries, cfg);
+    const withinclude = await (0, dependency_1.applyIncludes)(cfg, result?.files ?? []);
+    if (!withinclude.length)
+        return logger_1.logger.info("No Includes found. Exiting process...");
+    const autoName = (0, helpers_2.smartNaming)(entries);
     const outputPath = await (0, output_1.produceOutput)({ name: cliName ?? autoName, files: withinclude, cfg, showUi });
+    persistAliases();
     (0, summary_1.endSummary)(outputPath, result);
 }
 async function resolveEntries(showUi, cfg) {
-    const { root, entry } = cfg;
-    const { files } = entry;
+    const { root, entry: { files }, resolve: { include }, } = cfg;
     if (!showUi) {
         logger_1.logger.info("CI Mode");
         if (!files?.length) {
             logger_1.logger.warn("No entry files defined and UI mode is disabled.");
-            process.exit(1);
+            if (!include.length)
+                process.exit(1);
+            logger_1.logger.info("Applying Includes");
         }
-        return (await (0, file_utils_1.globScan)(files, { cwd: root })).files;
+        return (await (0, helpers_1.globScan)(files, { cwd: root })).files;
     }
     else {
         return await (0, picker_1.pickEntries)(cfg);
     }
 }
+/**
+ * 🧩 Persist discovered aliases (if any)
+ */
+function persistAliases() {
+    const aliases = cache_1.CacheManager.dump(cache_keys_1.CACHE_KEYS.ALIASES);
+    if (Object.keys(aliases).length) {
+        config_1.ConfigManager.persist({ resolve: { aliases } });
+    }
+}

package/dist/core/dependency.js

@@ -4,20 +4,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.followChain = followChain;
-exports.applyincludes = applyincludes;
+exports.applyIncludes = applyIncludes;
 const path_1 = __importDefault(require("path"));
 const config_1 = require("../constants/config");
-const file_utils_1 = require("./file-utils");
+const helpers_1 = require("./helpers");
 const logger_1 = require("../lib/logger");
-const utils_1 = require("../lib/utils");
+const collections_1 = require("../shared/collections");
+/**
+ * 🧩 followChain()
+ * Traverses all dependencies starting from the given entry files.
+ * Uses language-specific resolvers (JS / PHP) under the hood.
+ */
 async function followChain(entryFiles, cfg) {
     const limit = cfg.resolve.limit;
+    const resolverDepth = cfg.resolve.depth;
     logger_1.logger.debug("🧩 Following dependency chain...");
     const visited = new Set();
     const all = [];
     const expected = new Set();
     const resolved = new Set();
-    const resolverDepth = cfg.resolve.depth;
     for (const f of entryFiles) {
         if (visited.has(f))
             continue;
@@ -26,30 +31,45 @@ async function followChain(entryFiles, cfg) {
         if (!config_1.CODE_EXTS.includes(ext))
             continue;
         const resolver = config_1.RESOLVERS[ext];
-        if (resolver) {
-            const result = await resolver(f, cfg, visited, 0, resolverDepth);
-            const { files, stats } = result;
-            all.push(...files);
-            stats?.expected?.forEach((x) => expected.add(x));
-            stats?.resolved?.forEach((x) => resolved.add(x));
+        if (!resolver)
+            continue;
+        const params = {
+            filePath: f,
+            visited,
+            depth: 0,
+            maxDepth: resolverDepth,
+        };
+        let result = null;
+        try {
+            result = await resolver(params);
         }
+        catch (err) {
+            logger_1.logger.warn(`⚠️ Resolver failed for ${f}:`, err.message || err);
+            continue;
+        }
+        if (!result)
+            continue;
+        const { files, stats } = result;
+        all.push(...files);
+        stats.expected.forEach((x) => expected.add(x));
+        stats.resolved.forEach((x) => resolved.add(x));
         if (limit && all.length >= limit) {
             logger_1.logger.warn("⚠️  Limit reached:", limit);
             break;
         }
     }
     return {
-        files: (0, utils_1.unique)(all),
+        files: (0, collections_1.unique)(all),
         stats: { expected, resolved },
     };
 }
-async function applyincludes(cfg, files) {
-    ;
-    const { resolve } = cfg;
-    const ROOT = cfg.root;
-    const scan = await (0, file_utils_1.globScan)(resolve.include, { cwd: ROOT });
+/**
+ * 🧩 applyIncludes()
+ * Scans and appends additional files defined in config.resolve.include.
+ */
+async function applyIncludes(cfg, files) {
+    const { resolve, root } = cfg;
+    const scan = await (0, helpers_1.globScan)(resolve.include, { cwd: root });
     logger_1.logger.debug("APPLY_include", _2j(scan));
-    const combined = (0, utils_1.unique)([...files, ...scan.files]);
-    ;
-    return combined;
+    return (0, collections_1.unique)([...files, ...scan.files]);
 }

package/dist/core/helpers.js

@@ -3,47 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rel = rel;
-exports.read = read;
-exports.isExcluded = isExcluded;
 exports.walk = walk;
 exports.orderByPriority = orderByPriority;
+exports.smartNaming = smartNaming;
+exports.globScan = globScan;
 const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
 const micromatch_1 = __importDefault(require("micromatch"));
-/**
- * Get a root-relative version of a path.
- */
-function rel(p, root = process.cwd()) {
-    return path_1.default.relative(root, p).replaceAll("\\", "/");
-}
-/**
- * Safe text read.
- */
-function read(p) {
-    try {
-        return fs_1.default.readFileSync(p, "utf8");
-    }
-    catch {
-        return "";
-    }
-}
-/**
- * Check if a path/file matches any of the provided glob patterns.
- */
-function isExcluded(p, patterns, root = process.cwd()) {
-    if (!patterns?.length)
-        return false;
-    const relPath = rel(p, root);
-    return micromatch_1.default.isMatch(relPath, patterns);
-}
+const shared_1 = require("../shared");
+const path_1 = __importDefault(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const constants_1 = require("../constants");
+const logger_1 = require("../lib/logger");
 /**
  * Recursive walker that respects glob exclude.
  * Returns all files under the given directory tree.
  */
 function* walk(dir, cfg, depth = 0) {
-    const { scanDepth, entry } = cfg;
-    const root = process.cwd();
+    const { root, entry: { ui: { scanDepth }, }, resolve: { exclude }, } = cfg;
     if (depth > scanDepth)
         return;
     const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
@@ -51,15 +27,15 @@ function* walk(dir, cfg, depth = 0) {
         const full = path_1.default.join(dir, e.name);
         if (e.isDirectory()) {
             // Skip excluded directories entirely
-            const relPath = rel(full, root);
-            if (isExcluded(relPath, entry.exclude))
+            const relPath = (0, shared_1.rel)(full, root);
+            if ((0, shared_1.isExcluded)(relPath, exclude))
                 continue;
             yield* walk(full, cfg, depth + 1);
             continue;
         }
         if (e.isFile()) {
-            const relPath = rel(full, root);
-            if (isExcluded(relPath, entry.exclude))
+            const relPath = (0, shared_1.rel)(full, root);
+            if ((0, shared_1.isExcluded)(relPath, exclude))
                 continue;
             yield full;
         }
@@ -72,10 +48,38 @@ function orderByPriority(files, priorityList = []) {
     const normal = [];
     for (const f of files) {
         const normalized = f.norm().toLowerCase();
-        if (priorityList.some(p => micromatch_1.default.isMatch(normalized, p.toLowerCase())))
+        if (priorityList.some((p) => micromatch_1.default.isMatch(normalized, p.toLowerCase())))
             prioritized.push(f);
         else
             normal.push(f);
     }
-    return [...new Set([...prioritized, ...normal])];
+    return (0, shared_1.unique)([...prioritized, ...normal]);
+}
+function smartNaming(entries) {
+    const names = (0, shared_1.unique)(entries.map((f) => path_1.default.basename(f, path_1.default.extname(f))));
+    if (names.length === 1)
+        return names[0];
+    if (names.length === 2)
+        return `${names[0]}-${names[1]}`;
+    if (names.length > 2)
+        return `${names[0]}-and-${names.length - 1}more`;
+    return "prodex";
+}
+/**
+ * Safe micromatch.scan wrapper (compatible with micromatch v4 & v5)
+ */
+async function globScan(patterns, opts) {
+    const { absolute = true, cwd = process.cwd() } = opts;
+    if (!patterns?.length)
+        return { files: [] };
+    const files = (await (0, fast_glob_1.default)(patterns, {
+        cwd,
+        extglob: true,
+        dot: true,
+        onlyFiles: true,
+        ignore: constants_1.GLOBAL_IGNORE,
+        absolute,
+    })).map((f) => path_1.default.resolve(f));
+    logger_1.logger.debug("globScan →", _2j(files));
+    return { files };
 }

package/dist/core/managers/cache.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheManager = void 0;
+const logger_1 = require("../../lib/logger");
+/**
+ * 🧩 CacheManager
+ * Unified in-memory registry for all runtime maps.
+ *
+ * - Namespaced storage (e.g., "aliases", "stats", "resolver")
+ * - Purely in-memory (no file I/O)
+ * - Static API for symmetry with ConfigManager
+ */
+class CacheManager {
+    static registry = new Map();
+    /** Ensure namespace map exists and return it */
+    static ns(ns) {
+        if (!this.registry.has(ns))
+            this.registry.set(ns, new Map());
+        return this.registry.get(ns);
+    }
+    /** Set or update a cached entry */
+    static set(ns, key, val) {
+        this.ns(ns).set(key, val);
+        logger_1.logger.debug(`🧩 [cache:${ns}] set ${key} → ${String(val)}`);
+    }
+    /** Retrieve a cached entry */
+    static get(ns, key) {
+        return this.ns(ns).get(key);
+    }
+    /** Remove all entries from one namespace or from all */
+    static clear(ns) {
+        if (ns) {
+            this.ns(ns).clear();
+            logger_1.logger.debug(`🧩 [cache:${ns}] cleared`);
+        }
+        else {
+            this.registry.forEach((m) => m.clear());
+            logger_1.logger.debug("🧩 [cache] cleared all namespaces");
+        }
+    }
+    /** Export a namespace as a plain object (for persistence or inspection) */
+    static dump(ns) {
+        return Object.fromEntries(this.ns(ns).entries());
+    }
+    /** Return count of entries per namespace */
+    static stats() {
+        const summary = {};
+        for (const [name, map] of this.registry)
+            summary[name] = map.size;
+        return summary;
+    }
+}
+exports.CacheManager = CacheManager;

package/dist/core/managers/config.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const default_config_1 = require("../../constants/default-config");
+const utils_1 = require("../../lib/utils");
+const flags_1 = require("../../constants/flags");
+const store_1 = require("../../store");
+/**
+ * 🧩 ConfigManager
+ * Unified loader, merger, and flag applier.
+ */
+class ConfigManager {
+    static load(cwd) {
+        const file = path_1.default.join(cwd, "prodex.json");
+        if (!fs_1.default.existsSync(file))
+            return default_config_1.DEFAULT_PRODEX_CONFIG;
+        try {
+            return JSON.parse(fs_1.default.readFileSync(file, "utf8"));
+        }
+        catch {
+            console.warn("⚠️ Invalid prodex.json — using defaults.");
+            return default_config_1.DEFAULT_PRODEX_CONFIG;
+        }
+    }
+    static merge(user, flags, cwd = process.cwd()) {
+        const merged = {
+            ...default_config_1.DEFAULT_PRODEX_CONFIG,
+            ...user,
+            output: { ...default_config_1.DEFAULT_PRODEX_CONFIG.output, ...user.output },
+            entry: {
+                ...default_config_1.DEFAULT_PRODEX_CONFIG.entry,
+                ...user.entry,
+                ui: { ...default_config_1.DEFAULT_PRODEX_CONFIG.entry.ui, ...user.entry?.ui },
+            },
+            resolve: { ...default_config_1.DEFAULT_PRODEX_CONFIG.resolve, ...user.resolve },
+            root: cwd,
+            name: flags?.name ?? null,
+        };
+        this.applyFlags(merged, flags);
+        return this.normalize(merged);
+    }
+    static applyFlags(cfg, flags) {
+        if (!flags)
+            return cfg;
+        for (const [key, val] of Object.entries(flags)) {
+            if (val === undefined)
+                continue;
+            const def = flags_1.FLAG_MAP[key];
+            if (def?.apply)
+                def.apply(cfg, val);
+        }
+        const hasFiles = Array.isArray(flags.files) ? flags.files.length > 0 : !!flags.files;
+        if (hasFiles && !flags.include)
+            cfg.resolve.include = [];
+        return cfg;
+    }
+    static normalize(cfg) {
+        cfg.entry.files = (0, utils_1.normalizePatterns)(cfg.entry.files);
+        //TODO: Is there a need?
+        // cfg.resolve.include = normalizePatterns(cfg.resolve.include);
+        // cfg.resolve.exclude = normalizePatterns(cfg.resolve.exclude);
+        return cfg;
+    }
+    static persist(partial) {
+        const cfg = (0, store_1.getConfig)();
+        const dest = path_1.default.join(cfg.root, "prodex.json");
+        const { root, name, ...pure } = cfg;
+        const merged = deepMerge(pure, partial);
+        try {
+            fs_1.default.writeFileSync(dest, JSON.stringify(merged, null, 2) + "\n", "utf8");
+            console.log(`✅ Updated ${dest}`);
+        }
+        catch (err) {
+            console.warn("⚠️ Failed to persist config:", err?.message || err);
+        }
+    }
+}
+exports.ConfigManager = ConfigManager;
+function deepMerge(base, patch) {
+    if (!patch)
+        return base;
+    const out = Array.isArray(base) ? [...base] : { ...base };
+    for (const [k, v] of Object.entries(patch)) {
+        if (v === undefined)
+            continue;
+        const bv = base[k];
+        if (Array.isArray(v))
+            out[k] = [...v]; // overwrite arrays
+        else if (isPlainObject(v) && isPlainObject(bv))
+            out[k] = deepMerge(bv, v);
+        else
+            out[k] = v;
+    }
+    return out;
+}
+function isPlainObject(x) {
+    return x && typeof x === "object" && !Array.isArray(x);
+}

package/dist/core/renderers.js

@@ -8,24 +8,25 @@ exports.renderMd = renderMd;
 exports.tocTxt = tocTxt;
 exports.renderTxt = renderTxt;
 const path_1 = __importDefault(require("path"));
-const helpers_1 = require("./helpers");
+const io_1 = require("../shared/io");
+const io_2 = require("../shared/io");
 const render_constants_1 = require("../constants/render-constants");
 /**
  * Generate Markdown Table of Contents with anchors
  */
 function tocMd(files) {
     const count = files.length;
-    const items = files.map((f, i) => `- [${(0, helpers_1.rel)(f)}](#${i + 1})`).join("\n");
-    return [`# Index `, `\nIncluded Source Files (${count})`, "", items, "", "---"].join("\n");
+    const items = files.map((f, i) => `- [${(0, io_2.rel)(f)}](#${i + 1})`).join("\n");
+    return ["# Index ", `\nIncluded Source Files (${count})`, items, "", "---"].join("\n");
 }
 /**
  * Render each file section with invisible anchors
  */
 function renderMd(p, i) {
-    const rp = (0, helpers_1.rel)(p);
+    const rp = (0, io_2.rel)(p);
     const ext = path_1.default.extname(p).toLowerCase();
     const lang = render_constants_1.LANG_MAP[ext] || "txt";
-    const code = (0, helpers_1.read)(p).trimEnd();
+    const code = (0, io_1.readFileSafe)(p).trimEnd();
     return [`---\n#### ${i + 1}`, "\n", "` File: " + rp + "`  [↑ Back to top](#index)", "", "```" + lang, code, "```", ""].join("\n");
 }
 /**
@@ -33,10 +34,10 @@ function renderMd(p, i) {
  */
 function tocTxt(files) {
     const sorted = [...files].sort((a, b) => a.localeCompare(b));
-    return ["##==== Combined Scope ====", ...sorted.map((f) => "## - " + (0, helpers_1.rel)(f))].join("\n") + "\n\n";
+    return ["##==== Combined Scope ====", ...sorted.map((f) => "## - " + (0, io_2.rel)(f))].join("\n") + "\n\n";
 }
 function renderTxt(p) {
-    const relPath = (0, helpers_1.rel)(p);
-    const code = (0, helpers_1.read)(p);
+    const relPath = (0, io_2.rel)(p);
+    const code = (0, io_1.readFileSafe)(p);
     return ["##==== path: " + relPath + " ====", "##region " + relPath, code, "##endregion", ""].join("\n");
 }