@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/flow-error.js

@@ -1,183 +0,0 @@
-import { ACTOR_IDENTITY, SETTINGS_PATH_SEGMENTS } from "./keiyaku-constants.js";
-import { formatArtifactDirectories, KEIYAKU_ARTIFACT_DIRS } from "./artifact-directories.js";
-const SETTINGS_DISPLAY_PATH = SETTINGS_PATH_SEGMENTS.join("/");
-const DEFAULT_HINT_CONTEXT = {
-    bindToolName: "bind",
-    arcToolName: "arc",
-    renewToolName: "renew",
-    closeToolName: "petition",
-    actorIdentity: ACTOR_IDENTITY,
-    availableActorNames: [],
-};
-const DEFAULT_ERROR_HINT = "Error details identify what must be corrected before retrying.";
-export function renderTemplate(template, values) {
-    return template.replace(/\$\{(?<key>[A-Za-z0-9_]+)\}/g, (match, _captured, _offset, _text, groups) => {
-        const key = groups?.key;
-        if (!key)
-            return match;
-        return Object.prototype.hasOwnProperty.call(values, key) ? values[key] : match;
-    });
-}
-function formatInvalidSettingsDiseaseHints(diseases) {
-    return diseases.map((disease) => {
-        const where = disease.knob ? `${disease.coordinate}:${disease.knob}` : `${disease.coordinate}:(root)`;
-        return `${where}: ${disease.reason}`;
-    });
-}
-/** CLI-owned typed hint table. Domain code supplies code + facts only. */
-export function resolveFlowErrorHints(code, context, facts) {
-    if (facts?.kind === "invalid_settings") {
-        return formatInvalidSettingsDiseaseHints(facts.diseases);
-    }
-    if (facts?.kind === "verification_failure") {
-        return [
-            `Fix failures from '${facts.label}', then retry CLAIM.`,
-            `stdout:\n${facts.stdout}`,
-            `stderr:\n${facts.stderr}`,
-        ];
-    }
-    if (facts?.kind === "dirty_worktree") {
-        return [
-            `Files under \`.keiyaku/\` are blocking the operation. Add ${formatArtifactDirectories(KEIYAKU_ARTIFACT_DIRS)} to \`.gitignore\` if you do not want those artifacts tracked.`,
-        ];
-    }
-    if (facts?.kind === "loose_commits") {
-        return [
-            `keiyaku @${facts.contractId} arc — opens a new arc to receipt them, then ${facts.nextVerb}`,
-        ];
-    }
-    if (facts?.kind === "needs_renew") {
-        return [`keiyaku @${facts.contractId} renew — renews delivery before petition`];
-    }
-    if (facts?.kind === "projection_in_flight") {
-        return ["keiyaku status — watch for the akuma to land, then renew"];
-    }
-    if (facts?.kind === "projection_wake_failure") {
-        return [];
-    }
-    switch (code) {
-        case "NOT_GIT_REPO":
-            return ["The provided `cwd` is not a git repository."];
-        case "GIT_UNAVAILABLE":
-            return ["Install Git, or use an explicitly bare command that does not require repository authority."];
-        case "ACTIVE_KEIYAKU_EXISTS":
-            return [`Next: open an arc with \`${context.arcToolName}\`, then use \`${context.renewToolName}\` when delivery must follow the current base, or \`${context.closeToolName}\` to settle it.`];
-        case "CONTRACT_AMBIGUOUS":
-            return ["Address a specific contract workspace, or use `call --bare` to run without contract attachment."];
-        case "TASK_AMBIGUOUS":
-            return ["Pass one complete task coordinate from the listed candidates."];
-        case "UNKNOWN_COMMAND":
-            return ["Run `keiyaku --help` to inspect available commands."];
-        case "UNKNOWN_OPTION":
-        case "UNKNOWN_ADDRESS":
-        case "INVALID_USAGE":
-        case "STDIN_EMPTY":
-            return [];
-        case "EMPTY_PARAM":
-            return ["One or more required parameters are empty."];
-        case "DIRTY_WORKTREE":
-            return ["The working tree has uncommitted changes."];
-        case "NOT_ACTIVE_KEIYAKU_BRANCH":
-            return ["keiyaku bind — opens a new contract"];
-        case "MISSING_KEIYAKU_BASE":
-            return ["Current branch is not associated with an active contract ledger."];
-        case "MISSING_PROTOCOL_FILES":
-            return ["Required protocol file is missing (`KEIYAKU.md`)."];
-        case "CLOSE_MERGE_CONFLICT":
-            return [];
-        case "RENEW_COORDINATE_DRIFT":
-            return [`Restore the delivery to its ledger-recorded history with Git reflog, then retry \`keiyaku ${context.renewToolName}\`.`];
-        case "RENEW_SCRATCH_NOT_FOUND":
-            return [`No renew conflict scratch is open; run \`keiyaku ${context.renewToolName}\` normally.`];
-        case "CLOSE_QUALITY_GATE_FAILED":
-            return [`CLAIM denied: a configured verification command failed. Use \`${context.arcToolName}\` after addressing the failure before petitioning again.`];
-        case "INVALID_BRANCH_TITLE":
-            return ["Title cannot be converted to a valid branch token for `keiyaku/<title>`."];
-        case "UNKNOWN_SUBAGENT": {
-            const names = context.availableActorNames.join(", ");
-            return [`Unknown ${context.actorIdentity.toLowerCase()} name. Valid options: ${names}.`];
-        }
-        case "FROM_DRAFT_NOT_FOUND":
-            return ["The path in `from_draft` does not exist. `from_draft` must reference an existing file path (absolute or relative to `cwd`)."];
-        case "INVALID_KEIYAKU_DRAFT":
-            return ["Invalid draft/input. Use a `# <title>` heading with non-empty `## Context`, `## Objective`, `## Design & Approach`, `## Scope`, `## Criteria`, and `## Verification` sections (or the equivalent shape in `from_draft`)."];
-        case "BIND_TASK_INCOMPLETE":
-            return ["Task supplies title/objective defaults; pipe only the missing sections as partial contract Markdown on stdin."];
-        case "KEIYAKU_FILE_EXISTS":
-            return [`\`${context.bindToolName}\` requires a clean slate. \`KEIYAKU.md\` must be removed before starting.`];
-        case "DETACHED_HEAD":
-            return ["Repository is in detached HEAD state. Address an active contract workspace before retrying."];
-        case "INVALID_RESPONSE_PATH":
-            return ["`keiyaku revive ARTIFACT_ID` needs a valid previous Keiyaku response artifact that includes complete provenance plus `session` and `subagent_name`."];
-        case "INVALID_CLOSE_INTENT":
-            return ["Invalid close intent. Valid values are `CLAIM` and `FORFEIT`."];
-        case "INVALID_SETTINGS":
-            return [`Fix invalid configuration in \`${SETTINGS_DISPLAY_PATH}\` and retry.`];
-        case "INVALID_EFFORT_OVERRIDE":
-            return ["Choose an effort value declared by the selected Akuma's effortOptions."];
-        case "CONCURRENT_MODIFICATION":
-            return [`Concurrent repository changes were detected during \`${context.arcToolName}\` or \`${context.renewToolName}\`. Retry on the latest branch state.`];
-        case "TASK_LOCK_ADMISSION_TIMEOUT":
-            return ["Task coordination did not become available before the bounded deadline. Retry the command; repeated timeouts indicate a stuck or damaged repository lock."];
-        case "INTERNAL_STATE":
-            return ["An internal state error occurred. Please verify your repository status."];
-        case "SCOPE_VIOLATION":
-            return ["Files outside the contract's declared scope were modified. Append ordered scope terms with `--append-scope`, amend the contract, or move the changes back."];
-        case "NO_OPEN_ARC":
-            return ["Open an arc to receipt delivery commits after the fence, then retry."];
-        case "REVIEW_REJECTED":
-            return [`CLAIM denied by the reviewer. Address the findings and retry \`${context.arcToolName}\` before petitioning again.`];
-        case "VERDICT_DENIED":
-        case "OATH_MISSING":
-            return [DEFAULT_ERROR_HINT];
-        default:
-            return [DEFAULT_ERROR_HINT];
-    }
-}
-function getDefaultErrorHint() {
-    return DEFAULT_ERROR_HINT;
-}
-export class FlowError extends Error {
-    code;
-    review;
-    facts;
-    constructor(code, message, options) {
-        super(message, options?.cause === undefined ? undefined : { cause: options.cause });
-        this.name = "FlowError";
-        this.code = code;
-        this.review = options?.review;
-        this.facts = options?.facts;
-    }
-}
-export function isFlowError(err) {
-    return err instanceof FlowError;
-}
-export function requireText(name, value) {
-    const normalized = value.trim();
-    if (!normalized) {
-        throw new FlowError("EMPTY_PARAM", `parameter '${name}' cannot be empty`);
-    }
-    return normalized;
-}
-export function asMessage(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-export function wrapFlowError(action, err) {
-    if (err instanceof Error && err.name === "AbortError") {
-        return err;
-    }
-    if (isFlowError(err)) {
-        return new FlowError(err.code, `${action} failed: ${err.message}`, {
-            cause: err,
-            review: err.review,
-            facts: err.facts,
-        });
-    }
-    return new Error(`${action} failed: ${asMessage(err)}`);
-}
-export function pickHintsFromError(err, hintContext = DEFAULT_HINT_CONTEXT) {
-    if (isFlowError(err)) {
-        return resolveFlowErrorHints(err.code, hintContext, err.facts);
-    }
-    return [getDefaultErrorHint()];
-}

package/build/fs/durability.js

@@ -1,27 +0,0 @@
-import * as fs from "node:fs";
-import * as fsPromises from "node:fs/promises";
-export function supportsDirectorySync(platform = process.platform) {
-    return platform !== "win32";
-}
-export function syncDirectorySync(directory, platform = process.platform) {
-    if (!supportsDirectorySync(platform))
-        return;
-    const descriptor = fs.openSync(directory, fs.constants.O_RDONLY);
-    try {
-        fs.fsyncSync(descriptor);
-    }
-    finally {
-        fs.closeSync(descriptor);
-    }
-}
-export async function syncDirectory(directory, platform = process.platform) {
-    if (!supportsDirectorySync(platform))
-        return;
-    const handle = await fsPromises.open(directory, "r");
-    try {
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-}

package/build/fs/path-coordinate.js

@@ -1,16 +0,0 @@
-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,3 +0,0 @@
-// Generated into build output by scripts/build.mjs
-export const VERSION = "2.9.12";
-export const GIT_HASH = "25d9570";

package/build/git/branches.js

@@ -1,113 +0,0 @@
-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(normalizeFilesystemCoordinate(cwd));
-        git.env("GIT_TERMINAL_PROMPT", "0");
-        git.env("GCM_INTERACTIVE", "Never");
-        git.env("GIT_MERGE_AUTOEDIT", "no");
-        git.env("LC_ALL", "C");
-        git.env("PATH", process.env.PATH ?? "");
-        const output = await git.raw(["rev-parse", "--is-inside-work-tree", "--is-bare-repository"]);
-        const [insideWorktree, bare] = output.trim().split(/\r?\n/);
-        return {
-            capability: "available",
-            coordinate: insideWorktree === "true" && bare !== "true" ? "repository" : "non-repository",
-        };
-    }
-    catch (err) {
-        if (isGitExecutableUnavailable(err))
-            return { capability: "unavailable" };
-        if (errorContainsAnyPattern(err, NOT_GIT_REPOSITORY_PATTERNS)) {
-            return { capability: "available", coordinate: "non-repository" };
-        }
-        return { capability: "unknown", error: wrapGitError("check-is-repo", err, cwd) };
-    }
-}
-export function assertGitObservation(observation, operation) {
-    if (observation.capability === "unavailable") {
-        throw new FlowError("GIT_UNAVAILABLE", `Git executable is unavailable; ${operation} requires repository authority.`);
-    }
-    if (observation.capability === "unknown")
-        throw observation.error;
-    return observation.coordinate;
-}
-export async function requireGitRepository(cwd, operation) {
-    if (assertGitObservation(await observeGitRepository(cwd), operation) === "non-repository") {
-        throw new FlowError("NOT_GIT_REPO", `${cwd} is not a git repository`);
-    }
-}
-export async function getCurrentBranch(cwd) {
-    const git = createGit(cwd);
-    let status;
-    try {
-        status = await git.status();
-    }
-    catch (err) {
-        throw wrapGitError("status", err, cwd);
-    }
-    if (!status.current) {
-        throw new FlowError("DETACHED_HEAD", "Detached HEAD or no branch found");
-    }
-    return status.current;
-}
-export async function listLocalBranches(cwd) {
-    const git = createGit(cwd);
-    let branches;
-    try {
-        branches = await git.branchLocal();
-    }
-    catch (err) {
-        throw wrapGitError("branch --list", err, cwd);
-    }
-    return branches.all;
-}
-export async function createAndSwitchBranch(cwd, branchName) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["switch", "-c", branchName]);
-    }
-    catch (err) {
-        throw wrapGitError(`switch -c ${branchName}`, err, cwd);
-    }
-}
-export async function switchBranch(cwd, branchName) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["switch", branchName]);
-    }
-    catch (err) {
-        throw wrapGitError(`switch ${branchName}`, err, cwd);
-    }
-}
-export async function deleteBranch(cwd, branchName, force = false) {
-    const git = createGit(cwd);
-    try {
-        await git.deleteLocalBranch(branchName, force);
-    }
-    catch (err) {
-        throw wrapGitError(`branch -d${force ? " -D" : ""} ${branchName}`, err, cwd);
-    }
-}
-export async function hasLocalBranch(cwd, branchName) {
-    const git = createGit(cwd);
-    let branches;
-    try {
-        branches = await git.branchLocal();
-    }
-    catch (err) {
-        throw wrapGitError("branch --list", err, cwd);
-    }
-    return branches.all.includes(branchName);
-}
-export async function assertValidBranchName(cwd, branchName) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["check-ref-format", "--branch", branchName]);
-    }
-    catch (err) {
-        throw wrapGitError(`check-ref-format --branch ${branchName}`, err, cwd);
-    }
-}

