prodex 2.0.0 → 2.1.0

package/dist/app/dependency-source-provider.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectDependencySources = collectDependencySources;
+const entry_resolver_1 = require("./entry-resolver");
+const target_resolver_1 = require("./target-resolver");
+const collect_trace_1 = require("../tracing/collect-trace");
+async function collectDependencySources(plan) {
+    const warnings = [];
+    const errors = [];
+    const resolveResult = plan.command === "trace"
+        ? await (0, target_resolver_1.resolveTargets)(plan)
+        : await (0, entry_resolver_1.resolveEntries)(plan);
+    warnings.push(...resolveResult.warnings);
+    errors.push(...resolveResult.errors);
+    const entries = resolveResult.entries;
+    const includes = plan.include ?? [];
+    const mode = getRunMode(entries.length, includes.length);
+    if (errors.length) {
+        return { files: [], entries, includes, mode, warnings, errors };
+    }
+    if (!entries.length && !includes.length) {
+        return {
+            files: [],
+            entries,
+            includes,
+            mode,
+            warnings,
+            errors: ["No entry files found and no include patterns were configured."],
+        };
+    }
+    const traceResult = await (0, collect_trace_1.collectTraceSources)({
+        cfg: {
+            root: plan.root,
+            name: plan.outputName,
+            entry: plan.entry,
+            include: plan.include,
+            exclude: plan.exclude,
+            aliases: plan.aliases,
+            depth: plan.depth,
+            maxFiles: plan.maxFiles,
+            output: plan.output,
+            scopes: {},
+            dryRun: plan.dryRun,
+        },
+        opts: {
+            entries,
+            outputName: plan.outputName,
+        },
+    });
+    return {
+        files: traceResult.files,
+        entries,
+        includes,
+        mode,
+        stats: traceResult.stats,
+        warnings,
+        errors,
+    };
+}
+function getRunMode(entryCount, includePatternCount) {
+    if (entryCount && includePatternCount)
+        return "mixed";
+    if (entryCount)
+        return "trace";
+    return "include-only";
+}

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

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

package/dist/app/entry-resolver.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEntries = resolveEntries;
+const exclude_1 = require("../tracing/exclude");
+const entry_discovery_1 = require("../filesystem/entry-discovery");
+async function resolveEntries(plan) {
+    const resolved = [];
+    const errors = [];
+    const warnings = [];
+    const root = plan.root;
+    const excludes = plan.exclude;
+    for (const entryPattern of plan.entry) {
+        const step1Matches = await (0, entry_discovery_1.scanGlob)([entryPattern], root);
+        const step1NonExcluded = step1Matches.filter((file) => !(0, exclude_1.isExcluded)(file, excludes, root));
+        if (step1NonExcluded.length > 0) {
+            resolved.push(...step1NonExcluded);
+            continue;
+        }
+        errors.push(`Entry "${entryPattern}" did not match any files.`);
+    }
+    return {
+        entries: [...new Set(resolved)],
+        errors,
+        warnings,
+    };
+}

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

@@ -1,2 +1,2 @@
-import type { RunPlan, RunResult } from "../types";
-export declare function executeRun(plan: RunPlan): Promise<RunResult>;
+import type { ExecutionPlan, RunResult } from "../types";
+export declare function executeRun(plan: ExecutionPlan): Promise<RunResult>;

package/dist/app/execute-run.js

@@ -1,19 +1,38 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeRun = executeRun;
+const fs_1 = __importDefault(require("fs"));
 const cache_manager_1 = require("../cache/cache-manager");
-const glob_scan_1 = require("../filesystem/glob-scan");
-const trace_run_1 = require("../tracing/trace-run");
 const logger_1 = require("../diagnostics/logger");
