prodex 2.0.1 → 2.1.0

package/dist/app/planners/pack-plan.d.ts

@@ -0,0 +1,13 @@
+import type { ExecutionPlan, CommandIntent, ProdexConfigFile, CommandAttachmentOptions } from "../../types";
+export declare function buildPackPlan(params: {
+    intent: CommandIntent;
+    userConfig: ProdexConfigFile;
+    root: string;
+    aliases: Record<string, string>;
+    depth: number;
+    maxFiles: number;
+    defaultOutput: ExecutionPlan["output"];
+    attachmentOptions: CommandAttachmentOptions | undefined;
+    warnings: string[];
+    errors: string[];
+}): ExecutionPlan[];

package/dist/app/planners/pack-plan.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPackPlan = buildPackPlan;
+const path_patterns_1 = require("../../filesystem/path-patterns");
+const list_utils_1 = require("./list-utils");
+function buildPackPlan(params) {
+    const { intent, userConfig, root, aliases, depth, maxFiles, defaultOutput, attachmentOptions, warnings, errors } = params;
+    const flags = intent.flags ?? {};
+    // Validation
+    if (flags.key !== undefined || flags.all !== undefined || flags.list !== undefined) {
+        errors.push('Command "pack" does not accept "--key", "--all", or "--list".');
+        return [];
+    }
+    const hasCliEntry = flags.entry && flags.entry.length > 0;
+    const hasCliInclude = flags.include && flags.include.length > 0;
+    const hasCliScope = flags.scope && flags.scope.length > 0;
+    if (!hasCliEntry && !hasCliInclude && !hasCliScope) {
+        errors.push('Command "pack" requires at least one source: --entry, --include, or --scope.');
+        return [];
+    }
+    const rootExclude = userConfig.exclude ?? [];
+    const scopeEntries = [];
+    const scopeIncludes = [];
+    const scopeExcludes = [];
+    if (flags.scope && flags.scope.length > 0) {
+        for (const scopeKey of flags.scope) {
+            const scope = userConfig.scopes?.[scopeKey];
+            if (!scope) {
+                errors.push(`Unknown scope "${scopeKey}".`);
+                return [];
+            }
+            if (scope.entry)
+                scopeEntries.push(...scope.entry);
+            if (scope.include)
+                scopeIncludes.push(...scope.include);
+            if (scope.exclude)
+                scopeExcludes.push(...scope.exclude);
+        }
+    }
+    const mergedEntry = [...scopeEntries, ...(flags.entry ?? [])].map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "entry" }));
+    const mergedInclude = [...scopeIncludes, ...(flags.include ?? [])].map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "include" }));
+    const mergedExclude = [...rootExclude, ...scopeExcludes, ...(flags.exclude ?? [])].map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "exclude" }));
+    if (errors.length) {
+        return [];
+    }
+    const plan = {
+        root,
+        command: "pack",
+        outputName: flags.name ?? "pack-combined",
+        entry: (0, list_utils_1.uniqueTrimmed)(mergedEntry),
+        include: (0, list_utils_1.uniqueTrimmed)(mergedInclude),
+        exclude: (0, list_utils_1.uniqueTrimmed)(mergedExclude),
+        depth: flags.depth ?? depth,
+        maxFiles: flags.maxFiles ?? maxFiles,
+        aliases,
+        output: {
+            dir: defaultOutput.dir,
+            versioned: defaultOutput.versioned,
+            format: flags.format ?? defaultOutput.format,
+        },
+        dryRun: !!flags.dryRun,
+        attachmentOptions,
+    };
+    return [plan];
+}

package/dist/app/planners/scope-plan.d.ts

@@ -0,0 +1,17 @@
+import type { ExecutionPlan, CommandIntent, ProdexConfigFile, CommandAttachmentOptions } from "../../types";
+export interface ScopePlanResult {
+    plans: ExecutionPlan[];
+    listScopes?: string[];
+}
+export declare function buildScopePlan(params: {
+    intent: CommandIntent;
+    userConfig: ProdexConfigFile;
+    root: string;
+    aliases: Record<string, string>;
+    depth: number;
+    maxFiles: number;
+    defaultOutput: ExecutionPlan["output"];
+    attachmentOptions: CommandAttachmentOptions | undefined;
+    warnings: string[];
+    errors: string[];
+}): ScopePlanResult;

