@astrosheep/keiyaku 0.1.11 → 0.1.13

package/build/utils/git-ops.js

@@ -0,0 +1,276 @@
+import { simpleGit } from "simple-git";
+import { appendDebugBlock } from "./debug-log.js";
+const DEFAULT_GIT_TIMEOUT_MS = 15 * 1000;
+function readPositiveIntEnv(name, fallback) {
+    const raw = process.env[name]?.trim();
+    if (!raw)
+        return fallback;
+    const value = Number.parseInt(raw, 10);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function readBooleanEnv(name, fallback) {
+    const raw = process.env[name]?.trim().toLowerCase();
+    if (!raw)
+        return fallback;
+    if (raw === "1" || raw === "true" || raw === "yes" || raw === "on")
+        return true;
+    if (raw === "0" || raw === "false" || raw === "no" || raw === "off")
+        return false;
+    return fallback;
+}
+function compactText(input, maxChars = 4000) {
+    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)}`;
+}
+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;
+}
+function createGit(cwd) {
+    const timeoutMs = readPositiveIntEnv("KEIYAKU_GIT_TIMEOUT_MS", DEFAULT_GIT_TIMEOUT_MS);
+    const git = simpleGit(cwd, {
+        timeout: { block: timeoutMs, stdErr: true, stdOut: true },
+    });
+    git.env("GIT_TERMINAL_PROMPT", "0");
+    git.env("GCM_INTERACTIVE", "Never");
+    git.env("GIT_ASKPASS", "false");
+    git.env("SSH_ASKPASS", "false");
+    git.env("GIT_EDITOR", "true");
+    git.env("GIT_MERGE_AUTOEDIT", "no");
+    git.env("LC_ALL", "C");
+    return git;
+}
+export async function isGitRepo(cwd) {
+    const git = createGit(cwd);
+    try {
+        return await git.checkIsRepo();
+    }
+    catch (err) {
+        throw wrapGitError("check-is-repo", err, cwd);
+    }
+}
+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 Error("Detached HEAD or no branch found");
+    }
+    return status.current;
+}
+export async function getActiveKeiyakuBranch(cwd) {
+    const current = await getCurrentBranch(cwd);
+    return current.startsWith("keiyaku/") ? current : null;
+}
+export async function listLocalKeiyakuBranches(cwd) {
+    const git = createGit(cwd);
+    let branches;
+    try {
+        branches = await git.branchLocal();
+    }
+    catch (err) {
+        throw wrapGitError("branch --list", err, cwd);
+    }
+    return branches.all.filter((name) => name.startsWith("keiyaku/"));
+}
+export async function createAndCheckoutBranch(cwd, branchName) {
+    const git = createGit(cwd);
+    try {
+        await git.checkoutLocalBranch(branchName);
+    }
+    catch (err) {
+        throw wrapGitError(`checkout -b ${branchName}`, err, cwd);
+    }
+}
+export async function checkoutBranch(cwd, branchName) {
+    const git = createGit(cwd);
+    try {
+        await git.checkout(branchName);
+    }
+    catch (err) {
+        throw wrapGitError(`checkout ${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 addFiles(cwd, files) {
+    const git = createGit(cwd);
+    try {
+        await git.add(files);
+    }
+    catch (err) {
+        throw wrapGitError("add", err, cwd);
+    }
+}
+export async function commit(cwd, message) {
+    const git = createGit(cwd);
+    const skipVerify = readBooleanEnv("KEIYAKU_GIT_NO_VERIFY", true);
+    const noGpgSign = readBooleanEnv("KEIYAKU_GIT_NO_GPG_SIGN", true);
+    const args = ["commit", "-m", message];
+    if (skipVerify)
+        args.push("--no-verify");
+    if (noGpgSign)
+        args.push("--no-gpg-sign");
+    try {
+        await git.raw(args);
+    }
+    catch (err) {
+        throw wrapGitError(args.join(" "), err, cwd);
+    }
+}
+export async function merge(cwd, branchName, message, options = {}) {
+    const git = createGit(cwd);
+    const { squash = true } = options;
+    const skipVerify = readBooleanEnv("KEIYAKU_GIT_NO_VERIFY", true);
+    const noGpgSign = readBooleanEnv("KEIYAKU_GIT_NO_GPG_SIGN", true);
+    if (!squash) {
+        const mergeOptions = [branchName, "--no-ff", "--no-edit", "-m", message];
+        if (skipVerify)
+            mergeOptions.push("--no-verify");
+        if (noGpgSign)
+            mergeOptions.push("--no-gpg-sign");
+        try {
+            await git.merge(mergeOptions);
+            return;
+        }
+        catch (err) {
+            throw wrapGitError(`merge ${mergeOptions.join(" ")}`, err, cwd);
+        }
+    }
+    const squashArgs = ["merge", "--squash", branchName];
+    try {
+        await git.raw(squashArgs);
+    }
+    catch (err) {
+        throw wrapGitError(squashArgs.join(" "), err, cwd);
+    }
+    const commitArgs = ["commit", "--allow-empty", "-m", message];
+    if (skipVerify)
+        commitArgs.push("--no-verify");
+    if (noGpgSign)
+        commitArgs.push("--no-gpg-sign");
+    try {
+        await git.raw(commitArgs);
+    }
+    catch (err) {
+        throw wrapGitError(commitArgs.join(" "), err, cwd);
+    }
+}
+export async function getUnmergedFiles(cwd) {
+    const git = createGit(cwd);
+    let output;
+    try {
+        output = await git.raw(["diff", "--name-only", "--diff-filter=U"]);
+    }
+    catch (err) {
+        throw wrapGitError("diff --name-only --diff-filter=U", err, cwd);
+    }
+    const files = output
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    return Array.from(new Set(files));
+}
+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 getDirtyFiles(cwd) {
+    const git = createGit(cwd);
+    let status;
+    try {
+        status = await git.status();
+    }
+    catch (err) {
+        throw wrapGitError("status --porcelain", err, cwd);
+    }
+    return status.files.map((f) => ({
+        path: f.path,
+        index: f.index,
+        working_dir: f.working_dir,
+    }));
+}
+export async function getDirtyPaths(cwd) {
+    const files = await getDirtyFiles(cwd);
+    return Array.from(new Set(files.map(f => f.path)));
+}
+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);
+    }
+}
+function branchBaseKey(branchName) {
+    return `branch.${branchName}.keiyakuBase`;
+}
+export async function setKeiyakuBase(cwd, branchName, baseBranch) {
+    const git = createGit(cwd);
+    try {
+        await git.raw(["config", branchBaseKey(branchName), baseBranch]);
+    }
+    catch (err) {
+        throw wrapGitError(`config ${branchBaseKey(branchName)} ${baseBranch}`, err, cwd);
+    }
+}
+export async function getKeiyakuBase(cwd, branchName) {
+    const git = createGit(cwd);
+    try {
+        const value = await git.raw(["config", "--get", branchBaseKey(branchName)]);
+        return value.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function clearKeiyakuBase(cwd, branchName) {
+    const git = createGit(cwd);
+    try {
+        await git.raw(["config", "--unset", branchBaseKey(branchName)]);
+    }
+    catch {
+        // Branch config may already be absent.
+    }
+}