@astrosheep/keiyaku 0.1.47 → 0.1.49

package/build/utils/git-diff/preview.js

@@ -0,0 +1,157 @@
+import { DIFF_PREVIEW_TEXT_MAX_CHARS } from "../../common/constants.js";
+import { createGit, wrapGitError } from "../git-ops.js";
+import { DIFF_EXCLUDES, DIFF_PREVIEW_MAX_FILES, DIFF_PREVIEW_MAX_HUNKS_PER_FILE, DIFF_PREVIEW_MAX_LINES_PER_HUNK, DIFF_PREVIEW_MAX_PRELUDE_LINES, } from "./constants.js";
+import { parseDiffPathFromHeader, parseNameStatus, parseNumStat, splitDiffByFile } from "./parsers.js";
+import { buildDiffPathspec, getDefaultPathspec, readStatDiff } from "./stat.js";
+export async function getDiffStats(cwd, baseBranch) {
+    const git = createGit(cwd);
+    const pathspec = buildDiffPathspec(baseBranch);
+    let rawNumStat;
+    try {
+        rawNumStat = await git.raw(["diff", "--numstat", ...pathspec]);
+    }
+    catch (err) {
+        throw wrapGitError(`diff --numstat ${baseBranch}...HEAD`, err, cwd);
+    }
+    const rows = parseNumStat(rawNumStat);
+    return {
+        filesChanged: rows.length,
+        insertions: rows.reduce((sum, row) => sum + row.additions, 0),
+        deletions: rows.reduce((sum, row) => sum + row.deletions, 0),
+    };
+}
+export async function getDiffPreviewText(cwd, baseBranch) {
+    const git = createGit(cwd);
+    const range = `${baseBranch}...HEAD`;
+    return readStatDiff(git, cwd, range, getDefaultPathspec(), DIFF_PREVIEW_TEXT_MAX_CHARS);
+}
+function buildPatchPreview(section) {
+    // Keep a small, representative prelude (diff header, index, ---/+++), then first N hunks.
+    const firstHunkIdx = section.findIndex((line) => line.startsWith("@@ "));
+    const prelude = firstHunkIdx === -1 ? section : section.slice(0, firstHunkIdx).slice(0, DIFF_PREVIEW_MAX_PRELUDE_LINES);
+    if (firstHunkIdx === -1) {
+        const truncated = section.length > DIFF_PREVIEW_MAX_PRELUDE_LINES;
+        const lines = truncated
+            ? [...prelude, `... [truncated ${section.length - prelude.length} prelude line(s)]`]
+            : prelude;
+        return { patch: lines.join("\n"), truncated };
+    }
+    const hunks = [];
+    let current = [];
+    for (const line of section.slice(firstHunkIdx)) {
+        if (line.startsWith("@@ ")) {
+            if (current.length > 0)
+                hunks.push(current);
+            current = [line];
+            continue;
+        }
+        if (current.length > 0)
+            current.push(line);
+    }
+    if (current.length > 0)
+        hunks.push(current);
+    let truncated = false;
+    const shownHunks = hunks.slice(0, DIFF_PREVIEW_MAX_HUNKS_PER_FILE).map((hunk) => {
+        if (hunk.length <= DIFF_PREVIEW_MAX_LINES_PER_HUNK)
+            return hunk;
+        truncated = true;
+        return [
+            ...hunk.slice(0, DIFF_PREVIEW_MAX_LINES_PER_HUNK),
+            `... [truncated ${hunk.length - DIFF_PREVIEW_MAX_LINES_PER_HUNK} line(s) in this hunk]`,
+        ];
+    });
+    if (hunks.length > DIFF_PREVIEW_MAX_HUNKS_PER_FILE) {
+        truncated = true;
+    }
+    const lines = [
+        ...prelude,
+        ...shownHunks.flat(),
+        ...(hunks.length > DIFF_PREVIEW_MAX_HUNKS_PER_FILE
+            ? [`... [omitted ${hunks.length - DIFF_PREVIEW_MAX_HUNKS_PER_FILE} hunk(s)]`]
+            : []),
+    ];
+    return { patch: lines.join("\n"), truncated };
+}
+/**
+ * Gets a compact, structured diff preview for quick review.
+ * - Always includes full stats for the whole range.
+ * - Includes patch previews for the top churn files only (hunk-based truncation).
+ */
+export async function getDiff(cwd, baseBranch) {
+    const git = createGit(cwd);
+    const pathspec = buildDiffPathspec(baseBranch);
+    const range = `${baseBranch}...HEAD`;
+    let rawNumStat;
+    try {
+        rawNumStat = await git.raw(["diff", "--numstat", ...pathspec]);
+    }
+    catch (err) {
+        throw wrapGitError(`diff --numstat ${range}`, err);
+    }
+    const rows = parseNumStat(rawNumStat);
+    const stats = {
+        filesChanged: rows.length,
+        insertions: rows.reduce((sum, row) => sum + row.additions, 0),
+        deletions: rows.reduce((sum, row) => sum + row.deletions, 0),
+    };
+    let rawNameStatus = "";
+    try {
+        rawNameStatus = await git.raw(["diff", "--name-status", ...pathspec]);
+    }
+    catch (err) {
+        throw wrapGitError(`diff --name-status ${range}`, err);
+    }
+    const statusByPath = parseNameStatus(rawNameStatus);
+    const sorted = [...rows].sort((a, b) => b.additions + b.deletions - (a.additions + a.deletions));
+    const selected = sorted.slice(0, DIFF_PREVIEW_MAX_FILES);
+    const omittedFileCount = Math.max(0, rows.length - selected.length);
+    const selectedPaths = selected.map((row) => row.path);
+    let rawPatch = "";
+    if (selectedPaths.length > 0) {
+        try {
+            rawPatch = await git.raw([
+                "diff",
+                "--no-color",
+                "--no-ext-diff",
+                "--unified=3",
+                range,
+                "--",
+                ...selectedPaths,
+                ...DIFF_EXCLUDES,
+            ]);
+        }
+        catch (err) {
+            throw wrapGitError(`diff --no-color --no-ext-diff --unified=3 ${range} -- <top files>`, err);
+        }
+    }
+    const sections = rawPatch ? splitDiffByFile(rawPatch) : [];
+    const patchByPath = new Map();
+    for (const section of sections) {
+        const path = parseDiffPathFromHeader(section[0] ?? "");
+        if (!path)
+            continue;
+        patchByPath.set(path, buildPatchPreview(section));
+    }
+    const files = selected.map((row) => {
+        const status = statusByPath.get(row.path);
+        const patch = patchByPath.get(row.path)?.patch ?? "";
+        const truncated = patchByPath.get(row.path)?.truncated ?? false;
+        return {
+            path: row.path,
+            status: status?.status ?? "M",
+            oldPath: status && (status.status === "R" || status.status === "C") ? status.oldPath : undefined,
+            additions: row.additions,
+            deletions: row.deletions,
+            binary: row.binary,
+            patch,
+            truncated,
+        };
+    });
+    return {
+        range,
+        excludes: DIFF_EXCLUDES,
+        stats,
+        files,
+        omittedFileCount,
+    };
+}

