@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/git/diff/parsers.js

@@ -1,181 +0,0 @@
-const DIFF_TRUNCATED_MARKER = "...[truncated]";
-export 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;
-}
-export 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),
-                        oldStart: parsed.oldStart,
-                        oldEnd: parsed.oldEnd,
-                        newStart: parsed.newStart,
-                        newEnd: parsed.newEnd,
-                    });
-                }
-            }
-            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),
-                oldStart: parsed.oldStart,
-                oldEnd: parsed.oldEnd,
-                newStart: parsed.newStart,
-                newEnd: parsed.newEnd,
-            });
-        }
-    }
-    return { prelude, hunks };
-}
-export function parseHunkRange(hunkHeader) {
-    const match = hunkHeader.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
-    if (!match)
-        return null;
-    const oldStart = Number.parseInt(match[1] ?? "", 10);
-    const oldLines = match[2] === undefined ? 1 : Number.parseInt(match[2], 10);
-    const newStart = Number.parseInt(match[3] ?? "", 10);
-    const newLines = match[4] === undefined ? 1 : Number.parseInt(match[4], 10);
-    if (![oldStart, oldLines, newStart, newLines].every(Number.isFinite))
-        return null;
-    return {
-        oldStart,
-        oldLines,
-        oldEnd: oldLines <= 0 ? oldStart - 1 : oldStart + oldLines - 1,
-        newStart,
-        newLines,
-        newEnd: newLines <= 0 ? newStart - 1 : newStart + newLines - 1,
-    };
-}
-export function isDeletedDiffSection(section) {
-    return section.some((line) => line.startsWith("deleted file mode ") || line.startsWith("+++ /dev/null"));
-}
-export 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"));
-}
-export function totalJoinedLength(blocks) {
-    if (blocks.length === 0)
-        return 0;
-    return blocks.reduce((sum, block) => sum + block.length, 0) + (blocks.length - 1) * 2;
-}
-export function truncateTextWithFooter(text, maxChars, omittedChars) {
-    if (maxChars <= 0)
-        return "";
-    const footer = `\n...[truncated ${omittedChars} chars]...`;
-    if (footer.length >= maxChars) {
-        return footer.slice(0, maxChars);
-    }
-    const cut = text.slice(0, maxChars - footer.length);
-    return `${cut}${footer}`;
-}
-function isChangedDiffLine(line) {
-    return (line.startsWith("+") && !line.startsWith("+++")) || (line.startsWith("-") && !line.startsWith("---"));
-}
-function trimUnsafeDiffBoundary(kept, remaining) {
-    if (kept.length === 0 || remaining.length === 0)
-        return kept;
-    const safe = [...kept];
-    while (safe.length > 0 && isChangedDiffLine(safe[safe.length - 1] ?? "") && isChangedDiffLine(remaining[0] ?? "")) {
-        safe.pop();
-    }
-    if ((safe[safe.length - 1] ?? "").startsWith("@@ ")) {
-        safe.pop();
-    }
-    return safe;
-}
-function renderTruncatedDiff(lines) {
-    if (lines.length === 0)
-        return DIFF_TRUNCATED_MARKER;
-    return `${lines.join("\n")}\n${DIFF_TRUNCATED_MARKER}`;
-}
-export function truncateDiffSectionByLineCount(section, maxLines) {
-    if (maxLines < 1)
-        return "";
-    const lines = section.split("\n");
-    if (lines.length <= maxLines)
-        return section;
-    const { prelude, hunks } = parseUnifiedHunks(lines);
-    if (hunks.length === 0 || prelude.length >= maxLines) {
-        return renderTruncatedDiff(trimUnsafeDiffBoundary(lines.slice(0, maxLines), lines.slice(maxLines)));
-    }
-    const kept = [...prelude];
-    let lineCount = prelude.length;
-    for (let index = 0; index < hunks.length; index += 1) {
-        const hunk = hunks[index];
-        const hunkLines = [hunk.header, ...hunk.lines];
-        if (lineCount + hunkLines.length <= maxLines) {
-            kept.push(...hunkLines);
-            lineCount += hunkLines.length;
-            continue;
-        }
-        kept.push(...hunkLines);
-        lineCount += hunkLines.length;
-        break;
-    }
-    if (lineCount >= lines.length)
-        return section;
-    return renderTruncatedDiff(kept);
-}
-export function truncateDiffBlockToCharBudget(block, maxChars) {
-    if (maxChars <= 0)
-        return "";
-    if (block.length <= maxChars)
-        return block;
-    if (DIFF_TRUNCATED_MARKER.length >= maxChars) {
-        return DIFF_TRUNCATED_MARKER.slice(0, maxChars);
-    }
-    const lines = block.split("\n");
-    const kept = [];
-    let used = 0;
-    for (const line of lines) {
-        const delta = (kept.length > 0 ? 1 : 0) + line.length;
-        const reservedMarker = 1 + DIFF_TRUNCATED_MARKER.length;
-        if (used + delta + reservedMarker > maxChars)
-            break;
-        kept.push(line);
-        used += delta;
-    }
-    const safe = trimUnsafeDiffBoundary(kept, lines.slice(kept.length));
-    if (safe.length === 0) {
-        return DIFF_TRUNCATED_MARKER.slice(0, maxChars);
-    }
-    return renderTruncatedDiff(safe);
-}

