@astrosheep/keiyaku 2.9.3 → 2.9.5

package/build/fs/path-coordinate.js

@@ -0,0 +1,16 @@
+import * as path from "node:path";
+/**
+ * Keep one host-native spelling before using a coordinate as a filesystem cwd.
+ * Git for Windows may emit or receive native, slash-normalized, or MSYS drive
+ * paths for the same location.
+ */
+export function normalizeFilesystemCoordinate(raw, platform = process.platform) {
+    const value = raw.trim();
+    if (platform !== "win32")
+        return path.normalize(value);
+    const msysDrive = value.match(/^\/([A-Za-z])(?:\/|$)(.*)$/);
+    if (msysDrive)
+        return path.win32.normalize(`${msysDrive[1].toUpperCase()}:/${msysDrive[2]}`);
+    const normalized = path.win32.normalize(value);
+    return normalized.replace(/^([a-z]):/, (_, drive) => `${drive.toUpperCase()}:`);
+}

package/build/generated/version.js

@@ -1,2 +1,3 @@
-// Auto-generated by scripts/generate-version.mjs
-export const VERSION = "2.9.2";
+// Generated into build output by scripts/build.mjs
+export const VERSION = "2.9.5";
+export const GIT_HASH = "ade1510";

package/build/git/branches.js

@@ -1,9 +1,10 @@
 import { simpleGit } from "simple-git";
 import { FlowError } from "../flow-error.js";
+import { normalizeFilesystemCoordinate } from "../fs/path-coordinate.js";
 import { createGit, errorContainsAnyPattern, isGitExecutableUnavailable, NOT_GIT_REPOSITORY_PATTERNS, wrapGitError, } from "./core.js";
 export async function observeGitRepository(cwd) {
     try {
-        const git = simpleGit(cwd);
+        const git = simpleGit(normalizeFilesystemCoordinate(cwd));
         git.env("GIT_TERMINAL_PROMPT", "0");
         git.env("GCM_INTERACTIVE", "Never");
         git.env("GIT_MERGE_AUTOEDIT", "no");

package/build/git/core.js

@@ -1,4 +1,6 @@
+import { spawn } from "node:child_process";
 import { simpleGit } from "simple-git";
+import { normalizeFilesystemCoordinate } from "../fs/path-coordinate.js";
 import { getConfig } from "../config/env.js";
 import { appendDebugBlock } from "../telemetry/debug-log.js";
 const GIT_ERROR_COMPACT_MAX_CHARS = 4000;
@@ -38,6 +40,14 @@ export function errorContainsAnyPattern(err, patterns) {
     const text = collectGitErrorText(err);
     return patterns.some((pattern) => text.includes(pattern));
 }
+/** Parse `git rev-list` stdout into ordered object ids. Sole shared line parser. */
+export function parseRevListOutput(output) {
+    return output
+        .trim()
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
 export function wrapGitError(commandLabel, err, cwd) {
     const source = (err ?? {});
     const message = source.message ?? String(err);
@@ -57,9 +67,31 @@ export function wrapGitError(commandLabel, err, cwd) {
     }
     return wrapped;
 }
+/** Configured Git timeout, with a bootstrap-safe default before env loads. */
+export function resolveGitTimeoutMs() {
+    try {
+        return getConfig().git.timeoutMs;
+    }
+    catch {
+        // Git coordinates and early probes remain usable before config bootstrap.
+        return 60_000;
+    }
+}
+/** Non-interactive Git process environment shared by one-shot and streaming gates. */
+export function gitProcessEnv(extra) {
+    return {
+        ...process.env,
+        ...extra,
+        GIT_TERMINAL_PROMPT: "0",
+        GCM_INTERACTIVE: "Never",
+        GIT_MERGE_AUTOEDIT: "no",
+        LC_ALL: "C",
+        PATH: extra?.PATH ?? process.env.PATH ?? "",
+    };
+}
 export function createGit(cwd) {
-    const timeoutMs = getConfig().git.timeoutMs;
-    const git = simpleGit(cwd, {
+    const timeoutMs = resolveGitTimeoutMs();
+    const git = simpleGit(normalizeFilesystemCoordinate(cwd), {
         timeout: { block: timeoutMs, stdErr: true, stdOut: true },
     });
     git.env("GIT_TERMINAL_PROMPT", "0");
@@ -69,3 +101,75 @@ export function createGit(cwd) {
     git.env("PATH", process.env.PATH ?? "");
     return git;
 }
+/**
+ * Asynchronous one-shot Git process boundary that preserves stdout/stderr/status facts.
+ * Prefer `createGit` when non-zero exits are fatal; use this when callers need
+ * soft status codes or stdin (simple-git drops empty-stderr non-zero exits).
+ * Long-lived multi-request stdin/stdout sessions use `openGitStreamingBatch`.
+ */
+export async function runGitProcess(cwd, args, options) {
+    const timeoutMs = resolveGitTimeoutMs();
+    const env = gitProcessEnv(options?.env);
+    return await new Promise((resolve) => {
+        const child = spawn("git", [...args], {
+            cwd: normalizeFilesystemCoordinate(cwd),
+            env,
+            shell: false,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let settled = false;
+        let timedOut = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            resolve(result);
+        };
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGKILL");
+        }, timeoutMs);
+        if (options?.input !== undefined) {
+            child.stdin.end(options.input, "utf8");
+        }
+        else {
+            child.stdin.end();
+        }
+        child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+        child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+        child.on("error", (error) => {
+            finish({
+                stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+                stderr: Buffer.concat(stderrChunks).toString("utf8"),
+                status: null,
+                error,
+            });
+        });
+        child.on("close", (code, signal) => {
+            const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+            const stderr = Buffer.concat(stderrChunks).toString("utf8");
+            if (timedOut) {
+                finish({
+                    stdout,
+                    stderr,
+                    status: null,
+                    error: new Error("git timed out"),
+                });
+                return;
+            }
+            if (signal) {
+                finish({
+                    stdout,
+                    stderr,
+                    status: null,
+                    error: new Error(`git exited from signal ${signal}`),
+                });
+                return;
+            }
+            finish({ stdout, stderr, status: code });
+        });
+    });
+}

package/build/git/diff/parsers.js

@@ -32,8 +32,10 @@ export function parseUnifiedHunks(section) {
                     hunks.push({
                         header: current[0] ?? "",
                         lines: current.slice(1),
-                        newStart: parsed.start,
-                        newEnd: parsed.end,
+                        oldStart: parsed.oldStart,
+                        oldEnd: parsed.oldEnd,
+                        newStart: parsed.newStart,
+                        newEnd: parsed.newEnd,
                     });
                 }
             }
@@ -49,25 +51,33 @@ export function parseUnifiedHunks(section) {
             hunks.push({
                 header: current[0] ?? "",
                 lines: current.slice(1),
-                newStart: parsed.start,
-                newEnd: parsed.end,
+                oldStart: parsed.oldStart,
+                oldEnd: parsed.oldEnd,
+                newStart: parsed.newStart,
+                newEnd: parsed.newEnd,
             });
         }
     }
     return { prelude, hunks };
 }
-function parseHunkRange(hunkHeader) {
-    const match = hunkHeader.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+export 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))
+    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;
-    if (count <= 0)
-        return { start, end: start - 1 };
-    return { start, end: start + count - 1 };
+    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"));

package/build/git/diff/structured.js

@@ -0,0 +1,127 @@
+import { createGit, wrapGitError } from "../core.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 git = createGit(cwd);
+    const range = `${from}..${to}`;
+    const pathspec = diffPathspecArgs({ excludePaths: options.excludePaths });
+    try {
+        const [raw, numstat, patch] = await Promise.all([
+            git.raw(["diff", "--raw", "-z", "--find-renames", range, ...pathspec]),
+            git.raw(["diff", "--numstat", "-z", "--find-renames", range, ...pathspec]),
+            git.raw(["diff", "--no-color", "--no-ext-diff", "--unified=3", "--find-renames", range, ...pathspec]),
+        ]);
+        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/path-coordinate.js

@@ -0,0 +1,17 @@
+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));
+}

