prodex 2.0.0 → 2.1.0

package/dist/output/markdown-sections.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDynamicFence = getDynamicFence;
+exports.renderFileSection = renderFileSection;
+exports.renderGenericSection = renderGenericSection;
+exports.renderMdCmdResults = renderMdCmdResults;
+const path_1 = __importDefault(require("path"));
+const render_constants_1 = require("./render-constants");
+const read_file_1 = require("../filesystem/read-file");
+const render_helpers_1 = require("./render-helpers");
+function getDynamicFence(output) {
+    const matches = output.match(/`+/g);
+    if (!matches)
+        return "```";
+    const maxLength = Math.max(...matches.map((m) => m.length));
+    if (maxLength >= 3) {
+        return "`".repeat(maxLength + 1);
+    }
+    return "```";
+}
+function renderFileSection(file, index, root, navLine) {
+    const relativePath = (0, read_file_1.rel)(file.path, root);
+    const ext = path_1.default.extname(file.path).toLowerCase();
+    const lang = render_constants_1.LANG_MAP[ext] || "txt";
+    const code = file.readError ? `Error reading file: ${file.readError}` : file.content.trimEnd();
+    const fence = getDynamicFence(code);
+    return [
+        `---\n#### ${index + 1}`,
+        "\n",
+        `\` File: ${relativePath} \`  ${navLine}`,
+        "",
+        fence + lang,
+        code,
+        fence,
+        "",
+    ].join("\n");
+}
+function renderGenericSection(sec, index, navLine) {
+    const lang = sec.language || "txt";
+    const fence = getDynamicFence(sec.content);
+    return [
+        `---\n<a id="sec-${index + 1}"></a>`,
+        `## ${sec.title}`,
+        navLine,
+        "",
+        fence + lang,
+        sec.content.trimEnd(),
+        fence,
+        "",
+    ].join("\n");
+}
+function renderMdCmdResults(cmdResults, root = process.cwd(), totalCount = 0, sectionCount = 0, orderedAnchors) {
+    if (!cmdResults || cmdResults.length === 0)
+        return "";
+    const lines = ["\n---", "# Command Outputs", ""];
+    const cmdCount = cmdResults.length;
+    for (let i = 0; i < cmdCount; i++) {
+        const res = cmdResults[i];
+        const relativeDir = (0, read_file_1.rel)(res.cwd, root) || ".";
+        const durationSec = (res.durationMs / 1000).toFixed(1);
+        const fence = getDynamicFence(res.combinedOutput);
+        const anchorId = `cmd-${i + 1}`;
+        let navLine;
+        if (orderedAnchors) {
+            const idx = orderedAnchors.indexOf(anchorId);
+            const navParts = [];
+            if (idx > 0) {
+                navParts.push(`[Previous](#${orderedAnchors[idx - 1]})`);
+            }
+            navParts.push(`[Back to top](#index)`);
+            if (idx < orderedAnchors.length - 1) {
+                navParts.push(`[Next](#${orderedAnchors[idx + 1]})`);
+            }
+            navLine = navParts.join(" | ");
+        }
+        else {
+            const navParts = [];
+            if (i > 0) {
+                navParts.push(`[Previous](#cmd-${i})`);
+            }
+            else if (totalCount > 0) {
+                navParts.push(`[Previous](#${totalCount})`);
+            }
+            else if (sectionCount > 0) {
+                navParts.push(`[Previous](#sec-${sectionCount})`);
+            }
+            navParts.push(`[Back to top](#index)`);
+            if (i < cmdCount - 1) {
+                navParts.push(`[Next](#cmd-${i + 2})`);
+            }
+            navLine = navParts.join(" | ");
+        }
+        lines.push(`---`, `<a id="cmd-${i + 1}"></a>`, `## Command ${i + 1}: ${res.command}`, navLine, "", `- Status: ${res.status}`, `- Exit code: ${(0, render_helpers_1.formatExitCode)(res.exitCode)}`, `- Duration: ${durationSec}s`, `- Timed out: ${(0, render_helpers_1.formatTimeout)(res.timedOut)}`, `- Working directory: ${relativeDir}`, "");
+        if (res.errorMessage) {
+            lines.push(`- Error message: ${res.errorMessage}`, "");
+        }
+        lines.push(fence + "text", res.combinedOutput, fence, "");
+    }
+    return lines.join("\n");
+}

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

@@ -0,0 +1,31 @@
+import type { ArtifactMetadata, ArtifactSection, CommandOutputResult, MdTraceEntry } from "../types";
+export declare function getLineBlocks(lines: string[]): boolean[];
+export declare function analyzeTrace(content: string, count: number, sectionCount: number, cmdCount: number): {
+    listingStart: number;
+    listingEnd: number;
+    trace: MdTraceEntry[];
+    sectionTrace: MdTraceEntry[];
+    cmdTrace: MdTraceEntry[];
+};
+export declare function analyzeListingRange(lines: string[], startMarkerIndex: number, endMarkerIndex: number, count: number): {
+    listingStart: number;
+    listingEnd: number;
+};
+export declare function findFooterStartIndex(lines: string[], insideCodeFence: boolean[]): number;
+export declare function findSectionStartIndexes(lines: string[], count: number, fallbackIndex: number, insideCodeFence: boolean[]): number[];
+export declare function findGenericSectionStartIndexes(lines: string[], sectionCount: number, fallbackIndex: number, insideCodeFence: boolean[]): number[];
+export declare function findCmdSectionStartIndexes(lines: string[], cmdCount: number, fallbackIndex: number, insideCodeFence: boolean[]): number[];
+export declare function buildToc(opts: {
+    files: string[];
+    root: string;
+    count: number;
+    listingStart: number;
+    listingEnd: number;
+    trace: MdTraceEntry[] | null;
+    sectionTrace: MdTraceEntry[] | null;
+    cmdTrace: MdTraceEntry[] | null;
+    sections?: ArtifactSection[];
+    commandOutputs?: CommandOutputResult[];
+    withRanges: boolean;
+    metadata?: ArtifactMetadata;
+}): string;

package/dist/output/markdown-toc.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLineBlocks = getLineBlocks;
+exports.analyzeTrace = analyzeTrace;
+exports.analyzeListingRange = analyzeListingRange;
+exports.findFooterStartIndex = findFooterStartIndex;
+exports.findSectionStartIndexes = findSectionStartIndexes;
+exports.findGenericSectionStartIndexes = findGenericSectionStartIndexes;
+exports.findCmdSectionStartIndexes = findCmdSectionStartIndexes;
+exports.buildToc = buildToc;
+const render_constants_1 = require("./render-constants");
+const read_file_1 = require("../filesystem/read-file");
+const render_helpers_1 = require("./render-helpers");
+function getLineBlocks(lines) {
+    const inside = new Array(lines.length).fill(false);
+    let activeFenceChar = null;
+    let activeFenceLength = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (activeFenceChar) {
+            inside[i] = true;
+            const match = trimmed.match(/^([`~]{3,})\s*$/);
+            if (match) {
+                const char = match[1][0];
+                const length = match[1].length;
+                if (char === activeFenceChar && length >= activeFenceLength) {
+                    activeFenceChar = null;
+                    activeFenceLength = 0;
+                }
+            }
+        }
+        else {
+            const match = trimmed.match(/^([`~]{3,})/);
+            if (match) {
+                activeFenceChar = match[1][0];
+                activeFenceLength = match[1].length;
+                inside[i] = true;
+            }
+        }
+    }
+    return inside;
+}
+function analyzeTrace(content, count, sectionCount, cmdCount) {
+    const lines = content.split("\n");
+    const insideCodeFence = getLineBlocks(lines);
+    const startMarkerIndex = lines.findIndex((line) => line.trim() === "<!-- PRODEX_INDEX_LIST_START -->");
+    const endMarkerIndex = lines.findIndex((line) => line.trim() === "<!-- PRODEX_INDEX_LIST_END -->");
+    const totalItems = count + sectionCount + cmdCount;
+    const { listingStart, listingEnd } = analyzeListingRange(lines, startMarkerIndex, endMarkerIndex, totalItems);
+    const footerStartIndex = findFooterStartIndex(lines, insideCodeFence);
+    const sectionStarts = findSectionStartIndexes(lines, count, footerStartIndex, insideCodeFence);
+    const genericStarts = findGenericSectionStartIndexes(lines, sectionCount, footerStartIndex, insideCodeFence);
+    const cmdStarts = findCmdSectionStartIndexes(lines, cmdCount, footerStartIndex, insideCodeFence);
+    const allStarts = [
+        ...sectionStarts,
+        ...genericStarts,
+        ...cmdStarts,
+        footerStartIndex
+    ];
+    const uniqueStarts = [...new Set(allStarts)].sort((a, b) => a - b);
+    const getEndLine = (start) => {
+        if (start >= footerStartIndex)
+            return start;
+        const nextStart = uniqueStarts.find(val => val > start) ?? footerStartIndex;
+        return Math.max(start, nextStart - 1);
+    };
+    return {
+        listingStart,
+        listingEnd,
+        sectionTrace: genericStarts.map((startIndex, index) => {
+            const endIndex = getEndLine(startIndex);
+            return {
+                file: "",
+                anchor: index + 1,
+                startLine: startIndex + 1,
+                endLine: endIndex + 1,
+            };
+        }),
+        trace: sectionStarts.map((startIndex, index) => {
+            const endIndex = getEndLine(startIndex);
+            return {
+                file: "",
+                anchor: index + 1,
+                startLine: startIndex + 1,
+                endLine: endIndex + 1,
+            };
+        }),
+        cmdTrace: cmdStarts.map((startIndex, index) => {
+            const endIndex = getEndLine(startIndex);
+            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, insideCodeFence) {
+    let footerMarker = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (insideCodeFence[i])
+            continue;
+        const line = lines[i];
+        if (line.includes("<!-- PRODEx " + "v") || line.includes("*Generated with " + "[Prodex]")) {
+            footerMarker = i;
+            break;
+        }
+    }
+    let footerStart = footerMarker >= 0 ? footerMarker : lines.length;
+    if (footerStart > 0 && lines[footerStart - 1].trim() === "---")
+        footerStart--;
+    return footerStart;
+}
+function findSectionStartIndexes(lines, count, fallbackIndex, insideCodeFence) {
+    const markerByAnchor = new Map();
+    for (let index = 0; index < lines.length; index++) {
+        if (insideCodeFence[index])
+            continue;
+        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 findGenericSectionStartIndexes(lines, sectionCount, fallbackIndex, insideCodeFence) {
+    const markerBySec = new Map();
+    for (let index = 0; index < lines.length; index++) {
+        if (insideCodeFence[index])
+            continue;
+        const match = lines[index].trim().match(/<a id="sec-(\d+)"><\/a>/);
+        if (!match)
+            continue;
+        const secIdx = Number(match[1]);
+        if (Number.isFinite(secIdx) && secIdx >= 1 && secIdx <= sectionCount && !markerBySec.has(secIdx)) {
+            let startIndex = index;
+            if (startIndex > 0 && lines[startIndex - 1].trim() === "---") {
+                startIndex--;
+            }
+            markerBySec.set(secIdx, startIndex);
+        }
+    }
+    const starts = [];
+    for (let secIdx = 1; secIdx <= sectionCount; secIdx++) {
+        const markerIndex = markerBySec.get(secIdx);
+        starts.push(markerIndex !== undefined ? markerIndex : fallbackIndex);
+    }
+    return starts;
+}
+function findCmdSectionStartIndexes(lines, cmdCount, fallbackIndex, insideCodeFence) {
+    const markerByCmd = new Map();
+    for (let index = 0; index < lines.length; index++) {
+        if (insideCodeFence[index])
+            continue;
+        const match = lines[index].trim().match(/<a id="cmd-(\d+)"><\/a>/);
+        if (!match)
+            continue;
+        const cmdIdx = Number(match[1]);
+        if (Number.isFinite(cmdIdx) && cmdIdx >= 1 && cmdIdx <= cmdCount && !markerByCmd.has(cmdIdx)) {
+            let startIndex = index;
+            if (startIndex > 0 && lines[startIndex - 1].trim() === "---") {
+                startIndex--;
+            }
+            markerByCmd.set(cmdIdx, startIndex);
+        }
+    }
+    const starts = [];
+    for (let cmdIdx = 1; cmdIdx <= cmdCount; cmdIdx++) {
+        const markerIndex = markerByCmd.get(cmdIdx);
+        starts.push(markerIndex !== undefined ? markerIndex : fallbackIndex);
+    }
+    return starts;
+}
+function buildToc(opts) {
+    const sectionCount = opts.sections?.length ?? 0;
+    const cmdCount = opts.commandOutputs?.length ?? 0;
+    const fileCount = opts.files.length;
+    const indexRange = opts.withRanges && opts.listingStart && opts.listingEnd
+        ? `L${opts.listingStart}-L${opts.listingEnd}`
+        : render_constants_1.INDEX_RANGE_PLACEHOLDER;
+    const headers = [
+        render_constants_1.MD_HEADER,
+        render_constants_1.LLM_NOTE,
+        "",
+        "# Index",
+    ];
+    if (opts.metadata?.commandKind === "trace" && opts.metadata.targets && opts.metadata.targets.length > 0) {
+        const relativeEntries = opts.metadata.entries.map(e => (0, read_file_1.rel)(e, opts.root));
+        headers.push("", "> **Trace Target Context**", `> - **Requested Target(s):** ${opts.metadata.targets.map(t => `\`${t}\``).join(", ")}`, `> - **Resolved Starting Point(s):** ${relativeEntries.map(e => `\`${e}\``).join(", ") || "none"}`, `> - **Traversal Depth:** \`${opts.metadata.depth !== undefined ? opts.metadata.depth : "none"}\``, "");
+    }
+    headers.push(`<!-- PRODEX_INDEX_RANGE: ${indexRange} -->`, `<!-- PRODEX_FILE_COUNT: ${opts.count} -->`);
+    if (sectionCount > 0) {
+        headers.push(`<!-- PRODEX_SECTION_COUNT: ${sectionCount} -->`);
+    }
+    if (cmdCount > 0) {
+        headers.push(`<!-- PRODEX_COMMAND_OUTPUT_COUNT: ${cmdCount} -->`);
+    }
+    headers.push("<!-- PRODEX_INDEX_LIST_START -->");
+    const layoutOrder = (0, render_helpers_1.getLayoutOrder)(opts.metadata?.commandKind);
+    const isFileFirst = layoutOrder === "files-first";
+    const secItems = (sectionCount > 0 && opts.sections) ? opts.sections.map((sec, index) => {
+        const label = sec.title;
+        if (!opts.withRanges || !opts.sectionTrace) {
+            return `- [${label}](#sec-${index + 1})`;
+        }
+        const trace = opts.sectionTrace[index];
+        return `- [${label}](#sec-${index + 1}) L${trace.startLine}-L${trace.endLine}`;
+    }) : [];
+    const fileItems = fileCount > 0 ? 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}`;
+    }) : [];
+    const cmdItems = (cmdCount > 0 && opts.commandOutputs) ? opts.commandOutputs.map((cmd, index) => {
+        const label = `Command ${index + 1}: ${cmd.command}`;
+        if (!opts.withRanges || !opts.cmdTrace) {
+            return `- [${label}](#cmd-${index + 1})`;
+        }
+        const trace = opts.cmdTrace[index];
+        return `- [${label}](#cmd-${index + 1}) L${trace.startLine}-L${trace.endLine}`;
+    }) : [];
+    const categoryCount = (sectionCount > 0 ? 1 : 0) + (fileCount > 0 ? 1 : 0) + (cmdCount > 0 ? 1 : 0);
+    const showHeaders = categoryCount > 1;
+    const parts = [];
+    if (isFileFirst) {
+        if (fileCount > 0)
+            parts.push({ header: "## Files", items: fileItems });
+        if (cmdCount > 0)
+            parts.push({ header: "## Command Outputs", items: cmdItems });
+        if (sectionCount > 0)
+            parts.push({ header: "## Metadata Sections", items: secItems });
+    }
+    else {
+        if (sectionCount > 0)
+            parts.push({ header: "## Metadata Sections", items: secItems });
+        if (fileCount > 0)
+            parts.push({ header: "## Files", items: fileItems });
+        if (cmdCount > 0)
+            parts.push({ header: "## Command Outputs", items: cmdItems });
+    }
+    parts.forEach((part, pIdx) => {
+        if (pIdx > 0) {
+            headers.push("");
+        }
+        if (showHeaders) {
+            headers.push(part.header);
+        }
+        headers.push(...part.items);
+    });
+    headers.push("<!-- PRODEX_INDEX_LIST_END -->", "", "---");
+    return headers.join("\n");
+}