package/dist/app/planners/scope-plan.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildScopePlan = buildScopePlan;
+const path_patterns_1 = require("../../filesystem/path-patterns");
+const list_utils_1 = require("./list-utils");
+function buildScopePlan(params) {
+    const { intent, userConfig, root, aliases, depth, maxFiles, defaultOutput, attachmentOptions, warnings, errors } = params;
+    const flags = intent.flags ?? {};
+    // Validation
+    if (flags.entry !== undefined ||
+        flags.include !== undefined ||
+        flags.scope !== undefined ||
+        flags.name !== undefined ||
+        flags.depth !== undefined ||
+        flags.maxFiles !== undefined) {
+        errors.push('Command "scope" does not accept "--entry", "--include", "--scope", "--name", "--depth", or "--max-files".');
+        return { plans: [] };
+    }
+    const hasKey = flags.key && flags.key.length > 0;
+    const hasAll = !!flags.all;
+    const hasList = !!flags.list;
+    if (!hasKey && !hasAll && !hasList) {
+        errors.push('Command "scope" requires specifying "-k/--key", "--all", or "--list".');
+        return { plans: [] };
+    }
+    let selectedModesCount = 0;
+    if (hasKey)
+        selectedModesCount++;
+    if (hasAll)
+        selectedModesCount++;
+    if (hasList)
+        selectedModesCount++;
+    if (selectedModesCount > 1) {
+        errors.push('Command "scope" options "--key", "--all", and "--list" are mutually exclusive.');
+        return { plans: [] };
+    }
+    const availableScopes = Object.keys(userConfig.scopes ?? {}).sort();
+    if (hasList) {
+        if ((flags.cmd && flags.cmd.length > 0) || flags.cmdTimeout !== undefined || flags.failOnCmdError !== undefined) {
+            errors.push('Option "--list" cannot be used with command attachment options.');
+            return { plans: [] };
+        }
+        return { plans: [], listScopes: availableScopes };
+    }
+    if (errors.length) {
+        return { plans: [] };
+    }
+    let targetKeys = [];
+    if (hasAll) {
+        targetKeys = availableScopes;
+        if (!targetKeys.length) {
+            errors.push("No scopes are defined in prodex.json.");
+            return { plans: [] };
+        }
+    }
+    else if (flags.key) {
+        for (const key of flags.key) {
+            if (!userConfig.scopes?.[key]) {
+                errors.push(`Unknown scope "${key}".`);
+                return { plans: [] };
+            }
+            targetKeys.push(key);
+        }
+    }
+    const plans = [];
+    for (const key of targetKeys) {
+        const scope = userConfig.scopes[key];
+        const scopeIncludes = (scope.include ?? []).map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "include" }));
+        const scopeExcludes = [...(userConfig.exclude ?? []), ...(scope.exclude ?? []), ...(flags.exclude ?? [])].map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "exclude" }));
+        if (scope.grep) {
+            let grepMode = "query";
+            let grepTerms = [];
+            if (scope.grep.query !== undefined) {
+                grepMode = "query";
+                grepTerms = [scope.grep.query];
+            }
+            else if (scope.grep.any !== undefined) {
+                grepMode = "any";
+                grepTerms = scope.grep.any;
+            }
+            else if (scope.grep.all !== undefined) {
+                grepMode = "all";
+                grepTerms = scope.grep.all;
+            }
+            else if (scope.grep.regex !== undefined) {
+                grepMode = "regex";
+                grepTerms = [scope.grep.regex];
+            }
+            const negativeTerms = scope.grep.not ?? [];
+            const mergedWithin = (scope.grep.within ?? []).map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "within" }));
+            const mergedSkip = (scope.grep.skip ?? []).map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "skip" }));
+            plans.push({
+                root,
+                command: "scope",
+                outputName: scope.name ?? key,
+                entry: [],
+                include: scopeIncludes,
+                exclude: (0, list_utils_1.uniqueTrimmed)(scopeExcludes),
+                depth,
+                maxFiles,
+                aliases,
+                output: {
+                    dir: defaultOutput.dir,
+                    versioned: defaultOutput.versioned,
+                    format: flags.format ?? defaultOutput.format,
+                },
+                dryRun: !!flags.dryRun,
+                scopeKey: key,
+                attachmentOptions,
+                grepOptions: {
+                    mode: grepMode,
+                    terms: grepTerms,
+                    negativeTerms: (0, list_utils_1.uniqueTrimmed)(negativeTerms),
+                    within: (0, list_utils_1.uniqueTrimmed)(mergedWithin),
+                    skip: (0, list_utils_1.uniqueTrimmed)(mergedSkip),
+                },
+            });
+        }
+        else {
+            const scopeEntries = (scope.entry ?? []).map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "entry" }));
+            plans.push({
+                root,
+                command: "scope",
+                outputName: scope.name ?? key,
+                entry: scopeEntries,
+                include: scopeIncludes,
+                exclude: (0, list_utils_1.uniqueTrimmed)(scopeExcludes),
+                depth,
+                maxFiles,
+                aliases,
+                output: {
+                    dir: defaultOutput.dir,
+                    versioned: defaultOutput.versioned,
+                    format: flags.format ?? defaultOutput.format,
+                },
+                dryRun: !!flags.dryRun,
+                scopeKey: key,
+                attachmentOptions,
+            });
+        }
+    }
+    return { plans };
+}