package/build/git/commits.js

@@ -1,80 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { createGit, wrapGitError } from "./core.js";
-export function shortCommitHash(hash) {
-    return hash.slice(0, 12);
-}
-export async function resolveCommitRef(cwd, ref) {
-    const git = createGit(cwd);
-    try {
-        const output = await git.raw(["rev-parse", "--verify", `${ref}^{commit}`]);
-        return output.trim();
-    }
-    catch (error) {
-        throw new FlowError("INVALID_COMMIT", `commit '${ref}' does not resolve to a commit`, { cause: error });
-    }
-}
-export async function isCommitReachableFromHead(cwd, commit) {
-    return isCommitAncestor(cwd, commit, "HEAD");
-}
-export async function isCommitAncestor(cwd, ancestor, descendant) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["merge-base", "--is-ancestor", ancestor, descendant]);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function getHeadCommitHash(cwd) {
-    const git = createGit(cwd);
-    try {
-        const output = await git.raw(["rev-parse", "HEAD"]);
-        return output.trim();
-    }
-    catch (error) {
-        throw wrapGitError("rev-parse HEAD", error, cwd);
-    }
-}
-export async function resolveCommitRefs(cwd, refs) {
-    if (refs.length === 0) {
-        throw new FlowError("INVALID_COMMIT", "commits must include at least one commit ref");
-    }
-    const resolved = [];
-    const seen = new Set();
-    for (const ref of refs) {
-        const trimmedRef = ref.trim();
-        if (!trimmedRef) {
-            throw new FlowError("INVALID_COMMIT", "commit refs cannot be empty");
-        }
-        const commit = await resolveCommitRef(cwd, trimmedRef);
-        if (seen.has(commit)) {
-            throw new FlowError("INVALID_COMMIT", `duplicate commit ref '${trimmedRef}' resolves to ${commit}`);
-        }
-        if (!(await isCommitReachableFromHead(cwd, commit))) {
-            throw new FlowError("INVALID_COMMIT", `commit '${trimmedRef}' (${commit}) is not reachable from HEAD`);
-        }
-        seen.add(commit);
-        resolved.push(commit);
-    }
-    return resolved;
-}
-export async function renderCommitStatPreview(cwd, commits) {
-    if (commits.length === 0)
-        return "No delivery commits recorded.";
-    const git = createGit(cwd);
-    try {
-        const chunks = await Promise.all(commits.map(async (commit) => (await git.raw([
-            "show",
-            "--stat",
-            "--summary",
-            "--format=commit %H%n%s",
-            "--no-renames",
-            commit,
-        ])).trim()));
-        return chunks.filter((chunk) => chunk.length > 0).join("\n\n");
-    }
-    catch (error) {
-        throw wrapGitError("show --stat delivery commits", error, cwd);
-    }
-}

