prodex 1.4.11 → 2.0.1

package/dist/config/migration/transform.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateConfig = migrateConfig;
+const default_config_1 = require("../default-config");
+const detect_1 = require("./detect");
+const string_list_1 = require("../string-list");
+function migrateConfig(input) {
+    if (!(0, detect_1.requiresConfigMigration)(input)) {
+        return {
+            needed: false,
+            fromVersion: typeof input?.version === "number" ? input.version : undefined,
+            toVersion: detect_1.REQUIRED_CONFIG_VERSION,
+            changes: [],
+            config: input,
+        };
+    }
+    const changes = [];
+    const output = {
+        ...default_config_1.DEFAULT_PRODEX_CONFIG.output,
+        ...(input.output ?? {}),
+    };
+    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.");
+    }
+    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),
+    };
+    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,
+        toVersion: detect_1.REQUIRED_CONFIG_VERSION,
+        changes: unique(changes),
+        config,
+    };
+}
+function migrateProfiles(input, changes) {
+    const profiles = {};
+    for (const [key, value] of Object.entries(input || {})) {
+        profiles[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) } : {}),
+            ...(value?.include ? { include: (0, string_list_1.toStringList)(value.include) } : {}),
+            ...(value?.exclude ? { exclude: (0, string_list_1.toStringList)(value.exclude) } : {}),
+        };
+        if (value?.prefix !== undefined)
+            changes.push("shortcuts.*.prefix -> profiles.*.name");
+        if (value?.files !== undefined)
+            changes.push("shortcuts.*.files -> profiles.*.entry");
+    }
+    return profiles;
+}
+function unique(items) {
+    return [...new Set(items)];
+}

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

@@ -0,0 +1,16 @@
+import type { ProdexConfigFile } from "../../types";
+export interface MigrationPreview {
+    needed: boolean;
+    fromVersion?: number;
+    toVersion: number;
+    changes: string[];
+    config?: ProdexConfigFile;
+}
+export interface MigrationCommandResult extends MigrationPreview {
+    ok: boolean;
+    written: boolean;
+    backupPath?: string;
+    path: string;
+    warnings: string[];
+    errors: string[];
+}

package/dist/config/string-list.d.ts

@@ -0,0 +1,2 @@
+export declare function toStringList(value: unknown): string[];
+export declare function splitStringList(value: string): string[];

package/dist/config/string-list.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStringList = toStringList;
+exports.splitStringList = splitStringList;
+function toStringList(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => (typeof item === "string" ? item.trim() : ""))
+            .filter(Boolean);
+    }
+    if (typeof value === "string")
+        return splitStringList(value);
+    return [];
+}
+function splitStringList(value) {
+    return value.split(",").map((item) => item.trim()).filter(Boolean);
+}

package/dist/diagnostics/logger.d.ts

@@ -0,0 +1,3 @@
+import type { Logger, ProdexFlags } from "../types";
+export declare function setLoggerOptions(flags?: Partial<ProdexFlags>): void;
+export declare const logger: Logger;

package/dist/diagnostics/logger.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.setLoggerOptions = setLoggerOptions;
+let DEBUG = false;
+let SILENT = false;
+function setLoggerOptions(flags = {}) {
+    DEBUG = !!flags.debug;
+    SILENT = !!flags.silent;
+}
+exports.logger = {
+    debug: (...args) => {
+        if (DEBUG && !SILENT)
+            console.log("\n[debug]", ...args);
+    },
+    info: (...args) => {
+        if (!SILENT)
+            console.log("\n[info]", ...args);
+    },
+    warn: (...args) => {
+        if (!SILENT)
+            console.warn("\n[warn]", ...args);
+    },
+    error: (...args) => {
+        if (!SILENT)
+            console.error("\n[error]", ...args);
+    },
+    log: (...args) => {
+        if (!SILENT)
+            console.log("\n", ...args);
+    },
+    clear: () => console.clear(),
+};

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