+const naming_1 = require("../output/naming");
+const shell_command_runner_1 = require("../runtime/shell-command-runner");
+const produce_output_1 = require("../output/produce-output");
+const source_collector_1 = require("./source-collector");
+const package_json_1 = __importDefault(require("../../package.json"));
+function hasMeaningfulSectionContent(section) {
+    const content = section.content.trim();
+    if (!content)
+        return false;
+    const normalized = content.toLowerCase();
+    return ![
+        "(none)",
+        "(no changes)",
+        "(no cached diff stat)",
+    ].includes(normalized);
+}
 async function executeRun(plan) {
     cache_manager_1.CacheManager.clear();
-    (0, logger_1.setLoggerOptions)(plan.flags);
+    (0, logger_1.setLoggerOptions)(plan);
     const warnings = [];
     const errors = [];
-    const entries = await resolveHeadlessEntries(plan);
-    const includes = plan.config.include ?? [];
-    const mode = getRunMode(entries.length, includes.length);
-    if (!entries.length && !includes.length) {
+    const collectResult = await (0, source_collector_1.collectSources)(plan);
+    warnings.push(...collectResult.warnings);
+    errors.push(...collectResult.errors);
+    const { entries, includes, mode } = collectResult;
+    if (errors.length) {
         return {
             ok: false,
             root: plan.root,
@@ -22,52 +41,135 @@ async function executeRun(plan) {
             includes,
             files: [],
             warnings,
-            errors: ["No entry files found and no include patterns were configured."],
-            profile: plan.profile,
+            errors,
+            scopeKey: plan.scopeKey,
         };
     }
-    const result = await (0, trace_run_1.runTrace)({
-        cfg: plan.config,
-        opts: {
-            entries,
-            outputName: plan.outputName,
-        },
-    });
-    if (!result.outputPath) {
+    const rawSections = collectResult.sections ?? [];
+    const filteredSections = rawSections.filter(hasMeaningfulSectionContent);
+    const hasContent = collectResult.files.length > 0 || filteredSections.length > 0;
+    if (!hasContent) {
         return {
             ok: false,
             root: plan.root,
             mode,
             entries,
             includes,
-            files: result.files,
-            stats: result.stats,
+            files: [],
+            stats: collectResult.stats,
             warnings,
-            errors: ["No files matched the selected entries or include patterns."],
-            profile: plan.profile,
+            errors: ["No files or metadata sections matched the selected options."],
+            scopeKey: plan.scopeKey,
         };
     }
+    const resolvedOutputName = plan.outputName?.trim() ||
+        (plan.command === "trace"
+            ? (0, naming_1.smartNaming)(entries)
+            : plan.command === "scope"
+                ? plan.scopeKey
+                : "pack-combined");
+    if (plan.dryRun) {
+        return {
+            ok: true,
+            root: plan.root,
+            mode,
+            outputName: resolvedOutputName,
+            entries,
+            includes,
+            files: collectResult.files,
+            stats: collectResult.stats,
+            warnings,
+            errors,
+            scopeKey: plan.scopeKey,
+            plannedCommands: plan.attachmentOptions?.commands ?? [],
+        };
+    }
+    // 1. Snapshot resolved files
+    const filesSnapshots = [];
+    const snapshotsMap = new Map();
+    if (collectResult.snapshots) {
+        for (const snap of collectResult.snapshots) {
+            snapshotsMap.set(snap.path, snap);
+        }
+    }
+    for (const file of collectResult.files) {
+        const cachedSnap = snapshotsMap.get(file);
+        if (cachedSnap) {
+            filesSnapshots.push(cachedSnap);
+        }
+        else {
+            try {
+                const content = fs_1.default.readFileSync(file, "utf8");
+                filesSnapshots.push({ path: file, content });
+            }
+            catch (err) {
+                filesSnapshots.push({ path: file, content: "", readError: err.message || String(err) });
+            }
+        }
+    }
+    // 2. Spawn attached commands sequentially
+    const commandOutputs = [];
+    if (plan.attachmentOptions && plan.attachmentOptions.commands.length > 0) {
+        for (const command of plan.attachmentOptions.commands) {
+            const cmdRes = await (0, shell_command_runner_1.executeAttachedCommand)(command, plan.root, plan.attachmentOptions.timeoutSeconds);
+            commandOutputs.push(cmdRes);
+            if (cmdRes.status !== "success") {
+                const errorMsg = `Attached command "${command}" failed with status: ${cmdRes.status}`;
+                if (plan.attachmentOptions.failOnError) {
+                    errors.push(errorMsg);
+                }
+                else {
+                    warnings.push(errorMsg);
+                }
+            }
+        }
+    }
+    // 3. Construct payload and write output
+    const payload = {
+        root: plan.root,
+        sections: filteredSections,
+        files: filesSnapshots,
+        commandOutputs,
+        metadata: {
+            version: package_json_1.default.version,
+            timestamp: new Date().toISOString(),
+            commandKind: plan.command,
+            mode,
+            outputName: resolvedOutputName,
+            entries,
+            includes,
+            scopeKey: plan.scopeKey,
+            targets: plan.target,
+            depth: plan.depth,
+        },
+    };
+    let produceResult;
+    try {
+        produceResult = await (0, produce_output_1.produceOutput)({
+            name: resolvedOutputName,
+            payload,
+            format: plan.output.format,
+            dir: plan.output.dir,
+            versioned: plan.output.versioned,
+        });
+    }
+    catch (err) {
+        errors.push(`Failed to generate output file: ${err.message || String(err)}`);
+    }
+    const ok = errors.length === 0 && produceResult !== undefined;
     return {
-        ok: true,
+        ok,
         root: plan.root,
         mode,
-        outputPath: result.outputPath,
+        outputPath: produceResult?.outputPath,
+        outputSizeBytes: produceResult?.outputSizeBytes,
+        outputName: resolvedOutputName,
         entries,
         includes,
-        files: result.files,
-        stats: result.stats,
+        files: collectResult.files,
+        stats: collectResult.stats,
         warnings,
         errors,
-        profile: plan.profile,
+        scopeKey: plan.scopeKey,
     };
 }
-async function resolveHeadlessEntries(plan) {
-    return (await (0, glob_scan_1.globScan)(plan.config.entry, { cwd: plan.root })).files;
-}
-function getRunMode(entryCount, includePatternCount) {
-    if (entryCount && includePatternCount)
-        return "mixed";
-    if (entryCount)
-        return "trace";
-    return "include-only";
-}

package/dist/app/git-source-provider.d.ts

@@ -0,0 +1,4 @@
+import type { ExecutionPlan, SourceCollectionResult } from "../types";
+export declare function runGit(args: string[], cwd: string, warnings: string[], errors: string[], maxBuffer?: number): string;
+export declare function runGitBuffer(args: string[], cwd: string, warnings: string[], errors: string[], maxBuffer?: number): Buffer | null;
+export declare function collectGitSources(plan: ExecutionPlan): Promise<SourceCollectionResult>;