package/dist/output/markdown.d.ts

@@ -1,12 +1,9 @@
-export interface MdTraceEntry {
-    file: string;
-    anchor: number;
-    startLine: number;
-    endLine: number;
-}
-export declare function renderTraceMd(files: string[], root?: string): {
+import type { ArtifactPayload } from "../types";
+export { MdTraceEntry } from "../types";
+export { renderMdCmdResults } from "./markdown-sections";
+export declare function renderTraceMd(payload: ArtifactPayload): {
     content: string;
-    trace: MdTraceEntry[];
+    trace: import("../types").MdTraceEntry[];
     listingStart: number;
     listingEnd: number;
 };

package/dist/output/markdown.js

@@ -1,36 +1,99 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMdCmdResults = void 0;
 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,
+const render_helpers_1 = require("./render-helpers");
+const markdown_toc_1 = require("./markdown-toc");
+const markdown_sections_1 = require("./markdown-sections");
+var markdown_sections_2 = require("./markdown-sections");
+Object.defineProperty(exports, "renderMdCmdResults", { enumerable: true, get: function () { return markdown_sections_2.renderMdCmdResults; } });
+function renderTraceMd(payload) {
+    const root = payload.root;
+    const sorted = [...payload.files].sort((a, b) => a.path.localeCompare(b.path));
+    const filesList = sorted.map((f) => f.path);
+    const cmdCount = payload.commandOutputs?.length ?? 0;
+    const sectionCount = payload.sections?.length ?? 0;
+    const layoutOrder = (0, render_helpers_1.getLayoutOrder)(payload.metadata?.commandKind);
+    const isFileFirst = layoutOrder === "files-first";
+    // Build exact sequence of anchors to generate correct sequentially-flowing navigation
+    const orderedAnchors = [];
+    if (isFileFirst) {
+        for (let i = 1; i <= sorted.length; i++)
+            orderedAnchors.push(`${i}`);
+        for (let i = 1; i <= cmdCount; i++)
+            orderedAnchors.push(`cmd-${i}`);
+        for (let i = 1; i <= sectionCount; i++)
+            orderedAnchors.push(`sec-${i}`);
+    }
+    else {
+        for (let i = 1; i <= sectionCount; i++)
+            orderedAnchors.push(`sec-${i}`);
+        for (let i = 1; i <= sorted.length; i++)
+            orderedAnchors.push(`${i}`);
+        for (let i = 1; i <= cmdCount; i++)
+            orderedAnchors.push(`cmd-${i}`);
+    }
+    const getNavLine = (anchorId) => {
+        const idx = orderedAnchors.indexOf(anchorId);
+        if (idx === -1)
+            return `[Back to top](#index)`;
+        const navParts = [];
+        if (idx > 0) {
+            navParts.push(`[Previous](#${orderedAnchors[idx - 1]})`);
+        }
+        navParts.push(`[Back to top](#index)`);
+        if (idx < orderedAnchors.length - 1) {
+            navParts.push(`[Next](#${orderedAnchors[idx + 1]})`);
+        }
+        return navParts.join(" | ");
+    };
+    // Render generic sections
+    const genericSections = (payload.sections ?? []).map((sec, index) => {
+        const navLine = getNavLine(`sec-${index + 1}`);
+        return (0, markdown_sections_1.renderGenericSection)(sec, index, navLine);
+    });
+    // Render file snapshots
+    const fileSections = sorted.map((file, index) => {
+        const navLine = getNavLine(`${index + 1}`);
+        return (0, markdown_sections_1.renderFileSection)(file, index, root, navLine);
+    });
+    const firstPassToc = (0, markdown_toc_1.buildToc)({
+        files: filesList,
         root,
-        count: files.length,
+        count: sorted.length,
         listingStart: 0,
         listingEnd: 0,
         trace: null,
+        sectionTrace: null,
+        cmdTrace: null,
+        sections: payload.sections,
+        commandOutputs: payload.commandOutputs,
         withRanges: false,
+        metadata: payload.metadata,
     });
-    const firstPassContent = [firstPassToc, ...sections, render_constants_1.MD_FOOTER].join("\n");
-    const firstPassAnalysis = analyzeTrace(firstPassContent, files.length);
-    const finalToc = buildToc({
-        files,
+    const cmdSections = (0, markdown_sections_1.renderMdCmdResults)(payload.commandOutputs, root, sorted.length, sectionCount, orderedAnchors);
+    const bodySections = isFileFirst
+        ? [...fileSections, cmdSections, ...genericSections]
+        : [...genericSections, ...fileSections, cmdSections];
+    const firstPassContent = [firstPassToc, ...bodySections.filter(Boolean), render_constants_1.MD_FOOTER].join("\n");
+    const firstPassAnalysis = (0, markdown_toc_1.analyzeTrace)(firstPassContent, sorted.length, sectionCount, cmdCount);
+    const finalToc = (0, markdown_toc_1.buildToc)({
+        files: filesList,
         root,
-        count: files.length,
+        count: sorted.length,
         listingStart: firstPassAnalysis.listingStart,
         listingEnd: firstPassAnalysis.listingEnd,
         trace: firstPassAnalysis.trace,
+        sectionTrace: firstPassAnalysis.sectionTrace,
+        cmdTrace: firstPassAnalysis.cmdTrace,
+        sections: payload.sections,
+        commandOutputs: payload.commandOutputs,
         withRanges: true,
+        metadata: payload.metadata,
     });
-    const content = [finalToc, ...sections, render_constants_1.MD_FOOTER].join("\n");
-    const analysis = analyzeTrace(content, files.length);
+    const content = [finalToc, ...bodySections.filter(Boolean), render_constants_1.MD_FOOTER].join("\n");
+    const analysis = (0, markdown_toc_1.analyzeTrace)(content, sorted.length, sectionCount, cmdCount);
     return {
         content,
         trace: analysis.trace,
@@ -38,113 +101,3 @@ function renderTraceMd(files, root = process.cwd()) {
         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/produce-output.d.ts

@@ -1,2 +1,5 @@
 import type { OutputParams } from "../types";
-export declare function produceOutput({ name, files, cfg }: OutputParams): Promise<string>;
+export declare function produceOutput({ name, payload, format, dir, versioned, }: OutputParams): Promise<{
+    outputPath: string;
+    outputSizeBytes: number;
+}>;