@astrosheep/keiyaku 0.1.13 → 0.1.15

package/build/utils/keiyaku-document.js

@@ -0,0 +1,542 @@
+import { FlowError } from "../common/errors.js";
+const BASE_CONSTRAINTS_SOURCE = ".keiyaku/base-constraints.md";
+function countLeadingSpaces(line) {
+    let idx = 0;
+    while (idx < line.length && line[idx] === " ") {
+        idx += 1;
+    }
+    return idx;
+}
+function parseFence(trimmedLine) {
+    if (!trimmedLine.startsWith("```"))
+        return null;
+    let idx = 0;
+    while (idx < trimmedLine.length && trimmedLine[idx] === "`") {
+        idx += 1;
+    }
+    if (idx < 3)
+        return null;
+    return {
+        length: idx,
+        info: trimmedLine.slice(idx).trim(),
+    };
+}
+function isAsciiDigit(char) {
+    return char !== undefined && char >= "0" && char <= "9";
+}
+function isSpaceOrTab(char) {
+    return char === " " || char === "\t";
+}
+function parseHeader(trimmedLine) {
+    let level = 0;
+    while (level < trimmedLine.length && trimmedLine[level] === "#") {
+        level += 1;
+    }
+    if (level === 0)
+        return null;
+    if (!isSpaceOrTab(trimmedLine[level]))
+        return null;
+    const text = trimmedLine.slice(level).trim();
+    if (!text)
+        return null;
+    return { level, text };
+}
+function stripUtf8Bom(content) {
+    if (!content.startsWith("\uFEFF"))
+        return content;
+    return content.slice(1);
+}
+function parseListMarker(line) {
+    let indent = 0;
+    while (indent < line.length && line[indent] === " ") {
+        indent += 1;
+    }
+    const markerStart = indent;
+    const markerChar = line[markerStart];
+    let markerEnd = markerStart;
+    let ordered = false;
+    if (markerChar === "-" || markerChar === "*" || markerChar === "+") {
+        markerEnd += 1;
+    }
+    else if (isAsciiDigit(markerChar)) {
+        while (isAsciiDigit(line[markerEnd])) {
+            markerEnd += 1;
+        }
+        const orderedSuffix = line[markerEnd];
+        if (orderedSuffix !== "." && orderedSuffix !== ")")
+            return null;
+        markerEnd += 1;
+        ordered = true;
+    }
+    else {
+        return null;
+    }
+    if (!isSpaceOrTab(line[markerEnd]))
+        return null;
+    let contentStart = markerEnd;
+    while (isSpaceOrTab(line[contentStart])) {
+        contentStart += 1;
+    }
+    return {
+        indent,
+        ordered,
+        marker: line.slice(markerStart, markerEnd),
+        body: line.slice(contentStart),
+    };
+}
+function isBlankLine(line) {
+    return line.trim().length === 0;
+}
+function stripTrailingBlankLines(lines) {
+    const trimmed = [...lines];
+    while (trimmed.length > 0 && isBlankLine(trimmed[trimmed.length - 1])) {
+        trimmed.pop();
+    }
+    return trimmed;
+}
+function normalizeSectionTitle(title) {
+    return title.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function isSectionHeaderToken(token) {
+    return token.type === "header" && (token.level === 1 || token.level === 2);
+}
+function isFenceClosingToken(token, fence) {
+    return token.type === "fence" && token.length >= fence.length;
+}
+function lexMarkdown(content) {
+    const lines = stripUtf8Bom(content).split(/\r?\n/);
+    const tokens = [];
+    for (const line of lines) {
+        const leadingSpaces = countLeadingSpaces(line);
+        if (leadingSpaces <= 3) {
+            const trimmedLine = line.trimStart();
+            const fence = parseFence(trimmedLine);
+            if (fence) {
+                tokens.push({
+                    type: "fence",
+                    raw: line,
+                    leadingSpaces,
+                    length: fence.length,
+                    info: fence.info,
+                });
+                continue;
+            }
+            const header = parseHeader(trimmedLine);
+            if (header) {
+                tokens.push({
+                    type: "header",
+                    raw: line,
+                    leadingSpaces,
+                    level: header.level,
+                    text: header.text,
+                });
+                continue;
+            }
+        }
+        const marker = parseListMarker(line);
+        if (marker) {
+            tokens.push({
+                type: "list_marker",
+                raw: line,
+                leadingSpaces,
+                indent: marker.indent,
+                ordered: marker.ordered,
+                marker: marker.marker,
+                body: marker.body,
+            });
+            continue;
+        }
+        tokens.push({
+            type: "text",
+            raw: line,
+            leadingSpaces,
+        });
+    }
+    return tokens;
+}
+class MarkdownParser {
+    tokens;
+    options;
+    index = 0;
+    constructor(tokens, options) {
+        this.tokens = tokens;
+        this.options = options;
+    }
+    parseDocument() {
+        return {
+            type: "document",
+            children: this.parseBlocks(() => false),
+        };
+    }
+    parseBlocks(shouldStop) {
+        const blocks = [];
+        while (!this.isEof()) {
+            if (shouldStop())
+                break;
+            const token = this.peek();
+            if (!token)
+                break;
+            if (this.options.allowSections && isSectionHeaderToken(token)) {
+                blocks.push(this.parseSection());
+                continue;
+            }
+            if (token.type === "fence") {
+                blocks.push(this.parseCodeBlock());
+                continue;
+            }
+            if (token.type === "header") {
+                blocks.push(this.parseHeading());
+                continue;
+            }
+            if (token.type === "list_marker" && token.indent <= 3) {
+                blocks.push(this.parseList(token.indent, token.ordered));
+                continue;
+            }
+            blocks.push(this.parseText(shouldStop));
+        }
+        return blocks;
+    }
+    parseSection() {
+        const header = this.consume();
+        if (!header || !isSectionHeaderToken(header)) {
+            throw new FlowError("INVALID_KEIYAKU_DRAFT", "invalid markdown parse state: expected section header");
+        }
+        const children = this.parseBlocks(() => {
+            const next = this.peek();
+            return next ? this.options.allowSections && isSectionHeaderToken(next) : false;
+        });
+        return {
+            type: "section",
+            level: header.level,
+            title: header.text,
+            children,
+        };
+    }
+    parseCodeBlock() {
+        const opener = this.consume();
+        if (!opener || opener.type !== "fence") {
+            throw new FlowError("INVALID_KEIYAKU_DRAFT", "invalid markdown parse state: expected code fence");
+        }
+        const lines = [opener.raw];
+        const fence = { length: opener.length };
+        while (!this.isEof()) {
+            const token = this.consume();
+            if (!token)
+                break;
+            lines.push(token.raw);
+            if (isFenceClosingToken(token, fence)) {
+                break;
+            }
+        }
+        return {
+            type: "code_block",
+            fenceLength: opener.length,
+            info: opener.info,
+            lines,
+        };
+    }
+    parseHeading() {
+        const header = this.consume();
+        if (!header || header.type !== "header") {
+            throw new FlowError("INVALID_KEIYAKU_DRAFT", "invalid markdown parse state: expected heading");
+        }
+        return {
+            type: "heading",
+            level: header.level,
+            text: header.text,
+        };
+    }
+    parseList(indent, ordered) {
+        const items = [];
+        while (!this.isEof()) {
+            const token = this.peek();
+            if (!token || token.type !== "list_marker")
+                break;
+            if (token.indent !== indent)
+                break;
+            if (token.ordered !== ordered)
+                break;
+            this.consume();
+            items.push(this.parseListItem(token, indent));
+        }
+        return {
+            type: "list",
+            ordered,
+            indent,
+            items,
+        };
+    }
+    parseListItem(markerToken, listIndent) {
+        const lines = [markerToken.body];
+        let itemFence = null;
+        while (!this.isEof()) {
+            const token = this.peek();
+            if (!token)
+                break;
+            if (itemFence) {
+                const consumed = this.consume();
+                if (!consumed)
+                    break;
+                lines.push(consumed.raw);
+                if (isFenceClosingToken(consumed, itemFence)) {
+                    itemFence = null;
+                }
+                continue;
+            }
+            if (this.options.allowSections && isSectionHeaderToken(token)) {
+                break;
+            }
+            if (token.type === "header" && token.leadingSpaces <= listIndent) {
+                break;
+            }
+            if (token.type === "fence" && token.leadingSpaces <= listIndent) {
+                break;
+            }
+            if (token.type === "list_marker") {
+                if (token.indent < listIndent) {
+                    break;
+                }
+                if (token.indent === listIndent) {
+                    if (token.ordered !== markerToken.ordered) {
+                        break;
+                    }
+                    break;
+                }
+            }
+            const consumed = this.consume();
+            if (!consumed)
+                break;
+            lines.push(consumed.raw);
+            if (consumed.type === "fence") {
+                itemFence = { length: consumed.length };
+            }
+        }
+        const normalizedLines = stripTrailingBlankLines(lines);
+        const body = normalizedLines.join("\n");
+        const children = parseToAST(body, { allowSections: false }).children;
+        return {
+            type: "list_item",
+            marker: markerToken.marker,
+            indent: markerToken.indent,
+            children,
+        };
+    }
+    parseText(shouldStop) {
+        const lines = [];
+        while (!this.isEof()) {
+            if (shouldStop())
+                break;
+            const token = this.peek();
+            if (!token)
+                break;
+            if (token.type === "fence")
+                break;
+            if (token.type === "header")
+                break;
+            if (token.type === "list_marker" && token.indent <= 3)
+                break;
+            if (this.options.allowSections && isSectionHeaderToken(token))
+                break;
+            lines.push(token.raw);
+            this.consume();
+        }
+        if (lines.length === 0) {
+            const fallback = this.consume();
+            if (fallback) {
+                lines.push(fallback.raw);
+            }
+        }
+        return {
+            type: "text",
+            lines,
+            value: lines.join("\n"),
+        };
+    }
+    peek() {
+        return this.tokens[this.index];
+    }
+    consume() {
+        const token = this.tokens[this.index];
+        this.index += 1;
+        return token;
+    }
+    isEof() {
+        return this.index >= this.tokens.length;
+    }
+}
+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");
+}
+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 "text":
+            return node.value;
+        case "heading":
+            return `${"#".repeat(node.level)} ${node.text}`;
+    }
+}
+export function parseToAST(content, options = {}) {
+    const parser = new MarkdownParser(lexMarkdown(content), {
+        allowSections: options.allowSections ?? true,
+    });
+    return parser.parseDocument();
+}
+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 "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;
+}
+function splitByHeadingBlocks(sectionNode) {
+    const groups = [];
+    let currentGroup = [];
+    const commitGroup = () => {
+        if (currentGroup.length === 0)
+            return;
+        const rendered = currentGroup.map((node) => renderBlock(node)).join("\n").trim();
+        if (rendered.length > 0) {
+            groups.push(rendered);
+        }
+        currentGroup = [];
+    };
+    for (const child of sectionNode.children) {
+        if (child.type === "heading" && child.level >= 2) {
+            commitGroup();
+            currentGroup = [child];
+            continue;
+        }
+        currentGroup.push(child);
+    }
+    commitGroup();
+    return groups;
+}
+export function renderMarkdownSections(items) {
+    return items
+        .map((item) => {
+        validateMarkdownHeaders(item);
+        const trimmed = item.trimStart();
+        if (/^[-*+]\s+/.test(trimmed) || /^\d+\.\s+/.test(trimmed)) {
+            return item;
+        }
+        return `- ${item}`;
+    })
+        .join("\n\n");
+}
+export function validateMarkdownHeaders(text) {
+    if (/^(#|##)\s/m.test(text)) {
+        throw new FlowError("INVALID_KEIYAKU_DRAFT", "Constraints/Criteria cannot contain H1/H2 headers (#/##). Use H3 (###) or list items.");
+    }
+}
+export function parseMarkdownListSection(text) {
+    const ast = parseToAST(text, { allowSections: false });
+    const pseudoSection = {
+        type: "section",
+        level: 2,
+        title: "",
+        children: ast.children,
+    };
+    const listItems = extractListItems(pseudoSection);
+    if (listItems.length > 0) {
+        return listItems;
+    }
+    const nonHeadingSection = {
+        type: "section",
+        level: 2,
+        title: "",
+        children: pseudoSection.children.filter((child) => child.type !== "heading"),
+    };
+    const fallback = renderSectionContent(nonHeadingSection).trim();
+    return fallback ? [fallback] : [];
+}
+export function parseMarkdownSections(text) {
+    const ast = parseToAST(text, { allowSections: false });
+    const pseudoSection = {
+        type: "section",
+        level: 2,
+        title: "",
+        children: ast.children,
+    };
+    return splitByHeadingBlocks(pseudoSection);
+}
+export function parseMarkdownStructure(content) {
+    const ast = parseToAST(content);
+    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}'`);
+        }
+        const body = renderSectionContent(node).trim();
+        sections.set(normalizedSection, body ? body.split("\n") : []);
+    }
+    return { title, sections };
+}
+export function renderKeiyaku(title, goal, context, baseConstraints, taskConstraints, taskCriteria) {
+    validateMarkdownHeaders(goal);
+    validateMarkdownHeaders(context);
+    let content = `# ${title}\n\n## Context\n${context}\n\n## Goal\n${goal}`;
+    content += "\n\n## Constraints";
+    if (baseConstraints.length > 0) {
+        content += `\n\n### Project Constraints\nLoaded from: \`${BASE_CONSTRAINTS_SOURCE}\`\n\n${renderMarkdownSections(baseConstraints)}`;
+    }
+    content += `\n\n### Task Constraints\n${renderMarkdownSections(taskConstraints)}`;
+    content += "\n\n## Acceptance Criteria";
+    content += `\n\n### Task Criteria\n${renderMarkdownSections(taskCriteria)}`;
+    return content;
+}