prodex 1.1.0 → 1.3.0

package/dist/lib/prompt.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prompt = prompt;
+const inquirer_1 = __importDefault(require("inquirer"));
+const logger_1 = require("./logger");
+/**
+ * 🧩 prompt()
+ * Unified and safe wrapper for inquirer.prompt()
+ *
+ * - Requires explicit `showUi` flag (no env auto-detection).
+ * - Returns `null` or `fallback` on failure or disabled UI.
+ * - Handles TTY errors and user cancellations gracefully.
+ */
+async function prompt(questions, fallback) {
+    try {
+        const answers = (await inquirer_1.default.prompt(questions));
+        return answers;
+    }
+    catch (err) {
+        if (err?.isTtyError) {
+            logger_1.logger.warn("Interactive prompts not supported (no TTY).");
+        }
+        else if (/canceled|aborted/i.test(err?.message)) {
+            logger_1.logger.warn("Prompt canceled by user.");
+        }
+        else {
+            logger_1.logger.error("Prompt failed:", err.message || err);
+        }
+        return fallback ?? null;
+    }
+}

package/dist/lib/questions.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PICK_ENTRIES_QUESTION = exports.OUTPUT_NAME_QUESTION = void 0;
+/**
+ * 🧩 Centralized Inquirer question definitions.
+ * Each export is a named, reusable question set.
+ */
+/** Ask for the output filename (used in produceOutput). */
+exports.OUTPUT_NAME_QUESTION = [
+    {
+        type: "input",
+        name: "outputBase",
+        message: "Output file name (without extension):",
+        default: "combined",
+        filter: (v) => v.trim().replace(/[<>:\"/\\|?*]+/g, "_") || "combined",
+    },
+];
+const PICK_ENTRIES_QUESTION = (choices, depth) => [
+    {
+        type: "checkbox",
+        name: "picks",
+        message: `Select entry files (depth ${depth})`,
+        choices,
+        loop: false,
+        pageSize: 20,
+    },
+];
+exports.PICK_ENTRIES_QUESTION = PICK_ENTRIES_QUESTION;

package/dist/lib/utils.js

@@ -0,0 +1,51 @@
+"use strict";
+// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unique = unique;
+exports.setDiff = setDiff;
+exports.toArray = toArray;
+exports.shortTimestamp = shortTimestamp;
+exports.normalizePatterns = normalizePatterns;
+const config_1 = require("../constants/config");
+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];
+}
+/** Compact YYMMDD-HHmm timestamp for versioned filenames. */
+function shortTimestamp() {
+    const d = new Date();
+    const yy = String(d.getFullYear()).slice(-2);
+    const MM = String(d.getMonth() + 1).padStart(2, "0");
+    const dd = String(d.getDate()).padStart(2, "0");
+    const hh = String(d.getHours()).padStart(2, "0");
+    const mm = String(d.getMinutes()).padStart(2, "0");
+    return `${yy}${MM}${dd}-${hh}${mm}`;
+}
+function normalizePatterns(input) {
+    if (!input)
+        return [];
+    let arr;
+    if (typeof input === "string") {
+        arr = input.split(",").map((s) => s.trim());
+    }
+    else if (Array.isArray(input)) {
+        arr = input.map((s) => (typeof s === "string" ? s.trim() : ""));
+    }
+    else {
+        return [];
+    }
+    return arr
+        .filter((s) => s.length > 0)
+        .map((s) => s.replace(/\\/g, "/")) // normalize slashes
+        .filter((s) => {
+        const valid = config_1.VALID_GLOB_CHARS.test(s);
+        if (!valid)
+            console.warn(`⚠️  Invalid glob pattern skipped: "${s}"`);
+        return valid;
+    });
+}

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;
+}

package/dist/resolvers/js/js-resolver.js