package/build/utils/git-diff/stat.js

@@ -0,0 +1,27 @@
+import { wrapGitError } from "../git-ops.js";
+import { DIFF_EXCLUDES } from "./constants.js";
+export function buildDiffPathspec(baseBranch) {
+    return [`${baseBranch}...HEAD`, "--", ".", ...DIFF_EXCLUDES];
+}
+export function renderStatDiffPreviewText(output, maxChars) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return "No diff.";
+    if (trimmed.length <= maxChars)
+        return trimmed;
+    const cut = trimmed.slice(0, maxChars);
+    return `${cut}\n...[truncated ${trimmed.length - maxChars} chars]...`;
+}
+export async function readStatDiff(git, cwd, range, pathspec, maxChars) {
+    let output = "";
+    try {
+        output = await git.raw(["diff", "--stat=120,80", "--compact-summary", range, ...pathspec]);
+    }
+    catch (err) {
+        throw wrapGitError(`diff --stat=120,80 --compact-summary ${range}`, err, cwd);
+    }
+    return renderStatDiffPreviewText(output, maxChars);
+}
+export function getDefaultPathspec() {
+    return ["--", ".", ...DIFF_EXCLUDES];
+}

package/build/utils/git-diff/types.js

@@ -0,0 +1 @@
+export {};

package/build/utils/git-ops.js

@@ -96,6 +96,15 @@ export async function getActiveKeiyakuBranch(cwd) {
     const current = await getCurrentBranch(cwd);
     return current.startsWith(KEIYAKU_BRANCH_PREFIX) ? current : null;
 }