package/build/git/refs.js

@@ -0,0 +1,57 @@
+import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "./core.js";
+const ZERO_OBJECT_ID = "0000000000000000000000000000000000000000";
+async function resolveRefOrNull(cwd, ref) {
+    const git = createGit(cwd);
+    try {
+        return (await git.raw(["rev-parse", "--verify", ref])).trim();
+    }
+    catch (error) {
+        if (errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS))
+            return null;
+        throw wrapGitError(`rev-parse ${ref}`, error, cwd);
+    }
+}
+/** Create an immutable recovery ref, accepting an earlier identical attempt. */
+export async function createRecoveryRef(cwd, ref, objectId) {
+    const existing = await resolveRefOrNull(cwd, ref);
+    if (existing === objectId)
+        return;
+    if (existing !== null) {
+        throw new Error(`recovery ref ${ref} already resolves to ${existing}, not ${objectId}`);
+    }
+    const git = createGit(cwd);
+    try {
+        await git.raw(["update-ref", ref, objectId, ZERO_OBJECT_ID]);
+    }
+    catch (error) {
+        // Another identical attempt may have won the create race.
+        if (await resolveRefOrNull(cwd, ref) === objectId)
+            return;
+        throw wrapGitError(`update-ref ${ref}`, error, cwd);
+    }
+}
+/** Remove only the exact attempt ref, returning truthful non-fatal cleanup facts. */
+export async function deleteRecoveryRef(cwd, ref, objectId) {
+    try {
+        const existing = await resolveRefOrNull(cwd, ref);
+        if (existing === null)
+            return { ref, status: "already-absent" };
+        if (existing !== objectId) {
+            return {
+                ref,
+                status: "retained",
+                diagnostic: `ref resolves to ${existing}, not expected object ${objectId}`,
+            };
+        }
+        const git = createGit(cwd);
+        await git.raw(["update-ref", "-d", ref, objectId]);
+        return { ref, status: "removed" };
+    }
+    catch (error) {
+        return {
+            ref,
+            status: "retained",
+            diagnostic: wrapGitError(`update-ref -d ${ref}`, error, cwd).message,
+        };
+    }
+}