package/dist/app/planners/trace-plan.d.ts

@@ -0,0 +1,13 @@
+import type { ExecutionPlan, CommandIntent, ProdexConfigFile, CommandAttachmentOptions } from "../../types";
+export declare function buildTracePlan(params: {
+    intent: CommandIntent;
+    userConfig: ProdexConfigFile;
+    root: string;
+    aliases: Record<string, string>;
+    depth: number;
+    maxFiles: number;
+    defaultOutput: ExecutionPlan["output"];
+    attachmentOptions: CommandAttachmentOptions | undefined;
+    warnings: string[];
+    errors: string[];
+}): ExecutionPlan[];

package/dist/app/planners/trace-plan.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTracePlan = buildTracePlan;
+const default_config_1 = require("../../config/default-config");
+const path_patterns_1 = require("../../filesystem/path-patterns");
+const list_utils_1 = require("./list-utils");
+function buildTracePlan(params) {
+    const { intent, userConfig, root, aliases, depth, maxFiles, defaultOutput, attachmentOptions, warnings, errors } = params;
+    const flags = intent.flags ?? {};
+    // Validation
+    if (flags.entry && flags.entry.length > 0) {
+        errors.push("`prodex trace --entry` has been removed.\n" +
+            "Use `prodex trace --target <target> --depth <number>` to trace from a semantic target.\n" +
+            "Use `prodex pack --entry <path-or-glob>` to collect files directly.");
+    }
+    if (flags.scope !== undefined) {
+        errors.push('Command "trace" does not accept "--scope" (or "-s").');
+    }
+    if (flags.key !== undefined || flags.all !== undefined || flags.list !== undefined) {
+        errors.push('Command "trace" does not accept "--key", "--all", or "--list".');
+    }
+    let finalDepth = depth;
+    const configDepth = userConfig.depth !== undefined && userConfig.depth !== null ? userConfig.depth : default_config_1.DEFAULT_PRODEX_CONFIG.depth;
+    const hasTarget = flags.target && flags.target.length > 0;
+    if (!hasTarget) {
+        if (!flags.entry || flags.entry.length === 0) {
+            errors.push('Command "trace" requires --target.');
+        }
+    }
+    else {
+        // Validate configured default depth
+        const configDepthVal = Number(configDepth);
+        if (!Number.isInteger(configDepthVal) || configDepthVal < 0) {
+            errors.push('--depth must be an integer greater than or equal to 0.');
+        }
+        if (flags.depth !== undefined && flags.depth !== null) {
+            const depthVal = Number(flags.depth);
+            if (!Number.isInteger(depthVal) || depthVal < 0) {
+                errors.push('--depth must be an integer greater than or equal to 0.');
+            }
+            else {
+                finalDepth = depthVal;
+            }
+        }
+        else {
+            if (Number.isInteger(configDepthVal) && configDepthVal >= 0) {
+                finalDepth = configDepthVal;
+                warnings.push(`No --depth provided. Using configured default depth: ${finalDepth}.\n` +
+                    `Override with --depth <number> or -d <number>.`);
+            }
+        }
+    }
+    if (errors.length)
+        return [];
+    const mergedExclude = [...(userConfig.exclude ?? []), ...(flags.exclude ?? [])].map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "exclude" }));
+    const finalInclude = (flags.include ?? []).map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "include" }));
+    const plan = {
+        root,
+        command: "trace",
+        outputName: flags.name,
+        entry: [],
+        target: (0, list_utils_1.uniqueTrimmed)(flags.target ?? []),
+        include: (0, list_utils_1.uniqueTrimmed)(finalInclude),
+        exclude: (0, list_utils_1.uniqueTrimmed)(mergedExclude),
+        depth: finalDepth,
+        maxFiles: flags.maxFiles ?? maxFiles,
+        aliases,
+        output: {
+            dir: defaultOutput.dir,
+            versioned: defaultOutput.versioned,
+            format: flags.format ?? defaultOutput.format,
+        },
+        dryRun: !!flags.dryRun,
+        attachmentOptions,
+    };
+    return [plan];
+}

