prodex 1.4.11 → 2.0.1

package/dist/resolvers/php/php-resolver.js

@@ -5,120 +5,89 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolvePhpImports = resolvePhpImports;
 const fs_1 = __importDefault(require("fs"));
+const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
-const extract_imports_1 = require("./extract-imports");
+const cache_keys_1 = require("../../cache/cache-keys");
+const cache_manager_1 = require("../../cache/cache-manager");
+const logger_1 = require("../../diagnostics/logger");
+const path_2 = require("../../filesystem/path");
+const read_file_1 = require("../../filesystem/read-file");
+const resolver_result_1 = require("../resolver-result");
 const bindings_1 = require("./bindings");
+const extract_imports_1 = require("./extract-imports");
 const psr4_1 = require("./psr4");
-const logger_1 = require("../../lib/logger");
-const shared_1 = require("../../shared");
-const store_1 = require("../../store");
-const constants_1 = require("../../constants");
-const cache_1 = require("../../core/managers/cache");
-const collections_1 = require("../../shared/collections");
-const promises_1 = __importDefault(require("fs/promises")); // (add near the top if not present)
-/**
- * Typed PHP resolver (aligned with JS resolver signature).
- * - Uses global config via getConfig()
- * - Returns ResolverResult (files + stats)
- * - Depth/visited guarded recursion
- */
-async function resolvePhpImports({ filePath, visited = new Set(), depth = 0, maxDepth, ctx }) {
-    const { root: ROOT, resolve: { exclude: excludePatterns = [], depth: defaultDepth = 10 }, } = (0, store_1.getConfig)();
-    const limitDepth = maxDepth ?? defaultDepth;
-    if (depth >= limitDepth)
-        return (0, collections_1.emptyResult)(visited);
-    if (visited.has(filePath))
-        return (0, collections_1.emptyResult)(visited);
-    visited.add(filePath);
-    // Fast existence / read
+async function resolvePhpImports({ cfg, filePath, ctx }) {
     if (!fs_1.default.existsSync(filePath))
-        return (0, collections_1.emptyResult)(visited);
-    const code = (0, shared_1.readFileSafe)(filePath);
+        return (0, resolver_result_1.emptyResolverResult)();
+    const code = (0, read_file_1.readFileSafe)(filePath);
     if (!code)
-        return (0, collections_1.emptyResult)(visited);
-    const nsMatch = code.match(/\bnamespace\s+([^;]+);/);
-    const currentNamespace = nsMatch ? nsMatch[1].trim() : null;
-    // Context + exclusions
-    const phpCtx = buildPhpCtx(ROOT, ctx);
-    // Parse imports (expand grouped `use` syntax)
-    const raw = (0, extract_imports_1.extractPhpImports)(code);
-    const imports = (0, extract_imports_1.expandGroupedUses)(raw);
-    // Accumulators
-    const stats = (0, shared_1.newStats)();
-    const filesOut = [];
-    for (const imp0 of imports) {
-        let imp = imp0;
-        if (!imp || typeof imp !== "string")
-            continue;
-        // Fully-qualified check
-        const isFullyQualified = imp.includes("\\") || imp.startsWith("\\");
-        if (!isFullyQualified && currentNamespace) {
-            imp = `${currentNamespace}\\${imp}`;
-        }
-        // Respect Laravel container bindings (Interface → Implementation)
-        if (phpCtx.bindings[imp]) {
-            // logger.debug("[php-resolver] binding:", imp, "→", _2j(phpCtx.bindings[imp]));
-            imp = phpCtx.bindings[imp];
-        }
-        // Only resolve PSR-4 mapped namespaces
-        if (!startsWithAnyNamespace(imp, phpCtx.nsKeys))
+        return (0, resolver_result_1.emptyResolverResult)();
+    const currentNamespace = getCurrentNamespace(code);
+    const phpCtx = buildPhpCtx(cfg.root, ctx);
+    const imports = (0, extract_imports_1.expandGroupedUses)((0, extract_imports_1.extractPhpImports)(code));
+    const stats = (0, resolver_result_1.newResolverStats)();
+    const files = [];
+    for (const importName of imports) {
+        const resolvedImport = resolveNamespaceImport(importName, currentNamespace, phpCtx);
+        if (!resolvedImport)
             continue;
-        // Resolve namespace → file path (sync helper retained)
-        const resolvedPath = await tryResolvePhpFile(imp, filePath, phpCtx.psr4);
-        // Exclusion check after final resolution
-        if ((0, shared_1.isExcluded)(resolvedPath, excludePatterns, ROOT))
-            continue;
-        stats.expected.add(imp);
+        const resolvedPath = await tryResolvePhpFile(resolvedImport, filePath, phpCtx.psr4);
+        stats.expected.add(resolvedImport);
         if (!resolvedPath)
             continue;
-        stats.resolved.add(imp);
-        filesOut.push(resolvedPath);
-        // Recurse
-        const sub = await resolvePhpImports({
-            filePath: resolvedPath,
-            visited,
-            depth: depth + 1,
-            maxDepth: limitDepth,
-            ctx: phpCtx,
-        });
-        filesOut.push(...sub.files);
-        (0, shared_1.mergeStats)(stats, sub.stats);
+        stats.resolved.add(resolvedImport);
+        files.push(resolvedPath);
     }
-    const out = (0, shared_1.unique)(filesOut);
-    const unresolved = (0, shared_1.setDiff)(stats.expected, stats.resolved);
-    logger_1.logger.debug(`🪶 [php-resolver] ${path_1.default.basename(filePath)} → expected: ${stats.expected.size}, resolved: ${stats.resolved.size}`);
+    const unresolved = (0, resolver_result_1.resolverSetDiff)(stats.expected, stats.resolved);
+    logger_1.logger.debug(`[php-resolver] ${path_1.default.basename(filePath)} -> expected: ${stats.expected.size}, resolved: ${stats.resolved.size}`);
     if (unresolved.size)
         logger_1.logger.debug("[php-resolver] unresolved:", [...unresolved]);
-    return { files: out, visited, stats };
+    return { files: (0, resolver_result_1.uniqueResolvedFiles)(files), stats };
+}
+function getCurrentNamespace(code) {
+    const nsMatch = code.match(/\bnamespace\s+([^;]+);/);
+    return nsMatch ? nsMatch[1].trim() : null;
+}
+function resolveNamespaceImport(importName, currentNamespace, ctx) {
+    if (!importName || typeof importName !== "string")
+        return null;
+    let resolved = importName;
+    const isFullyQualified = resolved.includes("\\") || resolved.startsWith("\\");
+    if (!isFullyQualified && currentNamespace)
+        resolved = `${currentNamespace}\\${resolved}`;
+    if (ctx.bindings[resolved])
+        resolved = ctx.bindings[resolved];
+    return startsWithAnyNamespace(resolved, ctx.nsKeys) ? resolved : null;
 }
 async function tryResolvePhpFile(imp, fromFile, psr4) {
     const key = `php:${imp}:${fromFile}`;
-    const cached = cache_1.CacheManager.get(constants_1.CACHE_KEYS.PHP_FILECACHE, key);
+    const cached = cache_manager_1.CacheManager.get(cache_keys_1.CACHE_KEYS.PHP_FILECACHE, key);
     if (cached !== undefined)
         return cached;
-    const nsKey = Object.keys(psr4).find((k) => imp.startsWith(k));
+    const nsKey = Object.keys(psr4).find((candidate) => imp.startsWith(candidate));
     if (!nsKey) {
-        cache_1.CacheManager.set(constants_1.CACHE_KEYS.PHP_FILECACHE, key, null);
+        cache_manager_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_FILECACHE, key, null);
         return null;
     }
-    const rel = imp.replace(nsKey, "").norm();
-    const tries = [path_1.default.join(psr4[nsKey], rel), path_1.default.join(psr4[nsKey], rel + ".php"), path_1.default.join(psr4[nsKey], rel, "index.php")];
-    // 🔹 Run all stats concurrently
-    const results = await Promise.allSettled(tries.map(async (p) => {
+    const relativeImport = (0, path_2.normalizePath)(imp.replace(nsKey, ""));
+    const candidates = [
+        path_1.default.join(psr4[nsKey], relativeImport),
+        path_1.default.join(psr4[nsKey], relativeImport + ".php"),
+        path_1.default.join(psr4[nsKey], relativeImport, "index.php"),
+    ];
+    const results = await Promise.allSettled(candidates.map(async (candidate) => {
         try {
-            const st = await promises_1.default.stat(p);
-            return st.isFile() ? path_1.default.resolve(p) : null;
+            const stats = await promises_1.default.stat(candidate);
+            return stats.isFile() ? path_1.default.resolve(candidate) : null;
         }
         catch {
             return null;
         }
     }));
-    //@ts-ignore
-    const resolved = results.find((r) => r.status === "fulfilled" && r.value)?.value ?? null;
-    cache_1.CacheManager.set(constants_1.CACHE_KEYS.PHP_FILECACHE, key, resolved);
+    const resolved = results.find(isFulfilledPath)?.value ?? null;
+    cache_manager_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_FILECACHE, key, resolved);
     return resolved;
 }
-/** Ensure we have a PHP resolver context for the current root */
 function buildPhpCtx(root, prev) {
     if (prev?.kind === "php")
         return prev;
@@ -127,10 +96,12 @@ function buildPhpCtx(root, prev) {
     const bindings = (0, bindings_1.loadLaravelBindings)(root);
     return { kind: "php", psr4, nsKeys, bindings };
 }
-/** Namespace prefix check */
 function startsWithAnyNamespace(imp, nsKeys) {
-    for (const k of nsKeys)
-        if (imp.startsWith(k))
+    for (const nsKey of nsKeys)
+        if (imp.startsWith(nsKey))
             return true;
     return false;
 }
+function isFulfilledPath(result) {
+    return result.status === "fulfilled" && !!result.value;
+}

package/dist/resolvers/php/psr4.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Builds a PSR-4 namespace to directory map from composer.json.
+ * Returns absolute paths in the map values.
+ */
+export declare function resolvePsr4(root: string): Record<string, string>;

package/dist/resolvers/php/psr4.js

@@ -6,19 +6,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolvePsr4 = resolvePsr4;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const cache_1 = require("../../core/managers/cache");
-const cache_keys_1 = require("../../constants/cache-keys");
+const cache_manager_1 = require("../../cache/cache-manager");
+const cache_keys_1 = require("../../cache/cache-keys");
 /**
- * Builds a PSR-4 namespace → directory map from composer.json.
+ * Builds a PSR-4 namespace to directory map from composer.json.
  * Returns absolute paths in the map values.
  */
 function resolvePsr4(root) {
-    const cached = cache_1.CacheManager.get(cache_keys_1.CACHE_KEYS.PHP_PSR4, root);
+    const cached = cache_manager_1.CacheManager.get(cache_keys_1.CACHE_KEYS.PHP_PSR4, root);
     if (cached)
         return cached;
     const composer = path_1.default.join(root, "composer.json");
     if (!fs_1.default.existsSync(composer)) {
-        cache_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_PSR4, root, {});
+        cache_manager_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_PSR4, root, {});
         return {};
     }
     try {
@@ -29,11 +29,11 @@ function resolvePsr4(root) {
             const cleanNs = ns.replace(/\\+$/, "");
             map[cleanNs] = path_1.default.resolve(root, src[ns]);
         }
-        cache_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_PSR4, root, map);
+        cache_manager_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_PSR4, root, map);
         return map;
     }
     catch {
-        cache_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_PSR4, root, {});
+        cache_manager_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_PSR4, root, {});
         return {};
     }
 }