+export async function getActiveKeiyakuGitState(cwd) {
+    const branch = await getActiveKeiyakuBranch(cwd);
+    if (!branch)
+        return null;
+    const baseBranch = await getKeiyakuBase(cwd, branch);
+    if (!baseBranch)
+        return null;
+    return { branch, baseBranch };
+}
 export async function listLocalKeiyakuBranches(cwd) {
     const git = createGit(cwd);
     let branches;

package/build/utils/git.js

@@ -1,2 +1,2 @@
 export * from "./git-ops.js";
-export * from "./git-diff.js";
+export * from "./git-diff/index.js";

package/build/utils/keiyaku-document/index.js

@@ -0,0 +1,13 @@
+/**
+ * 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
+ *   start/drive policy decisions.
+ * - Domain-specific draft/schema logic belongs in workflow-layer modules.
+ */
+export { KeiyakuParseError, } from "./types.js";
+export { parseToAST } from "./parser.js";
+export { extractListItems, renderNodeContent, renderSectionContent } from "./render.js";
+export { hasTopLevelHeaders, parseMarkdownListSection, parseMarkdownSections, parseMarkdownStructure } from "./sections.js";

package/build/utils/keiyaku-document/lex.js

@@ -0,0 +1,178 @@
+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 parseBlockquote(line) {
+    let idx = 0;
+    while (idx < line.length && line[idx] === " ") {
+        idx += 1;
+    }
+    if (idx > 3 || line[idx] !== ">")
+        return null;
+    let markerEnd = idx + 1;
+    if (line[markerEnd] === " ") {
+        markerEnd += 1;
+    }
+    return {
+        marker: line.slice(0, markerEnd),
+        body: line.slice(markerEnd),
+    };
+}
+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;
+}
+export function stripTrailingBlankLines(lines) {
+    const trimmed = [...lines];
+    while (trimmed.length > 0 && isBlankLine(trimmed[trimmed.length - 1])) {
+        trimmed.pop();
+    }
+    return trimmed;
+}
+export function isSectionHeaderToken(token) {
+    return token.type === "header" && (token.level === 1 || token.level === 2);
+}
+export function isFenceClosingToken(token, fence) {
+    return token.type === "fence" && token.length >= fence.length;
+}
+export 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;
+        }
+        const blockquote = parseBlockquote(line);
+        if (blockquote) {
+            tokens.push({
+                type: "blockquote",
+                raw: line,
+                leadingSpaces,
+                marker: blockquote.marker,
+                body: blockquote.body,
+            });
+            continue;
+        }
+        tokens.push({
+            type: "text",
+            raw: line,
+            leadingSpaces,
+        });
+    }
+    return tokens;
+}

package/build/utils/keiyaku-document/parser.js

@@ -0,0 +1,242 @@
+import { isFenceClosingToken, isSectionHeaderToken, lexMarkdown, stripTrailingBlankLines } from "./lex.js";
+import { KeiyakuParseError, } from "./types.js";
+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;
+            }
+            if (token.type === "blockquote") {
+                blocks.push(this.parseBlockquote());
+                continue;
+            }
+            blocks.push(this.parseText(shouldStop));
+        }
+        return blocks;
+    }
+    parseSection() {
+        const header = this.consume();
+        if (!header || !isSectionHeaderToken(header)) {
+            throw new KeiyakuParseError("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 KeiyakuParseError("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 KeiyakuParseError("invalid markdown parse state: expected heading");
+        }
+        return {
+            type: "heading",
+            level: header.level,
+            text: header.text,
+        };
+    }
+    parseBlockquote() {
+        const lines = [];
+        let marker = "> ";
+        while (!this.isEof()) {
+            const token = this.peek();
+            if (!token || token.type !== "blockquote")
+                break;
+            marker = token.marker;
+            lines.push(token.body);
+            this.consume();
+        }
+        return {
+            type: "blockquote",
+            marker,
+            lines,
+            value: lines.join("\n"),
+        };
+    }
+    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 (token.type === "blockquote")
+                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;
+    }
+}
+export function parseToAST(content, options = {}) {
+    const parser = new MarkdownParser(lexMarkdown(content), {
+        allowSections: options.allowSections ?? true,
+    });
+    return parser.parseDocument();
+}