prodex 1.4.11 → 2.0.1

package/dist/cli/report-command.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportCommandResult = reportCommandResult;
+const path_1 = __importDefault(require("path"));
+const path_2 = require("../filesystem/path");
+function reportCommandResult(result) {
+    for (const warning of result.warnings)
+        console.warn(`Warning: ${warning}`);
+    for (const error of result.errors)
+        console.error(`Error: ${error}`);
+    if (result.message)
+        console.log(result.message);
+    if (result.profiles)
+        reportProfiles(result.profiles);
+    if (result.migration)
+        reportMigration(result.migration);
+    reportRuns(result.runs);
+}
+function reportRuns(runs) {
+    for (const run of runs) {
+        reportRunWarningsAndErrors(run);
+    }
+    const successfulRuns = runs.filter((run) => run.outputPath);
+    if (!successfulRuns.length)
+        return;
+    const rows = successfulRuns.map((run) => ({
+        label: formatRunLabel(run),
+        mode: run.mode,
+        files: String(run.files.length),
+        output: formatPath(run.outputPath, run.root),
+    }));
+    const labelWidth = maxWidth(rows.map((row) => row.label));
+    const modeWidth = maxWidth(rows.map((row) => row.mode));
+    const filesWidth = maxWidth(rows.map((row) => row.files));
+    for (const row of rows) {
+        console.log(`✓ ${row.label.padEnd(labelWidth)}  ${row.mode.padEnd(modeWidth)}  ${row.files.padStart(filesWidth)}  ${row.output}`);
+    }
+}
+function reportRunWarningsAndErrors(run) {
+    const label = run.profile ? ` [${run.profile}]` : "";
+    for (const warning of run.warnings)
+        console.warn(`Warning${label}: ${warning}`);
+    for (const error of run.errors)
+        console.error(`Error${label}: ${error}`);
+}
+function reportMigration(migration) {
+    if (migration.errors.length)
+        return;
+    if (!migration.needed) {
+        console.log("prodex.json is already using config version 4.");
+        return;
+    }
+    if (migration.written) {
+        console.log(`Backed up prodex.json to ${formatPath(migration.backupPath, path_1.default.dirname(migration.path))}`);
+        console.log("Migrated prodex.json to version 4.");
+        return;
+    }
+    const from = migration.fromVersion ?? "legacy";
+    console.log(`prodex.json can be migrated from version ${from} to version 4.`);
+    if (migration.changes.length) {
+        console.log("");
+        console.log("Changes:");
+        for (const change of migration.changes)
+            console.log(`  ${change}`);
+    }
+    console.log("");
+    console.log("Run `prodex migrate --write` to update prodex.json.");
+}
+function reportProfiles(profiles) {
+    if (!profiles.length) {
+        console.log("No profiles configured.");
+        return;
+    }
+    console.log("Available profiles:");
+    for (const profile of profiles)
+        console.log(`  ${profile}`);
+}
+function formatRunLabel(run) {
+    if (run.profile)
+        return run.profile;
+    if (run.outputName)
+        return run.outputName;
+    if (!run.outputPath)
+        return "run";
+    const ext = path_1.default.extname(run.outputPath);
+    const base = path_1.default.basename(run.outputPath, ext);
+    return base.replace(/-trace(?:_\d{6}-\d{4})?$/, "") || "run";
+}
+function formatPath(filePath, root) {
+    const absolute = path_1.default.resolve(filePath);
+    const relative = path_1.default.relative(root, absolute);
+    if (!relative.startsWith("..") && !path_1.default.isAbsolute(relative))
+        return (0, path_2.normalizePath)(relative);
+    return (0, path_2.normalizePath)(absolute);
+}
+function maxWidth(values) {
+    return values.reduce((max, value) => Math.max(max, value.length), 0);
+}

package/dist/cli/reporter.d.ts

@@ -0,0 +1,2 @@
+export { renderHelp, renderVersion } from "./help";
+export { reportCommandResult } from "./report-command";

package/dist/cli/reporter.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportCommandResult = exports.renderVersion = exports.renderHelp = void 0;
+var help_1 = require("./help");
+Object.defineProperty(exports, "renderHelp", { enumerable: true, get: function () { return help_1.renderHelp; } });
+Object.defineProperty(exports, "renderVersion", { enumerable: true, get: function () { return help_1.renderVersion; } });
+var report_command_1 = require("./report-command");
+Object.defineProperty(exports, "reportCommandResult", { enumerable: true, get: function () { return report_command_1.reportCommandResult; } });

package/dist/commands/init-command.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(rootArg: string | undefined, cwd: string, force?: boolean): import("../config/create-default-config").InitResult;