package/dist/resolvers/resolver-constants.d.ts

@@ -0,0 +1,4 @@
+export declare const CODE_EXTS: string[];
+export declare const BASE_EXTS: string[];
+export declare const REAL_EXTS: Set<string>;
+export declare const DTS_EXT = ".d.ts";

package/dist/resolvers/resolver-constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DTS_EXT = exports.REAL_EXTS = exports.BASE_EXTS = exports.CODE_EXTS = void 0;
+exports.CODE_EXTS = [".js", ".mjs", ".ts", ".tsx", ".d.ts", ".php"];
+exports.BASE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
+exports.REAL_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".d.ts", ".json"]);
+exports.DTS_EXT = ".d.ts";

package/dist/resolvers/resolver-result.d.ts

@@ -0,0 +1,5 @@
+import type { ResolverResult } from "../types";
+export declare function newResolverStats(): ResolverResult["stats"];
+export declare function emptyResolverResult(): ResolverResult;
+export declare function resolverSetDiff<A>(left: Set<A>, right: Set<A>): Set<A>;
+export declare function uniqueResolvedFiles(files: string[]): string[];

package/dist/resolvers/resolver-result.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newResolverStats = newResolverStats;
+exports.emptyResolverResult = emptyResolverResult;
+exports.resolverSetDiff = resolverSetDiff;
+exports.uniqueResolvedFiles = uniqueResolvedFiles;
+function newResolverStats() {
+    return { expected: new Set(), resolved: new Set() };
+}
+function emptyResolverResult() {
+    return { files: [], stats: newResolverStats() };
+}
+function resolverSetDiff(left, right) {
+    return new Set([...left].filter((item) => !right.has(item)));
+}
+function uniqueResolvedFiles(files) {
+    return [...new Set(files)];
+}

