@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.1

package/src/ship.js

@@ -0,0 +1,344 @@
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
+import { envNumber, timerMs } from "./config.js";
+import {
+  assertWorktree,
+  classifyGitFailure,
+  describeGitFailure,
+  git,
+  gitAtLeast,
+  gitError,
+  withRepoLock,
+  worktreeRoot
+} from "./git.js";
+import { createPullRequest } from "./github.js";
+import { logWarn } from "./log.js";
+const MAX_PATCH = 2e5;
+async function branchDiff(repo, base, branch) {
+  const range = `${base}..${branch}`;
+  const safeDiff = ["-c", "core.fsmonitor=false", "diff", "--no-ext-diff", "--no-textconv"];
+  const numstat = await gitOrThrow([...safeDiff, "--numstat", "-M", "-z", range], repo);
+  const status = await gitOrThrow([...safeDiff, "--name-status", "-M", "-z", range], repo);
+  const patch = await gitOrThrow([...safeDiff, "--no-color", "-M", range], repo);
+  const statusTokens = status.split("\0").filter((t) => t !== "");
+  const kinds = /* @__PURE__ */ new Map();
+  for (let i = 0; i < statusTokens.length; i++) {
+    const code = statusTokens[i][0];
+    if (code === "R" || code === "C") {
+      kinds.set(statusTokens[i + 2], { status: "renamed", oldPath: statusTokens[i + 1] });
+      i += 2;
+    } else {
+      kinds.set(statusTokens[i + 1], { status: code === "A" ? "added" : code === "D" ? "deleted" : "modified" });
+      i += 1;
+    }
+  }
+  const counts = /* @__PURE__ */ new Map();
+  const numTokens = numstat.split("\0");
+  for (let i = 0; i < numTokens.length; i++) {
+    const token = numTokens[i];
+    if (!token) continue;
+    const [add = "", del = "", path = ""] = token.split("	");
+    let file = path;
+    if (!file) {
+      file = numTokens[i + 2] ?? "";
+      i += 2;
+    }
+    counts.set(file, { additions: Number(add) || 0, deletions: Number(del) || 0, binary: add === "-" });
+  }
+  const patches = /* @__PURE__ */ new Map();
+  for (const chunk of patch.split(/^diff --git /m).slice(1)) {
+    const header = chunk.slice(0, chunk.indexOf("\n"));
+    const target = header.match(/ b\/(.+)$/)?.[1];
+    if (target) patches.set(target, chunk.slice(chunk.indexOf("\n") + 1));
+  }
+  return [...kinds.entries()].map(([path, kind]) => {
+    const full = patches.get(path) ?? "";
+    const count = counts.get(path) ?? { additions: 0, deletions: 0, binary: false };
+    return {
+      path,
+      oldPath: kind.oldPath,
+      status: kind.status,
+      ...count,
+      patch: full.length > MAX_PATCH ? full.slice(0, MAX_PATCH) : full,
+      truncated: full.length > MAX_PATCH
+    };
+  });
+}
+async function checkedOutAt(repo, branch) {
+  const out = await gitOrThrow(["worktree", "list", "--porcelain"], repo);
+  let path;
+  for (const line of out.split("\n")) {
+    if (line.startsWith("worktree ")) path = line.slice("worktree ".length);
+    else if (line === `branch refs/heads/${branch}`) return path;
+  }
+  return void 0;
+}
+const CHECKOUT_TIMEOUT_MS = timerMs(envNumber("CODEFLOW_MERGE_TIMEOUT_SEC", 1800, { min: 1 }) * 1e3);
+async function mergeInto(repo, branch, into, message, expected) {
+  if ((await git(["show-ref", "--verify", "--quiet", `refs/heads/${into}`], repo)).code !== 0) {
+    throw new Error(`Branch "${into}" doesn't exist`);
+  }
+  return withRepoLock(repo, async () => {
+    if (expected) {
+      const [source, target] = await Promise.all([gitOrThrow(["rev-parse", branch], repo), gitOrThrow(["rev-parse", `refs/heads/${into}`], repo)]);
+      if (source.trim() !== expected.source || target.trim() !== expected.target) throw new Error("The result or merge target moved after validation. Validate the current merge target again.");
+    }
+    const checkout = await checkedOutAt(repo, into);
+    if (!checkout) await refuseIfBusy(repo, into);
+    return checkout ? mergeInCheckout(repo, checkout, expected?.source ?? branch, into, message, expected) : mergeByRef(repo, expected?.source ?? branch, into, message, expected);
+  });
+}
+async function refuseIfBusy(repo, into) {
+  const out = await gitOrThrow(["worktree", "list", "--porcelain"], repo);
+  const detached = [];
+  let path;
+  for (const line of out.split("\n")) {
+    if (line.startsWith("worktree ")) path = line.slice("worktree ".length);
+    else if (line === "detached" && path) detached.push(path);
+  }
+  const ref = `refs/heads/${into}`;
+  for (const wt of detached.filter((p) => existsSync(p))) {
+    const res = await git(["rev-parse", "--git-path", "rebase-merge/head-name", "--git-path", "rebase-apply/head-name", "--git-path", "BISECT_START"], wt);
+    if (res.code !== 0) continue;
+    const [merge = "", apply = "", bisect = ""] = res.stdout.split("\n").map((p) => resolve(wt, p.trim()));
+    const read = (file) => existsSync(file) ? readFileSync(file, "utf8").trim() : "";
+    if (read(merge) === ref || read(apply) === ref) {
+      throw new Error(`"${into}" is being rebased in ${wt}. Finish the rebase (\`git rebase --continue\`) or abort it (\`git rebase --abort\`) there, then merge again.`);
+    }
+    const started = read(bisect);
+    if (started === into || started === ref) {
+      throw new Error(`"${into}" is being bisected in ${wt}. End the bisect there (\`git bisect reset\`), then merge again.`);
+    }
+  }
+}
+async function mergeInCheckout(repo, checkout, branch, into, message, expected) {
+  if (!existsSync(checkout)) throw new Error(`"${into}" is checked out at ${checkout}, which no longer exists`);
+  const at = await assertWorktree(repo, { path: checkout, branch: into });
+  const status = await git(["status", "--porcelain", "--untracked-files=no"], at);
+  if (status.code !== 0) throw new Error(`Couldn't read the state of ${checkout}: ${gitError(["status"], status)}`);
+  if (status.stdout.trim()) {
+    throw new Error(`"${into}" is checked out at ${checkout} and has uncommitted changes. Commit or stash them, then merge again.`);
+  }
+  if (await midMerge(at)) throw new Error(`${checkout} is in the middle of another merge. Finish it, or run \`git merge --abort\` there, then merge again.`);
+  const lockPath = (await git(["rev-parse", "--git-path", "index.lock"], at)).stdout.trim();
+  const lock = lockPath && resolve(checkout, lockPath);
+  if (lock && existsSync(lock)) throw new Error(`Couldn't merge into ${into}: ${describeGitFailure("locked")} (${lock})`);
+  const before = (await gitOrThrow(["rev-parse", "HEAD"], at)).trim();
+  const merging = (await gitOrThrow(["rev-parse", branch], at)).trim();
+  if (expected && (before !== expected.target || merging !== expected.source)) throw new Error("The checkout moved after merge validation; validate the current target again");
+  const options = { timeoutMs: CHECKOUT_TIMEOUT_MS, hooks: !isInside(worktreeRoot(repo), checkout) };
+  const finish = async (commit, warning) => {
+    if (expected?.tree && (await gitOrThrow(["rev-parse", `${commit}^{tree}`], at)).trim() !== expected.tree) {
+      const status2 = await git(["status", "--porcelain", "--untracked-files=no"], at);
+      const stillOurCommit = (await gitOrThrow(["rev-parse", "HEAD"], at)).trim() === commit;
+      const rollback = status2.code === 0 && !status2.stdout.trim() && stillOurCommit ? await git(["reset", "--merge", expected.target], at) : void 0;
+      throw new Error(rollback?.code === 0 ? "A commit hook changed the verified merge tree. The merge was undone; review the hook and validate again." : "A commit hook changed the verified merge tree and the checkout changed afterwards. It was retained; inspect the checkout before proceeding.");
+    }
+    return { ok: true, commit, method: "checkout", ...warning ? { warning } : {} };
+  };
+  let res = await git(["merge", "--no-ff", ...expected?.tree ? ["--no-commit"] : [], "-m", message, branch], at, options);
+  if (res.code === 0 && expected?.tree) {
+    const tree = (await gitOrThrow(["write-tree"], at)).trim();
+    if (tree !== expected.tree) {
+      if (await midMerge(at)) {
+        const abort = await git(["merge", "--abort"], at, { timeoutMs: CHECKOUT_TIMEOUT_MS });
+        if (abort.code) throw new Error("The merge tree differed from the verified tree and abort failed. Inspect the checkout before proceeding.");
+      }
+      throw new Error("The merge produced a different tree than validation. No merge was committed; validate the current result again.");
+    }
+    if (await midMerge(at)) res = await git(["commit", "-m", message], at, options);
+  }
+  if (res.code === 0) return finish((await gitOrThrow(["rev-parse", "HEAD"], at)).trim());
+  if (res.timedOut) {
+    const head = (await git(["rev-parse", "HEAD"], at)).stdout.trim();
+    const parents = (await git(["log", "-1", "--format=%P", head], at)).stdout.trim();
+    if (head !== before && parents === `${before} ${merging}`) {
+      const after = CHECKOUT_TIMEOUT_MS >= 6e4 ? `${Math.round(CHECKOUT_TIMEOUT_MS / 6e4)} min` : `${Math.round(CHECKOUT_TIMEOUT_MS / 1e3)} s`;
+      const left2 = lock && existsSync(lock) ? `, and it left ${lock} behind; remove it once no git is running there` : "";
+      const warning = `Merged into ${into}, but git was stopped after ${after}, once the merge commit was made: a post-merge hook (an install, a download) may not have finished in ${checkout}${left2}.`;
+      logWarn(warning, { checkout, commit: head });
+      return finish(head, warning);
+    }
+  }
+  let kind = mergeFailure(res);
+  const conflicts = kind === "conflict" ? (await git(["diff", "--name-only", "--no-ext-diff", "--diff-filter=U"], at)).stdout.trim().split("\n").filter(Boolean) : [];
+  if (kind === "conflict" && !conflicts.length) kind = "other";
+  if (await midMerge(at)) {
+    const abort = await git(["merge", "--abort"], at, { timeoutMs: CHECKOUT_TIMEOUT_MS });
+    if (abort.code !== 0) {
+      throw new Error(`Merging into ${into} failed (${describeGitFailure(kind)}), and undoing it failed too: ${gitError(["merge", "--abort"], abort)}. Run \`git merge --abort\` in ${checkout}.`);
+    }
+  }
+  if (kind === "conflict") return { ok: false, conflicts, message: `Merging into ${into} would conflict` };
+  const left = res.timedOut && lock && existsSync(lock) ? ` It left ${lock} behind; remove it once no git is running there.` : "";
+  throw new Error(`Couldn't merge into ${into} at ${checkout}: ${describeGitFailure(kind)}${details(kind, res)}${left}`);
+}
+async function mergeByRef(repo, branch, into, message, expected) {
+  if (!await gitAtLeast(2, 38)) {
+    throw new Error(`Merging into "${into}" without checking it out needs git 2.38 or later. Check out ${into} somewhere and merge there, or upgrade git.`);
+  }
+  const intoSha = (await gitOrThrow(["rev-parse", `refs/heads/${into}`], repo)).trim();
+  const branchSha = (await gitOrThrow(["rev-parse", branch], repo)).trim();
+  if (expected && (intoSha !== expected.target || branchSha !== expected.source)) throw new Error("The result or merge target moved after validation; validate again");
+  const tree = await git(["merge-tree", "--write-tree", "--name-only", intoSha, branchSha], repo);
+  if (tree.code === 1) {
+    const lines = tree.stdout.split("\n");
+    const conflicts = lines.slice(1, lines.indexOf("") === -1 ? void 0 : lines.indexOf("")).filter(Boolean);
+    return { ok: false, conflicts, message: `Merging into ${into} would conflict` };
+  }
+  if (tree.code !== 0) throw new Error(gitError(["merge-tree", "--write-tree", into, branch], tree));
+  const treeId = tree.stdout.split("\n")[0].trim();
+  if (expected?.tree && treeId !== expected.tree) throw new Error("The merge produced a different tree than validation. No branch was changed; validate again.");
+  const commit = await git(["commit-tree", treeId, "-p", intoSha, "-p", branchSha, "-m", message], repo);
+  if (commit.code !== 0) throw new Error(`Couldn't make the merge commit: ${describeGitFailure(classifyGitFailure(commit))}${details("other", commit)}`);
+  const update = await git(["update-ref", `refs/heads/${into}`, commit.stdout.trim(), intoSha], repo);
+  if (update.code !== 0) {
+    const kind = classifyGitFailure(update);
+    throw new Error(kind === "locked" ? `Couldn't move ${into}: ${describeGitFailure(kind)}` : `${into} moved while merging, or couldn't be updated; merge again. ${gitError(["update-ref"], update)}`);
+  }
+  return { ok: true, commit: commit.stdout.trim(), method: "ref" };
+}
+const isInside = (dir, path) => {
+  const rel = relative(resolve(dir), resolve(path));
+  return !!rel && !rel.startsWith("..") && !isAbsolute(rel);
+};
+async function midMerge(checkout) {
+  return (await git(["rev-parse", "-q", "--verify", "MERGE_HEAD"], checkout)).code === 0;
+}
+function mergeFailure(res) {
+  const text = `${res.stderr}
+${res.stdout}`;
+  if (/Unable to write (?:new )?index/i.test(text)) return "locked";
+  const kind = classifyGitFailure(res);
+  return kind === "other" && /Not committing merge/i.test(text) ? "hook" : kind;
+}
+function details(kind, res) {
+  const text = `${res.stderr}
+${res.stdout}`;
+  const files = text.split("\n").filter((l) => /^\t\S/.test(l)).map((l) => l.trim());
+  if ((kind === "untracked" || kind === "dirty") && files.length) return `: ${files.slice(0, 10).join(", ")}${files.length > 10 ? ` and ${files.length - 10} more` : ""}. Move or commit them, then merge again.`;
+  const last = text.split("\n").map((l) => l.trim()).filter(Boolean).pop();
+  return last ? ` (git: ${last.slice(0, 300)})` : "";
+}
+async function remoteBranches(repo) {
+  const remote = await git(["remote", "get-url", "origin"], repo);
+  if (remote.code !== 0) throw new Error("This repository has no 'origin' remote to open a pull request on");
+  const out = await gitOrThrow(["ls-remote", "--symref", "origin", "HEAD", "refs/heads/*"], repo);
+  const branches = [];
+  let defaultBranch;
+  for (const line of out.split("\n")) {
+    const [left = "", ref = ""] = line.split("	");
+    if (left.startsWith("ref: refs/heads/") && ref === "HEAD") defaultBranch = left.slice("ref: refs/heads/".length);
+    else if (ref.startsWith("refs/heads/")) branches.push(ref.slice("refs/heads/".length));
+  }
+  return { branches, defaultBranch };
+}
+async function pullRequestTarget(repo, startedFrom) {
+  const { branches, defaultBranch } = await remoteBranches(repo);
+  if (startedFrom && branches.includes(startedFrom)) return startedFrom;
+  if (defaultBranch) return defaultBranch;
+  throw new Error("Pick a branch to open the pull request into");
+}
+async function openPullRequest(repo, branch, into, title, body, base, options = {}) {
+  const { branches, defaultBranch } = await remoteBranches(repo);
+  if (!branches.includes(into)) {
+    const instead = defaultBranch && defaultBranch !== into ? `, such as ${defaultBranch}` : "";
+    throw new Error(`"${into}" isn't a branch on GitHub (it may have been merged and deleted), so a pull request can't go into it. Pick another branch${instead}.`);
+  }
+  const caught = base && !options.expectedHead ? await catchUpWithSquashedBase(repo, branch, into, base) : {};
+  if (options.expectedHead && (await gitOrThrow(["rev-parse", `refs/heads/${branch}`], repo)).trim() !== options.expectedHead) throw new Error("The approved result moved before publication; review the current commit again");
+  const push = await git(options.expectedHead ? ["push", "origin", `${options.expectedHead}:refs/heads/${branch}`] : ["push", "-u", "origin", branch], repo, { hooks: true });
+  if (push.code !== 0) {
+    const kind = classifyGitFailure(push);
+    throw new Error(`Pushing ${branch} failed: ${kind === "other" ? push.stderr.trim().split("\n").slice(-2).join(" ") : describeGitFailure(kind)}`);
+  }
+  const url = await createPullRequest(repo, { base: into, head: branch, title, body });
+  return { url, caughtUp: caught.commit, note: caught.note };
+}
+async function catchUpWithSquashedBase(repo, branch, into, base) {
+  const target = `refs/remotes/origin/${into}`;
+  await gitOrThrow(["fetch", "--quiet", "origin", `+refs/heads/${into}:${target}`], repo);
+  if ((await git(["merge-base", "--is-ancestor", base, target], repo)).code === 0) return {};
+  const cantTell = (why) => {
+    const note = `Couldn't check whether the run's starting point was already squash-merged into ${into} (${why}); the pull request may show those changes again`;
+    logWarn(note, { repo, branch });
+    return { note };
+  };
+  if (!await gitAtLeast(2, 38)) return cantTell("that needs git 2.38 or later");
+  const merged = await git(["merge-tree", "--write-tree", target, base], repo);
+  if (merged.code === 1) return {};
+  if (merged.code !== 0) return cantTell(gitError(["merge-tree"], merged));
+  const targetTree = (await gitOrThrow(["rev-parse", `${target}^{tree}`], repo)).trim();
+  if (merged.stdout.split("\n")[0].trim() !== targetTree) return {};
+  const outcome = await mergeInto(repo, target, branch, `Merge origin/${into} into ${branch}`);
+  if (!outcome.ok) {
+    throw new Error(`origin/${into} conflicts with ${branch} in ${outcome.conflicts.join(", ")}. Merge it into the branch and resolve them, then open the pull request again.`);
+  }
+  return { commit: outcome.commit };
+}
+async function removeWorktrees(repo, worktrees, deleteBranches) {
+  return withRepoLock(repo, async () => {
+    const removed = [];
+    const deletedBranches = [];
+    const failed = [];
+    for (const wt of worktrees) {
+      if (existsSync(wt.path)) {
+        const unsafe = await assertWorktree(repo, { path: wt.path }).then(
+          () => void 0,
+          (err) => err.message
+        );
+        if (unsafe) {
+          failed.push(unsafe);
+          continue;
+        }
+        let res = await git(["worktree", "remove", "--force", wt.path], repo);
+        if (res.code !== 0) res = await git(["worktree", "remove", "--force", "--force", wt.path], repo);
+        if (res.code === 0) removed.push(wt.path);
+        else failed.push(`${wt.path}: ${shortError(res)}`);
+      }
+      if (deleteBranches && (await git(["show-ref", "--verify", "--quiet", `refs/heads/${wt.branch}`], repo)).code === 0) {
+        const res = await git(["branch", "-D", wt.branch], repo);
+        if (res.code === 0) deletedBranches.push(wt.branch);
+        else failed.push(`branch ${wt.branch}: ${shortError(res)}`);
+      }
+    }
+    await git(["worktree", "prune"], repo);
+    if (failed.length) logWarn(`Couldn't remove everything in ${repo}`, { failed });
+    return { removed, deletedBranches, failed };
+  });
+}
+function shortError(res) {
+  const kind = classifyGitFailure(res);
+  const last = (res.stderr.trim() || res.stdout.trim()).split("\n").pop()?.trim() ?? "";
+  return kind === "other" ? last.replace(/^(fatal|error):\s*/, "") || "git failed" : describeGitFailure(kind);
+}
+async function gitOrThrow(args, cwd) {
+  const res = await git(args, cwd);
+  if (res.code !== 0) throw new Error(`git ${args[0]} failed: ${res.stderr.trim() || res.stdout.trim()}`);
+  return res.stdout;
+}
+async function folderSizes(paths, timeoutMs = 3e4) {
+  const existing = paths.filter((p) => existsSync(p));
+  const sizes = {};
+  for (let i = 0; i < existing.length; i += 50) {
+    const batch = existing.slice(i, i + 50);
+    const out = await new Promise((resolve2) => {
+      execFile("du", ["-sk", ...batch], { timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024 }, (_err, stdout) => resolve2(stdout?.toString() ?? ""));
+    });
+    for (const line of out.split("\n")) {
+      const tab = line.indexOf("	");
+      if (tab > 0) sizes[line.slice(tab + 1)] = Number(line.slice(0, tab)) * 1024;
+    }
+  }
+  return sizes;
+}
+export {
+  branchDiff,
+  folderSizes,
+  mergeInto,
+  openPullRequest,
+  pullRequestTarget,
+  remoteBranches,
+  removeWorktrees
+};