package/dist/app/source-collector.d.ts

@@ -0,0 +1,5 @@
+import type { ExecutionPlan, SourceCollectionResult } from "../types";
+export interface SourceProvider {
+    collect(plan: ExecutionPlan): Promise<SourceCollectionResult>;
+}
+export declare function collectSources(plan: ExecutionPlan): Promise<SourceCollectionResult>;

package/dist/app/source-collector.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSources = collectSources;
+const dependency_source_provider_1 = require("./dependency-source-provider");
+const git_source_provider_1 = require("./git-source-provider");
+const grep_source_provider_1 = require("./grep-source-provider");
+async function collectSources(plan) {
+    switch (plan.command) {
+        case "pack":
+        case "trace":
+            return (0, dependency_source_provider_1.collectDependencySources)(plan);
+        case "scope":
+            if (plan.grepOptions !== undefined) {
+                return (0, grep_source_provider_1.collectGrepSources)(plan);
+            }
+            return (0, dependency_source_provider_1.collectDependencySources)(plan);
+        case "git":
+            return (0, git_source_provider_1.collectGitSources)(plan);
+        case "grep":
+            return (0, grep_source_provider_1.collectGrepSources)(plan);
+        default: {
+            const exhaustiveCheck = plan.command;
+            return {
+                files: [],
+                entries: [],
+                includes: [],
+                mode: "include-only",
+                warnings: [],
+                errors: [`Unsupported command kind for source collection: ${exhaustiveCheck}`],
+            };
+        }
+    }
+}

package/dist/app/target-resolver.d.ts

@@ -0,0 +1,7 @@
+import type { ExecutionPlan } from "../types";
+export interface TargetResolutionResult {
+    entries: string[];
+    warnings: string[];
+    errors: string[];
+}
+export declare function resolveTargets(plan: ExecutionPlan): Promise<TargetResolutionResult>;

package/dist/app/target-resolver.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTargets = resolveTargets;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const exclude_1 = require("../tracing/exclude");
+const entry_discovery_1 = require("../filesystem/entry-discovery");
+const path_patterns_1 = require("../filesystem/path-patterns");
+// runBareNameDiscovery consolidated into discoverBareName from entry-discovery
+function formatAmbiguousTargetError(target, candidates, root) {
+    const formattedMatches = candidates
+        .map((c) => `- ${path_1.default.relative(root, c).replaceAll("\\", "/")}`)
+        .join("\n");
+    const exampleCandidate = candidates[1] || candidates[0];
+    const relativeCandidate = path_1.default.relative(root, exampleCandidate).replaceAll("\\", "/");
+    const ext = path_1.default.extname(relativeCandidate);
+    const suggestion = ext ? relativeCandidate.slice(0, -ext.length) : relativeCandidate;
+    const targetStem = path_1.default.basename(target, path_1.default.extname(target));
+    const uniqueExts = [...new Set(candidates.map((c) => path_1.default.extname(c).toLowerCase()))];
+    const extensionsDiffer = uniqueExts.length > 1;
+    const packExtension = extensionsDiffer ? ".*" : (uniqueExts[0] || ".ts");
+    return `Ambiguous target "${target}". Matches:\n` +
+        `${formattedMatches}\n\n` +
+        `Use a more specific target, such as:\n` +
+        `  prodex trace --target ${suggestion} --depth 2\n\n` +
+        `If you intended to collect all matching files directly, use a glob with pack:\n` +
+        `  prodex pack --entry "src/**/${targetStem}${packExtension}"`;
+}
+async function resolveTargets(plan) {
+    const resolved = [];
+    const errors = [];
+    const warnings = [];
+    const root = plan.root;
+    const excludes = plan.exclude;
+    const targets = plan.target ?? [];
+    for (const target of targets) {
+        if ((0, path_patterns_1.isGlobPattern)(target)) {
+            errors.push(`Command "trace" does not accept glob targets.\n` +
+                `Use \`prodex pack --entry <glob>\` to collect files directly.`);
+            continue;
+        }
+        // 1. Exact path match
+        const absPath = path_1.default.resolve(root, target);
+        let isFile = false;
+        try {
+            isFile = fs_1.default.statSync(absPath).isFile();
+        }
+        catch { }
+        if (isFile) {
+            if (!(0, exclude_1.isExcluded)(absPath, excludes, root)) {
+                resolved.push(absPath);
+            }
+            continue;
+        }
+        // 2. Extensionless path expansion
+        const hasExt = path_1.default.extname(target) !== "";
+        if (!hasExt) {
+            const step2Matches = (0, entry_discovery_1.expandPathLike)(target, root);
+            const step2NonExcluded = step2Matches.filter((file) => !(0, exclude_1.isExcluded)(file, excludes, root));
+            if (step2NonExcluded.length > 0) {
+                if (step2NonExcluded.length === 1) {
+                    resolved.push(step2NonExcluded[0]);
+                }
+                else {
+                    errors.push(formatAmbiguousTargetError(target, step2NonExcluded, root));
+                }
+                continue;
+            }
+        }
+        // 3. Bare-name discovery
+        const isPathLike = target.includes("/") || target.includes("\\");
+        if (!isPathLike) {
+            const step3Matches = await (0, entry_discovery_1.discoverBareName)(target, root, true);
+            const step3NonExcluded = step3Matches.filter((file) => !(0, exclude_1.isExcluded)(file, excludes, root));
+            if (step3NonExcluded.length > 0) {
+                if (step3NonExcluded.length === 1) {
+                    resolved.push(step3NonExcluded[0]);
+                }
+                else {
+                    errors.push(formatAmbiguousTargetError(target, step3NonExcluded, root));
+                }
+                continue;
+            }
+        }
+        // 4. Case-insensitive bare-name discovery
+        if (!isPathLike) {
+            const step4Matches = await (0, entry_discovery_1.discoverBareName)(target, root, false);
+            const step4NonExcluded = step4Matches.filter((file) => !(0, exclude_1.isExcluded)(file, excludes, root));
+            if (step4NonExcluded.length > 0) {
+                if (step4NonExcluded.length === 1) {
+                    resolved.push(step4NonExcluded[0]);
+                }
+                else {
+                    errors.push(formatAmbiguousTargetError(target, step4NonExcluded, root));
+                }
+                continue;
+            }
+        }
+        // Fail clearly if no matches found
+        errors.push(`Target "${target}" did not match any files.`);
+    }
+    return {
+        entries: [...new Set(resolved)],
+        errors,
+        warnings,
+    };
+}

