prodex 2.0.1 → 2.1.0

package/dist/config/migration/messages.js

@@ -3,14 +3,15 @@ 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",
+const V5_CHANGES = [
+    "Prodex v5 changed the config shape:",
+    "  entry -> scopes.default.entry",
+    "  include -> scopes.default.include",
+    "  profiles -> scopes",
+    "  profiles.*.name -> scopes.*.name",
+    "  resolve.aliases -> aliases",
+    "  resolve.maxDepth -> depth",
+    "  resolve.maxFiles -> maxFiles",
     "",
     "Preview migration:",
     "  prodex migrate",
@@ -23,13 +24,13 @@ function configVersionError(version) {
     return [
         `prodex.json uses config version ${label}, but this Prodex version requires config version ${detect_1.REQUIRED_CONFIG_VERSION}.`,
         "",
-        ...V4_CHANGES,
+        ...V5_CHANGES,
     ].join("\n");
 }
 function legacyConfigShapeError() {
     return [
-        "prodex.json contains legacy config fields that must be migrated to config version 4.",
+        "prodex.json contains legacy config fields that must be migrated to config version 5.",
         "",
-        ...V4_CHANGES,
+        ...V5_CHANGES,
     ].join("\n");
 }

package/dist/config/migration/transform.js

@@ -15,41 +15,86 @@ function migrateConfig(input) {
         };
     }
     const changes = [];
+    const inputOutput = input.output ?? {};
     const output = {
-        ...default_config_1.DEFAULT_PRODEX_CONFIG.output,
-        ...(input.output ?? {}),
+        dir: inputOutput.dir !== undefined ? String(inputOutput.dir) : default_config_1.DEFAULT_PRODEX_CONFIG.output.dir,
+        versioned: inputOutput.versioned !== undefined ? Boolean(inputOutput.versioned) : default_config_1.DEFAULT_PRODEX_CONFIG.output.versioned,
+        format: (inputOutput.format === "md" || inputOutput.format === "txt") ? inputOutput.format : default_config_1.DEFAULT_PRODEX_CONFIG.output.format,
     };
-    delete output.prefix;
     if (input.output?.prefix !== undefined) {
-        changes.push("output.prefix removed; use --name or profile.name when you need to override the profile key.");
+        changes.push("output.prefix removed; use scope.name when you need to override scope output names.");
+    }
+    const aliases = input.aliases ?? input.resolve?.aliases ?? default_config_1.DEFAULT_PRODEX_CONFIG.aliases;
+    if (input.resolve?.aliases !== undefined)
+        changes.push("resolve.aliases -> aliases");
+    const depth = input.depth ?? input.resolve?.maxDepth ?? input.resolve?.depth ?? default_config_1.DEFAULT_PRODEX_CONFIG.depth;
+    if (input.resolve?.maxDepth !== undefined || input.resolve?.depth !== undefined)
+        changes.push("resolve.maxDepth -> depth");
+    const maxFiles = input.maxFiles ?? input.resolve?.maxFiles ?? input.resolve?.limit ?? default_config_1.DEFAULT_PRODEX_CONFIG.maxFiles;
+    if (input.resolve?.maxFiles !== undefined || input.resolve?.limit !== undefined)
+        changes.push("resolve.maxFiles -> maxFiles");
+    const exclude = (0, string_list_1.toStringList)(input.exclude ?? input.resolve?.exclude ?? default_config_1.DEFAULT_PRODEX_CONFIG.exclude);
+    if (input.resolve?.exclude !== undefined)
+        changes.push("resolve.exclude -> exclude");
+    if (input.profiles !== undefined) {
+        changes.push("profiles -> scopes");
+        let hasProfileName = false;
+        for (const key of Object.keys(input.profiles)) {
+            if (input.profiles[key]?.name !== undefined) {
+                hasProfileName = true;
+                break;
+            }
+        }
+        if (hasProfileName) {
+            changes.push("profiles.*.name -> scopes.*.name");
+        }
+    }
+    if (input.shortcuts !== undefined)
+        changes.push("shortcuts -> scopes");
+    const scopes = migrateScopes(input.scopes ?? input.profiles ?? input.shortcuts ?? {}, changes);
+    const entryList = input.entry !== undefined ? (0, string_list_1.toStringList)(input.entry?.files ?? input.entry) : [];
+    const includeList = (input.include !== undefined || input.resolve?.include !== undefined)
+        ? (0, string_list_1.toStringList)(input.include ?? input.resolve?.include)
+        : [];
+    const hasRootEntry = entryList.length > 0;
+    const hasRootInclude = includeList.length > 0;
+    if (hasRootEntry || hasRootInclude) {
+        if (!scopes.default) {
+            scopes.default = {};
+        }
+        const defScope = scopes.default;
+        if (hasRootEntry) {
+            const existingEntry = defScope.entry ?? [];
+            defScope.entry = unique([...existingEntry, ...entryList]);
+            changes.push("entry -> scopes.default.entry");
+        }
+        if (hasRootInclude) {
+            const existingInclude = defScope.include ?? [];
+            defScope.include = unique([...existingInclude, ...includeList]);
+            changes.push("include -> scopes.default.include");
+        }
+        if (input.output?.prefix !== undefined && defScope.name === undefined) {
+            defScope.name = input.output.prefix;
+        }
+    }
+    else {
+        if (input.entry !== undefined) {
+            changes.push("entry -> scopes.default.entry");
+        }
+        if (input.include !== undefined || input.resolve?.include !== undefined) {
+            changes.push("include -> scopes.default.include");
+        }
     }