@@ -0,0 +1,4 @@
+import { Options } from "fast-glob";
+export declare function globScan(patterns: string[], opts: Options): Promise<{
+    files: string[];
+}>;

package/dist/filesystem/glob-scan.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globScan = globScan;
+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;
+    if (!patterns?.length)
+        return { files: [] };
+    const files = (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));
+    logger_1.logger.debug("globScan ->", (0, inspect_1.inspectValue)(files));
+    return { files };
+}

package/dist/filesystem/inspect.d.ts

@@ -0,0 +1 @@
+export declare function inspectValue(value: unknown): string;

package/dist/filesystem/inspect.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectValue = inspectValue;
+const util_1 = __importDefault(require("util"));
+function inspectValue(value) {
+    return util_1.default.inspect(value, {
+        colors: true,
+        depth: null,
+        breakLength: 150,
+        compact: 3,
+    });
+}

package/dist/filesystem/path.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizePath(value: string): string;
+export declare function sanitizeFileName(value: string, fallback?: string): string;

package/dist/filesystem/path.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = normalizePath;
+exports.sanitizeFileName = sanitizeFileName;
+function normalizePath(value) {
+    return value.replace(/\\/g, "/");
+}
+function sanitizeFileName(value, fallback = "combined") {
+    const cleaned = value.trim().replace(/[<>:"/\\|?*]+/g, "_");
+    return cleaned || fallback;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Read a file safely. Returns "" if the file cannot be read.
+ */
+export declare function readFileSafe(p: string): string;
+/**
+ * Return a path relative to a root, normalized for forward slashes.
+ */
+export declare function rel(p: string, root?: string): string;

package/dist/{shared/io.js → filesystem/read-file.js}

@@ -1,16 +1,12 @@
 "use strict";
-// File: src/shared/io.ts
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readFileSafe = readFileSafe;
-exports.safeStatCached = safeStatCached;
 exports.rel = rel;
-const cache_1 = require("../core/managers/cache");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
-const promises_1 = __importDefault(require("fs/promises"));
 /**
  * Read a file safely. Returns "" if the file cannot be read.
  */
@@ -22,30 +18,9 @@ function readFileSafe(p) {
         return "";
     }
 }
-/**
- * Cached version of fs.stat().
- * Takes a cache namespace to preserve behavior across resolvers.
- */
-async function safeStatCached(ns, p) {
-    const cached = cache_1.CacheManager.get(ns, p);
-    if (cached !== undefined)
-        return cached;
-    try {
-        const st = await promises_1.default.stat(p);
-        cache_1.CacheManager.set(ns, p, st);
-        return st;
-    }
-    catch {
-        cache_1.CacheManager.set(ns, p, null);
-        return null;
-    }
-}
 /**
  * Return a path relative to a root, normalized for forward slashes.
  */
 function rel(p, root = process.cwd()) {
     return path_1.default.relative(root, p).replaceAll("\\", "/");
 }
-/**
- * Get a root-relative version of a path.
- */

package/dist/filesystem/stat-cache.d.ts

@@ -0,0 +1 @@
+export declare function safeStatCached(namespace: string, filePath: string): Promise<import("fs").Stats | null>;

package/dist/filesystem/stat-cache.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeStatCached = safeStatCached;
+const promises_1 = __importDefault(require("fs/promises"));
+const cache_manager_1 = require("../cache/cache-manager");
+async function safeStatCached(namespace, filePath) {
+    const cached = cache_manager_1.CacheManager.get(namespace, filePath);
+    if (cached !== undefined)
+        return cached;
+    try {
+        const stats = await promises_1.default.stat(filePath);
+        cache_manager_1.CacheManager.set(namespace, filePath, stats);
+        return stats;
+    }
+    catch {
+        cache_manager_1.CacheManager.set(namespace, filePath, null);
+        return null;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { CommandResult } from "./types";
+export default function startProdex(args?: string[]): Promise<CommandResult>;
+export declare function runProdexCommand(args?: string[], cwd?: string): Promise<CommandResult>;

package/dist/index.js

@@ -1,94 +1,87 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = startProdex;
-const init_1 = require("./cli/init");
+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 cli_input_1 = require("./cli/cli-input");
-const config_1 = require("./core/managers/config");
-const store_1 = require("./store");
-const combine_1 = require("./core/combine");
+const reporter_1 = require("./cli/reporter");
 async function startProdex(args = process.argv) {
-    if (args.includes("init"))
-        return (0, init_1.initProdex)();
-    const { root, flags } = (0, cli_input_1.parseCliInput)(args);
-    const userConfig = config_1.ConfigManager.load(root);
-    // Determine which shortcut runs to execute (order irrelevant).
-    const selected = [];
-    if (flags.shortcutAll) {
-        selected.push(...Object.keys(userConfig.shortcuts ?? {}));
+    const result = await runProdexCommand(args, process.cwd());
+    (0, reporter_1.reportCommandResult)(result);
+    process.exitCode = result.exitCode;
+    return result;
+}
+async function runProdexCommand(args = process.argv, cwd = process.cwd()) {
+    const parsed = (0, cli_input_1.parseCliInput)(args);
+    const warnings = [...parsed.warnings];
+    const errors = [...parsed.errors];
+    if (errors.length || !parsed.command) {
+        return { ok: false, exitCode: 1, warnings, errors, runs: [] };
     }
-    else if (Array.isArray(flags.shortcuts) && flags.shortcuts.length) {
-        selected.push(...flags.shortcuts);
+    if (parsed.command.kind === "help") {
+        return { ok: true, exitCode: 0, message: (0, reporter_1.renderHelp)(parsed.command.topic), warnings, errors, runs: [] };
     }
-    else if (flags.shortcut) {
-        selected.push(flags.shortcut);
+    if (parsed.command.kind === "version") {
+        return { ok: true, exitCode: 0, message: (0, reporter_1.renderVersion)(), warnings, errors, runs: [] };
     }
-    const shortcutRuns = Array.from(new Set(selected.map((s) => String(s).trim()).filter(Boolean))).sort();
-    await Promise.resolve().then(() => __importStar(require("./lib/polyfills")));
-    // Multi-run mode (shortcuts)
-    if (shortcutRuns.length) {
-        for (const shortcut of shortcutRuns) {
-            const runFlags = {
-                ...flags,
-                shortcut,
-                shortcuts: undefined,
-                shortcutAll: false,
-            };
-            const config = config_1.ConfigManager.merge(userConfig, runFlags, root);
-            (0, store_1.setGlobals)(config, runFlags);
-            const opts = {
-                showUi: false,
-                // Avoid output collisions when running multiple shortcuts.
-                cliName: config.name ?? shortcut,
-            };
-            await (0, combine_1.runCombine)({ cfg: config, opts });
-        }
-        return;
+    if (parsed.command.kind === "init") {
+        const init = (0, init_command_1.initCommand)(parsed.command.rootArg, cwd, parsed.command.force);
+        return {
+            ok: init.ok,
+            exitCode: init.ok ? 0 : 1,
+            message: init.message,
+            warnings,
+            errors: init.error ? [...errors, init.error] : errors,
+            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,
+            cwd,
+            write: parsed.command.write,
+            check: parsed.command.check,
+        });
+        return {
+            ok: migration.ok,
+            exitCode: migration.ok ? 0 : 1,
+            migration,
+            warnings: [...warnings, ...migration.warnings],
+            errors: [...errors, ...migration.errors],
+            runs: [],
+        };
     }
-    // If "@" was used but no shortcuts exist, fall back to a normal single run.
-    const baseFlags = flags.shortcutAll ? { ...flags, shortcutAll: false } : flags;
-    const config = config_1.ConfigManager.merge(userConfig, baseFlags, root);
-    (0, store_1.setGlobals)(config, baseFlags);
-    const opts = {
-        showUi: !baseFlags.ci &&
-            !baseFlags?.files?.length &&
-            config?.entry?.ui?.enablePicker &&
-            !baseFlags.shortcut &&
-            !baseFlags.shortcuts?.length &&
-            !baseFlags.shortcutAll,
-        cliName: config.name,
+    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);
+    return {
+        ok,
+        exitCode: ok ? 0 : 1,
+        warnings,
+        errors,
+        runs: run.runs,
     };
-    await (0, combine_1.runCombine)({ cfg: config, opts });
 }

package/dist/output/markdown.d.ts

@@ -0,0 +1,12 @@
+export interface MdTraceEntry {
+    file: string;
+    anchor: number;
+    startLine: number;
+    endLine: number;
+}
+export declare function renderTraceMd(files: string[], root?: string): {
+    content: string;
+    trace: MdTraceEntry[];
+    listingStart: number;
+    listingEnd: number;
+};

package/dist/output/markdown.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTraceMd = renderTraceMd;
+const path_1 = __importDefault(require("path"));
+const render_constants_1 = require("./render-constants");
+const read_file_1 = require("../filesystem/read-file");
+function renderTraceMd(files, root = process.cwd()) {
+    const sections = files.map((file, index) => renderMdSection(file, index, root));
+    const firstPassToc = buildToc({
+        files,
+        root,
+        count: files.length,
+        listingStart: 0,
+        listingEnd: 0,
+        trace: null,
+        withRanges: false,
+    });
+    const firstPassContent = [firstPassToc, ...sections, render_constants_1.MD_FOOTER].join("\n");
+    const firstPassAnalysis = analyzeTrace(firstPassContent, files.length);
+    const finalToc = buildToc({
+        files,
+        root,
+        count: files.length,
+        listingStart: firstPassAnalysis.listingStart,
+        listingEnd: firstPassAnalysis.listingEnd,
+        trace: firstPassAnalysis.trace,
+        withRanges: true,
+    });
+    const content = [finalToc, ...sections, render_constants_1.MD_FOOTER].join("\n");
+    const analysis = analyzeTrace(content, files.length);
+    return {
+        content,
+        trace: analysis.trace,
+        listingStart: analysis.listingStart,
+        listingEnd: analysis.listingEnd,
+    };
+}
+function buildToc(opts) {
+    const indexRange = opts.withRanges && opts.listingStart && opts.listingEnd
+        ? `L${opts.listingStart}-L${opts.listingEnd}`
+        : render_constants_1.INDEX_RANGE_PLACEHOLDER;
+    const items = opts.files.map((file, index) => {
+        const relativePath = (0, read_file_1.rel)(file, opts.root);
+        if (!opts.withRanges || !opts.trace)
+            return `- [${relativePath}](#${index + 1})`;
+        const trace = opts.trace[index];
+        return `- [${relativePath}](#${index + 1}) L${trace.startLine}-L${trace.endLine}`;
+    });
+    return [
+        render_constants_1.MD_HEADER,
+        render_constants_1.LLM_NOTE,
+        "",
+        "# Index",
+        `<!-- PRODEX_INDEX_RANGE: ${indexRange} -->`,
+        `<!-- PRODEX_FILE_COUNT: ${opts.count} -->`,
+        "<!-- PRODEX_INDEX_LIST_START -->",
+        ...items,
+        "<!-- PRODEX_INDEX_LIST_END -->",
+        "",
+        "---",
+    ].join("\n");
+}
+function analyzeTrace(content, count) {
+    const lines = content.split("\n");
+    const startMarkerIndex = lines.findIndex((line) => line.trim() === "<!-- PRODEX_INDEX_LIST_START -->");
+    const endMarkerIndex = lines.findIndex((line) => line.trim() === "<!-- PRODEX_INDEX_LIST_END -->");
+    const { listingStart, listingEnd } = analyzeListingRange(lines, startMarkerIndex, endMarkerIndex, count);
+    const footerStartIndex = findFooterStartIndex(lines);
+    const sectionStarts = findSectionStartIndexes(lines, count, footerStartIndex);
+    return {
+        listingStart,
+        listingEnd,
+        trace: sectionStarts.map((startIndex, index) => {
+            const nextStart = index < count - 1 ? sectionStarts[index + 1] : footerStartIndex;
+            const endIndex = Math.max(startIndex, nextStart - 1);
+            return {
+                file: "",
+                anchor: index + 1,
+                startLine: startIndex + 1,
+                endLine: endIndex + 1,
+            };
+        }),
+    };
+}
+function analyzeListingRange(lines, startMarkerIndex, endMarkerIndex, count) {
+    if (startMarkerIndex < 0 || endMarkerIndex <= startMarkerIndex)
+        return { listingStart: 0, listingEnd: 0 };
+    const itemIndexes = [];
+    for (let index = startMarkerIndex + 1; index < endMarkerIndex; index++) {
+        if (lines[index].trim().startsWith("- "))
+            itemIndexes.push(index);
+    }
+    if (!itemIndexes.length) {
+        const markerLine = startMarkerIndex + 2;
+        return { listingStart: markerLine, listingEnd: markerLine };
+    }
+    const cappedCount = count > 0 ? Math.min(itemIndexes.length, count) : itemIndexes.length;
+    return {
+        listingStart: itemIndexes[0] + 1,
+        listingEnd: itemIndexes[cappedCount - 1] + 1,
+    };
+}
+function findFooterStartIndex(lines) {
+    const footerMarker = lines.findIndex((line) => line.includes("<!-- PRODEx v") || line.includes("*Generated with [Prodex]"));
+    let footerStart = footerMarker >= 0 ? footerMarker : lines.length;
+    if (footerStart > 0 && lines[footerStart - 1].trim() === "---")
+        footerStart--;
+    return footerStart;
+}
+function findSectionStartIndexes(lines, count, fallbackIndex) {
+    const markerByAnchor = new Map();
+    for (let index = 0; index < lines.length; index++) {
+        const match = lines[index].trim().match(/^####\s+(\d+)\s*$/);
+        if (!match)
+            continue;
+        const anchor = Number(match[1]);
+        if (Number.isFinite(anchor) && anchor >= 1 && anchor <= count && !markerByAnchor.has(anchor)) {
+            markerByAnchor.set(anchor, index);
+        }
+    }
+    const starts = [];
+    for (let anchor = 1; anchor <= count; anchor++) {
+        const markerIndex = markerByAnchor.get(anchor);
+        if (markerIndex == null) {
+            starts.push(fallbackIndex);
+            continue;
+        }
+        starts.push(markerIndex > 0 && lines[markerIndex - 1].trim() === "---" ? markerIndex - 1 : markerIndex);
+    }
+    return starts;
+}
+function renderMdSection(filePath, index, root) {
+    const relativePath = (0, read_file_1.rel)(filePath, root);
+    const ext = path_1.default.extname(filePath).toLowerCase();
+    const lang = render_constants_1.LANG_MAP[ext] || "txt";
+    const code = (0, read_file_1.readFileSafe)(filePath).trimEnd();
+    return [
+        `---\n#### ${index + 1}`,
+        "\n",
+        "` File: " + relativePath + "`  [Back to top](#index)",
+        "",
+        "```" + lang,
+        code,
+        "```",
+        "",
+    ].join("\n");
+}

package/dist/output/naming.d.ts

@@ -0,0 +1,2 @@
+export declare function smartNaming(entries: string[]): string;
+export declare function shortTimestamp(): string;