prodex 1.4.11 → 2.0.1

package/dist/app/project-context.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadProjectContext = loadProjectContext;
+exports.resolveRoot = resolveRoot;
+exports.validateRoot = validateRoot;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const load_1 = require("../config/load");
+function loadProjectContext(rootArg, cwd = process.cwd()) {
+    const root = resolveRoot(rootArg, cwd);
+    const warnings = [];
+    const errors = validateRoot(root, rootArg);
+    if (errors.length) {
+        return {
+            root,
+            config: {},
+            configPath: path_1.default.join(root, "prodex.json"),
+            configExists: false,
+            warnings,
+            errors,
+        };
+    }
+    const loaded = (0, load_1.loadConfig)(root);
+    return fromLoadedConfig(root, loaded);
+}
+function resolveRoot(rootArg, cwd = process.cwd()) {
+    return rootArg ? path_1.default.resolve(cwd, rootArg) : cwd;
+}
+function validateRoot(root, rootArg) {
+    if (!fs_1.default.existsSync(root))
+        return [`Invalid root path "${rootArg}".`];
+    if (!fs_1.default.statSync(root).isDirectory())
+        return [`Root path "${rootArg}" is not a directory.`];
+    return [];
+}
+function fromLoadedConfig(root, loaded) {
+    return {
+        root,
+        config: loaded.config,
+        configPath: loaded.path,
+        configExists: loaded.exists,
+        warnings: [...loaded.warnings],
+        errors: [...loaded.errors],
+    };
+}

package/dist/app/run-plans.d.ts

@@ -0,0 +1,11 @@
+import type { ProdexFlags, RunPlan } from "../types";
+export interface CreateRunPlansResult {
+    plans: RunPlan[];
+    warnings: string[];
+    errors: string[];
+}
+export declare function createRunPlans(params: {
+    rootArg?: string;
+    flags?: Partial<ProdexFlags>;
+    cwd?: string;
+}): CreateRunPlansResult;

package/dist/app/run-plans.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRunPlans = createRunPlans;
+const build_config_1 = require("../config/build-config");
+const project_context_1 = require("./project-context");
+function createRunPlans(params) {
+    const project = (0, project_context_1.loadProjectContext)(params.rootArg, params.cwd);
+    const warnings = [...project.warnings];
+    const errors = [...project.errors];
+    const flags = params.flags ?? {};
+    if (errors.length)
+        return { plans: [], warnings, errors };
+    const profileNames = resolveProfileNames(flags, project.config.profiles ?? {}, errors);
+    if (errors.length)
+        return { plans: [], warnings, errors };
+    const plans = [];
+    for (const profileName of profileNames.length ? profileNames : [undefined]) {
+        const runFlags = flagsForProfileRun(flags, profileName);
+        const built = (0, build_config_1.buildConfig)({
+            root: project.root,
+            userConfig: project.config,
+            flags: runFlags,
+            profileName,
+        });
+        warnings.push(...built.warnings);
+        errors.push(...built.errors);
+        if (!built.config)
+            continue;
+        plans.push({
+            root: project.root,
+            config: built.config,
+            flags: runFlags,
+            outputName: built.config.name,
+            profile: profileName,
+        });
+    }
+    return { plans, warnings, errors };
+}
+function resolveProfileNames(flags, profiles, errors) {
+    if (flags.allProfiles) {
+        const names = Object.keys(profiles);
+        if (!names.length)
+            errors.push("No profiles are defined in prodex.json.");
+        return names;
+    }
+    if (Array.isArray(flags.profiles) && flags.profiles.length)
+        return unique(flags.profiles);
+    return [];
+}
+function flagsForProfileRun(flags, profile) {
+    if (!profile)
+        return flags;
+    return {
+        ...flags,
+        profiles: undefined,
+        allProfiles: false,
+    };
+}
+function unique(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}

package/dist/cache/cache-keys.d.ts

@@ -0,0 +1,9 @@
+export declare const CACHE_KEYS: {
+    readonly ALIASES: "aliases";
+    readonly JS_IMPORTS: "js:imports";
+    readonly JS_STATS: "js:stats";
+    readonly PHP_PSR4: "php:psr4";
+    readonly PHP_BINDINGS: "php:bindings";
+    readonly PHP_FILECACHE: "php:fileCache";
+};
+export type CacheNamespace = (typeof CACHE_KEYS)[keyof typeof CACHE_KEYS];

package/dist/cache/cache-manager.d.ts