package/dist/tracing/exclude.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Centralized exclusion logic.
+ * Accepts namespaces, absolute paths, or relative paths
+ * and converts everything to a normalized, root-relative glob target.
+ */
+export declare function isExcluded(p: string, patterns?: string[], root?: string): boolean;

package/dist/{shared/patterns.js → tracing/exclude.js}

@@ -4,10 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isExcluded = isExcluded;
-// File: src/shared/patterns.ts
 const micromatch_1 = __importDefault(require("micromatch"));
 const path_1 = __importDefault(require("path"));
-const _1 = require(".");
+const read_file_1 = require("../filesystem/read-file");
+const path_2 = require("../filesystem/path");
 /**
  * Centralized exclusion logic.
  * Accepts namespaces, absolute paths, or relative paths
@@ -18,10 +18,10 @@ function isExcluded(p, patterns = [], root = process.cwd()) {
         return false;
     if (!p)
         return false;
-    let norm = p.norm();
+    let norm = (0, path_2.normalizePath)(p);
     if (!path_1.default.isAbsolute(norm) && /^[A-Z]/.test(norm))
         return false;
     if (path_1.default.isAbsolute(norm))
-        norm = (0, _1.rel)(norm, root).norm();
+        norm = (0, path_2.normalizePath)((0, read_file_1.rel)(norm, root));
     return micromatch_1.default.isMatch(norm, patterns);
 }

package/dist/tracing/follow-chain.d.ts

@@ -0,0 +1,5 @@
+import type { ProdexConfig } from "../types";
+export declare function followChain(entryFiles: string[], cfg: ProdexConfig): Promise<{
+    files: string[];
+    stats: import("../types").TraceStats;
+}>;

package/dist/tracing/follow-chain.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.followChain = followChain;
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../diagnostics/logger");
+const exclude_1 = require("./exclude");
+const trace_stats_1 = require("./trace-stats");
+const resolver_registry_1 = require("./resolver-registry");
+async function followChain(entryFiles, cfg) {
+    const limit = cfg.resolve.maxFiles;
+    const resolverDepth = cfg.resolve.maxDepth;
+    logger_1.logger.debug("Following dependency chain...");
+    const visited = new Set();
+    const all = [];
+    const stats = (0, trace_stats_1.newStats)();
+    for (const file of entryFiles) {
+        await visitFile(file, 0);
+    }
+    return {
+        files: (0, trace_stats_1.unique)(all),
+        stats,
+    };
+    async function visitFile(file, depth) {
+        if (visited.has(file))
+            return;
+        visited.add(file);
+        all.push(file);
+        if (limit && all.length >= limit) {
+            logger_1.logger.warn("File limit reached:", limit);
+            return;
+        }
+        if (depth >= resolverDepth)
+            return;
+        const ext = path_1.default.extname(file);
+        if (!(0, resolver_registry_1.hasResolver)(ext))
+            return;
+        const resolver = (0, resolver_registry_1.getResolver)(ext);
+        if (!resolver)
+            return;
+        const params = { cfg, filePath: file };
+        let result = null;
+        try {
+            result = await resolver(params);
+        }
+        catch (err) {
+            logger_1.logger.warn(`Resolver failed for ${file}:`, err.message || err);
+            return;
+        }
+        if (!result)
+            return;
+        (0, trace_stats_1.mergeStats)(stats, result.stats);
+        for (const resolvedFile of result.files) {
+            if ((0, exclude_1.isExcluded)(resolvedFile, cfg.exclude, cfg.root))
+                continue;
+            if (limit && all.length >= limit)
+                return;
+            await visitFile(resolvedFile, depth + 1);
+        }
+    }
+}

package/dist/tracing/include-files.d.ts

@@ -0,0 +1,2 @@
+import type { ProdexConfig } from "../types";
+export declare function applyIncludes(cfg: ProdexConfig, files: string[]): Promise<string[]>;

package/dist/tracing/include-files.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyIncludes = applyIncludes;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const glob_scan_1 = require("../filesystem/glob-scan");
+const path_2 = require("../filesystem/path");
+const trace_stats_1 = require("./trace-stats");
+async function applyIncludes(cfg, files) {
+    const { include, root } = cfg;
+    const absoluteFiles = [];
+    const patterns = [];
+    for (const raw of include) {
+        const candidate = String(raw ?? "").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.push(path_1.default.resolve(normalized));
+                    continue;
+                }
+            }
+            catch {
+                // Treat unreadable absolute paths as glob patterns so include handling stays consistent.
+            }
+        }
+        patterns.push(normalized);
+    }
+    const scan = await (0, glob_scan_1.globScan)(patterns, { cwd: root });
+    return (0, trace_stats_1.unique)([...files, ...absoluteFiles, ...scan.files]);
+}

package/dist/tracing/resolver-registry.d.ts

@@ -0,0 +1,5 @@
+import type { ResolverParams, ResolverResult } from "../types";
+type Resolver = (params: ResolverParams) => Promise<ResolverResult>;
+export declare function hasResolver(extension: string): boolean;
+export declare function getResolver(extension: string): Resolver | undefined;
+export {};

package/dist/tracing/resolver-registry.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasResolver = hasResolver;
+exports.getResolver = getResolver;
+const resolver_constants_1 = require("../resolvers/resolver-constants");
+const js_resolver_1 = require("../resolvers/js/js-resolver");
+const php_resolver_1 = require("../resolvers/php/php-resolver");
+const RESOLVERS = {
+    ".php": php_resolver_1.resolvePhpImports,
+    ".ts": js_resolver_1.resolveJsImports,
+    ".tsx": js_resolver_1.resolveJsImports,
+    ".d.ts": js_resolver_1.resolveJsImports,
+    ".js": js_resolver_1.resolveJsImports,
+};
+function hasResolver(extension) {
+    return resolver_constants_1.CODE_EXTS.includes(extension) && !!RESOLVERS[extension];
+}
+function getResolver(extension) {
+    return RESOLVERS[extension];
+}

package/dist/tracing/trace-run.d.ts

@@ -0,0 +1,2 @@
+import type { TraceParams, TraceResult } from "../types";
+export declare function runTrace({ cfg, opts }: TraceParams): Promise<TraceResult>;

package/dist/tracing/trace-run.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTrace = runTrace;
+const follow_chain_1 = require("./follow-chain");
+const include_files_1 = require("./include-files");
+const naming_1 = require("../output/naming");
+const produce_output_1 = require("../output/produce-output");
+async function runTrace({ cfg, opts }) {
+    const entries = opts.entries ?? [];
+    const result = entries.length ? await (0, follow_chain_1.followChain)(entries, cfg) : undefined;
+    const files = await (0, include_files_1.applyIncludes)(cfg, result?.files ?? []);
+    if (!files.length) {
+        return { entries, files: [], stats: result?.stats };
+    }
+    const outputPath = await (0, produce_output_1.produceOutput)({
+        name: opts.outputName ?? (0, naming_1.smartNaming)(entries),
+        files,
+        cfg,
+    });
+    return { outputPath, entries, files, stats: result?.stats };
+}

package/dist/tracing/trace-stats.d.ts

@@ -0,0 +1,4 @@
+import type { TraceStats } from "../types";
+export declare function newStats(): TraceStats;
+export declare function mergeStats(target: TraceStats, src: TraceStats): TraceStats;
+export declare function unique<T>(arr: T[]): T[];

package/dist/tracing/trace-stats.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newStats = newStats;
+exports.mergeStats = mergeStats;
+exports.unique = unique;
+function newStats() {
+    return { expected: new Set(), resolved: new Set() };
+}
+function mergeStats(target, src) {
+    src.expected.forEach((item) => target.expected.add(item));
+    src.resolved.forEach((item) => target.resolved.add(item));
+    return target;
+}
+function unique(arr) {
+    return [...new Set(arr)];
+}

package/dist/types/app.types.d.ts

@@ -0,0 +1,62 @@
+import type { MigrationCommandResult } from "../config/migration";
+import type { ProdexFlags } from "./cli.types";
+import type { ProdexConfig } from "./config.types";
+import type { ChainResult } from "./tracing.types";
+export type CliCommand = {
+    kind: "run";
+    rootArg?: string;
+    flags: Partial<ProdexFlags>;
+} | {
+    kind: "init";
+    rootArg?: string;
+    force?: boolean;
+} | {
+    kind: "profiles";
+    rootArg?: string;
+} | {
+    kind: "migrate";
+    rootArg?: string;
+    write?: boolean;
+    check?: boolean;
+} | {
+    kind: "help";
+    topic?: string;
+} | {
+    kind: "version";
+};
+export interface CliParseResult {
+    command?: CliCommand;
+    warnings: string[];
+    errors: string[];
+}
+export interface RunPlan {
+    root: string;
+    config: ProdexConfig;
+    flags: Partial<ProdexFlags>;
+    outputName?: string;
+    profile?: string;
+}
+export interface RunResult {
+    ok: boolean;
+    root: string;
+    mode: "trace" | "include-only" | "mixed";
+    outputPath?: string;
+    outputName?: string;
+    entries: string[];
+    includes: string[];
+    files: string[];
+    stats?: ChainResult["stats"];
+    warnings: string[];
+    errors: string[];
+    profile?: string;
+}
+export interface CommandResult {
+    ok: boolean;
+    exitCode: number;
+    message?: string;
+    profiles?: string[];
+    migration?: MigrationCommandResult;
+    warnings: string[];
+    errors: string[];
+    runs: RunResult[];
+}

package/dist/types/app.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/cli.types.d.ts

@@ -0,0 +1,22 @@
+export interface ProdexFlags {
+    /** Entry globs or file paths. Repeatable and comma-aware. */
+    entry?: string[];
+    /** Extra files or globs appended without dependency resolution. */
+    include?: string[];
+    /** Files or globs to skip during traversal. */
+    exclude?: string[];
+    /** Output format override. */
+    format?: "md" | "txt";
+    /** Output basename override for this run. */
+    name?: string | null;
+    /** Maximum dependency traversal depth. */
+    maxDepth?: number | null;
+    /** Maximum number of files to trace. */
+    maxFiles?: number | null;
+    /** Enable debug logs. */
+    debug?: boolean;
+    /** Named profiles to run, in user-provided order. */
+    profiles?: string[];
+    /** Run all configured profiles. */
+    allProfiles?: boolean;
+}