package/dist/cli/cli-input.js

@@ -9,7 +9,7 @@ function parseCliInput(argv = process.argv) {
     const errors = [];
     const flags = {};
     if (!tokens.length) {
-        errors.push("Missing command. Use `prodex run`, `prodex init`, `prodex profiles`, or `prodex migrate`.");
+        errors.push("Missing command. Use `prodex pack`, `prodex trace`, `prodex scope`, `prodex grep`, `prodex git`, or `prodex migrate`.");
         return { warnings, errors };
     }
     if (tokens.includes("--version") || tokens.includes("-v")) {
@@ -20,21 +20,25 @@ function parseCliInput(argv = process.argv) {
     }
     const commandName = tokens[0];
     if (!isCommand(commandName)) {
-        errors.push(`Unknown command "${commandName}". Use run, init, profiles, or migrate.`);
+        errors.push(`Unknown command "${commandName}". Use pack, trace, scope, grep, git, or migrate.`);
         return { warnings, errors };
     }
+    const isGrep = commandName === "grep";
+    const flagsByLong = isGrep ? flag_specs_1.GREP_FLAGS_BY_LONG : flag_specs_1.FLAGS_BY_LONG;
+    const flagsByShort = isGrep ? flag_specs_1.GREP_FLAGS_BY_SHORT : flag_specs_1.FLAGS_BY_SHORT;
+    const flagAliases = isGrep ? flag_specs_1.GREP_FLAG_ALIASES : flag_specs_1.FLAG_ALIASES;
     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);
+            const consumed = readLongFlag(tokens, i, flags, errors, flagAliases, flagsByLong);
             i += consumed;
             continue;
         }
         if (token.startsWith("-") && token !== "-") {
-            const consumed = readShortFlag(tokens, i, flags, errors);
+            const consumed = readShortFlag(tokens, i, flags, errors, flagsByShort);
             i += consumed;
             continue;
         }
@@ -46,14 +50,57 @@ function parseCliInput(argv = process.argv) {
     }
     if (flags.help)
         return { command: { kind: "help", topic: commandName }, warnings, errors };