@@ -0,0 +1,153 @@
+"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.resolveJsImports = resolveJsImports;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const micromatch_1 = __importDefault(require("micromatch"));
+const extract_imports_1 = require("../../core/parsers/extract-imports");
+const alias_loader_1 = require("./alias-loader");
+const config_1 = require("../../constants/config");
+const utils_1 = require("../../lib/utils");
+const logger_1 = require("../../lib/logger");
+const IMPORTS_CACHE = new Map();
+const STAT_CACHE = new Map();
+async function resolveJsImports(filePath, cfg, visited = new Set(), depth = 0, maxDepth = cfg?.resolve?.depth ?? 8, ctx = {}) {
+    if (depth >= maxDepth)
+        return empty(visited);
+    const ROOT = cfg.root;
+    const resolveCfg = cfg.resolve ?? {};
+    // Single exclude list, applied to RAW SPECIFIERS only.
+    const exclude = resolveCfg.exclude ?? [];
+    const isExcluded = micromatch_1.default.matcher(exclude);
+    if (visited.has(filePath))
+        return empty(visited);
+    visited.add(filePath);
+    const ext = path_1.default.extname(filePath).toLowerCase();
+    const isDts = ext === config_1.DTS_EXT;
+    if (!config_1.BASE_EXTS.includes(ext) && !isDts)
+        return empty(visited);
+    let code;
+    try {
+        code = await promises_1.default.readFile(filePath, "utf8");
+    }
+    catch {
+        return empty(visited);
+    }
+    if (!ctx.aliases) {
+        ctx.aliases = { ...(0, alias_loader_1.loadProjectAliases)(ROOT), ...(resolveCfg.aliases || {}) };
+    }
+    const aliases = ctx.aliases;
+    const matches = await getImportsCached(filePath, code);
+    if (!matches.size)
+        return empty(visited);
+    const filesOut = [];
+    const expected = new Set();
+    const resolvedSet = new Set();
+    for (const imp of matches) {
+        // Only consider relative, absolute, or known-alias specifiers
+        if (!imp.startsWith(".") && !imp.startsWith("/") && !startsWithAnyAlias(imp, aliases)) {
+            continue;
+        }
+        // Apply single exclude matcher to the RAW specifier
+        if (isExcluded(imp))
+            continue;
+        // Always count valid, non-excluded specifiers as "expected"
+        expected.add(imp);
+        const basePath = resolveBasePath(filePath, imp, aliases);
+        if (!basePath)
+            continue;
+        const resolvedPath = await tryResolveImport(basePath, ROOT);
+        if (!resolvedPath)
+            continue;
+        filesOut.push(resolvedPath);
+        resolvedSet.add(imp);
+        // Never recurse into `.d.ts`
+        if (resolvedPath.toLowerCase().endsWith(config_1.DTS_EXT)) {
+            continue;
+            logger_1.logger.debug("HERE HERE");
+        }
+        const sub = await resolveJsImports(resolvedPath, cfg, visited, depth + 1, maxDepth, ctx);
+        if (sub.files.length)
+            filesOut.push(...sub.files);
+        for (const s of sub.stats.expected)
+            expected.add(s);
+        for (const r of sub.stats.resolved)
+            resolvedSet.add(r);
+    }
+    const uniqueFiles = [...new Set(filesOut)];
+    //Stat Log
+    const expCount = expected.size;
+    const resCount = resolvedSet.size;
+    const diff = (0, utils_1.setDiff)(expected, resolvedSet);
+    logger_1.logger.debug(`🪶 [js-resolver] ${filePath} → expected: ${expCount}, resolved: ${resCount}`);
+    logger_1.logger.debug([...diff], "🔴THE diff");
+    return { files: uniqueFiles, visited, stats: { expected, resolved: resolvedSet } };
+}
+// ---------- helpers ----------
+function startsWithAnyAlias(imp, aliases) {
+    return Object.keys(aliases).some((a) => imp === a || imp.startsWith(a + "/"));
+}
+function resolveBasePath(fromFile, specifier, aliases) {
+    if (specifier.startsWith("@")) {
+        const key = Object.keys(aliases)
+            .filter((a) => specifier === a || specifier.startsWith(a + "/"))
+            .sort((a, b) => b.length - a.length)[0];
+        if (!key)
+            return null;
+        const relPart = specifier.slice(key.length).replace(/^\/+/, "");
+        return path_1.default.resolve(aliases[key], relPart);
+    }
+    if (specifier.startsWith(".")) {
+        return path_1.default.resolve(path_1.default.dirname(fromFile), specifier);
+    }
+    if (specifier.startsWith("/")) {
+        return path_1.default.resolve(specifier);
+    }
+    return null;
+}
+async function tryResolveImport(basePath, ROOT) {
+    const candidates = [];
+    if (path_1.default.extname(basePath)) {
+        candidates.push(basePath);
+    }
+    else {
+        for (const ext of [...config_1.BASE_EXTS, config_1.DTS_EXT]) {
+            candidates.push(basePath + ext);
+            candidates.push(path_1.default.join(basePath, "index" + ext));
+        }
+    }
+    for (const c of candidates) {
+        const abs = path_1.default.resolve(c);
+        const st = await safeStat(abs);
+        if (st && st.isFile())
+            return abs;
+    }
+    return null;
+}
+async function safeStat(p) {
+    if (STAT_CACHE.has(p))
+        return STAT_CACHE.get(p);
+    try {
+        const st = await promises_1.default.stat(p);
+        STAT_CACHE.set(p, st);
+        return st;
+    }
+    catch {
+        STAT_CACHE.set(p, null);
+        return null;
+    }
+}
+async function getImportsCached(filePath, code) {
+    if (IMPORTS_CACHE.has(filePath))
+        return IMPORTS_CACHE.get(filePath);
+    const set = await (0, extract_imports_1.extractImports)(filePath, code);
+    IMPORTS_CACHE.set(filePath, set);
+    return set;
+}
+function empty(visited) {
+    return { files: [], visited, stats: { expected: new Set(), resolved: new Set() } };
+}

