mdkg 0.0.2 → 0.0.4

package/dist/pack/budget.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPackBudgets = applyPackBudgets;
+const metrics_1 = require("./metrics");
+function normalizeLimit(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative integer`);
+    }
+    if (value === 0) {
+        return undefined;
+    }
+    return value;
+}
+function exceeds(limits, totals) {
+    if (limits.maxChars !== undefined && totals.chars > limits.maxChars) {
+        return true;
+    }
+    if (limits.maxLines !== undefined && totals.lines > limits.maxLines) {
+        return true;
+    }
+    if (limits.maxTokens !== undefined && totals.tokens_estimate > limits.maxTokens) {
+        return true;
+    }
+    return false;
+}
+function exceededKinds(limits, totals) {
+    const kinds = [];
+    if (limits.maxChars !== undefined && totals.chars > limits.maxChars) {
+        kinds.push("chars");
+    }
+    if (limits.maxLines !== undefined && totals.lines > limits.maxLines) {
+        kinds.push("lines");
+    }
+    if (limits.maxTokens !== undefined && totals.tokens_estimate > limits.maxTokens) {
+        kinds.push("tokens");
+    }
+    return kinds;
+}
+function truncateBodyToFit(pack, limits) {
+    if (pack.nodes.length === 0) {
+        return pack;
+    }
+    const root = pack.nodes[0];
+    const sourceLines = root.body.split(/\r?\n/);
+    if (sourceLines.length === 0) {
+        return pack;
+    }
+    let low = 0;
+    let high = sourceLines.length;
+    let best = 0;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const candidateBody = sourceLines.slice(0, mid).join("\n").trimEnd();
+        const candidatePack = {
+            ...pack,
+            nodes: [{ ...root, body: candidateBody }],
+        };
+        const stats = (0, metrics_1.measurePack)(candidatePack);
+        if (!exceeds(limits, stats.totals)) {
+            best = mid;
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    const trimmedBody = sourceLines.slice(0, best).join("\n").trimEnd();
+    return {
+        ...pack,
+        nodes: [{ ...root, body: trimmedBody }],
+    };
+}
+function applyPackBudgets(pack, limitsInput, profile) {
+    const limits = {
+        maxChars: normalizeLimit(limitsInput.maxChars, "--max-chars"),
+        maxLines: normalizeLimit(limitsInput.maxLines, "--max-lines"),
+        maxTokens: normalizeLimit(limitsInput.maxTokens, "--max-tokens"),
+    };
+    const beforeStats = (0, metrics_1.measurePack)(pack);
+    let working = {
+        meta: {
+            ...pack.meta,
+            truncated: {
+                ...pack.meta.truncated,
+                max_chars: pack.meta.truncated.max_chars ?? false,
+                max_lines: pack.meta.truncated.max_lines ?? false,
+                max_tokens: pack.meta.truncated.max_tokens ?? false,
+                body_truncated: pack.meta.truncated.body_truncated
+                    ? [...pack.meta.truncated.body_truncated]
+                    : [],
+            },
+        },
+        nodes: [...pack.nodes],
+    };
+    const droppedNodes = [];
+    const bodyTruncatedNodes = [];
+    let stats = (0, metrics_1.measurePack)(working);
+    while (working.nodes.length > 1 && exceeds(limits, stats.totals)) {
+        const kinds = exceededKinds(limits, stats.totals);
+        for (const kind of kinds) {
+            if (kind === "chars") {
+                working.meta.truncated.max_chars = true;
+            }
+            else if (kind === "lines") {
+                working.meta.truncated.max_lines = true;
+            }
+            else if (kind === "tokens") {
+                working.meta.truncated.max_tokens = true;
+            }
+        }
+        const dropped = working.nodes[working.nodes.length - 1];
+        working = {
+            ...working,
+            nodes: working.nodes.slice(0, -1),
+        };
+        if (dropped) {
+            droppedNodes.push(dropped.qid);
+        }
+        stats = (0, metrics_1.measurePack)(working);
+    }
+    if (exceeds(limits, stats.totals) && working.nodes.length > 0) {
+        const beforeBody = working.nodes[0]?.body ?? "";
+        const truncated = truncateBodyToFit(working, limits);
+        const afterBody = truncated.nodes[0]?.body ?? "";
+        if (afterBody !== beforeBody) {
+            bodyTruncatedNodes.push(truncated.nodes[0].qid);
+            truncated.meta.truncated.body_truncated = [
+                ...(truncated.meta.truncated.body_truncated ?? []),
+                truncated.nodes[0].qid,
+            ];
+        }
+        const kinds = exceededKinds(limits, stats.totals);
+        for (const kind of kinds) {
+            if (kind === "chars") {
+                truncated.meta.truncated.max_chars = true;
+            }
+            else if (kind === "lines") {
+                truncated.meta.truncated.max_lines = true;
+            }
+            else if (kind === "tokens") {
+                truncated.meta.truncated.max_tokens = true;
+            }
+        }
+        working = truncated;
+        stats = (0, metrics_1.measurePack)(working);
+    }
+    if (droppedNodes.length > 0) {
+        working.meta.truncated.dropped.push(...droppedNodes);
+    }
+    if (bodyTruncatedNodes.length > 0) {
+        working.meta.truncated.body_truncated = [
+            ...(working.meta.truncated.body_truncated ?? []),
+            ...bodyTruncatedNodes,
+        ];
+    }
+    working.meta.node_count = working.nodes.length;
+    const report = {
+        root: pack.meta.root,
+        profile: pack.meta.profile ?? profile,
+        limits: {
+            max_chars: limits.maxChars,
+            max_lines: limits.maxLines,
+            max_tokens: limits.maxTokens,
+        },
+        before: {
+            node_count: pack.nodes.length,
+            chars: beforeStats.totals.chars,
+            lines: beforeStats.totals.lines,
+            bytes: beforeStats.totals.bytes,
+            tokens_estimate: beforeStats.totals.tokens_estimate,
+        },
+        after: {
+            node_count: working.nodes.length,
+            chars: stats.totals.chars,
+            lines: stats.totals.lines,
+            bytes: stats.totals.bytes,
+            tokens_estimate: stats.totals.tokens_estimate,
+        },
+        dropped_nodes: droppedNodes,
+        body_truncated_nodes: bodyTruncatedNodes,
+    };
+    return { pack: working, report };
+}

package/dist/pack/export_md.js

@@ -13,8 +13,20 @@ function renderHeader(meta, nodes) {
     lines.push(`root: ${meta.root}`);
     lines.push(`depth: ${meta.depth}`);
     lines.push(`verbose: ${meta.verbose}`);
+    if (meta.profile) {
+        lines.push(`profile: ${meta.profile}`);
+    }
+    if (meta.body_mode) {
+        lines.push(`body_mode: ${meta.body_mode}`);
+    }
+    if (meta.latest_checkpoint_qid) {
+        lines.push(`latest_checkpoint_qid: ${meta.latest_checkpoint_qid}`);
+    }
+    if (meta.latest_checkpoint_qid_hint) {
+        lines.push(`latest_checkpoint_qid_hint: ${meta.latest_checkpoint_qid_hint}`);
+    }
     lines.push(`nodes: ${nodes.length}`);
-    lines.push(`truncated: max_nodes=${meta.truncated.max_nodes} max_bytes=${meta.truncated.max_bytes}`);
+    lines.push(`truncated: max_nodes=${meta.truncated.max_nodes} max_bytes=${meta.truncated.max_bytes} max_chars=${Boolean(meta.truncated.max_chars)} max_lines=${Boolean(meta.truncated.max_lines)} max_tokens=${Boolean(meta.truncated.max_tokens)}`);
     if (meta.truncated.dropped.length > 0) {
         lines.push(`dropped: ${meta.truncated.dropped.join(", ")}`);
     }
@@ -55,6 +67,10 @@ function cloneTruncation(truncation) {
         max_nodes: truncation.max_nodes,
         max_bytes: truncation.max_bytes,
         dropped: [...truncation.dropped],
+        max_chars: truncation.max_chars,
+        max_lines: truncation.max_lines,
+        max_tokens: truncation.max_tokens,
+        body_truncated: truncation.body_truncated ? [...truncation.body_truncated] : [],
     };
 }
 function buildMeta(meta, nodes) {

package/dist/pack/export_xml.js

@@ -29,11 +29,26 @@ function exportXml(pack) {
     lines.push(`    <root>${escapeXml(pack.meta.root)}</root>`);
     lines.push(`    <depth>${pack.meta.depth}</depth>`);
     lines.push(`    <verbose>${pack.meta.verbose}</verbose>`);
+    if (pack.meta.profile) {
+        lines.push(`    <profile>${escapeXml(pack.meta.profile)}</profile>`);
+    }
+    if (pack.meta.body_mode) {
+        lines.push(`    <body_mode>${escapeXml(pack.meta.body_mode)}</body_mode>`);
+    }
+    if (pack.meta.latest_checkpoint_qid) {
+        lines.push(`    <latest_checkpoint_qid>${escapeXml(pack.meta.latest_checkpoint_qid)}</latest_checkpoint_qid>`);
+    }
+    if (pack.meta.latest_checkpoint_qid_hint) {
+        lines.push(`    <latest_checkpoint_qid_hint>${escapeXml(pack.meta.latest_checkpoint_qid_hint)}</latest_checkpoint_qid_hint>`);
+    }
     lines.push(`    <generated_at>${escapeXml(pack.meta.generated_at)}</generated_at>`);
     lines.push(`    <node_count>${pack.meta.node_count}</node_count>`);
     lines.push("    <truncated>");
     lines.push(`      <max_nodes>${pack.meta.truncated.max_nodes}</max_nodes>`);
     lines.push(`      <max_bytes>${pack.meta.truncated.max_bytes}</max_bytes>`);
+    lines.push(`      <max_chars>${Boolean(pack.meta.truncated.max_chars)}</max_chars>`);
+    lines.push(`      <max_lines>${Boolean(pack.meta.truncated.max_lines)}</max_lines>`);
+    lines.push(`      <max_tokens>${Boolean(pack.meta.truncated.max_tokens)}</max_tokens>`);
     if (pack.meta.truncated.dropped.length > 0) {
         lines.push("      <dropped>");
         for (const qid of pack.meta.truncated.dropped) {

package/dist/pack/metrics.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countLines = countLines;
+exports.estimateTokensFromChars = estimateTokensFromChars;
+exports.renderNodeMetricsText = renderNodeMetricsText;
+exports.measureNode = measureNode;
+exports.measurePack = measurePack;
+function countLines(text) {
+    if (text.length === 0) {
+        return 0;
+    }
+    return text.split(/\r?\n/).length;
+}
+function estimateTokensFromChars(chars) {
+    if (chars <= 0) {
+        return 0;
+    }
+    return Math.ceil(chars / 4);
+}
+function renderNodeMetricsText(node) {
+    const lines = [];
+    lines.push(`qid: ${node.qid}`);
+    lines.push(`id: ${node.id}`);
+    lines.push(`workspace: ${node.workspace}`);
+    lines.push(`type: ${node.type}`);
+    lines.push(`title: ${node.title}`);
+    if (node.status) {
+        lines.push(`status: ${node.status}`);
+    }
+    if (node.priority !== undefined) {
+        lines.push(`priority: ${node.priority}`);
+    }
+    lines.push(`path: ${node.path}`);
+    lines.push(`links: ${node.links.join(",")}`);
+    lines.push(`artifacts: ${node.artifacts.join(",")}`);
+    lines.push(`refs: ${node.refs.join(",")}`);
+    lines.push(`aliases: ${node.aliases.join(",")}`);
+    if (node.body.length > 0) {
+        lines.push("");
+        lines.push(node.body);
+    }
+    return lines.join("\n");
+}
+function measureNode(node) {
+    const rendered = renderNodeMetricsText(node);
+    const chars = rendered.length;
+    const lines = countLines(rendered);
+    const bytes = Buffer.byteLength(rendered, "utf8");
+    return {
+        qid: node.qid,
+        chars,
+        lines,
+        bytes,
+        tokens_estimate: estimateTokensFromChars(chars),
+    };
+}
+function measurePack(pack) {
+    const nodes = pack.nodes.map((node) => measureNode(node));
+    const totals = nodes.reduce((acc, node) => ({
+        chars: acc.chars + node.chars,
+        lines: acc.lines + node.lines,
+        bytes: acc.bytes + node.bytes,
+        tokens_estimate: acc.tokens_estimate + node.tokens_estimate,
+    }), { chars: 0, lines: 0, bytes: 0, tokens_estimate: 0 });
+    return { nodes, totals };
+}

package/dist/pack/pack.js

@@ -130,6 +130,24 @@ function buildPackNode(root, index, qid) {
 function mergeWarnings(warnings, message) {
     warnings.push(message);
 }
+function checkpointWorkspaceFromQid(qid) {
+    const [workspace] = qid.split(":");
+    return workspace ?? "root";
+}
+function resolveLatestCheckpointQid(index, workspace) {
+    const candidates = Object.values(index.nodes)
+        .filter((node) => node.ws === workspace && node.type === "checkpoint")
+        .sort((a, b) => {
+        if (a.updated !== b.updated) {
+            return b.updated.localeCompare(a.updated);
+        }
+        if (a.created !== b.created) {
+            return b.created.localeCompare(a.created);
+        }
+        return b.qid.localeCompare(a.qid);
+    });
+    return candidates[0]?.qid;
+}
 function applyMaxNodes(orderedQids, maxNodes, truncation) {
     if (maxNodes <= 0 || orderedQids.length <= maxNodes) {
         return { included: orderedQids, dropped: [] };
@@ -142,7 +160,22 @@ function applyMaxNodes(orderedQids, maxNodes, truncation) {
 }
 function buildPack(options) {
     const warnings = [];
+    const includeLatestCheckpoint = options.includeLatestCheckpoint ?? true;
     const { qids, depths } = collectNodes(options.index, options.rootQid, options.depth, options.edges);
+    const workspace = checkpointWorkspaceFromQid(options.rootQid);
+    const latestCheckpointHint = options.index.meta.latest_checkpoint_qid?.[workspace];
+    const latestCheckpointResolved = includeLatestCheckpoint
+        ? resolveLatestCheckpointQid(options.index, workspace)
+        : undefined;
+    if (latestCheckpointResolved && latestCheckpointResolved !== options.rootQid) {
+        qids.add(latestCheckpointResolved);
+    }
+    if (includeLatestCheckpoint &&
+        latestCheckpointHint &&
+        latestCheckpointResolved &&
+        latestCheckpointHint !== latestCheckpointResolved) {
+        mergeWarnings(warnings, `latest_checkpoint_qid hint mismatch for ${workspace}: ${latestCheckpointHint} -> ${latestCheckpointResolved}`);
+    }
     if (options.verbose) {
         const coreIds = (0, verbose_core_1.readVerboseCoreList)(options.verboseCoreListPath);
         for (const id of coreIds) {
@@ -173,6 +206,8 @@ function buildPack(options) {
             verbose: options.verbose,
             generated_at: new Date().toISOString(),
             node_count: nodes.length,
+            latest_checkpoint_qid: latestCheckpointResolved,
+            latest_checkpoint_qid_hint: latestCheckpointHint,
             truncated: truncation,
         },
         nodes,

package/dist/pack/profile.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listPackProfiles = listPackProfiles;
+exports.resolvePackProfile = resolvePackProfile;
+exports.shapePackBodies = shapePackBodies;
+const PACK_PROFILE_CATALOG = [
+    {
+        profile: "standard",
+        bodyMode: "full",
+        description: "Keep full node bodies (current default behavior).",
+        defaults: [],
+    },
+    {
+        profile: "concise",
+        bodyMode: "summary",
+        description: "Use summary-first excerpts for each node body.",
+        defaults: ["strip_code=true"],
+    },
+    {
+        profile: "headers",
+        bodyMode: "none",
+        description: "Frontmatter/metadata only; remove all node body content.",
+        defaults: [],
+    },
+];
+const CODE_FENCE_RE = /^(```|~~~)/;
+function normalizeHeading(value) {
+    return value.trim().toLowerCase();
+}
+function removeCodeBlocks(body) {
+    const lines = body.split(/\r?\n/);
+    const result = [];
+    let inFence = false;
+    for (const line of lines) {
+        if (CODE_FENCE_RE.test(line.trimStart())) {
+            inFence = !inFence;
+            if (!inFence) {
+                result.push("[code block omitted]");
+            }
+            continue;
+        }
+        if (!inFence) {
+            result.push(line);
+        }
+    }
+    return result.join("\n");
+}
+function capCodeBlocks(body, maxCodeLines) {
+    const lines = body.split(/\r?\n/);
+    const result = [];
+    let inFence = false;
+    let kept = 0;
+    let truncated = false;
+    for (const line of lines) {
+        if (CODE_FENCE_RE.test(line.trimStart())) {
+            if (inFence && truncated) {
+                result.push("[code lines truncated]");
+            }
+            inFence = !inFence;
+            kept = 0;
+            truncated = false;
+            result.push(line);
+            continue;
+        }
+        if (!inFence) {
+            result.push(line);
+            continue;
+        }
+        if (kept < maxCodeLines) {
+            result.push(line);
+            kept += 1;
+            continue;
+        }
+        truncated = true;
+    }
+    if (inFence && truncated) {
+        result.push("[code lines truncated]");
+    }
+    return result.join("\n");
+}
+function applyCodeTransform(body, stripCode, maxCodeLines) {
+    if (body.length === 0) {
+        return body;
+    }
+    if (stripCode) {
+        return removeCodeBlocks(body);
+    }
+    if (maxCodeLines !== undefined) {
+        return capCodeBlocks(body, maxCodeLines);
+    }
+    return body;
+}
+function splitSections(body) {
+    const lines = body.split(/\r?\n/);
+    const sections = [{ lines: [] }];
+    let current = sections[0];
+    let inFence = false;
+    for (const line of lines) {
+        const trimmed = line.trimStart();
+        if (CODE_FENCE_RE.test(trimmed)) {
+            inFence = !inFence;
+            current.lines.push(line);
+            continue;
+        }
+        if (!inFence) {
+            const match = /^#+\s+(.*)$/.exec(line);
+            if (match) {
+                current = {
+                    heading: normalizeHeading(match[1] ?? ""),
+                    headingLine: line,
+                    lines: [],
+                };
+                sections.push(current);
+                continue;
+            }
+        }
+        current.lines.push(line);
+    }
+    return sections;
+}
+function firstNonEmptyLines(lines, maxLines) {
+    const result = [];
+    for (const line of lines) {
+        if (line.trim().length === 0) {
+            continue;
+        }
+        result.push(line);
+        if (result.length >= maxLines) {
+            break;
+        }
+    }
+    return result;
+}
+function extractSummary(body, preferredHeadings, summaryMaxLines) {
+    if (body.trim().length === 0) {
+        return "";
+    }
+    const sections = splitSections(body);
+    for (const heading of preferredHeadings) {
+        const section = sections.find((candidate) => candidate.heading === heading);
+        if (!section) {
+            continue;
+        }
+        const excerpt = firstNonEmptyLines(section.lines, summaryMaxLines);
+        if (excerpt.length === 0) {
+            continue;
+        }
+        const summaryLines = section.headingLine ? [section.headingLine, ...excerpt] : excerpt;
+        return summaryLines.join("\n").trimEnd();
+    }
+    const fallback = firstNonEmptyLines(body.split(/\r?\n/), summaryMaxLines);
+    return fallback.join("\n").trimEnd();
+}
+function shapeNodeBody(node, options) {
+    const { resolved, templateHeadingMap } = options;
+    let shaped = node.body;
+    if (resolved.bodyMode === "none") {
+        shaped = "";
+    }
+    else if (resolved.bodyMode === "summary") {
+        const preferred = templateHeadingMap[node.type] ?? [];
+        shaped = extractSummary(node.body, preferred, resolved.summaryMaxLines);
+    }
+    shaped = applyCodeTransform(shaped, resolved.stripCode, resolved.maxCodeLines);
+    return shaped.trimEnd();
+}
+function listPackProfiles() {
+    return PACK_PROFILE_CATALOG.map((entry) => ({
+        profile: entry.profile,
+        bodyMode: entry.bodyMode,
+        description: entry.description,
+        defaults: [...entry.defaults],
+    }));
+}
+function resolvePackProfile(input) {
+    if (input.maxCodeLines !== undefined && (!Number.isInteger(input.maxCodeLines) || input.maxCodeLines < 0)) {
+        throw new Error("--max-code-lines must be a non-negative integer");
+    }
+    let profileRaw = input.profile;
+    if (input.concise) {
+        if (profileRaw && profileRaw.toLowerCase() !== "concise") {
+            throw new Error("--concise conflicts with --pack-profile");
+        }
+        profileRaw = "concise";
+    }
+    const normalized = (profileRaw ?? "standard").toLowerCase();
+    if (normalized !== "standard" && normalized !== "concise" && normalized !== "headers") {
+        throw new Error("--pack-profile must be one of standard, concise, headers");
+    }
+    const profile = normalized;
+    let bodyMode = "full";
+    let defaultStripCode = false;
+    if (profile === "concise") {
+        bodyMode = "summary";
+        defaultStripCode = true;
+    }
+    else if (profile === "headers") {
+        bodyMode = "none";
+    }
+    return {
+        profile,
+        bodyMode,
+        stripCode: input.stripCode || defaultStripCode,
+        maxCodeLines: input.maxCodeLines,
+        summaryMaxLines: 12,
+    };
+}
+function shapePackBodies(pack, options) {
+    const nodes = pack.nodes.map((node) => ({
+        ...node,
+        body: shapeNodeBody(node, options),
+    }));
+    return {
+        meta: {
+            ...pack.meta,
+            node_count: nodes.length,
+            profile: options.resolved.profile,
+            body_mode: options.resolved.bodyMode,
+        },
+        nodes,
+    };
+}