-    const resolve = {
-        aliases: input.resolve?.aliases ?? default_config_1.DEFAULT_PRODEX_CONFIG.resolve.aliases,
-        maxDepth: input.resolve?.maxDepth ?? input.resolve?.depth ?? default_config_1.DEFAULT_PRODEX_CONFIG.resolve.maxDepth,
-        maxFiles: input.resolve?.maxFiles ?? input.resolve?.limit ?? default_config_1.DEFAULT_PRODEX_CONFIG.resolve.maxFiles,
-    };
     const config = {
         version: detect_1.REQUIRED_CONFIG_VERSION,
         $schema: input.$schema ?? default_config_1.DEFAULT_PRODEX_CONFIG.$schema,
         output,
-        entry: (0, string_list_1.toStringList)(input.entry?.files ?? input.entry),
-        include: (0, string_list_1.toStringList)(input.include ?? input.resolve?.include),
-        exclude: (0, string_list_1.toStringList)(input.exclude ?? input.resolve?.exclude ?? default_config_1.DEFAULT_PRODEX_CONFIG.exclude),
-        resolve,
-        profiles: migrateProfiles(input.profiles ?? input.shortcuts ?? {}, changes),
+        exclude,
+        aliases,
+        depth,
+        maxFiles,
+        scopes,
     };
-    if (input.entry?.files !== undefined)
-        changes.push("entry.files -> entry");
-    if (input.resolve?.include !== undefined)
-        changes.push("resolve.include -> include");
-    if (input.resolve?.exclude !== undefined)
-        changes.push("resolve.exclude -> exclude");
-    if (input.resolve?.depth !== undefined)
-        changes.push("resolve.depth -> resolve.maxDepth");
-    if (input.resolve?.limit !== undefined)
-        changes.push("resolve.limit -> resolve.maxFiles");
-    if (input.shortcuts !== undefined)
-        changes.push("shortcuts -> profiles");
     return {
         needed: true,
         fromVersion: typeof input?.version === "number" ? input.version : undefined,
@@ -58,10 +103,10 @@ function migrateConfig(input) {
         config,
     };
 }