package/dist/commands/init-command.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const project_context_1 = require("../app/project-context");
+const create_default_config_1 = require("../config/create-default-config");
+function initCommand(rootArg, cwd, force) {
+    const root = (0, project_context_1.resolveRoot)(rootArg, cwd);
+    return (0, create_default_config_1.createDefaultConfig)(root, { force });
+}

package/dist/commands/migrate-command.d.ts

@@ -0,0 +1,7 @@
+import type { MigrationCommandResult } from "../config/migration/types";
+export declare function migrateCommand(params: {
+    rootArg?: string;
+    cwd?: string;
+    write?: boolean;
+    check?: boolean;
+}): MigrationCommandResult;

package/dist/commands/migrate-command.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateCommand = migrateCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const json_1 = require("../config/json");
+const transform_1 = require("../config/migration/transform");
+const detect_1 = require("../config/migration/detect");
+const project_context_1 = require("../app/project-context");
+function migrateCommand(params) {
+    const root = (0, project_context_1.resolveRoot)(params.rootArg, params.cwd);
+    const configPath = path_1.default.join(root, "prodex.json");
+    const warnings = [];
+    const errors = (0, project_context_1.validateRoot)(root, params.rootArg);
+    if (errors.length)
+        return emptyMigrationResult(configPath, warnings, errors);
+    if (!fs_1.default.existsSync(configPath)) {
+        errors.push("No prodex.json found.");
+        return emptyMigrationResult(configPath, warnings, errors);
+    }
+    let raw;
+    try {
+        raw = (0, json_1.parseJsonFile)(fs_1.default.readFileSync(configPath, "utf8"));
+    }
+    catch (err) {
+        errors.push(`Invalid prodex.json: ${err?.message || err}`);
+        return emptyMigrationResult(configPath, warnings, errors);
+    }
+    const preview = (0, transform_1.migrateConfig)(raw);
+    if (params.check && preview.needed) {
+        errors.push(`prodex.json requires migration to version ${detect_1.REQUIRED_CONFIG_VERSION}.`);
+    }
+    if (params.check) {
+        return { ...preview, ok: !preview.needed, written: false, path: configPath, warnings, errors };
+    }
+    if (!preview.needed || !params.write) {
+        return { ...preview, ok: !errors.length, written: false, path: configPath, warnings, errors };
+    }
+    const backupPath = nextBackupPath(root, preview.fromVersion);
+    fs_1.default.copyFileSync(configPath, backupPath);
+    fs_1.default.writeFileSync(configPath, `${JSON.stringify(preview.config, null, 4)}\n`, "utf8");
+    return {
+        ...preview,
+        ok: true,
+        written: true,
+        backupPath,
+        path: configPath,
+        warnings,
+        errors,
+    };
+}
+function nextBackupPath(root, version) {
+    const suffix = version ? `v${String(version).replace(/\W+/g, "_")}` : "legacy";
+    let backup = path_1.default.join(root, `prodex.${suffix}.backup.json`);
+    let index = 1;
+    while (fs_1.default.existsSync(backup)) {
+        backup = path_1.default.join(root, `prodex.${suffix}.backup.${index}.json`);
+        index++;
+    }
+    return backup;
+}
+function emptyMigrationResult(pathValue, warnings, errors) {
+    return {
+        ok: false,
+        needed: false,
+        toVersion: detect_1.REQUIRED_CONFIG_VERSION,
+        changes: [],
+        written: false,
+        path: pathValue,
+        warnings,
+        errors,
+    };
+}

package/dist/commands/profiles-command.d.ts

@@ -0,0 +1,6 @@
+export interface ProfilesCommandResult {
+    profiles: string[];
+    warnings: string[];
+    errors: string[];
+}
+export declare function profilesCommand(rootArg?: string, cwd?: string): ProfilesCommandResult;

package/dist/commands/profiles-command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profilesCommand = profilesCommand;
+const project_context_1 = require("../app/project-context");
+function profilesCommand(rootArg, cwd = process.cwd()) {
+    const project = (0, project_context_1.loadProjectContext)(rootArg, cwd);
+    const warnings = [...project.warnings];
+    const errors = [...project.errors];
+    if (errors.length)
+        return { profiles: [], warnings, errors };
+    return {
+        profiles: Object.keys(project.config.profiles ?? {}).sort(),
+        warnings,
+        errors,
+    };
+}

package/dist/commands/run-command.d.ts

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