package/dist/types/cli.types.js

@@ -1,12 +1,2 @@
 "use strict";
-/**
- * CLI flag schema for Prodex.
- * Mirrors the current CLI synopsis:
- *
- *   prodex [entries...] [-tcdv]
- *          [--txt] [--ci] [--debug] [--verbose]
- *          [--name=<string>|-n=<string>]
- *          [--limit=<int>|-l=<int>]
- *          [--inc=<globs>] [--exc=<globs>]
- */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/config.types.d.ts

@@ -0,0 +1,34 @@
+export interface ProdexConfig extends ProdexBase {
+    root: string;
+    name?: string;
+}
+export type ProdexConfigFile = DeepPartial<ProdexBase> & {
+    $schema: string;
+    version: number;
+};
+export type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends Array<infer Item> ? Item[] : T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+export type ProdexProfile = {
+    name?: string;
+    entry?: string[];
+    include?: string[];
+    exclude?: string[];
+};
+interface ProdexBase {
+    output: {
+        dir: string;
+        versioned: boolean;
+        format: "md" | "txt";
+    };
+    entry: string[];
+    include: string[];
+    exclude: string[];
+    resolve: {
+        aliases: Record<string, string>;
+        maxDepth: number;
+        maxFiles: number;
+    };
+    profiles: Record<string, ProdexProfile>;
+}
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./config.types";
+export * from "./cli.types";
+export * from "./tracing.types";
+export * from "./output.types";
+export * from "./resolver.types";
+export * from "./utils.types";
+export * from "./app.types";