@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/flow-error.js

@@ -1,191 +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 [];
-    }
-    if (facts?.kind === "task_contract_workspace") {
-        return ["Select an active contract with a materialized workspace, or retry from the desired checkout with -C."];
-    }
-    if (facts?.kind === "carrier_dispatch_refusal") {
-        return [facts.recoveryCommand];
-    }
-    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 "CONTRACT_WORKSPACE_UNAVAILABLE":
-            return [];
-        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 fork 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.13";
-export const GIT_HASH = "0971934";

package/build/git/branches.js

@@ -1,84 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { errorContainsAnyPattern, isGitExecutableUnavailable, NOT_GIT_REPOSITORY_PATTERNS, wrapGitError, } from "./core.js";
-import { runGitOrThrow, runGitProcess } from "./process.js";
-async function gitOutput(cwd, args, label) {
-    try {
-        return (await runGitOrThrow(cwd, args)).stdout;
-    }
-    catch (error) {
-        throw wrapGitError(label, error, cwd);
-    }
-}
-function processFailure(result) {
-    return result.error ?? Object.assign(new Error(`git exited with status ${result.status ?? "unknown"}`), {
-        stdout: result.stdout,
-        stderr: result.stderr,
-        status: result.status,
-    });
-}
-export async function observeGitRepository(cwd) {
-    try {
-        const output = await runGitOrThrow(cwd, ["rev-parse", "--is-inside-work-tree", "--is-bare-repository"]);
-        const [insideWorktree, bare] = output.stdout.trim().split(/\r?\n/);
-        return {
-            capability: "available",
-            coordinate: insideWorktree === "true" && bare !== "true" ? "repository" : "non-repository",
-        };
-    }
-    catch (error) {
-        if (isGitExecutableUnavailable(error))
-            return { capability: "unavailable" };
-        if (errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS)) {
-            return { capability: "available", coordinate: "non-repository" };
-        }
-        return { capability: "unknown", error: wrapGitError("check-is-repo", error, 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 symbolic = await runGitProcess(cwd, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
-    if (symbolic.error || (symbolic.status !== 0 && symbolic.status !== 1)) {
-        throw wrapGitError("symbolic-ref --quiet --short HEAD", processFailure(symbolic), cwd);
-    }
-    if (symbolic.status === 1 || !symbolic.stdout.trim()) {
-        throw new FlowError("DETACHED_HEAD", "Detached HEAD or no branch found");
-    }
-    const head = await runGitProcess(cwd, ["rev-parse", "--verify", "--quiet", "HEAD"]);
-    if (head.error || (head.status !== 0 && head.status !== 1)) {
-        throw wrapGitError("rev-parse --verify HEAD", processFailure(head), cwd);
-    }
-    if (head.status === 0)
-        return symbolic.stdout.trim();
-    throw new FlowError("DETACHED_HEAD", "Detached HEAD or no branch found");
-}
-export async function listLocalBranches(cwd) {
-    const output = await gitOutput(cwd, ["for-each-ref", "--format=%(refname:short)", "refs/heads"], "branch --list");
-    return output.split(/\r?\n/).filter((branch) => branch.length > 0);
-}
-export async function createAndSwitchBranch(cwd, branchName) {
-    await gitOutput(cwd, ["switch", "-c", branchName], `switch -c ${branchName}`);
-}
-export async function switchBranch(cwd, branchName) {
-    await gitOutput(cwd, ["switch", branchName], `switch ${branchName}`);
-}
-export async function deleteBranch(cwd, branchName, force = false) {
-    await gitOutput(cwd, ["branch", force ? "-D" : "-d", branchName], `branch -d${force ? " -D" : ""} ${branchName}`);
-}
-export async function hasLocalBranch(cwd, branchName) {
-    return (await listLocalBranches(cwd)).includes(branchName);
-}
-export async function assertValidBranchName(cwd, branchName) {
-    await gitOutput(cwd, ["check-ref-format", "--branch", branchName], `check-ref-format --branch ${branchName}`);
-}

package/build/git/commits.js

@@ -1,151 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { isFullGitObjectId, runGitProcess, wrapGitError, } from "./core.js";
-import { runGitOrThrow } from "./process.js";
-const COMMIT_COORDINATE_FORMAT = "format:%H%x00%T%x00%P";
-/**
- * Resolve one revision to a peeled commit coordinate through a single argv-safe,
- * non-walking Git query. Ordinary commits and annotated tags share the peeled tip.
- * Missing revisions, non-commit terminal objects, malformed output, and process
- * failures stay distinguishable without matching localized presentation text.
- */
-export async function readCommitCoordinate(cwd, revision) {
-    const result = await runGitProcess(cwd, [
-        "log",
-        "--no-walk",
-        "-1",
-        `--format=${COMMIT_COORDINATE_FORMAT}`,
-        "--end-of-options",
-        revision,
-        "--",
-    ]);
-    if (result.error) {
-        return { status: "failed", revision, error: result.error, result };
-    }
-    if (result.status !== 0) {
-        return { status: "missing", revision };
-    }
-    const raw = result.stdout.replace(/(?:\r?\n)+$/, "");
-    if (raw.length === 0) {
-        return { status: "non-commit", revision };
-    }
-    const fields = raw.split("\0");
-    if (fields.length !== 3) {
-        return {
-            status: "malformed",
-            revision,
-            detail: `expected 3 NUL fields, received ${fields.length}`,
-        };
-    }
-    const [commit, tree, parentsField] = fields;
-    if (!isFullGitObjectId(commit) || !isFullGitObjectId(tree)) {
-        return {
-            status: "malformed",
-            revision,
-            detail: "commit or tree field is not a full object id",
-        };
-    }
-    const parents = parentsField.trim().length === 0
-        ? []
-        : parentsField.trim().split(/\s+/).filter((part) => part.length > 0);
-    if (parents.some((parent) => !isFullGitObjectId(parent))) {
-        return {
-            status: "malformed",
-            revision,
-            detail: "parent field contains a non-object id",
-        };
-    }
-    return { status: "ok", coordinate: { commit, tree, parents } };
-}
-/** Map a failed coordinate read into a wrapped Git error for throw-style callers. */
-export function commitCoordinateFailureError(read, cwd) {
-    if (read.status === "failed") {
-        const failure = read.error ?? Object.assign(new Error(read.result.stderr || `git log --no-walk exited ${read.result.status}`), {
-            stderr: read.result.stderr,
-            stdout: read.result.stdout,
-        });
-        return wrapGitError(`log --no-walk coordinate ${read.revision}`, failure, cwd);
-    }
-    if (read.status === "missing") {
-        return wrapGitError(`log --no-walk coordinate ${read.revision}`, Object.assign(new Error(`revision '${read.revision}' does not resolve`), { stderr: "" }), cwd);
-    }
-    if (read.status === "non-commit") {
-        return wrapGitError(`log --no-walk coordinate ${read.revision}`, Object.assign(new Error(`revision '${read.revision}' does not resolve to a commit`), { stderr: "" }), cwd);
-    }
-    return wrapGitError(`log --no-walk coordinate ${read.revision}`, Object.assign(new Error(`malformed commit coordinate for '${read.revision}': ${read.detail}`), { stderr: "" }), cwd);
-}
-/** Require a resolved coordinate or throw a wrapped Git error. */
-export async function requireCommitCoordinate(cwd, revision) {
-    const read = await readCommitCoordinate(cwd, revision);
-    if (read.status === "ok")
-        return read.coordinate;
-    throw commitCoordinateFailureError(read, cwd);
-}
-export function shortCommitHash(hash) {
-    return hash.slice(0, 12);
-}
-export async function resolveCommitRef(cwd, ref) {
-    const read = await readCommitCoordinate(cwd, ref);
-    if (read.status !== "ok") {
-        throw new FlowError("INVALID_COMMIT", `commit '${ref}' does not resolve to a commit`, {
-            cause: read.status === "failed" ? read.error : undefined,
-        });
-    }
-    return read.coordinate.commit;
-}
-export async function isCommitReachableFromHead(cwd, commit) {
-    return isCommitAncestor(cwd, commit, "HEAD");
-}
-export async function isCommitAncestor(cwd, ancestor, descendant) {
-    const result = await runGitProcess(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]);
-    return result.status === 0 && result.error === undefined;
-}
-export async function getHeadCommitHash(cwd) {
-    try {
-        const output = (await runGitOrThrow(cwd, ["rev-parse", "HEAD"])).stdout;
-        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.";
-    try {
-        const chunks = await Promise.all(commits.map(async (commit) => (await runGitOrThrow(cwd, [
-            "show",
-            "--stat",
-            "--summary",
-            "--format=commit %H%n%s",
-            "--no-renames",
-            commit,
-        ])).stdout.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,86 +0,0 @@
-import { simpleGit } from "simple-git";
-import { existsSync } from "node:fs";
-import { normalizeFilesystemCoordinate } from "../fs/path-coordinate.js";
-import { appendDebugBlock } from "../telemetry/debug-log.js";
-import { gitProcessEnv, resolveGitExecutable, resolveGitTimeoutMs } from "./process.js";
-export { GIT_ABORT_FORCE_KILL_MS, gitProcessEnv, openGitProcess, resolveGitExecutable, resolveGitTimeoutMs, runGitOrThrow, runGitProcess, runGitProcessBytes, terminateGitChild, } from "./process.js";
-const GIT_ERROR_COMPACT_MAX_CHARS = 4000;
-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 typeof source.gitCwd !== "string" || existsSync(source.gitCwd);
-    }
-    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;
-}
-export function createGit(cwd) {
-    const timeoutMs = resolveGitTimeoutMs();
-    const git = simpleGit(normalizeFilesystemCoordinate(cwd), {
-        binary: resolveGitExecutable(),
-        timeout: { block: timeoutMs, stdErr: true, stdOut: true },
-        unsafe: { allowUnsafeCustomBinary: true },
-    });
-    // simple-git replaces its child environment when configured through env().
-    git.env(gitProcessEnv());
-    return git;
-}