package/dist/commands/run-command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = runCommand;
+const execute_run_1 = require("../app/execute-run");
+const run_plans_1 = require("../app/run-plans");
+async function runCommand(params) {
+    const planned = (0, run_plans_1.createRunPlans)(params);
+    const warnings = [...planned.warnings];
+    const errors = [...planned.errors];
+    if (errors.length)
+        return { runs: [], warnings, errors };
+    const runs = [];
+    for (const plan of planned.plans) {
+        runs.push(await (0, execute_run_1.executeRun)(plan));
+    }
+    return { runs, warnings, errors };
+}

package/dist/config/build-config.d.ts

@@ -0,0 +1,13 @@
+import type { DeepPartial, ProdexConfig, ProdexConfigFile, ProdexFlags } from "../types";
+export interface ConfigBuildResult {
+    config?: ProdexConfig;
+    warnings: string[];
+    errors: string[];
+}
+export declare function buildConfig(params: {
+    root: string;
+    userConfig: ProdexConfigFile;
+    flags?: Partial<ProdexFlags>;
+    profileName?: string;
+}): ConfigBuildResult;
+export declare function deepMerge<T extends Record<string, any>>(base: T, patch: DeepPartial<T>): T;

package/dist/config/build-config.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConfig = buildConfig;
+exports.deepMerge = deepMerge;
+const path_1 = __importDefault(require("path"));
+const default_config_1 = require("./default-config");
+const path_2 = require("../filesystem/path");
+const string_list_1 = require("./string-list");
+function buildConfig(params) {
+    const warnings = [];
+    const errors = [];
+    const base = deepMerge(default_config_1.DEFAULT_PRODEX_CONFIG, params.userConfig || {});
+    const profile = params.profileName ? base.profiles?.[params.profileName] : undefined;
+    if (params.profileName && !profile) {
+        errors.push(`Unknown profile "${params.profileName}".`);
+        return { warnings, errors };
+    }
+    const layered = applyProfileLayer(base, profile);
+    const config = toRuntimeConfig(layered, params.root, params.flags, profile, params.profileName);
+    normalizeRuntimeConfig(config, warnings);
+    validateRuntimeConfig(config, errors);
+    return { config, warnings, errors };
+}
+function applyProfileLayer(config, profile) {
+    if (!profile)
+        return config;
+    const patch = {};
+    if (profile.entry)
+        patch.entry = profile.entry;
+    if (profile.include)
+        patch.include = profile.include;
+    if (profile.exclude)
+        patch.exclude = profile.exclude;
+    return deepMerge(config, patch);
+}
+function toRuntimeConfig(fileConfig, root, flags, profile, profileName) {
+    const output = {
+        ...default_config_1.DEFAULT_PRODEX_CONFIG.output,
+        ...fileConfig.output,
+    };
+    const resolve = {
+        ...default_config_1.DEFAULT_PRODEX_CONFIG.resolve,
+        ...fileConfig.resolve,
+    };
+    const cfg = {
+        ...fileConfig,
+        output,
+        resolve,
+        entry: fileConfig.entry ?? [],
+        include: fileConfig.include ?? [],
+        exclude: fileConfig.exclude ?? [],
+        profiles: fileConfig.profiles ?? {},
+        root,
+        name: flags?.name ?? profile?.name ?? profileName,
+    };
+    applyExplicitFlags(cfg, flags);
+    return cfg;
+}
+function applyExplicitFlags(cfg, flags) {
+    if (!flags)
+        return;
+    if (flags.format !== undefined)
+        cfg.output.format = flags.format;
+    if (flags.name !== undefined && flags.name !== null)
+        cfg.name = (0, path_2.sanitizeFileName)(flags.name);
+    if (flags.maxDepth !== undefined && flags.maxDepth !== null)
+        cfg.resolve.maxDepth = flags.maxDepth;
+    if (flags.maxFiles !== undefined && flags.maxFiles !== null)
+        cfg.resolve.maxFiles = flags.maxFiles;
+    if (flags.entry !== undefined)
+        cfg.entry = flags.entry;
+    if (flags.include !== undefined)
+        cfg.include = flags.include;
+    if (flags.exclude !== undefined)
+        cfg.exclude = flags.exclude;
+}
+function normalizeRuntimeConfig(cfg, warnings) {
+    cfg.root = path_1.default.resolve(cfg.root);
+    cfg.output.dir = (0, path_2.normalizePath)(String(cfg.output.dir || "prodex"));
+    cfg.name = cfg.name ? (0, path_2.sanitizeFileName)(String(cfg.name)) : undefined;
+    cfg.entry = normalizePatterns(cfg.entry, warnings, "entry");
+    cfg.include = normalizePatterns(cfg.include, warnings, "include");
+    cfg.exclude = normalizePatterns(cfg.exclude, warnings, "exclude");
+    cfg.resolve.aliases = cfg.resolve.aliases ?? {};
+    cfg.profiles = cfg.profiles ?? {};
+}
+function normalizePatterns(value, warnings, field) {
+    const normalized = [];
+    for (const item of (0, string_list_1.toStringList)(value))
+        normalized.push((0, path_2.normalizePath)(item));
+    if (!Array.isArray(value) && value !== undefined && typeof value !== "string") {
+        warnings.push(`${field} should be a string array; ignoring invalid value.`);
+    }
+    return normalized;
+}
+function validateRuntimeConfig(cfg, errors) {
+    if (!["md", "txt"].includes(cfg.output.format)) {
+        errors.push(`output.format must be "md" or "txt".`);
+    }
+    if (!Number.isFinite(cfg.resolve.maxDepth) || cfg.resolve.maxDepth < 0) {
+        errors.push("resolve.maxDepth must be a non-negative number.");
+    }
+    if (!Number.isFinite(cfg.resolve.maxFiles) || cfg.resolve.maxFiles < 0) {
+        errors.push("resolve.maxFiles must be a non-negative number.");
+    }
+}
+function deepMerge(base, patch) {
+    const out = Array.isArray(base) ? [...base] : { ...base };
+    for (const [key, value] of Object.entries(patch || {})) {
+        if (value === undefined)
+            continue;
+        const current = base[key];
+        if (Array.isArray(value))
+            out[key] = [...value];
+        else if (isPlainObject(value) && isPlainObject(current))
+            out[key] = deepMerge(current, value);
+        else
+            out[key] = value;
+    }
+    return out;
+}
+function isPlainObject(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}