package/build/git/core.js

@@ -1,238 +0,0 @@
-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;
-export const GIT_ABORT_FORCE_KILL_MS = 250;
-/** Terminate one non-detached Git child and wait until Node drains its stdio close. */
-export async function terminateGitChild(child, closed, graceMs = GIT_ABORT_FORCE_KILL_MS) {
-    if (child.exitCode === null && child.signalCode === null)
-        child.kill("SIGTERM");
-    let grace;
-    const exited = await Promise.race([
-        closed.then(() => true),
-        new Promise((resolve) => {
-            grace = setTimeout(() => resolve(false), graceMs);
-            grace.unref();
-        }),
-    ]);
-    if (grace)
-        clearTimeout(grace);
-    // Only the close event proves process exit and stdio drain. `killed` and
-    // `signalCode` merely report signal delivery and can be set while a handler
-    // keeps the child alive.
-    if (!exited)
-        child.kill("SIGKILL");
-    await closed;
-}
-export const MISSING_GIT_CONFIG_PATTERNS = ["No such section or key"];
-export const NOT_GIT_REPOSITORY_PATTERNS = ["not a git repository"];
-export const MISSING_HEAD_PATTERNS = [
-    "Needed a single revision",
-    "ambiguous argument 'HEAD'",
-    "unknown revision or path not in the working tree",
-    "bad revision 'HEAD'",
-];
-/** Accept only a complete object id from either supported Git object format. */
-export function isFullGitObjectId(value) {
-    return /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(value);
-}
-/** Git is an optional adapter for directory-local product surfaces. */
-export function isGitExecutableUnavailable(error) {
-    const source = (error ?? {});
-    if (source.code === "ENOENT")
-        return true;
-    const message = typeof source.message === "string" ? source.message : String(error);
-    return /spawn\s+git\s+ENOENT|git(?:\.exe)?["']?\s*:\s*(?:not found|no such file)/i.test(message);
-}
-export function compactText(input, maxChars = GIT_ERROR_COMPACT_MAX_CHARS) {
-    const text = input.trim();
-    if (!text)
-        return "";
-    if (text.length <= maxChars)
-        return text;
-    const marker = `\n...[truncated ${text.length - maxChars} chars]...\n`;
-    const side = Math.floor((maxChars - marker.length) / 2);
-    return `${text.slice(0, side)}${marker}${text.slice(text.length - side)}`;
-}
-export function collectGitErrorText(err) {
-    const source = (err ?? {});
-    return [source.message, source.stderr, source.stdErr, source.stdout, source.stdOut]
-        .filter((value) => typeof value === "string" && value.length > 0)
-        .join("\n");
-}
-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);
-    const stderr = compactText(source.stderr ?? source.stdErr ?? "");
-    const stdout = compactText(source.stdout ?? source.stdOut ?? "");
-    let detailedMessage = `[git ${commandLabel}] ${message}`;
-    if (stderr)
-        detailedMessage += `\n\n--- GIT STDERR ---\n${stderr}\n------------------`;
-    if (stdout)
-        detailedMessage += `\n\n--- GIT STDOUT ---\n${stdout}\n------------------`;
-    if (stderr || stdout) {
-        appendDebugBlock(`git ${commandLabel} failure details`, `${detailedMessage}`, { cwd, section: "git-error" });
-    }
-    const wrapped = new Error(detailedMessage, err === undefined ? undefined : { cause: err });
-    if (source.git !== undefined) {
-        Object.assign(wrapped, { git: source.git });
-    }
-    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 = resolveGitTimeoutMs();
-    const git = simpleGit(normalizeFilesystemCoordinate(cwd), {
-        timeout: { block: timeoutMs, stdErr: true, stdOut: true },
-    });
-    // simple-git replaces its child environment when configured through env().
-    // Preserve trace controls explicitly without admitting unrelated ambient Git
-    // behavior such as a pager into command execution.
-    const traceEnvironment = Object.fromEntries(Object.entries(process.env).filter(([key]) => key.startsWith("GIT_TRACE2")));
-    git.env({
-        ...traceEnvironment,
-        GIT_TERMINAL_PROMPT: "0",
-        GCM_INTERACTIVE: "Never",
-        GIT_MERGE_AUTOEDIT: "no",
-        LC_ALL: "C",
-        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 runGitProcessBytes(cwd, args, options) {
-    options?.signal?.throwIfAborted();
-    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;
-        let aborting = false;
-        let terminationPromise;
-        const closed = new Promise((resolveClosed) => child.once("close", () => resolveClosed()));
-        const finish = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeout);
-            options?.signal?.removeEventListener("abort", abort);
-            resolve(result);
-        };
-        const abort = () => {
-            if (aborting)
-                return;
-            aborting = true;
-            terminationPromise = terminateGitChild(child, closed);
-        };
-        options?.signal?.addEventListener("abort", abort, { once: true });
-        if (options?.signal?.aborted)
-            abort();
-        const timeout = setTimeout(() => {
-            timedOut = true;
-            child.kill("SIGKILL");
-        }, timeoutMs);
-        if (options?.input !== undefined) {
-            if (typeof options.input === "string")
-                child.stdin.end(options.input, "utf8");
-            else
-                child.stdin.end(options.input);
-        }
-        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),
-                stderr: Buffer.concat(stderrChunks),
-                status: null,
-                error,
-            });
-        });
-        child.on("close", async (code, signal) => {
-            if (terminationPromise)
-                await terminationPromise;
-            const stdout = Buffer.concat(stdoutChunks);
-            const stderr = Buffer.concat(stderrChunks);
-            if (timedOut) {
-                finish({
-                    stdout,
-                    stderr,
-                    status: null,
-                    error: new Error("git timed out"),
-                });
-                return;
-            }
-            if (signal) {
-                finish({
-                    stdout,
-                    stderr,
-                    status: null,
-                    error: options?.signal?.aborted
-                        ? options.signal.reason instanceof Error ? options.signal.reason : new DOMException("The operation was aborted", "AbortError")
-                        : new Error(`git exited from signal ${signal}`),
-                });
-                return;
-            }
-            finish({ stdout, stderr, status: code });
-        });
-    });
-}
-export async function runGitProcess(cwd, args, options) {
-    const result = await runGitProcessBytes(cwd, args, options);
-    return {
-        stdout: result.stdout.toString("utf8"),
-        stderr: result.stderr.toString("utf8"),
-        status: result.status,
-        ...(result.error ? { error: result.error } : {}),
-    };
-}