prodex 1.1.0 → 1.2.0

package/dist/constants/config.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DTS_EXT = exports.BASE_EXTS = exports.GLOBAL_IGNORE = exports.RESOLVERS = exports.CODE_EXTS = exports.ROOT = void 0;
+exports.ROOT = process.cwd();
+exports.CODE_EXTS = [".js", ".mjs", ".ts", ".tsx", ".d.ts", ".php"];
+const js_resolver_1 = require("../resolvers/js/js-resolver");
+const php_resolver_1 = require("../resolvers/php/php-resolver");
+exports.RESOLVERS = {
+    ".php": php_resolver_1.resolvePhpImports,
+    ".ts": js_resolver_1.resolveJsImports,
+    ".tsx": js_resolver_1.resolveJsImports,
+    ".d.ts": js_resolver_1.resolveJsImports,
+    ".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";

package/dist/constants/default-config.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PRODEX_CONFIG = void 0;
+/**
+ * Default configuration for Prodex.
+ * Conforms strictly to ProdexConfig for full type safety.
+ */
+exports.DEFAULT_PRODEX_CONFIG = {
+    version: 3.1,
+    output: {
+        dir: "prodex",
+        versioned: false,
+        prefix: "combined",
+        format: "md",
+    },
+    entry: {
+        files: [],
+        ui: {
+            roots: ["app", "routes", "resources/js/**"],
+            scanDepth: 2,
+            priority: [
+                "**/routes/web.php",
+                "**/routes/api.php",
+                "**/*index.*",
+                "**/*main.*",
+                "**/app.*"
+            ],
+        },
+    },
+    resolve: {
+        include: ["**/*.d.ts", "**/*.interface.ts"],
+        aliases: {
+            "@hooks": "resources/js/hooks",
+            "@data": "resources/js/data",
+        },
+        exclude: [
+            "node_modules/**",
+            "@shadcn/**",
+            "**/components/ui/**"
+        ],
+        depth: 10,
+        limit: 200,
+    },
+    debug: {
+        verbose: false,
+        showSummary: true,
+    },
+};

package/dist/constants/render-constants.js

@@ -0,0 +1,23 @@
+"use strict";
+// ================================================================
+// 🧩 Prodex — Render Constants
+// Defines shared constants for renderer outDir formats.
+// ================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEXT_HEADERS = exports.LANG_MAP = void 0;
+exports.LANG_MAP = {
+    "": "js",
+    ".mjs": "js",
+    ".jsx": "jsx",
+    ".ts": "ts",
+    ".tsx": "tsx",
+    ".php": "php",
+    ".json": "json",
+    ".d.ts": "ts"
+};
+exports.TEXT_HEADERS = {
+    toc: "##==== Combined Scope ====",
+    path: p => `##==== path: ${p} ====`,
+    regionStart: p => `##region ${p}`,
+    regionEnd: "##endregion"
+};

package/dist/core/combine.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCombine = runCombine;
+const fs_1 = __importDefault(require("fs"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const path_1 = __importDefault(require("path"));
+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 renderers_1 = require("./renderers");
+const logger_1 = require("../lib/logger");
+const package_json_1 = __importDefault(require("../../package.json"));
+async function runCombine(cfg, showUi) {
+    const { output, entry, resolve } = cfg;
+    const toMd = cfg.output.format == "md";
+    const ROOT = cfg.root;
+    const { ui } = entry;
+    const entryFiles = entry.files ?? [];
+    let entries = [];
+    if (!showUi) {
+        logger_1.logger.info("CI Mode");
+        if (!entryFiles.length) {
+            logger_1.logger.warn("No entry files defined and UI mode is disabled.");
+            return;
+        }
+        entries = (await (0, file_utils_1.globScan)(entryFiles, { cwd: ROOT })).files;
+    }
+    else {
+        entries = await (0, picker_1.pickEntries)(ui.roots, ui.scanDepth, cfg);
+    }
+    if (!entries.length) {
+        logger_1.logger.error("No entries selected.");
+        return;
+    }
+    logger_1.logger.log("\n📋 You selected:");
+    for (const e of entries)
+        logger_1.logger.log(" -", e.replace(ROOT + "/", ""));
+    const autoName = (0, file_utils_1.generateOutputName)(entries);
+    const outDir = output.dir;
+    const limit = resolve.limit;
+    let outputBase = autoName;
+    if (showUi) {
+        const { outputBase: answer } = await inquirer_1.default.prompt([
+            {
+                type: "input",
+                name: "outputBase",
+                message: "Output file name (without extension):",
+                default: autoName,
+                filter: (v) => (v.trim() || autoName).replace(/[<>:"/\\|?*]+/g, "_"),
+            },
+        ]);
+        outputBase = answer;
+    }
+    try {
+        fs_1.default.mkdirSync(outDir, { recursive: true });
+    }
+    catch {
+        logger_1.logger.warn("Could not create outDir directory:", outDir);
+    }
+    const outputPath = (0, file_utils_1.resolveOutDirPath)(outDir, outputBase, toMd);
+    (0, summary_1.showSummary)({ outDir, fileName: path_1.default.basename(outputPath), entries });
+    const result = await (0, dependency_1.followChain)(entries, cfg, limit);
+    const withinclude = await (0, dependency_1.applyincludes)(cfg, result.files);
+    const sorted = [...withinclude].sort((a, b) => a.localeCompare(b));
+    const footer = ["\n---", "*Generated with [Prodex](https://github.com/emxhive/prodex) — Codebase decoded.*", `<!-- PRODEx v${package_json_1.default.version} | ${new Date().toISOString()} -->`].join("\n");
+    const content = toMd ? [(0, renderers_1.tocTxt)(sorted), ...sorted.map(renderers_1.renderTxt)].join("") : [(0, renderers_1.tocMd)(sorted), ...sorted.map((f, i) => (0, renderers_1.renderMd)(f, i)), footer].join("\n");
+    fs_1.default.writeFileSync(outputPath, content, "utf8");
+    logger_1.logger.log(`\n✅ ${outputPath.norm()}`);
+    (0, summary_1.importSummary)(result);
+}

package/dist/core/dependency.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.followChain = followChain;
+exports.applyincludes = applyincludes;
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../constants/config");
+const file_utils_1 = require("./file-utils");
+const logger_1 = require("../lib/logger");
+async function followChain(entryFiles, cfg, limit = 200) {
+    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;
+        all.push(f);
+        const ext = path_1.default.extname(f);
+        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 (limit && all.length >= limit) {
+            logger_1.logger.warn("⚠️  Limit reached:", limit);
+            break;
+        }
+    }
+    return {
+        files: [...new Set(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 });
+    logger_1.logger.debug("APPLY_include", _2j(scan));
+    const combined = [...new Set([...files, ...scan.files])];
+    return combined;
+}

package/dist/core/file-utils.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globScan = globScan;
+exports.generateOutputName = generateOutputName;
+exports.resolveOutDirPath = resolveOutDirPath;
+const path_1 = __importDefault(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const config_1 = require("../constants/config");
+const logger_1 = require("../lib/logger");
+/**
+ * Safe micromatch.scan wrapper (compatible with micromatch v4 & v5)
+ */
+async function globScan(pattern, opts) {
+    logger_1.logger.debug("PATTERN", pattern);
+    const { absolute = true, cwd = process.cwd() } = opts;
+    if (!pattern?.length)
+        return { files: [] };
+    const files = await (0, fast_glob_1.default)(pattern, {
+        cwd,
+        dot: true,
+        onlyFiles: true,
+        ignore: config_1.GLOBAL_IGNORE,
+        absolute,
+    });
+    logger_1.logger.debug("GLOB-SCAN_FILES ", _2j(files));
+    return { files };
+}
+function generateOutputName(entries) {
+    const names = 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 "unknown";
+}
+function resolveOutDirPath(outDir, base, asTxt = false) {
+    const ext = asTxt ? "txt" : "md";
+    return path_1.default.join(outDir, `${base}-combined.${ext}`);
+}

package/dist/core/helpers.js

@@ -0,0 +1,81 @@
+"use strict";
+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;
+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);
+}
+/**
+ * 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();
+    if (depth > scanDepth)
+        return;
+    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+        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))
+                continue;
+            yield* walk(full, cfg, depth + 1);
+            continue;
+        }
+        if (e.isFile()) {
+            const relPath = rel(full, root);
+            if (isExcluded(relPath, entry.exclude))
+                continue;
+            yield full;
+        }
+    }
+}
+function orderByPriority(files, priorityList = []) {
+    if (!priorityList.length)
+        return files;
+    const prioritized = [];
+    const normal = [];
+    for (const f of files) {
+        const normalized = f.norm().toLowerCase();
+        if (priorityList.some(p => micromatch_1.default.isMatch(normalized, p.toLowerCase())))
+            prioritized.push(f);
+        else
+            normal.push(f);
+    }
+    return [...new Set([...prioritized, ...normal])];
+}

package/dist/core/parsers/extract-imports.js

@@ -0,0 +1,51 @@
+"use strict";
+// @ts-nocheck
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractImports = extractImports;
+const promises_1 = __importDefault(require("fs/promises"));
+const es_module_lexer_1 = require("es-module-lexer");
+let initialized = false;
+async function extractImports(filePath, code) {
+    if (!initialized) {
+        await es_module_lexer_1.init;
+        initialized = true;
+    }
+    let src = code;
+    if (src == null) {
+        try {
+            src = await promises_1.default.readFile(filePath, "utf8");
+        }
+        catch {
+            return new Set();
+        }
+    }
+    try {
+        const [imports] = (0, es_module_lexer_1.parse)(src);
+        const out = new Set();
+        for (const i of imports)
+            if (i.n)
+                out.add(i.n);
+        return out;
+    }
+    catch {
+        return fallbackRegex(src);
+    }
+}
+function fallbackRegex(code) {
+    const patterns = [
+        /import\s+[^'"]*['"]([^'"]+)['"]/g,
+        /import\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /require\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /export\s+\*\s+from\s+['"]([^'"]+)['"]/g,
+    ];
+    const matches = new Set();
+    for (const r of patterns) {
+        let m;
+        while ((m = r.exec(code)))
+            matches.add(m[1]);
+    }
+    return matches;
+}

package/dist/core/renderers.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tocMd = tocMd;
+exports.renderMd = renderMd;
+exports.tocTxt = tocTxt;
+exports.renderTxt = renderTxt;
+const path_1 = __importDefault(require("path"));
+const helpers_1 = require("./helpers");
+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");
+}
+/**
+ * Render each file section with invisible anchors
+ */
+function renderMd(p, i) {
+    const rp = (0, helpers_1.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();
+    return [`---\n#### ${i + 1}`, "\n", "` File: " + rp + "`  [↑ Back to top](#index)", "", "```" + lang, code, "```", ""].join("\n");
+}
+/**
+ * TXT version (unchanged)
+ */
+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";
+}
+function renderTxt(p) {
+    const relPath = (0, helpers_1.rel)(p);
+    const code = (0, helpers_1.read)(p);
+    return ["##==== path: " + relPath + " ====", "##region " + relPath, code, "##endregion", ""].join("\n");
+}

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = startProdex;
+const combine_1 = require("./core/combine");
+const init_1 = require("./cli/init");
+const logger_1 = require("./lib/logger");
+const cli_input_1 = require("./cli/cli-input");
+const config_loader_1 = require("./constants/config-loader");
+require("./lib/polyfills");
+async function startProdex() {
+    const args = process.argv;
+    // Handle init mode
+    if (args.includes("init")) {
+        return (0, init_1.initProdex)();
+    }
+    // Parse CLI input
+    const { root, flags, warnings, errors } = (0, cli_input_1.parseCliInput)(args);
+    if (warnings.length)
+        logger_1.logger.warn("Warnings:", warnings);
+    if (errors.length)
+        logger_1.logger.error("Errors:", errors);
+    // Load and merge configuration (with flag overrides)
+    const config = await (0, config_loader_1.loadProdexConfig)(flags, root);
+    logger_1.logger.log(`------- PRODEx RUN @ ${new Date().toLocaleTimeString()} — Codebase decoded -------`);
+    // Log parse results for testing
+    logger_1.logger.debug("🧩 Parsed CLI input:", _2j({ flags }));
+    logger_1.logger.debug("Final merged config:", _2j(config));
+    await (0, combine_1.runCombine)(config, !flags.ci && !flags?.files?.length);
+}

package/dist/lib/logger.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const env = () => {
+    const obj = { debug: process.env.PRODEX_DEBUG === "1", silent: process.env.PRODEX_SILENT === "1" };
+    return obj;
+};
+exports.logger = {
+    debug: (...args) => !env().silent && env().debug && console.log("\n🪶 [debug]", ...args),
+    info: (...args) => !env().silent && console.log("\n📌 [info]", ...args),
+    warn: (...args) => !env().silent && console.warn("\n⚠️ [warn]", ...args),
+    error: (...args) => !env().silent && console.error("\n💥 [error]", ...args),
+    log: (...args) => !env().silent && console.log("\n", ...args),
+};

package/dist/lib/polyfills.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = __importDefault(require("util"));
+if (!String.prototype.norm) {
+    String.prototype.norm = function () {
+        return this.replace(/\\/g, "/");
+    };
+}
+globalThis._2j = (obj) => util_1.default.inspect(obj, { colors: true, depth: null, breakLength: 150, compact: 3 });

package/dist/lib/utils.js

@@ -0,0 +1,15 @@
+"use strict";
+// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unique = unique;
+exports.setDiff = setDiff;
+exports.toArray = toArray;
+function unique(arr) {
+    return [...new Set(arr)];
+}
+function setDiff(A, B) {
+    return new Set([...A].filter(x => !B.has(x)));
+}
+function toArray(v) {
+    return Array.isArray(v) ? v : [v];
+}

package/dist/resolvers/js/alias-loader.js

@@ -0,0 +1,52 @@
+"use strict";
+// @ts-nocheck
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadProjectAliases = loadProjectAliases;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+let cacheByRoot = new Map();
+function loadProjectAliases(root) {
+    if (cacheByRoot.has(root))
+        return cacheByRoot.get(root);
+    const aliases = {};
+    const tsPath = path_1.default.join(root, "tsconfig.json");
+    const viteJs = path_1.default.join(root, "vite.config");
+    const viteTs = path_1.default.join(root, "vite.config.ts");
+    if (fs_1.default.existsSync(tsPath)) {
+        try {
+            const ts = JSON.parse(fs_1.default.readFileSync(tsPath, "utf8"));
+            const paths = ts.compilerOptions?.paths || {};
+            for (const [key, value] of Object.entries(paths)) {
+                const cleanedKey = key.replace(/\/\*$/, "");
+                const first = Array.isArray(value) ? value[0] : value;
+                if (!first)
+                    continue;
+                const cleanedVal = first.replace(/\/\*$/, "");
+                aliases[cleanedKey] = path_1.default.resolve(root, cleanedVal);
+            }
+        }
+        catch { }
+    }
+    for (const vitePath of [viteJs, viteTs]) {
+        if (!fs_1.default.existsSync(vitePath))
+            continue;
+        try {
+            const content = fs_1.default.readFileSync(vitePath, "utf8");
+            const blocks = [...content.matchAll(/alias\s*:\s*\{([^}]+)\}/g)];
+            for (const m of blocks) {
+                const inner = m[1];
+                const pairs = [...inner.matchAll(/['"](.+?)['"]\s*:\s*['"](.+?)['"]/g)];
+                for (const [, key, val] of pairs) {
+                    const abs = path_1.default.isAbsolute(val) ? val : path_1.default.resolve(root, val);
+                    aliases[key] = abs;
+                }
+            }
+        }
+        catch { }
+    }
+    cacheByRoot.set(root, aliases);
+    return aliases;
+}