package/dist/pack/stats.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPackStats = renderPackStats;
+function pad(value, width) {
+    if (value.length >= width) {
+        return value;
+    }
+    return `${value}${" ".repeat(width - value.length)}`;
+}
+function padLeft(value, width) {
+    if (value.length >= width) {
+        return value;
+    }
+    return `${" ".repeat(width - value.length)}${value}`;
+}
+function renderPackStats(stats) {
+    const rows = stats.nodes.map((node) => ({
+        qid: node.qid,
+        chars: String(node.chars),
+        lines: String(node.lines),
+        bytes: String(node.bytes),
+        tokens: String(node.tokens_estimate),
+    }));
+    const qidWidth = Math.max(3, ...rows.map((row) => row.qid.length), 5);
+    const charsWidth = Math.max(5, ...rows.map((row) => row.chars.length), String(stats.totals.chars).length);
+    const linesWidth = Math.max(5, ...rows.map((row) => row.lines.length), String(stats.totals.lines).length);
+    const bytesWidth = Math.max(5, ...rows.map((row) => row.bytes.length), String(stats.totals.bytes).length);
+    const tokensWidth = Math.max(6, ...rows.map((row) => row.tokens.length), String(stats.totals.tokens_estimate).length);
+    const lines = [];
+    lines.push(`${pad("qid", qidWidth)}  ${padLeft("chars", charsWidth)}  ${padLeft("lines", linesWidth)}  ${padLeft("bytes", bytesWidth)}  ${padLeft("tokens", tokensWidth)}`);
+    lines.push(`${"-".repeat(qidWidth)}  ${"-".repeat(charsWidth)}  ${"-".repeat(linesWidth)}  ${"-".repeat(bytesWidth)}  ${"-".repeat(tokensWidth)}`);
+    for (const row of rows) {
+        lines.push(`${pad(row.qid, qidWidth)}  ${padLeft(row.chars, charsWidth)}  ${padLeft(row.lines, linesWidth)}  ${padLeft(row.bytes, bytesWidth)}  ${padLeft(row.tokens, tokensWidth)}`);
+    }
+    lines.push(`${pad("TOTAL", qidWidth)}  ${padLeft(String(stats.totals.chars), charsWidth)}  ${padLeft(String(stats.totals.lines), linesWidth)}  ${padLeft(String(stats.totals.bytes), bytesWidth)}  ${padLeft(String(stats.totals.tokens_estimate), tokensWidth)}`);
+    return lines.join("\n");
+}

package/dist/templates/headings.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMarkdownHeadings = extractMarkdownHeadings;
+exports.loadTemplateHeadingMap = loadTemplateHeadingMap;
+const loader_1 = require("./loader");
+function normalizeHeading(value) {
+    return value.trim().toLowerCase();
+}
+function extractMarkdownHeadings(body) {
+    const lines = body.split(/\r?\n/);
+    const headings = [];
+    const seen = new Set();
+    for (const line of lines) {
+        const match = /^#+\s+(.*)$/.exec(line);
+        if (!match) {
+            continue;
+        }
+        const heading = normalizeHeading(match[1] ?? "");
+        if (!heading || seen.has(heading)) {
+            continue;
+        }
+        headings.push(heading);
+        seen.add(heading);
+    }
+    return headings;
+}
+function loadTemplateHeadingMap(root, config, types) {
+    const map = {};
+    for (const type of types) {
+        const template = (0, loader_1.loadTemplate)(root, config, type);
+        map[type] = extractMarkdownHeadings(template.body);
+    }
+    return map;
+}