package/dist/resolvers/php/bindings.js

@@ -0,0 +1,32 @@
+"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.loadLaravelBindings = loadLaravelBindings;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../../constants/config");
+function loadLaravelBindings() {
+    const providersDir = path_1.default.join(config_1.ROOT, "app", "Providers");
+    const bindings = {};
+    if (!fs_1.default.existsSync(providersDir))
+        return bindings;
+    const files = fs_1.default
+        .readdirSync(providersDir)
+        .filter(f => f.endsWith(".php"))
+        .map(f => path_1.default.join(providersDir, f));
+    // Match: $this->app->bind(Interface::class, Implementation::class)
+    const re = /$this->app->(?:bind|singleton)\s*\(\s*([A-Za-z0-9_:\\\\]+)::class\s*,\s*([A-Za-z0-9_:\\\\]+)::class/g;
+    for (const file of files) {
+        const code = fs_1.default.readFileSync(file, "utf8");
+        let m;
+        while ((m = re.exec(code))) {
+            const iface = m[1].replace(/\\\\/g, "\\");
+            const impl = m[2].replace(/\\\\/g, "\\");
+            bindings[iface] = impl;
+        }
+    }
+    return bindings;
+}

package/dist/resolvers/php/patterns.js

@@ -0,0 +1,17 @@
+"use strict";
+// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPhpImports = extractPhpImports;
+function extractPhpImports(code) {
+    const out = new Set();
+    const patterns = [
+        /\b(?:require|include|require_once|include_once)\s*\(?['"]([^'"]+)['"]\)?/g,
+        /\buse\s+([A-Z][\w\\]+(?:\s*{[^}]+})?)/g
+    ];
+    for (const r of patterns) {
+        let m;
+        while ((m = r.exec(code)))
+            out.add(m[1]);
+    }
+    return out;
+}

package/dist/resolvers/php/php-resolver.js