package/dist/config/create-default-config.d.ts

@@ -0,0 +1,9 @@
+export interface InitResult {
+    ok: boolean;
+    path: string;
+    message?: string;
+    error?: string;
+}
+export declare function createDefaultConfig(root?: string, opts?: {
+    force?: boolean;
+}): InitResult;

package/dist/config/create-default-config.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultConfig = createDefaultConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const default_config_1 = require("./default-config");
+function createDefaultConfig(root = process.cwd(), opts = {}) {
+    const dest = path_1.default.join(root, "prodex.json");
+    if (fs_1.default.existsSync(dest) && !opts.force) {
+        return {
+            ok: false,
+            path: dest,
+            error: "prodex.json already exists.",
+        };
+    }
+    fs_1.default.writeFileSync(dest, `${JSON.stringify(default_config_1.DEFAULT_PRODEX_CONFIG, null, 4)}\n`, "utf8");
+    return {
+        ok: true,
+        path: dest,
+        message: `Created ${dest}`,
+    };
+}

package/dist/config/default-config.d.ts

@@ -0,0 +1,2 @@
+import type { ProdexConfigFile } from "../types/config.types";
+export declare const DEFAULT_PRODEX_CONFIG: ProdexConfigFile;

package/dist/config/default-config.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PRODEX_CONFIG = void 0;
+exports.DEFAULT_PRODEX_CONFIG = {
+    version: 4,
+    $schema: "https://raw.githubusercontent.com/emxhive/prodex/main/schema/prodex.schema.json",
+    output: {
+        dir: "prodex",
+        versioned: true,
+        format: "md",
+    },
+    entry: [],
+    include: [],
+    exclude: ["node_modules/**", "vendor/**", "dist/**", "@shadcn/**", "**/components/ui/**"],
+    resolve: {
+        aliases: {
+            "@": "resources/js",
+        },
+        maxDepth: 10,
+        maxFiles: 200,
+    },
+    profiles: {},
+};

package/dist/config/json.d.ts

@@ -0,0 +1,2 @@
+export declare function parseJsonFile(text: string): unknown;
+export declare function stripBom(text: string): string;

package/dist/config/json.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJsonFile = parseJsonFile;
+exports.stripBom = stripBom;
+function parseJsonFile(text) {
+    return JSON.parse(stripBom(text));
+}
+function stripBom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}

package/dist/config/load.d.ts

@@ -0,0 +1,9 @@
+import type { ProdexConfigFile } from "../types";
+export interface LoadConfigResult {
+    config: ProdexConfigFile;
+    path: string;
+    warnings: string[];
+    errors: string[];
+    exists: boolean;
+}
+export declare function loadConfig(root: string): LoadConfigResult;