package/build/git/diff/pathspec.js

@@ -1,3 +0,0 @@
-export function diffPathspecArgs(options = {}) {
-    return ["--", ".", ...(options.excludePaths ?? []).map((path) => `:(exclude)${path}`)];
-}

package/build/git/diff/preview.js

@@ -1,38 +0,0 @@
-import { wrapGitError } from "../core.js";
-import { runGitOrThrow } from "../process.js";
-import { diffPathspecArgs } from "./pathspec.js";
-export async function getDiffStats(cwd, baseBranch, options = {}) {
-    let rawNumStat;
-    try {
-        rawNumStat = (await runGitOrThrow(cwd, [
-            "diff",
-            "--numstat",
-            `${baseBranch}...HEAD`,
-            ...diffPathspecArgs({ excludePaths: options.excludePaths }),
-        ])).stdout;
-    }
-    catch (err) {
-        throw wrapGitError(`diff --numstat ${baseBranch}...HEAD`, err, cwd);
-    }
-    const rows = rawNumStat
-        .split(/\r?\n/)
-        .flatMap((line) => {
-        if (!line.trim())
-            return [];
-        const [addRaw, delRaw, ...pathParts] = line.split("\t");
-        const filePath = pathParts.join("\t").trim();
-        if (!filePath)
-            return [];
-        const binary = addRaw === "-" || delRaw === "-";
-        return [{
-                path: filePath,
-                additions: binary ? 0 : Number.parseInt(addRaw, 10) || 0,
-                deletions: binary ? 0 : Number.parseInt(delRaw, 10) || 0,
-            }];
-    });
-    return {
-        filesChanged: rows.length,
-        insertions: rows.reduce((sum, row) => sum + row.additions, 0),
-        deletions: rows.reduce((sum, row) => sum + row.deletions, 0),
-    };
-}

package/build/git/diff/read.js

