@astrosheep/keiyaku 0.1.47 → 0.1.49

package/build/utils/git-diff.js

@@ -1,519 +0,0 @@
-import { DEFAULT_INCREMENTAL_DIFF_MODE, MAX_TARGETED_DIFF_CHARS, } from "../common/constants.js";
-import { createGit, wrapGitError } from "./git-ops.js";
-const DIFF_EXCLUDES = [":(exclude)KEIYAKU.md", ":(exclude)KEIYAKU_TRACE.md"];
-// Diff preview limits (no env/config knobs on purpose).
-const DIFF_PREVIEW_MAX_FILES = 12;
-const DIFF_PREVIEW_MAX_HUNKS_PER_FILE = 4;
-const DIFF_PREVIEW_MAX_LINES_PER_HUNK = 80;
-const DIFF_PREVIEW_MAX_PRELUDE_LINES = 50;
-const DIFF_PREVIEW_TEXT_MAX_CHARS = 10000;
-const INCREMENTAL_DIFF_RANGE = "HEAD~1...HEAD";
-const TARGETED_DIFF_WARNING = "Warning: no valid diff coordinates found in KEIYAKU_TRACE.md; showing stat-only diff.";
-const NOT_SHOWN_IN_DETAIL_PREFIX = "--- not shown in detail: ";
-function buildDiffPathspec(baseBranch) {
-    return [`${baseBranch}...HEAD`, "--", ".", ...DIFF_EXCLUDES];
-}
-function parseNumStat(content) {
-    const rows = [];
-    for (const line of content.split(/\r?\n/)) {
-        if (!line.trim())
-            continue;
-        const [addRaw, delRaw, ...pathParts] = line.split("\t");
-        const filePath = pathParts.join("\t").trim();
-        if (!filePath)
-            continue;
-        const binary = addRaw === "-" || delRaw === "-";
-        rows.push({
-            path: filePath,
-            additions: binary ? 0 : Number.parseInt(addRaw, 10) || 0,
-            deletions: binary ? 0 : Number.parseInt(delRaw, 10) || 0,
-            binary,
-        });
-    }
-    return rows;
-}
-function parseNameStatus(content) {
-    const map = new Map();
-    for (const line of content.split(/\r?\n/)) {
-        if (!line.trim())
-            continue;
-        const parts = line.split("\t");
-        const statusRaw = (parts[0] ?? "").trim();
-        if (!statusRaw)
-            continue;
-        if ((statusRaw.startsWith("R") || statusRaw.startsWith("C")) && parts.length >= 3) {
-            const scoreRaw = statusRaw.slice(1);
-            const score = Number.parseInt(scoreRaw, 10);
-            const oldPath = (parts[1] ?? "").trim();
-            const path = (parts[2] ?? "").trim();
-            if (!path)
-                continue;
-            const status = statusRaw[0] === "R" ? "R" : "C";
-            map.set(path, { status, score: Number.isFinite(score) ? score : 0, oldPath, path });
-            continue;
-        }
-        const path = (parts[1] ?? "").trim();
-        if (!path)
-            continue;
-        // Git can emit single-letter statuses, possibly in combinations; we keep just the first.
-        const status = statusRaw[0];
-        map.set(path, { status, path });
-    }
-    return map;
-}
-function splitDiffByFile(content) {
-    const sections = [];
-    let current = [];
-    for (const line of content.split(/\r?\n/)) {
-        if (line.startsWith("diff --git ")) {
-            if (current.length > 0)
-                sections.push(current);
-            current = [line];
-            continue;
-        }
-        if (current.length > 0)
-            current.push(line);
-    }
-    if (current.length > 0)
-        sections.push(current);
-    return sections;
-}
-function parseUnifiedHunks(section) {
-    const firstHunkIndex = section.findIndex((line) => line.startsWith("@@ "));
-    if (firstHunkIndex === -1) {
-        return { prelude: [...section], hunks: [] };
-    }
-    const prelude = section.slice(0, firstHunkIndex);
-    const hunks = [];
-    let current = [];
-    for (const line of section.slice(firstHunkIndex)) {
-        if (line.startsWith("@@ ")) {
-            if (current.length > 0) {
-                const parsed = parseHunkRange(current[0] ?? "");
-                if (parsed) {
-                    hunks.push({
-                        header: current[0] ?? "",
-                        lines: current.slice(1),
-                        newStart: parsed.start,
-                        newEnd: parsed.end,
-                    });
-                }
-            }
-            current = [line];
-            continue;
-        }
-        if (current.length > 0)
-            current.push(line);
-    }
-    if (current.length > 0) {
-        const parsed = parseHunkRange(current[0] ?? "");
-        if (parsed) {
-            hunks.push({
-                header: current[0] ?? "",
-                lines: current.slice(1),
-                newStart: parsed.start,
-                newEnd: parsed.end,
-            });
-        }
-    }
-    return { prelude, hunks };
-}
-function parseHunkRange(hunkHeader) {
-    const match = hunkHeader.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
-    if (!match)
-        return null;
-    const start = Number.parseInt(match[1] ?? "", 10);
-    const countRaw = match[2];
-    const count = countRaw ? Number.parseInt(countRaw, 10) : 1;
-    if (!Number.isFinite(start) || !Number.isFinite(count))
-        return null;
-    if (count <= 0)
-        return { start, end: start - 1 };
-    return { start, end: start + count - 1 };
-}
-function rangesOverlap(aStart, aEnd, bStart, bEnd) {
-    return aStart <= bEnd && bStart <= aEnd;
-}
-function isDeletedDiffSection(section) {
-    return section.some((line) => line.startsWith("deleted file mode ") || line.startsWith("+++ /dev/null"));
-}
-function buildCoordinateIndex(coordinates) {
-    const index = new Map();
-    for (const coordinate of coordinates) {
-        const existing = index.get(coordinate.path) ?? [];
-        existing.push(coordinate);
-        index.set(coordinate.path, existing);
-    }
-    return index;
-}
-function capTargetedDiffText(diffText) {
-    if (diffText.length <= MAX_TARGETED_DIFF_CHARS)
-        return diffText;
-    const cut = diffText.slice(0, MAX_TARGETED_DIFF_CHARS);
-    return `${cut}\n...[truncated ${diffText.length - MAX_TARGETED_DIFF_CHARS} chars]...`;
-}
-export function filterDiffByCoordinates(rawPatch, coordinates) {
-    const sections = splitDiffByFile(rawPatch);
-    if (sections.length === 0)
-        return "";
-    const byPath = buildCoordinateIndex(coordinates);
-    const selectedSectionsByPath = new Map();
-    const deletedSections = [];
-    const nonDeletedPathsInPatch = [];
-    const sectionByPath = new Map();
-    for (const section of sections) {
-        const path = parseDiffPathFromHeader(section[0] ?? "");
-        if (!path)
-            continue;
-        if (isDeletedDiffSection(section)) {
-            deletedSections.push(section.join("\n"));
-            continue;
-        }
-        if (!sectionByPath.has(path)) {
-            nonDeletedPathsInPatch.push(path);
-            sectionByPath.set(path, section);
-        }
-    }
-    for (const coordinate of coordinates) {
-        const section = sectionByPath.get(coordinate.path);
-        if (!section || selectedSectionsByPath.has(coordinate.path))
-            continue;
-        const fileCoordinates = byPath.get(coordinate.path);
-        if (!fileCoordinates || fileCoordinates.length === 0)
-            continue;
-        const { prelude, hunks } = parseUnifiedHunks(section);
-        if (hunks.length === 0)
-            continue;
-        const matchingHunks = hunks.filter((hunk) => fileCoordinates.some((coord) => rangesOverlap(hunk.newStart, hunk.newEnd, coord.start, coord.end)));
-        if (matchingHunks.length === 0)
-            continue;
-        const rendered = [
-            ...prelude,
-            ...matchingHunks.flatMap((hunk) => [hunk.header, ...hunk.lines]),
-        ].join("\n");
-        selectedSectionsByPath.set(coordinate.path, rendered);
-    }
-    const selectedSections = [...selectedSectionsByPath.values(), ...deletedSections];
-    if (selectedSections.length === 0)
-        return "";
-    const filteredOutPaths = nonDeletedPathsInPatch.filter((path) => !selectedSectionsByPath.has(path));
-    if (filteredOutPaths.length > 0) {
-        selectedSections.push(`${NOT_SHOWN_IN_DETAIL_PREFIX}${filteredOutPaths.join(", ")}`);
-    }
-    return selectedSections.join("\n");
-}
-function totalJoinedLength(blocks) {
-    if (blocks.length === 0)
-        return 0;
-    return blocks.reduce((sum, block) => sum + block.length, 0) + (blocks.length - 1);
-}
-function truncateBlockToLineBudget(block, maxChars) {
-    if (maxChars <= 0)
-        return "";
-    if (block.length <= maxChars)
-        return block;
-    const lines = block.split("\n");
-    const kept = [];
-    let used = 0;
-    for (const line of lines) {
-        const delta = (kept.length > 0 ? 1 : 0) + line.length;
-        if (used + delta > maxChars)
-            break;
-        kept.push(line);
-        used += delta;
-    }
-    return kept.join("\n");
-}
-function isMissingBaseRevisionError(err) {
-    const source = (err ?? {});
-    const text = [source.message, source.stderr, source.stdErr, source.stdout, source.stdOut]
-        .filter((value) => typeof value === "string" && value.length > 0)
-        .join("\n");
-    return (text.includes("bad revision") ||
-        text.includes("unknown revision or path not in the working tree") ||
-        text.includes("ambiguous argument"));
-}
-function renderStatDiffPreviewText(output) {
-    const trimmed = output.trim();
-    if (!trimmed)
-        return "No diff.";
-    if (trimmed.length <= DIFF_PREVIEW_TEXT_MAX_CHARS)
-        return trimmed;
-    const cut = trimmed.slice(0, DIFF_PREVIEW_TEXT_MAX_CHARS);
-    return `${cut}\n...[truncated ${trimmed.length - DIFF_PREVIEW_TEXT_MAX_CHARS} chars]...`;
-}
-async function readStatDiff(git, cwd, range, pathspec) {
-    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);
-}
-async function readIncrementalPatch(git, cwd) {
-    try {
-        return await git.raw([
-            "diff",
-            "--no-color",
-            "--no-ext-diff",
-            "--unified=3",
-            INCREMENTAL_DIFF_RANGE,
-            "--",
-            ".",
-            ...DIFF_EXCLUDES,
-        ]);
-    }
-    catch (err) {
-        if (isMissingBaseRevisionError(err)) {
-            return null;
-        }
-        throw wrapGitError(`diff --no-color --no-ext-diff --unified=3 ${INCREMENTAL_DIFF_RANGE}`, err, cwd);
-    }
-}
-function renderIncrementalUnifiedDiff(rawPatch) {
-    const sections = splitDiffByFile(rawPatch);
-    if (sections.length === 0)
-        return "No changes in last round.";
-    const MAX_TOTAL_CHARS = 15000;
-    const MAX_LINES_PER_FILE = 90;
-    const filePreviews = [];
-    let omittedFiles = 0;
-    for (let i = 0; i < sections.length; i += 1) {
-        const section = sections[i];
-        const fileName = parseDiffPathFromHeader(section[0] ?? "") ?? "unknown";
-        const header = `--- ${fileName} ---`;
-        const content = section.slice(0, MAX_LINES_PER_FILE);
-        const isTruncated = section.length > MAX_LINES_PER_FILE;
-        if (isTruncated) {
-            content.push(`... [truncated ${section.length - MAX_LINES_PER_FILE} lines for this file]`);
-        }
-        const fileBlock = `${header}\n${content.join("\n")}\n`;
-        const projected = totalJoinedLength([...filePreviews, fileBlock]);
-        if (projected <= MAX_TOTAL_CHARS) {
-            filePreviews.push(fileBlock);
-            continue;
-        }
-        omittedFiles = sections.length - i;
-        if (filePreviews.length === 0) {
-            const notice = `... [omitted ${omittedFiles} file(s) to stay under ${MAX_TOTAL_CHARS} chars] ...`;
-            const partialBudget = Math.max(0, MAX_TOTAL_CHARS - notice.length - 1);
-            const partial = truncateBlockToLineBudget(fileBlock, partialBudget);
-            if (partial.trim().length > 0) {
-                filePreviews.push(partial);
-            }
-        }
-        break;
-    }
-    if (omittedFiles > 0) {
-        const notice = `... [omitted ${omittedFiles} file(s) to stay under ${MAX_TOTAL_CHARS} chars] ...`;
-        while (filePreviews.length > 0 && totalJoinedLength([...filePreviews, notice]) > MAX_TOTAL_CHARS) {
-            filePreviews.pop();
-        }
-        if (totalJoinedLength([...filePreviews, notice]) <= MAX_TOTAL_CHARS) {
-            filePreviews.push(notice);
-        }
-    }
-    return filePreviews.join("\n");
-}
-async function getIncrementalUnifiedDiff(git, cwd) {
-    const rawPatch = await readIncrementalPatch(git, cwd);
-    if (rawPatch === null)
-        return "No incremental diff available.";
-    return renderIncrementalUnifiedDiff(rawPatch);
-}
-async function getIncrementalStatDiff(git, cwd) {
-    let output = "";
-    try {
-        output = await git.raw(["diff", "--numstat", INCREMENTAL_DIFF_RANGE, "--", ".", ...DIFF_EXCLUDES]);
-    }
-    catch (err) {
-        if (isMissingBaseRevisionError(err))
-            return "No incremental diff available.";
-        throw wrapGitError(`diff --numstat ${INCREMENTAL_DIFF_RANGE}`, err, cwd);
-    }
-    return renderStatDiffPreviewText(output);
-}
-export async function getIncrementalDiff(cwd, mode = DEFAULT_INCREMENTAL_DIFF_MODE, coordinates) {
-    const git = createGit(cwd);
-    const renderByMode = {
-        unified: () => getIncrementalUnifiedDiff(git, cwd),
-        stat: () => getIncrementalStatDiff(git, cwd),
-        targeted: async () => {
-            const stat = await getIncrementalStatDiff(git, cwd);
-            if (!coordinates || coordinates.length === 0) {
-                return `${stat}\n\n${TARGETED_DIFF_WARNING}`;
-            }
-            const rawPatch = await readIncrementalPatch(git, cwd);
-            if (rawPatch === null)
-                return stat;
-            const targetedPatch = filterDiffByCoordinates(rawPatch, coordinates).trim();
-            if (!targetedPatch) {
-                return `${stat}\n\n${TARGETED_DIFF_WARNING}`;
-            }
-            return `${stat}\n\n${capTargetedDiffText(targetedPatch)}`;
-        },
-    };
-    return renderByMode[mode]();
-}
-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, ["--", ".", ...DIFF_EXCLUDES]);
-}
-function parseDiffPathFromHeader(diffGitLine) {
-    // Format: diff --git a/<path> b/<path>
-    const parts = diffGitLine.split(" ");
-    const bPart = parts[3] ?? "";
-    if (!bPart.startsWith("b/"))
-        return null;
-    return bPart.slice(2);
-}
-function buildPatchPreview(section) {
-    // Keep a small, representative prelude (diff header, index, ---/+++), then first N hunks.
-    const firstHunkIdx = section.findIndex((l) => l.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((r) => r.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,
-    };
-}