@astrosheep/keiyaku 0.1.87 → 1.0.0

package/build/protocol/keiyaku-draft.js

@@ -1,168 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { KeiyakuParseError, parseToAST, renderSectionContent, } from "./markdown/index.js";
-import { computeHeadingDelta } from "./markdown/normalization.js";
-const KNOWN_DRAFT_SECTIONS = new Set([
-    "goal",
-    "context",
-    "rules",
-    "criteria",
-    "acceptance criteria",
-]);
-function normalizeSectionTitle(title) {
-    return title.trim().toLowerCase().replace(/\s+/g, " ");
-}
-function parseFenceLine(trimmedLine) {
-    if (!trimmedLine.startsWith("```"))
-        return null;
-    let idx = 0;
-    while (idx < trimmedLine.length && trimmedLine[idx] === "`")
-        idx += 1;
-    if (idx < 3)
-        return null;
-    return idx;
-}
-function normalizeDraftHeadings(content) {
-    const lines = content.split(/\r?\n/);
-    if (lines.length > 0) {
-        lines[0] = lines[0].replace(/^\uFEFF/, "");
-    }
-    // Keep structural title/known section headings stable, and shift payload headings together.
-    const MIN_HEADING_LEVEL = 3;
-    let sawTitleH1 = false;
-    let fence = null;
-    let shallowestNonStructural = null;
-    for (const line of lines) {
-        let leadingSpaces = 0;
-        while (leadingSpaces < line.length && line[leadingSpaces] === " ")
-            leadingSpaces += 1;
-        const trimmed = leadingSpaces <= 3 ? line.trimStart() : line;
-        if (leadingSpaces <= 3) {
-            const fenceLen = parseFenceLine(trimmed);
-            if (fenceLen !== null) {
-                if (!fence)
-                    fence = { length: fenceLen };
-                else if (fenceLen >= fence.length)
-                    fence = null;
-                continue;
-            }
-        }
-        if (fence)
-            continue;
-        if (leadingSpaces > 3)
-            continue;
-        const headerMatch = trimmed.match(/^(#{1,6})[ \t]+(.+?)\s*$/);
-        if (!headerMatch)
-            continue;
-        const level = (headerMatch[1] ?? "").length;
-        const text = (headerMatch[2] ?? "").trim();
-        if (level === 1 && !sawTitleH1) {
-            sawTitleH1 = true;
-            continue;
-        }
-        if (level === 2) {
-            // Keep ALL H2 section headers structural in from_draft drafts. Unknown headers
-            // should remain visible to validation instead of being silently demoted.
-            continue;
-        }
-        shallowestNonStructural = shallowestNonStructural === null ? level : Math.min(shallowestNonStructural, level);
-    }
-    const delta = computeHeadingDelta(shallowestNonStructural, MIN_HEADING_LEVEL);
-    if (delta === 0) {
-        return lines.join("\n");
-    }
-    const out = [];
-    sawTitleH1 = false;
-    fence = null;
-    for (const line of lines) {
-        let leadingSpaces = 0;
-        while (leadingSpaces < line.length && line[leadingSpaces] === " ")
-            leadingSpaces += 1;
-        const trimmed = leadingSpaces <= 3 ? line.trimStart() : line;
-        const prefix = line.slice(0, leadingSpaces);
-        if (leadingSpaces <= 3) {
-            const fenceLen = parseFenceLine(trimmed);
-            if (fenceLen !== null) {
-                if (!fence)
-                    fence = { length: fenceLen };
-                else if (fenceLen >= fence.length)
-                    fence = null;
-                out.push(line);
-                continue;
-            }
-        }
-        if (fence) {
-            out.push(line);
-            continue;
-        }
-        if (leadingSpaces <= 3) {
-            const headerMatch = trimmed.match(/^(#{1,6})[ \t]+(.+?)\s*$/);
-            if (headerMatch) {
-                const hashes = headerMatch[1] ?? "";
-                const text = (headerMatch[2] ?? "").trim();
-                const level = hashes.length;
-                if (level === 1) {
-                    if (!sawTitleH1) {
-                        sawTitleH1 = true;
-                        out.push(line);
-                        continue;
-                    }
-                    out.push(`${prefix}${"#".repeat(Math.min(6, level + delta))} ${text}`);
-                    continue;
-                }
-                if (level === 2) {
-                    out.push(line);
-                    continue;
-                }
-                out.push(`${prefix}${"#".repeat(Math.min(6, level + delta))} ${text}`);
-                continue;
-            }
-        }
-        out.push(line);
-    }
-    return out.join("\n");
-}
-export function parseAndValidateKeiyakuDraft(content) {
-    try {
-        const normalized = normalizeDraftHeadings(content);
-        const ast = parseToAST(normalized);
-        const sections = new Map();
-        let title;
-        for (const node of ast.children) {
-            if (node.type !== "section")
-                continue;
-            if (node.level === 1 && !title) {
-                title = node.title.trim() || undefined;
-                continue;
-            }
-            if (node.level !== 2)
-                continue;
-            const normalizedSection = normalizeSectionTitle(node.title);
-            if (sections.has(normalizedSection)) {
-                throw new FlowError("INVALID_KEIYAKU_DRAFT", `invalid keiyaku draft: duplicate section header '${normalizedSection}'`);
-            }
-            sections.set(normalizedSection, renderSectionContent(node).trim());
-        }
-        const unknownSections = [...sections.keys()].filter((section) => !KNOWN_DRAFT_SECTIONS.has(section));
-        if (unknownSections.length > 0) {
-            const allowedSections = [...KNOWN_DRAFT_SECTIONS].map((section) => `'${section}'`).join(", ");
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", `invalid keiyaku draft: unknown section header(s): ${unknownSections.map((section) => `'${section}'`).join(", ")}. Valid section header(s): ${allowedSections}. Fix the header or delete the draft file and retry.`);
-        }
-        const goal = sections.get("goal")?.trim();
-        const context = sections.get("context")?.trim();
-        const rules = sections.get("rules")?.trim();
-        const criteria = sections.get("acceptance criteria")?.trim() ?? sections.get("criteria")?.trim();
-        return {
-            title: title?.trim() || undefined,
-            goal: goal || undefined,
-            context: context || undefined,
-            rules: rules || undefined,
-            criteria: criteria || undefined,
-        };
-    }
-    catch (error) {
-        if (error instanceof KeiyakuParseError) {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", `invalid keiyaku draft: ${error.message}`, { cause: error });
-        }
-        throw error;
-    }
-}

package/build/protocol/ledger.js

@@ -1,374 +0,0 @@
-import { createGit, wrapGitError } from "../git/core.js";
-import { toStatusPreview } from "./status-previews.js";
-const ROUND_OPEN_ROOT_HEADING = "## Round Open";
-const ROUND_CLOSE_ROOT_HEADING = "## Round Close";
-const LEDGER_SECTION_PREFIX = "### ";
-const LEDGER_COMMIT_SUBJECT_RE = /^keiyaku\((.+)\): round (open|close) (\d+) - (.+)$/i;
-const LIST_ITEM_PREFIX_RE = /^[-*+]\s+/;
-function normalizeTitle(value) {
-    return value.trim().replace(/\r?\n+/g, " ");
-}
-function splitBodyLines(body) {
-    return body.replace(/\r\n/g, "\n").split("\n");
-}
-function readSection(lines, startIndex) {
-    const collected = [];
-    let index = startIndex;
-    while (index < lines.length) {
-        const line = lines[index] ?? "";
-        const trimmed = line.trim();
-        if (trimmed === "## Brief" || trimmed === "## Report" || trimmed.startsWith(LEDGER_SECTION_PREFIX)) {
-            break;
-        }
-        collected.push(line);
-        index += 1;
-    }
-    return { body: collected.join("\n").trim(), nextIndex: index };
-}
-function readListSection(lines, startIndex) {
-    const collected = [];
-    let index = startIndex;
-    while (index < lines.length) {
-        const line = lines[index] ?? "";
-        const trimmed = line.trim();
-        if (trimmed === "## Report" || trimmed.startsWith(LEDGER_SECTION_PREFIX)) {
-            break;
-        }
-        if (trimmed.length > 0) {
-            collected.push(trimmed.replace(LIST_ITEM_PREFIX_RE, "").trim());
-        }
-        index += 1;
-    }
-    return {
-        items: collected.filter((item) => item.length > 0),
-        nextIndex: index,
-    };
-}
-function makeHeaderReader(lines, startIndex) {
-    let index = startIndex;
-    return {
-        getIndex() {
-            return index;
-        },
-        setIndex(nextIndex) {
-            index = nextIndex;
-        },
-        readSectionHeader(expected) {
-            while (index < lines.length && lines[index]?.trim().length === 0) {
-                index += 1;
-            }
-            if (lines[index]?.trim() !== expected) {
-                return false;
-            }
-            index += 1;
-            return true;
-        },
-    };
-}
-function parseRoundOpenSections(message) {
-    const lines = splitBodyLines(message.trimEnd());
-    let index = 0;
-    while (index < lines.length && lines[index]?.trim().length === 0) {
-        index += 1;
-    }
-    if (lines[index]?.trim() !== ROUND_OPEN_ROOT_HEADING) {
-        return null;
-    }
-    index += 1;
-    const reader = makeHeaderReader(lines, index);
-    if (!reader.readSectionHeader("### Round"))
-        return null;
-    const roundSection = readSection(lines, reader.getIndex());
-    reader.setIndex(roundSection.nextIndex);
-    const round = Number.parseInt(roundSection.body.trim(), 10);
-    if (!Number.isFinite(round))
-        return null;
-    if (!reader.readSectionHeader("### Title"))
-        return null;
-    const titleSection = readSection(lines, reader.getIndex());
-    reader.setIndex(titleSection.nextIndex);
-    const title = titleSection.body.trim();
-    if (!title)
-        return null;
-    if (!reader.readSectionHeader("### Objective"))
-        return null;
-    const objectiveSection = readSection(lines, reader.getIndex());
-    reader.setIndex(objectiveSection.nextIndex);
-    const objective = objectiveSection.body.trim();
-    if (!objective)
-        return null;
-    index = reader.getIndex();
-    while (index < lines.length && lines[index]?.trim().length === 0) {
-        index += 1;
-    }
-    if (lines[index]?.trim() !== "## Brief") {
-        return null;
-    }
-    index += 1;
-    const brief = lines.slice(index).join("\n").trim();
-    if (!brief)
-        return null;
-    return {
-        round,
-        title,
-        objective,
-        brief,
-    };
-}
-function parseRoundCloseSections(message) {
-    const lines = splitBodyLines(message.trimEnd());
-    let index = 0;
-    while (index < lines.length && lines[index]?.trim().length === 0) {
-        index += 1;
-    }
-    if (lines[index]?.trim() !== ROUND_CLOSE_ROOT_HEADING) {
-        return null;
-    }
-    index += 1;
-    const reader = makeHeaderReader(lines, index);
-    if (!reader.readSectionHeader("### Round"))
-        return null;
-    const roundSection = readSection(lines, reader.getIndex());
-    reader.setIndex(roundSection.nextIndex);
-    const round = Number.parseInt(roundSection.body.trim(), 10);
-    if (!Number.isFinite(round))
-        return null;
-    if (!reader.readSectionHeader("### Title"))
-        return null;
-    const titleSection = readSection(lines, reader.getIndex());
-    reader.setIndex(titleSection.nextIndex);
-    const title = titleSection.body.trim();
-    if (!title)
-        return null;
-    if (!reader.readSectionHeader("### Objective"))
-        return null;
-    const objectiveSection = readSection(lines, reader.getIndex());
-    reader.setIndex(objectiveSection.nextIndex);
-    const objective = objectiveSection.body.trim();
-    if (!objective)
-        return null;
-    if (!reader.readSectionHeader("### Commits"))
-        return null;
-    const commitsSection = readListSection(lines, reader.getIndex());
-    reader.setIndex(commitsSection.nextIndex);
-    if (commitsSection.items.length === 0)
-        return null;
-    index = reader.getIndex();
-    while (index < lines.length && lines[index]?.trim().length === 0) {
-        index += 1;
-    }
-    if (lines[index]?.trim() !== "## Report") {
-        return null;
-    }
-    index += 1;
-    const report = lines.slice(index).join("\n").trim();
-    if (!report)
-        return null;
-    return {
-        round,
-        title,
-        objective,
-        commits: commitsSection.items,
-        report,
-    };
-}
-export function formatRoundOpenLedgerCommitMessage(input) {
-    const title = normalizeTitle(input.title);
-    const objective = input.objective.trim();
-    const brief = input.brief.trimEnd();
-    return [
-        `keiyaku(${input.branchToken}): round open ${input.round} - ${title}`,
-        "",
-        ROUND_OPEN_ROOT_HEADING,
-        "### Round",
-        String(input.round),
-        "",
-        "### Title",
-        title,
-        "",
-        "### Objective",
-        objective,
-        "",
-        "## Brief",
-        brief,
-        "",
-    ].join("\n");
-}
-export function formatRoundCloseLedgerCommitMessage(input) {
-    const title = normalizeTitle(input.title);
-    const objective = input.objective.trim();
-    const commits = input.commits.map((commit) => commit.trim()).filter((commit) => commit.length > 0);
-    const report = input.report.trimEnd();
-    return [
-        `keiyaku(${input.branchToken}): round close ${input.round} - ${title}`,
-        "",
-        ROUND_CLOSE_ROOT_HEADING,
-        "### Round",
-        String(input.round),
-        "",
-        "### Title",
-        title,
-        "",
-        "### Objective",
-        objective,
-        "",
-        "### Commits",
-        ...commits.map((commit) => `- ${commit}`),
-        "",
-        "## Report",
-        report,
-        "",
-    ].join("\n");
-}
-export function parseRoundLedgerCommit(commit, message) {
-    const subject = message.split(/\r?\n/, 1)[0]?.trim() ?? "";
-    const subjectMatch = LEDGER_COMMIT_SUBJECT_RE.exec(subject);
-    if (!subjectMatch)
-        return null;
-    const kind = subjectMatch[2];
-    const subjectRound = Number.parseInt(subjectMatch[3] ?? "", 10);
-    const subjectTitle = subjectMatch[4] ?? "";
-    const bodyStart = message.indexOf("\n");
-    const body = bodyStart === -1 ? "" : message.slice(bodyStart + 1);
-    const parsed = kind === "open" ? parseRoundOpenSections(body) : parseRoundCloseSections(body);
-    if (!parsed)
-        return null;
-    if (parsed.round !== subjectRound)
-        return null;
-    if (normalizeTitle(parsed.title) !== normalizeTitle(subjectTitle))
-        return null;
-    return {
-        ...parsed,
-        kind,
-        commit,
-        branchToken: subjectMatch[1] ?? "",
-    };
-}
-export async function scanRoundLedger(cwd) {
-    const git = createGit(cwd);
-    try {
-        const output = await git.raw(["log", "--reverse", "--format=%H%x00%B%x1e", "HEAD"]);
-        return output
-            .split("\x1e")
-            .map((record) => record.trim())
-            .filter((record) => record.length > 0)
-            .flatMap((record) => {
-            const separatorIndex = record.indexOf("\u0000");
-            if (separatorIndex === -1) {
-                return [];
-            }
-            const commit = record.slice(0, separatorIndex).trim();
-            const message = record.slice(separatorIndex + 1);
-            const parsed = parseRoundLedgerCommit(commit, message);
-            return parsed ? [parsed] : [];
-        });
-    }
-    catch (error) {
-        throw wrapGitError("log round ledger", error, cwd);
-    }
-}
-export function buildRoundLedgerRounds(entries) {
-    const rounds = new Map();
-    for (const entry of entries) {
-        const current = rounds.get(entry.round) ?? {
-            round: entry.round,
-            branchToken: entry.branchToken,
-            title: entry.title,
-        };
-        current.branchToken = current.open?.branchToken ?? current.close?.branchToken ?? entry.branchToken;
-        current.title = current.open?.title ?? current.close?.title ?? entry.title;
-        if (entry.kind === "open") {
-            current.open = entry;
-            current.branchToken = entry.branchToken;
-            current.title = entry.title;
-        }
-        else {
-            current.close = entry;
-            if (!current.open) {
-                current.branchToken = entry.branchToken;
-                current.title = entry.title;
-            }
-        }
-        rounds.set(entry.round, current);
-    }
-    return [...rounds.values()].sort((left, right) => left.round - right.round);
-}
-export function findOpenRound(entries) {
-    return buildRoundLedgerRounds(entries)
-        .filter((round) => round.open && !round.close)
-        .at(-1) ?? null;
-}
-export function findLatestClosedRound(entries) {
-    return buildRoundLedgerRounds(entries)
-        .filter((round) => round.close)
-        .at(-1) ?? null;
-}
-export async function getNextRoundNumber(cwd) {
-    const entries = await scanRoundLedger(cwd);
-    const maxRound = entries.reduce((max, entry) => Math.max(max, entry.round), 0);
-    return maxRound + 1;
-}
-export function getMaxRound(entries) {
-    return entries.reduce((maxRound, entry) => Math.max(maxRound, entry.round), 0);
-}
-export function renderRoundLedgerRound(round) {
-    const open = round.open;
-    const close = round.close;
-    const objective = open?.objective ?? close?.objective ?? "";
-    const lines = [
-        `## Round ${round.round} - ${round.title}`,
-        "",
-        "### Status",
-        close ? "Closed" : "Open",
-        "",
-        "### Branch",
-        round.branchToken,
-        "",
-    ];
-    if (open) {
-        lines.push("### Open Ledger Commit", open.commit, "", "### Objective", objective, "", "### Brief", open.brief.trimEnd(), "");
-    }
-    else if (objective) {
-        lines.push("### Objective", objective, "");
-    }
-    if (close) {
-        lines.push("### Close Ledger Commit", close.commit, "", "### Commits", ...close.commits.map((commit) => `- ${commit}`), "", "### Report", close.report.trimEnd(), "");
-    }
-    return lines.join("\n");
-}
-export function renderRoundLedgerHistory(entries) {
-    if (entries.length === 0) {
-        return "No round ledger entries recorded.";
-    }
-    return buildRoundLedgerRounds(entries).map((round) => renderRoundLedgerRound(round)).join("\n");
-}
-export function renderRoundLedgerPreview(round) {
-    if (!round)
-        return undefined;
-    const open = round.open;
-    const close = round.close;
-    const lines = [
-        `Round ${round.round} - ${round.title}`,
-        `Status: ${close ? "Closed" : "Open"}`,
-    ];
-    const objective = open?.objective ?? close?.objective;
-    if (objective) {
-        lines.push(`Objective: ${objective}`);
-    }
-    if (open) {
-        const briefPreview = toStatusPreview(open.brief);
-        if (briefPreview) {
-            lines.push(`Brief: ${briefPreview}`);
-        }
-        lines.push(`Open Ledger Commit: ${open.commit}`);
-    }
-    if (close) {
-        lines.push(`Commits: ${close.commits.join(", ")}`);
-        lines.push(`Close Ledger Commit: ${close.commit}`);
-        const reportPreview = toStatusPreview(close.report);
-        if (reportPreview) {
-            lines.push(`Report: ${reportPreview}`);
-        }
-    }
-    return lines.join("\n");
-}

package/build/protocol/markdown/index.js

@@ -1,14 +0,0 @@
-/**
- * Responsibility boundary:
- * - This module is a markdown-like parser/renderer utility layer only.
- * - It handles syntax-level concerns (tokens, AST, section extraction, rendering).
- * - It MUST NOT encode keiyaku workflow/domain semantics such as required fields
- *   (goal/context/rules/criteria), reserved business section names, or
- *   bind/round policy decisions.
- * - Domain-specific draft/schema logic belongs in tool/protocol modules.
- */
-export { KeiyakuParseError, } from "./types.js";
-export { parseToAST } from "./parser.js";
-export { computeHeadingDelta, demoteMarkdownHeadings, renderMarkdownSections } from "./normalization.js";
-export { extractListItems, renderNodeContent, renderSectionContent } from "./render.js";
-export { hasTopLevelHeaders, parseMarkdownListSection, parseMarkdownSections, parseMarkdownStructure } from "./sections.js";

package/build/protocol/markdown/normalization.js

@@ -1,71 +0,0 @@
-import { parseToAST } from "./parser.js";
-import { renderNodeContent } from "./render.js";
-export function computeHeadingDelta(shallowest, minLevel) {
-    if (shallowest === null || shallowest >= minLevel) {
-        return 0;
-    }
-    return minLevel - shallowest;
-}
-export function demoteMarkdownHeadings(text, minLevel = 3) {
-    const ast = parseToAST(text, { allowSections: false });
-    // Preserve relative heading hierarchy by shifting all headings together.
-    // This avoids collapsing something like `# A` and `### B` into the same level.
-    let shallowest = null;
-    {
-        const stack = [ast];
-        while (stack.length > 0) {
-            const node = stack.pop();
-            if (!node)
-                continue;
-            if (node.type === "heading") {
-                shallowest = shallowest === null ? node.level : Math.min(shallowest, node.level);
-            }
-            if (node.type === "code_block" || node.type === "blockquote" || node.type === "text")
-                continue;
-            if (node.type === "document" || node.type === "section" || node.type === "list_item") {
-                stack.push(...node.children);
-            }
-            else if (node.type === "list") {
-                stack.push(...node.items);
-            }
-        }
-    }
-    const delta = computeHeadingDelta(shallowest, minLevel);
-    if (delta === 0) {
-        // Return a normalized render (trimEnd) to avoid leaking extra trailing newlines.
-        return renderNodeContent(ast).trimEnd();
-    }
-    const shift = (node) => {
-        switch (node.type) {
-            case "heading": {
-                const nextLevel = Math.min(6, node.level + delta);
-                return nextLevel === node.level ? node : { ...node, level: nextLevel };
-            }
-            case "code_block":
-            case "blockquote":
-            case "text":
-                return node;
-            case "document":
-            case "section":
-                return { ...node, children: node.children.map((child) => shift(child)) };
-            case "list":
-                return { ...node, items: node.items.map((item) => shift(item)) };
-            case "list_item":
-                return { ...node, children: node.children.map((child) => shift(child)) };
-        }
-    };
-    return renderNodeContent(shift(ast)).trimEnd();
-}
-export function renderMarkdownSections(items) {
-    return items
-        .map((item) => {
-        // Keiyaku uses H2 as contract section delimiters. Keep payload headings at H3+.
-        const normalized = demoteMarkdownHeadings(item, 3);
-        const trimmed = normalized.trimStart();
-        if (/^[-*+]\s+/.test(trimmed) || /^\d+[.)]\s+/.test(trimmed)) {
-            return normalized;
-        }
-        return `- ${normalized}`;
-    })
-        .join("\n\n");
-}

package/build/protocol/markdown/render.js

@@ -1,68 +0,0 @@
-function renderListItemFirstLine(item) {
-    const content = renderNodeContent(item);
-    if (!content) {
-        return `${" ".repeat(item.indent)}${item.marker}`;
-    }
-    const [firstLine, ...rest] = content.split("\n");
-    const prefix = `${" ".repeat(item.indent)}${item.marker}${firstLine.length > 0 ? " " : ""}${firstLine}`;
-    if (rest.length === 0) {
-        return prefix;
-    }
-    return [prefix, ...rest].join("\n");
-}
-export function renderBlock(node) {
-    switch (node.type) {
-        case "section": {
-            const header = `${"#".repeat(node.level)} ${node.title}`;
-            const body = renderNodeContent(node);
-            return body ? `${header}\n${body}` : header;
-        }
-        case "list":
-            return node.items.map((item) => renderListItemFirstLine(item)).join("\n");
-        case "code_block":
-            return node.lines.join("\n");
-        case "blockquote":
-            return node.lines.map((line) => `${node.marker}${line}`).join("\n");
-        case "text":
-            return node.value;
-        case "heading":
-            return `${"#".repeat(node.level)} ${node.text}`;
-    }
-}
-export function renderNodeContent(node) {
-    switch (node.type) {
-        case "document":
-            return node.children.map((child) => renderBlock(child)).join("\n");
-        case "section":
-            return node.children.map((child) => renderBlock(child)).join("\n");
-        case "list":
-            return renderBlock(node);
-        case "list_item":
-            return node.children.map((child) => renderBlock(child)).join("\n");
-        case "code_block":
-            return node.lines.join("\n");
-        case "blockquote":
-            return node.lines.map((line) => `${node.marker}${line}`).join("\n");
-        case "text":
-            return node.value;
-        case "heading":
-            return `${"#".repeat(node.level)} ${node.text}`;
-    }
-}
-export function renderSectionContent(sectionNode) {
-    return sectionNode.children.map((child) => renderBlock(child)).join("\n");
-}
-export function extractListItems(sectionNode) {
-    const items = [];
-    for (const child of sectionNode.children) {
-        if (child.type !== "list")
-            continue;
-        for (const item of child.items) {
-            const rendered = renderNodeContent(item).trimEnd();
-            if (rendered.trim().length > 0) {
-                items.push(rendered);
-            }
-        }
-    }
-    return items;
-}