@@ -0,0 +1,88 @@
+"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.resolvePhpImports = resolvePhpImports;
+const fs_1 = __importDefault(require("fs"));
+const bindings_1 = require("./bindings");
+const psr4_1 = require("./psr4");
+const patterns_1 = require("./patterns");
+const logger_1 = require("../../lib/logger");
+const stats_1 = require("../shared/stats");
+const file_cache_1 = require("../shared/file-cache");
+const excludes_1 = require("../shared/excludes");
+async function resolvePhpImports(filePath, cfg, visited = new Set(), depth = 0, maxDepth = cfg?.resolve?.depth ?? 10, ctx = {}) {
+    if (depth >= maxDepth)
+        return empty(visited);
+    const stats = (0, stats_1.newStats)();
+    const filesOut = [];
+    const ROOT = cfg.root || process.cwd();
+    if (!ctx.psr4)
+        ctx.psr4 = (0, psr4_1.resolvePsr4)(ROOT);
+    if (!ctx.nsKeys)
+        ctx.nsKeys = Object.keys(ctx.psr4).sort((a, b) => b.length - a.length);
+    if (!ctx.bindings)
+        ctx.bindings = (0, bindings_1.loadLaravelBindings)();
+    if (visited.has(filePath))
+        return empty(visited);
+    visited.add(filePath);
+    if (!fs_1.default.existsSync(filePath))
+        return empty(visited);
+    const code = fs_1.default.readFileSync(filePath, "utf8");
+    const exclude = cfg.imports?.exclude ?? [];
+    const raw = (0, patterns_1.extractPhpImports)(code);
+    const imports = expandGroupedUses(raw);
+    for (const imp0 of imports) {
+        let imp = imp0;
+        if (ctx.bindings[imp]) {
+            log("🔗 Bound:", imp0, "→", ctx.bindings[imp]);
+            imp = ctx.bindings[imp];
+        }
+        if (!startsWithAny(imp, ctx.nsKeys))
+            continue;
+        if ((0, excludes_1.isExcluded)(imp, exclude))
+            continue;
+        stats.expected.add(imp);
+        const resolvedPath = (0, file_cache_1.tryResolvePhpFile)(imp, filePath, ctx.psr4);
+        if (!resolvedPath)
+            continue;
+        stats.resolved.add(imp);
+        filesOut.push(resolvedPath);
+        const sub = await resolvePhpImports(resolvedPath, cfg, visited, depth + 1, maxDepth, ctx);
+        filesOut.push(...sub.files);
+        (0, stats_1.mergeStats)(stats, sub.stats);
+    }
+    log("✅ PHP resolver:", filePath, "→", filesOut.length);
+    return {
+        files: [...new Set(filesOut)],
+        visited,
+        stats
+    };
+}
+// ---------- Local helpers (resolver-scoped only) ----------
+function startsWithAny(imp, nsKeys) {
+    return nsKeys.some(k => imp.startsWith(k));
+}
+function empty(visited) {
+    return { files: [], visited, stats: (0, stats_1.emptyStats)() };
+}
+const log = (...a) => logger_1.logger.debug("[php-resolver]", ...a);
+function expandGroupedUses(raw) {
+    const out = new Set();
+    for (const imp of raw) {
+        const g = imp.match(/^(.+?)\s*{([^}]+)}/);
+        if (g) {
+            const base = g[1].trim().replace(/\\+$/, "");
+            g[2]
+                .split(",")
+                .map(x => x.trim())
+                .forEach(p => out.add(`${base}\\${p}`));
+        }
+        else {
+            out.add(imp.trim());
+        }
+    }
+    return out;
+}

package/dist/resolvers/php/psr4.js

@@ -0,0 +1,26 @@
+"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.resolvePsr4 = resolvePsr4;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function resolvePsr4(ROOT) {
+    const composer = path_1.default.join(ROOT, "composer.json");
+    if (!fs_1.default.existsSync(composer))
+        return {};
+    try {
+        const data = JSON.parse(fs_1.default.readFileSync(composer, "utf8"));
+        const src = data.autoload?.["psr-4"] || {};
+        const map = {};
+        for (const ns in src) {
+            map[ns.replace(/\\+$/, "")] = path_1.default.resolve(ROOT, src[ns]);
+        }
+        return map;
+    }
+    catch {
+        return {};
+    }
+}

package/dist/resolvers/shared/excludes.js