package/src/slots.js

@@ -0,0 +1,74 @@
+class Slots {
+  constructor(size) {
+    this.size = size;
+  }
+  used = 0;
+  waiting = [];
+  activeGroups = /* @__PURE__ */ new Map();
+  lastGroup = "";
+  get busy() {
+    return this.used;
+  }
+  get queued() {
+    return this.waiting.length;
+  }
+  /** Resolves with a release function once a slot is free; rejects if `signal` aborts first. */
+  acquire(signal, opts = {}) {
+    const group = opts.group ?? "";
+    const priority = () => {
+      const value = typeof opts.priority === "function" ? opts.priority() : opts.priority ?? 0;
+      return Number.isFinite(value) ? value : 0;
+    };
+    if (signal?.aborted) return Promise.reject(new Error("aborted"));
+    if (this.used < this.size) {
+      this.used++;
+      this.activeGroups.set(group, (this.activeGroups.get(group) ?? 0) + 1);
+      this.lastGroup = group;
+      return Promise.resolve(this.releaser(group));
+    }
+    return new Promise((resolve, reject) => {
+      const entry = {
+        signal,
+        priority,
+        group,
+        grant: () => {
+          signal?.removeEventListener("abort", entry.onAbort);
+          this.used++;
+          this.activeGroups.set(group, (this.activeGroups.get(group) ?? 0) + 1);
+          this.lastGroup = group;
+          resolve(this.releaser(group));
+        },
+        onAbort: () => {
+          const i = this.waiting.indexOf(entry);
+          if (i >= 0) this.waiting.splice(i, 1);
+          reject(new Error("aborted"));
+        }
+      };
+      signal?.addEventListener("abort", entry.onAbort, { once: true });
+      this.waiting.push(entry);
+    });
+  }
+  releaser(group) {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.used--;
+      const remaining = (this.activeGroups.get(group) ?? 1) - 1;
+      if (remaining) this.activeGroups.set(group, remaining);
+      else this.activeGroups.delete(group);
+      let best = -1;
+      for (let i = 0; i < this.waiting.length; i++) {
+        const candidate = this.waiting[i];
+        const current = this.waiting[best];
+        const load = this.activeGroups.get(candidate.group) ?? 0;
+        const currentLoad = current ? this.activeGroups.get(current.group) ?? 0 : 0;
+        if (!current || candidate.priority() > current.priority() || candidate.priority() === current.priority() && (load < currentLoad || load === currentLoad && current.group === this.lastGroup && candidate.group !== this.lastGroup)) best = i;
+      }
+      if (best >= 0) this.waiting.splice(best, 1)[0].grant();
+    };
+  }
+}
+export {
+  Slots
+};