@@ -1,105 +0,0 @@
-import { wrapGitError } from "../core.js";
-import { runGitOrThrow } from "../process.js";
-import { diffPathspecArgs } from "./pathspec.js";
-import { isMissingBaseRevisionError, splitDiffByFile, totalJoinedLength, truncateDiffBlockToCharBudget, truncateDiffSectionByLineCount, truncateTextWithFooter, } from "./parsers.js";
-function normalizeDiffTarget(target) {
-    return typeof target === "string" ? [target] : [...target];
-}
-function formatDiffTarget(target) {
-    return typeof target === "string" ? target : target.join(" ");
-}
-function buildPatchCommand(target, options) {
-    const args = ["diff", "--no-color", "--no-ext-diff", "--unified=3"];
-    if (options.algorithm === "histogram") {
-        args.push("--diff-algorithm=histogram");
-    }
-    args.push(...normalizeDiffTarget(target), ...diffPathspecArgs({ excludePaths: options.excludePaths }));
-    return args;
-}
-function renderPatchDiff(output, options) {
-    const rawPatch = output.trim();
-    if (!rawPatch)
-        return "No diff.";
-    const maxLinesPerFile = options.maxLinesPerFile;
-    const maxChars = options.maxChars;
-    if (maxLinesPerFile === undefined && maxChars === undefined) {
-        return rawPatch;
-    }
-    const sections = splitDiffByFile(rawPatch);
-    if (sections.length === 0)
-        return "No diff.";
-    const renderedSections = [];
-    let omittedFiles = 0;
-    for (let i = 0; i < sections.length; i += 1) {
-        const section = sections[i];
-        const fileBlock = maxLinesPerFile === undefined
-            ? section.join("\n")
-            : truncateDiffSectionByLineCount(section.join("\n"), maxLinesPerFile);
-        if (maxChars === undefined) {
-            renderedSections.push(fileBlock);
-            continue;
-        }
-        const projected = totalJoinedLength([...renderedSections, fileBlock]);
-        if (projected <= maxChars) {
-            renderedSections.push(fileBlock);
-            continue;
-        }
-        omittedFiles = sections.length - i;
-        if (renderedSections.length === 0) {
-            const notice = `... [omitted ${omittedFiles} file(s) to stay under ${maxChars} chars] ...`;
-            const partialBudget = Math.max(0, maxChars - totalJoinedLength(["", notice]));
-            const partial = truncateDiffBlockToCharBudget(fileBlock, partialBudget);
-            if (partial.trim()) {
-                renderedSections.push(partial);
-            }
-        }
-        break;
-    }
-    if (omittedFiles > 0 && maxChars !== undefined) {
-        const notice = `... [omitted ${omittedFiles} file(s) to stay under ${maxChars} chars] ...`;
-        while (renderedSections.length > 0 && totalJoinedLength([...renderedSections, notice]) > maxChars) {
-            renderedSections.pop();
-        }
-        if (totalJoinedLength([...renderedSections, notice]) <= maxChars) {
-            renderedSections.push(notice);
-        }
-    }
-    return renderedSections.join("\n\n").trim() || "No diff.";
-}
-export async function readDiff(cwd, target, format, options = {}) {
-    const formattedTarget = formatDiffTarget(target);
-    try {
-        if (format === "stat") {
-            const statVariant = options.statVariant ?? "summary";
-            const pathspec = diffPathspecArgs({ excludePaths: options.excludePaths });
-            const args = statVariant === "numstat"
-                ? ["diff", "--numstat", ...normalizeDiffTarget(target), ...pathspec]
-                : ["diff", "--stat=120,80", "--compact-summary", ...normalizeDiffTarget(target), ...pathspec];
-            const output = (await runGitOrThrow(cwd, args)).stdout;
-            if (statVariant !== "summary") {
-                return output.trim() || "No diff.";
-            }
-            const trimmed = output.trim();
-            if (!trimmed)
-                return "No diff.";
-            const maxChars = options.maxChars ?? Number.POSITIVE_INFINITY;
-            if (trimmed.length <= maxChars) {
-                return trimmed;
-            }
-            return truncateTextWithFooter(trimmed, maxChars, trimmed.length - maxChars);
-        }
-        const output = (await runGitOrThrow(cwd, buildPatchCommand(target, options))).stdout;
-        return renderPatchDiff(output, options);
-    }
-    catch (error) {
-        if (isMissingBaseRevisionError(error)) {
-            return null;
-        }
-        const commandLabel = format === "stat"
-            ? options.statVariant === "numstat"
-                ? `diff --numstat ${formattedTarget}`
-                : `diff --stat=120,80 --compact-summary ${formattedTarget}`
-            : `diff --no-color --no-ext-diff --unified=3 ${formattedTarget}`;
-        throw wrapGitError(commandLabel, error, cwd);
-    }
-}

package/build/git/diff/structured.js