@@ -0,0 +1,9 @@
+export declare class CacheManager {
+    private static registry;
+    private static ns;
+    static set<T = any>(ns: string, key: string, val: T): void;
+    static get<T = any>(ns: string, key: string): T | undefined;
+    static clear(ns?: string): void;
+    static dump(ns: string): Record<string, any>;
+    static stats(): Record<string, number>;
+}

package/dist/{core/managers/cache.js → cache/cache-manager.js}

@@ -1,48 +1,35 @@
 "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
- */
+const logger_1 = require("../diagnostics/logger");
+const inspect_1 = require("../filesystem/inspect");
 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} \n→ ${_2j(val)}`);
+        logger_1.logger.debug(`[cache:${ns}] set ${key}\n-> ${(0, inspect_1.inspectValue)(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`);
+            logger_1.logger.debug(`[cache:${ns}] cleared`);
         }
         else {
             this.registry.forEach((m) => m.clear());
-            logger_1.logger.debug("🧩 [cache] cleared all namespaces");
+            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)

package/dist/cli/cli-input.d.ts

@@ -0,0 +1,2 @@
+import type { CliParseResult } from "../types";
+export declare function parseCliInput(argv?: string[]): CliParseResult;

package/dist/cli/cli-input.js

@@ -1,145 +1,159 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCliInput = parseCliInput;
-const sade_1 = __importDefault(require("sade"));
-const path_1 = __importDefault(require("path"));
-const package_json_1 = __importDefault(require("../../package.json"));
-const fs_1 = __importDefault(require("fs"));
-const flags_1 = require("../constants/flags");
-function extractShortcutTokens(argv) {
-    const cleaned = [];
-    const shortcuts = [];
-    let shortcutAll = false;
-    for (const arg of argv) {
-        if (arg === "@") {
-            shortcutAll = true;
+const string_list_1 = require("../config/string-list");
+const flag_specs_1 = require("./flag-specs");
+function parseCliInput(argv = process.argv) {
+    const tokens = stripExecutable(argv);
+    const warnings = [];
+    const errors = [];
+    const flags = {};
+    if (!tokens.length) {
+        errors.push("Missing command. Use `prodex run`, `prodex init`, `prodex profiles`, or `prodex migrate`.");
+        return { warnings, errors };
+    }
+    if (tokens.includes("--version") || tokens.includes("-v")) {
+        return { command: { kind: "version" }, warnings, errors };
+    }
+    if (tokens[0] === "--help" || tokens[0] === "-h") {
+        return { command: { kind: "help" }, warnings, errors };
+    }
+    const commandName = tokens[0];
+    if (!isCommand(commandName)) {
+        errors.push(`Unknown command "${commandName}". Use run, init, profiles, or migrate.`);
+        return { warnings, errors };
+    }
+    let rootArg;
+    for (let i = 1; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (!token)
+            continue;
+        if (token.startsWith("--")) {
+            const consumed = readLongFlag(tokens, i, flags, errors);
+            i += consumed;
             continue;
         }
-        if (arg?.startsWith("@")) {
-            const name = arg.slice(1).trim();
-            if (!name)
-                shortcutAll = true;
-            else
-                shortcuts.push(name);
+        if (token.startsWith("-") && token !== "-") {
+            const consumed = readShortFlag(tokens, i, flags, errors);
+            i += consumed;
             continue;
         }
-        cleaned.push(arg);
+        if (rootArg) {
+            errors.push(`Unexpected positional argument "${token}". Only one root path is accepted.`);
+            continue;
+        }
+        rootArg = token;
     }
-    return { argv: cleaned, shortcutAll, shortcuts };
+    if (flags.help)
+        return { command: { kind: "help", topic: commandName }, warnings, errors };
+    if (commandName === "init")
+        return { command: { kind: "init", rootArg }, warnings, errors };
+    if (commandName === "profiles")
+        return { command: { kind: "profiles", rootArg }, warnings, errors };
+    if (commandName === "migrate") {
+        return { command: { kind: "migrate", rootArg, write: !!flags.write, check: !!flags.check }, warnings, errors };
+    }
+    return { command: { kind: "run", rootArg, flags }, warnings, errors };
 }
-/**
- * Unified CLI parser powered by Sade and FLAG_MAP.
- * Returns { root, flags, warnings, errors }.
- */
-function parseCliInput(argv = process.argv) {
-    if (argv.includes("-v") || argv.includes("--version")) {
-        console.log(`prodex v${package_json_1.default.version}`);
-        process.exit(0);
-    }
-    const extracted = extractShortcutTokens(argv);
-    const argvCleaned = extracted.argv;
-    const program = (0, sade_1.default)("prodex [root]");
-    registerFlags(program);
-    let parsed = { rootArg: "", root: undefined, flags: {} };
-    program.action((root, opts) => {
-        const cwd = process.cwd();
-        parsed = {
-            rootArg: root,
-            root: root ? path_1.default.resolve(cwd, root) : cwd,
-            flags: { ...opts },
-        };
-    });
-    program.parse(argvCleaned);
-    // Merge shortcut tokens (@a @b @c / @) with existing --shortcut usage.
-    const fromTokens = extracted.shortcuts;
-    const shortcutAll = extracted.shortcutAll;
-    const fromFlag = typeof parsed.flags.shortcut === "string" ? parsed.flags.shortcut.trim() : "";
-    const selected = [...fromTokens, ...(fromFlag ? [fromFlag] : [])].filter(Boolean);
-    const uniq = Array.from(new Set(selected));
-    if (shortcutAll)
-        parsed.flags.shortcutAll = true;
-    if (uniq.length)
-        parsed.flags.shortcuts = uniq;
-    if (!shortcutAll && uniq.length === 1)
-        parsed.flags.shortcut = uniq[0];
-    else if (uniq.length > 1 || shortcutAll)
-        delete parsed.flags.shortcut;
-    const warnings = [];
-    const errors = [];
-    parsed.flags = normalizeFlags(parsed.flags, warnings, errors);
-    validateArgs(parsed, warnings, errors);
-    return { ...parsed, warnings, errors };
+function stripExecutable(argv) {
+    const [first, second, ...rest] = argv;
+    const firstBase = first ? basename(first) : "";
+    const secondBase = second ? basename(second) : "";
+    if (/^node(\.exe)?$/.test(firstBase))
+        return rest;
+    if (secondBase.startsWith("prodex") && firstBase)
+        return rest;
+    if (firstBase.startsWith("prodex"))
+        return argv.slice(1);
+    return argv;
 }
-function registerFlags(program) {
-    for (const [key, meta] of Object.entries(flags_1.FLAG_MAP)) {
-        const short = meta.short ? `-${meta.short}, ` : "";
-        const defaultVal = meta.type === "boolean" ? false : undefined;
-        program.option(`${short}--${key}`, meta.description, defaultVal);
-    }
+function basename(value) {
+    return value.split(/[\\/]/).pop()?.toLowerCase() ?? "";
 }
-function normalizeFlags(flags, warnings, errors) {
-    // Remap short aliases (-i/-f/-d) to long keys (include/files/debug)
-    for (const [short, longKey] of Object.entries(flags_1.FLAG_SHORT_MAP)) {
-        if (flags[longKey] === undefined && flags[short] !== undefined) {
-            flags[longKey] = flags[short];
-            delete flags[short];
-        }
+function isCommand(token) {
+    return flag_specs_1.COMMANDS.includes(token);
+}
+function readLongFlag(tokens, index, flags, errors) {
+    const token = tokens[index];
+    const raw = token.slice(2);
+    const equalsAt = raw.indexOf("=");
+    const rawName = equalsAt === -1 ? raw : raw.slice(0, equalsAt);
+    const name = flag_specs_1.FLAG_ALIASES[rawName] ?? rawName;
+    const inlineValue = equalsAt === -1 ? undefined : raw.slice(equalsAt + 1);
+    const spec = flag_specs_1.FLAGS_BY_LONG.get(name);
+    if (!spec) {
+        errors.push(`Unknown flag "--${rawName}".`);
+        return 0;
     }
-    for (const [key, meta] of Object.entries(flags_1.FLAG_MAP)) {
-        const raw = flags[key];
-        if (raw === undefined)
-            continue;
-        switch (meta.type) {
-            case "number": {
-                const num = Number(raw);
-                if (Number.isNaN(num))
-                    errors.push(`Flag --${key} expected a number but got "${raw}"`);
-                else
-                    flags[key] = num;
-                break;
-            }
-            case "list": {
-                flags[key] = String(raw)
-                    .split(",")
-                    .map((v) => v.trim())
-                    .filter(Boolean);
-                break;
-            }
-            case "boolean": {
-                flags[key] = Boolean(raw);
-                break;
+    if (spec.type === "boolean") {
+        flags[spec.long] = inlineValue === undefined ? true : coerceBoolean(inlineValue);
+        return 0;
+    }
+    const value = inlineValue ?? tokens[index + 1];
+    if (value === undefined || value.startsWith("-")) {
+        errors.push(`Flag "--${rawName}" expects a value.`);
+        return 0;
+    }
+    assignFlag(flags, spec, value, errors);
+    return inlineValue === undefined ? 1 : 0;
+}
+function readShortFlag(tokens, index, flags, errors) {
+    const token = tokens[index];
+    const cluster = token.slice(1);
+    if (cluster.length > 1) {
+        for (const ch of cluster) {
+            const spec = flag_specs_1.FLAGS_BY_SHORT.get(ch);
+            if (!spec) {
+                errors.push(`Unknown flag "-${ch}".`);
+                continue;
             }
-            default: {
-                if (meta.type === "string")
-                    flags[key] = String(raw);
+            if (spec.type !== "boolean") {
+                errors.push(`Flag "-${ch}" expects a value and cannot be used in a short flag cluster.`);
+                continue;
             }
+            flags[spec.long] = true;
         }
+        return 0;
+    }
+    const spec = flag_specs_1.FLAGS_BY_SHORT.get(cluster);
+    if (!spec) {
+        errors.push(`Unknown flag "-${cluster}".`);
+        return 0;
+    }
+    if (spec.type === "boolean") {
+        flags[spec.long] = true;
+        return 0;
+    }
+    const value = tokens[index + 1];
+    if (value === undefined || value.startsWith("-")) {
+        errors.push(`Flag "-${cluster}" expects a value.`);
+        return 0;
     }
-    return flags;
+    assignFlag(flags, spec, value, errors);
+    return 1;
 }
-/** Validate path argument and report unrecognized flags. */
-function validateArgs(parsed, warnings, errors) {
-    const { rootArg } = parsed;
-    if (rootArg) {
-        if (!fs_1.default.existsSync(parsed.root)) {
-            errors.push(`Invalid path "${rootArg}"`);
-        }
-        else if (!fs_1.default.statSync(parsed.root).isDirectory()) {
-            errors.push(`Path argument "${rootArg}" is not a directory.`);
-        }
+function assignFlag(flags, spec, value, errors) {
+    if (spec.type === "number") {
+        const numeric = Number(value);
+        if (!Number.isFinite(numeric))
+            errors.push(`Flag "--${spec.long}" expected a number but got "${value}".`);
+        else
+            flags[spec.long] = numeric;
+        return;
     }
-    const unknown = parsed.flags?._ || [];
-    if (unknown.length) {
-        warnings.push(`Unrecognized arguments detected [${unknown.join(", ")}]- They were ignored.`);
+    if (spec.type === "list") {
+        const values = (0, string_list_1.splitStringList)(value);
+        const target = spec.long === "profile" ? "profiles" : spec.long;
+        const current = (flags[target] ?? []);
+        flags[target] = [...current, ...values];
+        return;
     }
-    if (warnings.length)
-        console.warn("Warnings:", warnings);
-    if (errors.length) {
-        for (const err of errors)
-            console.error(err);
-        process.exit(1);
+    if (spec.long === "format" && !["md", "txt"].includes(value)) {
+        errors.push(`Flag "--format" expected "md" or "txt" but got "${value}".`);
+        return;
     }
+    flags[spec.long] = value;
+}
+function coerceBoolean(value) {
+    return !["0", "false", "no", "off"].includes(value.toLowerCase());
 }

package/dist/cli/flag-specs.d.ts

@@ -0,0 +1,12 @@
+import type { ProdexFlags } from "../types";
+export type FlagName = keyof ProdexFlags | "help" | "version" | "profile" | "write" | "check";
+export type FlagSpec = {
+    long: FlagName;
+    short?: string;
+    type: "boolean" | "string" | "number" | "list";
+};
+export declare const COMMANDS: readonly ["run", "init", "profiles", "migrate"];
+export declare const FLAGS: FlagSpec[];
+export declare const FLAG_ALIASES: Record<string, FlagName>;
+export declare const FLAGS_BY_LONG: Map<FlagName, FlagSpec>;
+export declare const FLAGS_BY_SHORT: Map<string, FlagSpec>;

package/dist/cli/flag-specs.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLAGS_BY_SHORT = exports.FLAGS_BY_LONG = exports.FLAG_ALIASES = exports.FLAGS = exports.COMMANDS = void 0;
+exports.COMMANDS = ["run", "init", "profiles", "migrate"];
+exports.FLAGS = [
+    { long: "entry", short: "e", type: "list" },
+    { long: "include", short: "i", type: "list" },
+    { long: "exclude", short: "x", type: "list" },
+    { long: "profile", short: "p", type: "list" },
+    { long: "allProfiles", short: "a", type: "boolean" },
+    { long: "name", short: "n", type: "string" },
+    { long: "format", short: "F", type: "string" },
+    { long: "maxDepth", type: "number" },
+    { long: "maxFiles", type: "number" },
+    { long: "debug", short: "d", type: "boolean" },
+    { long: "write", type: "boolean" },
+    { long: "check", type: "boolean" },
+    { long: "help", short: "h", type: "boolean" },
+    { long: "version", short: "v", type: "boolean" },
+];
+exports.FLAG_ALIASES = {
+    all: "allProfiles",
+    "all-profiles": "allProfiles",
+    "max-depth": "maxDepth",
+    "max-files": "maxFiles",
+};
+exports.FLAGS_BY_LONG = new Map(exports.FLAGS.map((flag) => [flag.long, flag]));
+exports.FLAGS_BY_SHORT = new Map(exports.FLAGS.filter((flag) => flag.short).map((flag) => [flag.short, flag]));

package/dist/cli/help.d.ts

@@ -0,0 +1,2 @@
+export declare function renderHelp(topic?: string): string;
+export declare function renderVersion(): string;

package/dist/cli/help.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderHelp = renderHelp;
+exports.renderVersion = renderVersion;
+const package_json_1 = __importDefault(require("../../package.json"));
+function renderHelp(topic) {
+    if (topic === "run")
+        return renderRunHelp();
+    if (topic === "init")
+        return renderInitHelp();
+    if (topic === "profiles")
+        return renderProfilesHelp();
+    if (topic === "migrate")
+        return renderMigrateHelp();
+    return [
+        "Usage:",
+        "  prodex run [root] [options]",
+        "  prodex init [root]",
+        "  prodex profiles [root]",
+        "  prodex migrate [root] [--write|--check]",
+        "",
+        "Global options:",
+        "  -h, --help                Show help.",
+        "  -v, --version             Show version.",
+        "",
+        "Run `prodex <command> --help` for command-specific help.",
+    ].join("\n");
+}
+function renderVersion() {
+    return `prodex v${package_json_1.default.version}`;
+}
+function renderRunHelp() {
+    return [
+        "Usage:",
+        "  prodex run [root] [options]",
+        "",
+        "Options:",
+        "  -e, --entry <glob>        Entry file/glob. Repeatable and comma-aware.",
+        "  -i, --include <glob>      Extra file/glob to append. Repeatable and comma-aware.",
+        "  -x, --exclude <glob>      File/glob to skip. Repeatable and comma-aware.",
+        "  -p, --profile <name>      Run a named profile. Repeatable.",
+        "  -a, --all                 Run every configured profile.",
+        "  --all-profiles            Alias for --all.",
+        "  -n, --name <name>         Output basename for this run.",
+        "  -F, --format <md|txt>     Output format.",
+        "  --max-depth <number>      Maximum dependency traversal depth.",
+        "  --max-files <number>      Maximum traced file count.",
+        "  -h, --help                Show run help.",
+    ].join("\n");
+}
+function renderInitHelp() {
+    return [
+        "Usage:",
+        "  prodex init [root]",
+        "",
+        "Create a prodex.json file in the target root.",
+    ].join("\n");
+}
+function renderProfilesHelp() {
+    return [
+        "Usage:",
+        "  prodex profiles [root]",
+        "",
+        "List configured profile keys without running Prodex.",
+    ].join("\n");
+}
+function renderMigrateHelp() {
+    return [
+        "Usage:",
+        "  prodex migrate [root]",
+        "  prodex migrate [root] --write",
+        "  prodex migrate [root] --check",
+        "",
+        "Preview, check, or write a prodex.json migration to config version 4.",
+        "",
+        "Options:",
+        "  --write                  Back up and update prodex.json.",
+        "  --check                  Exit nonzero if migration is required.",
+    ].join("\n");
+}

package/dist/cli/report-command.d.ts

@@ -0,0 +1,2 @@
+import type { CommandResult } from "../types";
+export declare function reportCommandResult(result: CommandResult): void;