-    if (commandName === "init")
+    const validationErrors = validateCliInput(commandName, flags);
+    errors.push(...validationErrors);
+    if (errors.length) {
+        return { 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 };
+    if (commandName === "pack") {
+        return { command: { kind: "pack", rootArg, flags }, warnings, errors };
+    }
+    if (commandName === "trace") {
+        return { command: { kind: "trace", rootArg, flags }, warnings, errors };
+    }
+    if (commandName === "scope") {
+        return { command: { kind: "scope", rootArg, flags }, warnings, errors };
+    }
+    if (commandName === "git") {
+        return { command: { kind: "git", rootArg, flags }, warnings, errors };
+    }
+    if (commandName === "grep") {
+        return { command: { kind: "grep", rootArg, flags }, warnings, errors };
+    }
+    return { warnings, errors };
+}
+function validateCliInput(commandName, flags) {
+    const errors = [];
+    if (commandName === "run") {
+        errors.push("`prodex run` has been replaced.\nUse `prodex pack`, `prodex trace`, or `prodex scope`.");
+    }
+    if (commandName === "profiles") {
+        errors.push("`prodex profiles` has been replaced.\nUse `prodex scope --list`.");
+    }
+    if (flags.profile !== undefined) {
+        errors.push("`--profile` has been replaced.\nUse `prodex pack --scope <key>` to merge scopes into one pack, or `prodex scope -k <key>` to run configured scopes separately.");
+    }
+    if (flags.allProfiles !== undefined) {
+        errors.push("`--all-profiles` has been replaced.\nUse `--all` with `prodex scope`.");
+    }
+    if (flags.maxDepth !== undefined) {
+        errors.push("`--max-depth` has been replaced.\nUse `--depth`.");
+    }
+    if (commandName === "init" || commandName === "migrate") {
+        if (flags.cmd !== undefined || flags.cmdTimeout !== undefined || flags.failOnCmdError !== undefined) {
+            errors.push(`Command "${commandName}" does not accept command attachment options.`);
+        }
+    }
+    return errors;
 }
 function stripExecutable(argv) {
     const [first, second, ...rest] = argv;
@@ -73,14 +120,14 @@ function basename(value) {
 function isCommand(token) {
     return flag_specs_1.COMMANDS.includes(token);
 }
-function readLongFlag(tokens, index, flags, errors) {
+function readLongFlag(tokens, index, flags, errors, flagAliases, flagsByLong) {
     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 name = flagAliases[rawName] ?? rawName;
     const inlineValue = equalsAt === -1 ? undefined : raw.slice(equalsAt + 1);
-    const spec = flag_specs_1.FLAGS_BY_LONG.get(name);
+    const spec = flagsByLong.get(name);
     if (!spec) {
         errors.push(`Unknown flag "--${rawName}".`);
         return 0;
@@ -90,19 +137,19 @@ function readLongFlag(tokens, index, flags, errors) {
         return 0;
     }
     const value = inlineValue ?? tokens[index + 1];
-    if (value === undefined || value.startsWith("-")) {
+    if (value === undefined || (value.startsWith("-") && !/^-?\d+(\.\d+)?$/.test(value))) {
         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) {
+function readShortFlag(tokens, index, flags, errors, flagsByShort) {
     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);
+            const spec = flagsByShort.get(ch);
             if (!spec) {
                 errors.push(`Unknown flag "-${ch}".`);
                 continue;
@@ -115,7 +162,7 @@ function readShortFlag(tokens, index, flags, errors) {
         }
         return 0;
     }
-    const spec = flag_specs_1.FLAGS_BY_SHORT.get(cluster);
+    const spec = flagsByShort.get(cluster);
     if (!spec) {
         errors.push(`Unknown flag "-${cluster}".`);
         return 0;
@@ -125,7 +172,7 @@ function readShortFlag(tokens, index, flags, errors) {
         return 0;
     }
     const value = tokens[index + 1];
-    if (value === undefined || value.startsWith("-")) {
+    if (value === undefined || (value.startsWith("-") && !/^-?\d+(\.\d+)?$/.test(value))) {
         errors.push(`Flag "-${cluster}" expects a value.`);
         return 0;
     }
@@ -143,9 +190,13 @@ function assignFlag(flags, spec, value, errors) {
     }
     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];
+        const current = (flags[spec.long] ?? []);
+        flags[spec.long] = [...current, ...values];
+        return;
+    }
+    if (spec.type === "raw-list") {
+        const current = (flags[spec.long] ?? []);
+        flags[spec.long] = [...current, value];
         return;
     }
     if (spec.long === "format" && !["md", "txt"].includes(value)) {