@@ -1,127 +0,0 @@
-import { wrapGitError } from "../core.js";
-import { runGitOrThrow } from "../process.js";
-import { diffPathspecArgs } from "./pathspec.js";
-import { parseHunkRange, parseUnifiedHunks, splitDiffByFile } from "./parsers.js";
-function parseRawDiff(output) {
-    const fields = output.split("\0");
-    const files = [];
-    let index = 0;
-    while (index < fields.length) {
-        const header = fields[index++];
-        if (!header)
-            continue;
-        const statusToken = header.trim().split(/\s+/).at(-1) ?? "";
-        const status = statusToken[0];
-        if (status !== "A" && status !== "M" && status !== "D" && status !== "R" && status !== "C" && status !== "T" && status !== "U")
-            continue;
-        const firstPath = fields[index++] ?? "";
-        if (status === "R" || status === "C") {
-            const path = fields[index++] ?? "";
-            files.push({
-                oldPath: firstPath,
-                path,
-                status,
-                similarity: Number.parseInt(statusToken.slice(1), 10) || 0,
-            });
-        }
-        else {
-            files.push({ path: firstPath, status });
-        }
-    }
-    return files;
-}
-function withoutTerminalPatchDelimiter(patch) {
-    return patch.endsWith("\n") ? patch.slice(0, -1) : patch;
-}
-function parseNumstat(output) {
-    const fields = output.split("\0");
-    const stats = [];
-    let index = 0;
-    while (index < fields.length) {
-        const record = fields[index++];
-        if (!record)
-            continue;
-        const [added = "0", removed = "0", path = ""] = record.split("\t");
-        const binary = added === "-" || removed === "-";
-        if (path) {
-            stats.push({ path, insertions: binary ? 0 : Number.parseInt(added, 10) || 0, deletions: binary ? 0 : Number.parseInt(removed, 10) || 0, binary });
-            continue;
-        }
-        const oldPath = fields[index++] ?? "";
-        const newPath = fields[index++] ?? "";
-        stats.push({ path: newPath, oldPath, insertions: binary ? 0 : Number.parseInt(added, 10) || 0, deletions: binary ? 0 : Number.parseInt(removed, 10) || 0, binary });
-    }
-    return stats;
-}
-function structuredLines(raw, oldStart, newStart) {
-    let oldLine = oldStart;
-    let newLine = newStart;
-    const lines = [];
-    for (const line of raw) {
-        if (line.startsWith("\"))
-            continue;
-        if (line.startsWith("+")) {
-            lines.push({ kind: "addition", content: line.slice(1), oldLine: null, newLine: newLine++ });
-        }
-        else if (line.startsWith("-")) {
-            lines.push({ kind: "deletion", content: line.slice(1), oldLine: oldLine++, newLine: null });
-        }
-        else {
-            lines.push({ kind: "context", content: line.startsWith(" ") ? line.slice(1) : line, oldLine: oldLine++, newLine: newLine++ });
-        }
-    }
-    return lines;
-}
-function parsePatchHunks(section) {
-    return parseUnifiedHunks([...section]).hunks.flatMap((hunk, index) => {
-        const range = parseHunkRange(hunk.header);
-        if (!range)
-            return [];
-        return [{
-                index,
-                header: hunk.header,
-                oldStart: range.oldStart,
-                oldLines: range.oldLines,
-                newStart: range.newStart,
-                newLines: range.newLines,
-                lines: structuredLines(hunk.lines, range.oldStart, range.newStart),
-            }];
-    });
-}
-export async function readStructuredDiff(cwd, from, to, options = {}) {
-    const range = `${from}..${to}`;
-    const pathspec = diffPathspecArgs({ excludePaths: options.excludePaths });
-    try {
-        const [raw, numstat, patch] = await Promise.all([
-            runGitOrThrow(cwd, ["diff", "--raw", "-z", "--find-renames", range, ...pathspec]).then((result) => result.stdout),
-            runGitOrThrow(cwd, ["diff", "--numstat", "-z", "--find-renames", range, ...pathspec]).then((result) => result.stdout),
-            runGitOrThrow(cwd, ["diff", "--no-color", "--no-ext-diff", "--unified=3", "--find-renames", range, ...pathspec]).then((result) => result.stdout),
-        ]);
-        const rawFiles = parseRawDiff(raw);
-        const stats = parseNumstat(numstat);
-        const sections = splitDiffByFile(withoutTerminalPatchDelimiter(patch));
-        const files = rawFiles.map((file, index) => {
-            const stat = stats[index];
-            return {
-                ...file,
-                insertions: stat?.insertions ?? 0,
-                deletions: stat?.deletions ?? 0,
-                binary: stat?.binary ?? false,
-                hunks: parsePatchHunks(sections[index] ?? []),
-            };
-        });
-        return {
-            from,
-            to,
-            files,
-            stat: {
-                filesChanged: files.length,
-                insertions: files.reduce((sum, file) => sum + file.insertions, 0),
-                deletions: files.reduce((sum, file) => sum + file.deletions, 0),
-            },
-        };
-    }
-    catch (error) {
-        throw wrapGitError(`diff --find-renames ${range}`, error, cwd);
-    }
-}

package/build/git/diff/types.js

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

package/build/git/path-coordinate.js

@@ -1,17 +0,0 @@
-import * as fs from "node:fs";
-import * as fsPromises from "node:fs/promises";
-import * as path from "node:path";
-import { normalizeFilesystemCoordinate } from "../fs/path-coordinate.js";
-export function normalizeGitPath(raw, platform = process.platform) {
-    return normalizeFilesystemCoordinate(raw, platform);
-}
-export function gitCommonRootPath(raw, platform = process.platform) {
-    const paths = platform === "win32" ? path.win32 : path.posix;
-    return paths.dirname(normalizeFilesystemCoordinate(raw, platform));
-}
-export async function resolveGitCommonRoot(raw) {
-    return await fsPromises.realpath(gitCommonRootPath(raw));
-}
-export function resolveGitCommonRootSync(raw) {
-    return fs.realpathSync(gitCommonRootPath(raw));
-}