-function migrateProfiles(input, changes) {
-    const profiles = {};
+function migrateScopes(input, changes) {
+    const scopes = {};
     for (const [key, value] of Object.entries(input || {})) {
-        profiles[key] = {
+        scopes[key] = {
             ...(value?.prefix ? { name: value.prefix } : {}),
             ...(value?.name ? { name: value.name } : {}),
             ...(value?.files || value?.entry ? { entry: (0, string_list_1.toStringList)(value.entry ?? value.files) } : {}),
@@ -69,11 +114,11 @@ function migrateProfiles(input, changes) {
             ...(value?.exclude ? { exclude: (0, string_list_1.toStringList)(value.exclude) } : {}),
         };
         if (value?.prefix !== undefined)
-            changes.push("shortcuts.*.prefix -> profiles.*.name");
+            changes.push("shortcuts.*.prefix -> scopes.*.name");
         if (value?.files !== undefined)
-            changes.push("shortcuts.*.files -> profiles.*.entry");
+            changes.push("shortcuts.*.files -> scopes.*.entry");
     }
-    return profiles;
+    return scopes;
 }
 function unique(items) {
     return [...new Set(items)];

package/dist/filesystem/binary.d.ts

@@ -0,0 +1,2 @@
+export declare function isBinaryFile(filePath: string): boolean;
+export declare function isBinaryBuffer(buffer: Buffer): boolean;

package/dist/filesystem/binary.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBinaryFile = isBinaryFile;
+exports.isBinaryBuffer = isBinaryBuffer;
+const fs_1 = __importDefault(require("fs"));
+function isBinaryFile(filePath) {
+    try {
+        const stat = fs_1.default.statSync(filePath);
+        if (!stat.isFile())
+            return false;
+        const fd = fs_1.default.openSync(filePath, "r");
+        const buffer = Buffer.alloc(1024);
+        const bytesRead = fs_1.default.readSync(fd, buffer, 0, 1024, 0);
+        fs_1.default.closeSync(fd);
+        for (let i = 0; i < bytesRead; i++) {
+            if (buffer[i] === 0)
+                return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+function isBinaryBuffer(buffer) {
+    return buffer.subarray(0, 1024).includes(0);
+}

package/dist/filesystem/entry-discovery.d.ts

@@ -0,0 +1,14 @@
+export declare const ENTRY_RESOLVE_EXTS: string[];
+/**
+ * Perform exact/glob match search.
+ */
+export declare function scanGlob(patterns: string[], root: string): Promise<string[]>;
+/**
+ * For a given path-like input, generate possible extensionless path expansions.
+ * Returns only files that physically exist.
+ */
+export declare function expandPathLike(pattern: string, root: string): string[];
+/**
+ * Searches the workspace for files that match the bare name stem exactly.
+ */
+export declare function discoverBareName(bareName: string, root: string, caseSensitive?: boolean): Promise<string[]>;

package/dist/filesystem/entry-discovery.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENTRY_RESOLVE_EXTS = void 0;
+exports.scanGlob = scanGlob;
+exports.expandPathLike = expandPathLike;
+exports.discoverBareName = discoverBareName;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const glob_scan_1 = require("./glob-scan");
+exports.ENTRY_RESOLVE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".php"];
+/**
+ * Perform exact/glob match search.
+ */
+async function scanGlob(patterns, root) {
+    const { files } = await (0, glob_scan_1.globScan)(patterns, { cwd: root });
+    return files;
+}
+/**
+ * For a given path-like input, generate possible extensionless path expansions.
+ * Returns only files that physically exist.
+ */
+function expandPathLike(pattern, root) {
+    const candidates = [];
+    for (const ext of exports.ENTRY_RESOLVE_EXTS) {
+        candidates.push(path_1.default.resolve(root, pattern + ext));
+        candidates.push(path_1.default.resolve(root, pattern, "index" + ext));
+    }
+    return candidates.filter((candidate) => {
+        try {
+            const stat = fs_1.default.statSync(candidate);
+            return stat.isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/**
+ * Searches the workspace for files that match the bare name stem exactly.
+ */
+async function discoverBareName(bareName, root, caseSensitive = false) {
+    const searchPatterns = [
+        `**/${bareName}`,
+        ...exports.ENTRY_RESOLVE_EXTS.map((ext) => `**/${bareName}${ext}`),
+        ...exports.ENTRY_RESOLVE_EXTS.map((ext) => `**/${bareName}/index${ext}`),
+    ];
+    const { files } = await (0, glob_scan_1.globScan)(searchPatterns, {
+        cwd: root,
+        caseSensitiveMatch: caseSensitive,
+    });
+    const resolvedMatches = new Set();
+    const targetStem = caseSensitive ? bareName : bareName.toLowerCase();
+    for (const file of files) {
+        const absFile = path_1.default.resolve(file);
+        const ext = path_1.default.extname(absFile);
+        const extLower = ext.toLowerCase();
+        // Ensure extension is empty or is one of the supported extensions
+        if (extLower !== "" && !exports.ENTRY_RESOLVE_EXTS.includes(extLower)) {
+            continue;
+        }
+        const stemRaw = path_1.default.basename(absFile, ext);
+        const stem = caseSensitive ? stemRaw : stemRaw.toLowerCase();
+        if (stem === targetStem) {
+            resolvedMatches.add(absFile);
+        }
+        else if (stem === "index") {
+            const parentDirRaw = path_1.default.basename(path_1.default.dirname(absFile));
+            const parentDir = caseSensitive ? parentDirRaw : parentDirRaw.toLowerCase();
+            if (parentDir === targetStem) {
+                resolvedMatches.add(absFile);
+            }
+        }
+    }
+    return Array.from(resolvedMatches);
+}

package/dist/filesystem/file-set.d.ts

@@ -0,0 +1,7 @@
+export interface BuildFinalFileSetParams {
+    root: string;
+    sources: string[];
+    include: string[];
+    exclude: string[];
+}
+export declare function buildFinalFileSet(params: BuildFinalFileSetParams): Promise<string[]>;

package/dist/filesystem/file-set.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFinalFileSet = buildFinalFileSet;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const glob_scan_1 = require("./glob-scan");
+const path_2 = require("./path");
+const exclude_1 = require("../tracing/exclude");
+async function buildFinalFileSet(params) {
+    const { root, sources, include, exclude } = params;
+    const absoluteFiles = new Set();
+    // 1. Start with selected source files
+    for (const src of sources) {
+        absoluteFiles.add((0, path_2.normalizePath)(path_1.default.resolve(root, src)));
+    }
+    // 2. Resolve and add include path/glob inputs
+    const patterns = [];
+    for (const inc of include) {
+        const candidate = String(inc ?? "").trim();
+        if (!candidate)
+            continue;
+        const normalized = (0, path_2.normalizePath)(candidate);
+        if (path_1.default.isAbsolute(normalized)) {
+            try {
+                if (fs_1.default.statSync(normalized).isFile()) {
+                    absoluteFiles.add((0, path_2.normalizePath)(path_1.default.resolve(normalized)));
+                    continue;
+                }
+            }
+            catch {
+                // Treat unreadable absolute paths as glob patterns
+            }
+        }
+        patterns.push(normalized);
+    }
+    if (patterns.length > 0) {
+        const { files: scanFiles } = await (0, glob_scan_1.globScan)(patterns, { cwd: root });
+        for (const f of scanFiles) {
+            absoluteFiles.add((0, path_2.normalizePath)(f));
+        }
+    }
+    // 3. Deduplicate (Set takes care of this)
+    let list = Array.from(absoluteFiles);
+    // 4. Apply exclude path/glob inputs
+    list = list.filter((p) => !(0, exclude_1.isExcluded)(p, exclude, root));
+    // 5. Sort deterministically by root-relative normalized path
+    list.sort((a, b) => {
+        const relA = (0, path_2.normalizePath)(path_1.default.relative(root, a));
+        const relB = (0, path_2.normalizePath)(path_1.default.relative(root, b));
+        return relA.localeCompare(relB);
+    });
+    // 6. Return absolute paths
+    return list;
+}

package/dist/filesystem/glob-scan.d.ts

@@ -1,4 +1,8 @@
-import { Options } from "fast-glob";
-export declare function globScan(patterns: string[], opts: Options): Promise<{
+export interface GlobScanOptions {
+    cwd?: string;
+    caseSensitiveMatch?: boolean;
+    ignore?: string[];
+}
+export declare function globScan(patterns: string[], opts?: GlobScanOptions): Promise<{
     files: string[];
 }>;

package/dist/filesystem/glob-scan.js

@@ -8,19 +8,24 @@ const path_1 = __importDefault(require("path"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const logger_1 = require("../diagnostics/logger");
 const inspect_1 = require("./inspect");
-const GLOBAL_IGNORE = ["**/node_modules/**", "**/vendor/**", "**/dist/**"];
-async function globScan(patterns, opts) {
-    const { absolute = true, cwd = process.cwd() } = opts;
+const path_2 = require("./path");
+async function globScan(patterns, opts = {}) {
+    const { cwd = process.cwd(), caseSensitiveMatch, ignore } = opts;
     if (!patterns?.length)
         return { files: [] };
-    const files = (await (0, fast_glob_1.default)(patterns, {
+    const rawFiles = await (0, fast_glob_1.default)(patterns, {
         cwd,
         extglob: true,
         dot: true,
         onlyFiles: true,
-        ignore: GLOBAL_IGNORE,
-        absolute,
-    })).map((file) => path_1.default.resolve(file));
+        ignore,
+        absolute: true,
+        caseSensitiveMatch,
+    });
+    // Slash normalization & absolute path resolution
+    const files = rawFiles.map((file) => (0, path_2.normalizePath)(path_1.default.resolve(cwd, file)));
+    // Deterministic file sorting
+    files.sort();
     logger_1.logger.debug("globScan ->", (0, inspect_1.inspectValue)(files));
     return { files };
 }

package/dist/filesystem/path-patterns.d.ts

@@ -0,0 +1,20 @@
+export declare function isGlobPattern(str: string): boolean;
+export interface NormalizationOptions {
+    role?: "entry" | "include" | "exclude" | "skip" | "within";
+}
+/**
+ * Normalizes a path or glob pattern.
+ *
+ * For "exclude" or "skip" roles:
+ * - If the pattern is not a glob and does not exist as a file, and has no extension,
+ *   it is assumed to be a directory shorthand and is expanded recursively (e.g., "dist" -> "dist/**").
+ * - Note: Ambiguous extensionless filenames (such as "README", "LICENSE", "Dockerfile", "Makefile")
+ *   are also treated as directories and expanded recursively if they do not exist on disk.
+ *
+ * For "entry" or "include" roles:
+ * - Non-existing directory-like inputs are NOT expanded and are kept as literal paths to preserve strictness.
+ *
+ * For all roles:
+ * - Existing directories are always expanded recursively (e.g., "src" -> "src/**").
+ */
+export declare function normalizePathOrGlob(pattern: string, root: string, options?: NormalizationOptions): string;

package/dist/filesystem/path-patterns.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGlobPattern = isGlobPattern;
+exports.normalizePathOrGlob = normalizePathOrGlob;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const path_2 = require("./path");
+function isGlobPattern(str) {
+    return str.includes("*") || str.includes("?") || str.includes("[") || str.includes("{");
+}
+/**
+ * Normalizes a path or glob pattern.
+ *
+ * For "exclude" or "skip" roles:
+ * - If the pattern is not a glob and does not exist as a file, and has no extension,
+ *   it is assumed to be a directory shorthand and is expanded recursively (e.g., "dist" -> "dist/**").
+ * - Note: Ambiguous extensionless filenames (such as "README", "LICENSE", "Dockerfile", "Makefile")
+ *   are also treated as directories and expanded recursively if they do not exist on disk.
+ *
+ * For "entry" or "include" roles:
+ * - Non-existing directory-like inputs are NOT expanded and are kept as literal paths to preserve strictness.
+ *
+ * For all roles:
+ * - Existing directories are always expanded recursively (e.g., "src" -> "src/**").
+ */
+function normalizePathOrGlob(pattern, root, options) {
+    const trimmed = String(pattern ?? "").trim();
+    if (!trimmed)
+        return "";
+    // 1. If it has glob characters, return normalized pattern
+    if (isGlobPattern(trimmed)) {
+        return (0, path_2.normalizePath)(trimmed);
+    }
+    // 2. Resolve absolute path to check disk status
+    const absPath = path_1.default.resolve(root, trimmed);
+    let isDir = false;
+    let isFile = false;
+    try {
+        const stat = fs_1.default.statSync(absPath);
+        isDir = stat.isDirectory();
+        isFile = stat.isFile();
+    }
+    catch {
+        // Path does not exist or cannot be read
+    }
+    // 3. Existing directories are expanded recursively
+    if (isDir) {
+        const normalized = (0, path_2.normalizePath)(trimmed);
+        if (normalized.endsWith("/")) {
+            return normalized + "**";
+        }
+        return normalized + "/**";
+    }
+    // 4. Role-aware normalization for exclude/skip roles (Option B)
+    const role = options?.role;
+    if (role === "exclude" || role === "skip") {
+        if (!isFile) {
+            const normalized = (0, path_2.normalizePath)(trimmed);
+            const hasExtension = path_1.default.extname(trimmed) !== "";
+            // Expand if it ends with a slash or has no extension
+            if (normalized.endsWith("/") || !hasExtension) {
+                return normalized.endsWith("/") ? normalized + "**" : normalized + "/**";
+            }
+        }
+    }
+    return (0, path_2.normalizePath)(trimmed);
+}

package/dist/index.js

@@ -4,8 +4,11 @@ exports.default = startProdex;
 exports.runProdexCommand = runProdexCommand;
 const init_command_1 = require("./commands/init-command");
 const migrate_command_1 = require("./commands/migrate-command");
-const profiles_command_1 = require("./commands/profiles-command");
-const run_command_1 = require("./commands/run-command");
+const pack_command_1 = require("./commands/pack-command");
+const trace_command_1 = require("./commands/trace-command");
+const scope_command_1 = require("./commands/scope-command");
+const git_command_1 = require("./commands/git-command");
+const grep_command_1 = require("./commands/grep-command");
 const cli_input_1 = require("./cli/cli-input");
 const reporter_1 = require("./cli/reporter");
 async function startProdex(args = process.argv) {
@@ -38,19 +41,6 @@ async function runProdexCommand(args = process.argv, cwd = process.cwd()) {
             runs: [],
         };
     }
-    if (parsed.command.kind === "profiles") {
-        const listed = (0, profiles_command_1.profilesCommand)(parsed.command.rootArg, cwd);
-        warnings.push(...listed.warnings);
-        errors.push(...listed.errors);
-        return {
-            ok: !errors.length,
-            exitCode: errors.length ? 1 : 0,
-            profiles: errors.length ? undefined : listed.profiles,
-            warnings,
-            errors,
-            runs: [],
-        };
-    }
     if (parsed.command.kind === "migrate") {
         const migration = (0, migrate_command_1.migrateCommand)({
             rootArg: parsed.command.rootArg,
@@ -67,21 +57,53 @@ async function runProdexCommand(args = process.argv, cwd = process.cwd()) {
             runs: [],
         };
     }
-    const run = await (0, run_command_1.runCommand)({
-        rootArg: parsed.command.rootArg,
-        flags: parsed.command.flags,
-        cwd,
-    });
-    warnings.push(...run.warnings);
-    errors.push(...run.errors);
-    if (errors.length)
-        return { ok: false, exitCode: 1, warnings, errors, runs: [] };
-    const ok = run.runs.every((item) => item.ok);
+    const kind = parsed.command.kind;
+    if (kind === "pack" || kind === "trace" || kind === "scope" || kind === "git" || kind === "grep") {
+        let cmdRes;
+        const params = { rootArg: parsed.command.rootArg, flags: parsed.command.flags, cwd };
+        if (kind === "pack") {
+            cmdRes = await (0, pack_command_1.packCommand)(params);
+        }
+        else if (kind === "trace") {
+            cmdRes = await (0, trace_command_1.traceCommand)(params);
+        }
+        else if (kind === "scope") {
+            cmdRes = await (0, scope_command_1.scopeCommand)(params);
+        }
+        else if (kind === "git") {
+            cmdRes = await (0, git_command_1.gitCommand)(params);
+        }
+        else {
+            cmdRes = await (0, grep_command_1.grepCommand)(params);
+        }
+        warnings.push(...cmdRes.warnings);
+        errors.push(...cmdRes.errors);
+        if (errors.length)
+            return { ok: false, exitCode: 1, warnings, errors, runs: [] };
+        if (kind === "scope" && cmdRes.scopes) {
+            return {
+                ok: true,
+                exitCode: 0,
+                scopes: cmdRes.scopes,
+                warnings,
+                errors,
+                runs: [],
+            };
+        }
+        const ok = cmdRes.runs.every((item) => item.ok);
+        return {
+            ok,
+            exitCode: ok ? 0 : 1,
+            warnings,
+            errors,
+            runs: cmdRes.runs,
+        };
+    }
     return {
-        ok,
-        exitCode: ok ? 0 : 1,
+        ok: false,
+        exitCode: 1,
         warnings,
-        errors,
-        runs: run.runs,
+        errors: [...errors, "Unknown command kind"],
+        runs: [],
     };
 }

package/dist/output/markdown-sections.d.ts

@@ -0,0 +1,5 @@
+import type { ArtifactSection, CommandOutputResult, FileSnapshot } from "../types";
+export declare function getDynamicFence(output: string): string;
+export declare function renderFileSection(file: FileSnapshot, index: number, root: string, navLine: string): string;
+export declare function renderGenericSection(sec: ArtifactSection, index: number, navLine: string): string;
+export declare function renderMdCmdResults(cmdResults?: CommandOutputResult[], root?: string, totalCount?: number, sectionCount?: number, orderedAnchors?: string[]): string;