package/dist/config/load.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.loadConfig = loadConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const default_config_1 = require("./default-config");
+const migration_1 = require("./migration");
+const json_1 = require("./json");
+function loadConfig(root) {
+    const configPath = path_1.default.join(root, "prodex.json");
+    const warnings = [];
+    const errors = [];
+    if (!fs_1.default.existsSync(configPath)) {
+        return {
+            config: default_config_1.DEFAULT_PRODEX_CONFIG,
+            path: configPath,
+            warnings,
+            errors,
+            exists: false,
+        };
+    }
+    try {
+        const parsed = (0, json_1.parseJsonFile)(fs_1.default.readFileSync(configPath, "utf8"));
+        if ((0, migration_1.requiresConfigMigration)(parsed)) {
+            errors.push((0, migration_1.isOutdatedConfig)(parsed) ? (0, migration_1.configVersionError)(parsed.version) : (0, migration_1.legacyConfigShapeError)());
+        }
+        return {
+            config: parsed,
+            path: configPath,
+            warnings,
+            errors,
+            exists: true,
+        };
+    }
+    catch (err) {
+        errors.push(`Invalid prodex.json: ${err?.message || err}`);
+        return {
+            config: default_config_1.DEFAULT_PRODEX_CONFIG,
+            path: configPath,
+            warnings,
+            errors,
+            exists: true,
+        };
+    }
+}

package/dist/config/migration/detect.d.ts

@@ -0,0 +1,4 @@
+export declare const REQUIRED_CONFIG_VERSION = 4;
+export declare function isOutdatedConfig(config: any): boolean;
+export declare function requiresConfigMigration(config: any): boolean;
+export declare function looksLikeLegacyConfig(config: any): boolean;

package/dist/config/migration/detect.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUIRED_CONFIG_VERSION = void 0;
+exports.isOutdatedConfig = isOutdatedConfig;
+exports.requiresConfigMigration = requiresConfigMigration;
+exports.looksLikeLegacyConfig = looksLikeLegacyConfig;
+exports.REQUIRED_CONFIG_VERSION = 4;
+function isOutdatedConfig(config) {
+    return typeof config?.version === "number" && config.version < exports.REQUIRED_CONFIG_VERSION;
+}
+function requiresConfigMigration(config) {
+    return isOutdatedConfig(config) || looksLikeLegacyConfig(config);
+}
+function looksLikeLegacyConfig(config) {
+    return !!(config?.shortcuts ||
+        config?.entry?.files ||
+        config?.resolve?.include ||
+        config?.resolve?.exclude ||
+        config?.resolve?.depth ||
+        config?.resolve?.limit ||
+        config?.output?.prefix);
+}

package/dist/config/migration/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./detect";
+export * from "./messages";
+export * from "./transform";
+export * from "./types";

package/dist/{shared → config/migration}/index.js

@@ -14,6 +14,7 @@ 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("./io"), exports);
-__exportStar(require("./patterns"), exports);
-__exportStar(require("./collections"), exports);
+__exportStar(require("./detect"), exports);
+__exportStar(require("./messages"), exports);
+__exportStar(require("./transform"), exports);
+__exportStar(require("./types"), exports);

package/dist/config/migration/messages.d.ts

@@ -0,0 +1,2 @@
+export declare function configVersionError(version: unknown): string;
+export declare function legacyConfigShapeError(): string;

package/dist/config/migration/messages.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configVersionError = configVersionError;
+exports.legacyConfigShapeError = legacyConfigShapeError;
+const detect_1 = require("./detect");
+const V4_CHANGES = [
+    "Prodex v4 changed the config shape:",
+    "  entry.files -> entry",
+    "  resolve.include -> include",
+    "  resolve.exclude -> exclude",
+    "  resolve.depth -> resolve.maxDepth",
+    "  resolve.limit -> resolve.maxFiles",
+    "  shortcuts -> profiles",
+    "",
+    "Preview migration:",
+    "  prodex migrate",
+    "",
+    "Update prodex.json:",
+    "  prodex migrate --write",
+];
+function configVersionError(version) {
+    const label = typeof version === "number" ? String(version) : "an older format";
+    return [
+        `prodex.json uses config version ${label}, but this Prodex version requires config version ${detect_1.REQUIRED_CONFIG_VERSION}.`,
+        "",
+        ...V4_CHANGES,
+    ].join("\n");
+}
+function legacyConfigShapeError() {
+    return [
+        "prodex.json contains legacy config fields that must be migrated to config version 4.",
+        "",
+        ...V4_CHANGES,
+    ].join("\n");
+}

package/dist/config/migration/transform.d.ts

@@ -0,0 +1,2 @@
+import type { MigrationPreview } from "./types";
+export declare function migrateConfig(input: any): MigrationPreview;