@@ -0,0 +1,11 @@
+"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.isExcluded = isExcluded;
+const micromatch_1 = __importDefault(require("micromatch"));
+function isExcluded(imp, exclude = []) {
+    return micromatch_1.default.isMatch(imp.replaceAll("\\", "/"), exclude);
+}

package/dist/resolvers/shared/file-cache.js

@@ -0,0 +1,29 @@
+"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.tryResolvePhpFile = tryResolvePhpFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const CACHE = new Map();
+function tryResolvePhpFile(imp, fromFile, psr4) {
+    const key = `php:${imp}:${fromFile}`;
+    if (CACHE.has(key))
+        return CACHE.get(key);
+    const nsKey = Object.keys(psr4).find(k => imp.startsWith(k));
+    if (!nsKey) {
+        CACHE.set(key, null);
+        return null;
+    }
+    const rel = imp.slice(nsKey.length).replace(/\\/g, "/");
+    const tries = [
+        path_1.default.join(psr4[nsKey], rel),
+        path_1.default.join(psr4[nsKey], rel + ".php"),
+        path_1.default.join(psr4[nsKey], rel, "index.php")
+    ];
+    const resolved = tries.find(p => fs_1.default.existsSync(p) && fs_1.default.statSync(p).isFile());
+    CACHE.set(key, resolved ? path_1.default.resolve(resolved) : null);
+    return CACHE.get(key);
+}

package/dist/resolvers/shared/stats.js

@@ -0,0 +1,17 @@
+"use strict";
+// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newStats = newStats;
+exports.mergeStats = mergeStats;
+exports.emptyStats = emptyStats;
+function newStats() {
+    return { expected: new Set(), resolved: new Set() };
+}
+function mergeStats(target, src) {
+    src.expected.forEach(i => target.expected.add(i));
+    src.resolved.forEach(i => target.resolved.add(i));
+    return target;
+}
+function emptyStats() {
+    return { expected: new Set(), resolved: new Set() };
+}

package/dist/types/cli.types.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * CLI flag schema for Prodex.
+ * Mirrors the current CLI synopsis:
+ *
+ *   prodex [entries...] [-tcdv]
+ *          [--txt] [--ci] [--debug] [--verbose]
+ *          [--name=<string>|-n=<string>]
+ *          [--limit=<int>|-l=<int>]
+ *          [--inc=<globs>] [--exc=<globs>]
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/config.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/core.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.js

@@ -0,0 +1,21 @@
+"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("./config.types"), exports);
+__exportStar(require("./cli.types"), exports);
+__exportStar(require("./core.types"), exports);
+__exportStar(require("./resolver.types"), exports);
+__exportStar(require("./utils.types"), exports);

package/dist/types/resolver.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/utils.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,15 +1,13 @@
 {
   "name": "prodex",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Unified Project Indexer & Dependency Extractor for Laravel + React + Node stacks.",
-  "type": "module",
+  "type": "commonjs",
   "bin": {
     "prodex": "./bin/prodex.js"
   },
-  "main": "./dist/core/combine.js",
-  "exports": {
-    ".": "./dist/core/combine.js"
-  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist/",
     "bin/",
@@ -27,19 +25,25 @@
     "indexer"
   ],
   "scripts": {
-    "clean": "rm -rf dist",
-    "build": "npm run clean && node -e \"require('fs').mkdirSync('dist',{recursive:true})\" && cp -r src bin package.json README.md LICENSE dist/",
+    "build": "tsc",
+    "dev": "tsc --watch",
     "prepare": "npm run build"
   },
+  "engines": {
+    "node": ">=16"
+  },
   "author": "emxhive",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "^24.9.1",
-    "tsup": "^8.5.0",
-    "typescript": "^5.9.3"
+    "@types/node": "^24.9.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.4"
   },
   "dependencies": {
+    "es-module-lexer": "^1.7.0",
+    "fast-glob": "^3.3.3",
     "inquirer": "^12.10.0",
-    "micromatch": "^4.0.8"
+    "micromatch": "^4.0.8",
+    "sade": "^1.8.1"
   }
 }