@a2f0/agent-tool 0.1.1

package/src/version/prepareVersions.ts

@@ -0,0 +1,135 @@
+import { loadConfig } from "../config";
+import { validateCommitSubject } from "../pr/validateCommitSubject";
+import { checkVersions, planVersions, rewriteVersions } from "./bumpVersions";
+import { assertBunLockVersions } from "./lockfileVersions";
+import {
+  assertAllowedPaths,
+  assertClean,
+  assertHead,
+  assertTracked,
+  changedPaths,
+  commitWithHooks,
+  git,
+  headOid,
+  runProjectCommand,
+} from "./versionPreparationGit";
+
+function commitPreparedVersions(
+  rootDir: string,
+  startHead: string,
+  allowed: readonly string[],
+  lockfile: string | null,
+  validate: readonly (readonly string[])[],
+  message: string,
+): void {
+  git(rootDir, ["add", "--", ...allowed]);
+  // A clean filter can make the staged blob differ from the checked file.
+  if (lockfile) assertBunLockVersions(rootDir, git(rootDir, ["show", `:${lockfile}`]));
+  const preparedTree = git(rootDir, ["write-tree"]);
+  for (const command of validate) runProjectCommand(rootDir, command);
+  assertHead(rootDir, startHead);
+  assertAllowedPaths(rootDir, allowed);
+  if (
+    git(rootDir, ["diff", "--name-only"]) ||
+    git(rootDir, ["write-tree"]) !== preparedTree
+  ) {
+    throw new Error("Validation changed the prepared files or index.");
+  }
+  commitWithHooks(rootDir, message);
+  if (
+    git(rootDir, ["rev-parse", "HEAD^", "HEAD^{tree}"]) !==
+    `${startHead}\n${preparedTree}`
+  ) {
+    throw new Error("The version commit differs from the prepared snapshot.");
+  }
+}
+
+/**
+ * Bump, refresh the lockfile, validate, and commit versions before a review
+ * snapshot. Writes one JSON receipt to stdout; diagnostics go to stderr.
+ */
+export function prepareVersions(rootDir: string, baseOid?: string): number {
+  const { lockfile, validate, commitMessage } = loadConfig(rootDir).versions;
+  validateCommitSubject(rootDir, commitMessage);
+  assertClean(rootDir);
+  if (lockfile) assertTracked(rootDir, lockfile);
+  const startHead = headOid(rootDir);
+  const plans = planVersions(rootDir, baseOid);
+  const baseCommit = git(rootDir, ["rev-parse", `${baseOid}^{commit}`]);
+  try {
+    git(rootDir, ["merge-base", "--is-ancestor", baseCommit, startHead]);
+  } catch {
+    throw new Error(
+      "Merge the pinned base into HEAD before preparing versions.",
+    );
+  }
+  const pending = plans.filter(
+    (plan) => plan.headVersion !== plan.targetVersion,
+  );
+  const allowed = [...pending.map((plan) => plan.manifest), ...(lockfile ? [lockfile] : [])];
+  let committed = false;
+  let lockfileChanged = false;
+  try {
+    assertHead(rootDir, startHead);
+    rewriteVersions(rootDir, baseCommit);
+    if (lockfile) {
+      // Also repairs a stale lockfile after a deliberate release or new package.
+      runProjectCommand(rootDir, ["bun", "install", "--lockfile-only", "--ignore-scripts"]);
+      assertBunLockVersions(rootDir);
+    }
+    assertHead(rootDir, startHead);
+    assertAllowedPaths(rootDir, allowed);
+    const changed = changedPaths(rootDir);
+    lockfileChanged = lockfile !== null && changed.includes(lockfile);
+    if (changed.length) {
+      commitPreparedVersions(rootDir, startHead, allowed, lockfile, validate, commitMessage);
+      committed = true;
+    }
+    if (checkVersions(rootDir, baseCommit) !== 0) {
+      throw new Error("Prepared versions do not match the pinned base.");
+    }
+    assertClean(rootDir);
+  } catch (error) {
+    // A clean starting tree permits a narrow rollback before a commit lands.
+    // Preserve intermediate state if another operation changed HEAD or other paths.
+    if (
+      headOid(rootDir) === startHead &&
+      changedPaths(rootDir).every((file) => allowed.includes(file))
+    ) {
+      if (allowed.length) {
+        git(rootDir, [
+          "restore",
+          `--source=${startHead}`,
+          "--staged",
+          "--worktree",
+          "--",
+          ...allowed,
+        ]);
+      }
+      process.stderr.write(
+        "Restored version manifests, lockfile, and index to the starting commit.\n",
+      );
+    } else {
+      process.stderr.write(
+        "Preserved intermediate state because HEAD or other files changed; inspect git status before retrying.\n",
+      );
+    }
+    throw error;
+  }
+  process.stdout.write(
+    `${JSON.stringify({
+      schemaVersion: 1,
+      baseOid: baseCommit,
+      startHead,
+      headOid: headOid(rootDir),
+      committed,
+      lockfileChanged,
+      versions: pending.map((plan) => ({
+        manifest: plan.manifest,
+        from: plan.headVersion,
+        to: plan.targetVersion,
+      })),
+    })}\n`,
+  );
+  return 0;
+}

package/src/version/resolveVersionConflicts.ts

@@ -0,0 +1,126 @@
+import { gitEnvironment } from "../git/environment";
+import { execFileSync, spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import {
+  isReleaseBump,
+  isVersionedManifest,
+  readVersion,
+  withVersion,
+} from "./packageVersion";
+
+const gitEnv = gitEnvironment();
+
+function git(rootDir: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd: rootDir,
+    env: gitEnv,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}
+
+function stage(rootDir: string, index: 1 | 2 | 3, file: string): string {
+  return git(rootDir, ["show", `:${index}:${file}`]);
+}
+
+/**
+ * Three-way merge a manifest with every side's version set to one version, so
+ * a version-only conflict merges cleanly: the branch's when it is a deliberate
+ * major or minor release over the incoming base, which `bumpVersions` keeps,
+ * and the base's otherwise. Null when anything besides the version still
+ * conflicts.
+ */
+function mergeIgnoringVersion(rootDir: string, file: string): string | null {
+  const ours = stage(rootDir, 2, file);
+  const theirs = stage(rootDir, 3, file);
+  const oursVersion = readVersion(ours);
+  const theirsVersion = readVersion(theirs);
+  const version = isReleaseBump(oursVersion, theirsVersion)
+    ? oursVersion
+    : theirsVersion;
+  const scratch = mkdtempSync(path.join(tmpdir(), "agent-tool-version-merge-"));
+  try {
+    const inputs = {
+      ours: withVersion(ours, version),
+      base: withVersion(stage(rootDir, 1, file), version),
+      theirs: withVersion(theirs, version),
+    };
+    const paths = Object.entries(inputs).map(([name, source]) => {
+      const scratchFile = path.join(scratch, name);
+      writeFileSync(scratchFile, source);
+      return scratchFile;
+    });
+    const result = spawnSync("git", ["merge-file", "-p", ...paths], {
+      cwd: rootDir,
+      env: gitEnv,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (result.error) {
+      throw result.error;
+    }
+    return result.status === 0 ? result.stdout : null;
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Finish an in-progress base merge whose only conflicts are the version field
+ * of versioned package.json files: take the base's version (or the branch's
+ * deliberate release) and stage the
+ * result, leaving the bump itself to `bumpVersions`. Touches nothing and exits
+ * non-zero when any conflict is something else.
+ */
+export function resolveVersionConflicts(rootDir: string): number {
+  const inMerge = spawnSync(
+    "git",
+    ["rev-parse", "-q", "--verify", "MERGE_HEAD"],
+    { cwd: rootDir, env: gitEnv, stdio: "ignore" },
+  );
+  if (inMerge.status !== 0) {
+    process.stderr.write("Error: no merge is in progress.\n");
+    return 1;
+  }
+  const conflicted = git(rootDir, [
+    "diff",
+    "--name-only",
+    "--diff-filter=U",
+    "-z",
+  ])
+    .split("\0")
+    .filter(Boolean);
+  if (conflicted.length === 0) {
+    process.stderr.write("Error: the merge has no conflicts to resolve.\n");
+    return 1;
+  }
+  const others = conflicted.filter(
+    (file) => !isVersionedManifest(rootDir, file),
+  );
+  if (others.length > 0) {
+    process.stderr.write(
+      `Error: conflicts outside the versioned package.json files: ${others.join(", ")}\n`,
+    );
+    return 1;
+  }
+  const resolved = new Map<string, string>();
+  for (const file of conflicted) {
+    const merged = mergeIgnoringVersion(rootDir, file);
+    if (merged === null) {
+      process.stderr.write(
+        `Error: ${file} conflicts beyond its version field.\n`,
+      );
+      return 1;
+    }
+    resolved.set(file, merged);
+  }
+  for (const [file, merged] of resolved) {
+    writeFileSync(path.join(rootDir, file), merged);
+    git(rootDir, ["add", "--", file]);
+    process.stderr.write(`Resolved the version conflict in ${file}.\n`);
+  }
+  return 0;
+}

package/src/version/versionPreparationGit.ts

@@ -0,0 +1,127 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { gitEnvironment } from "../git/environment";
+import { outsideExecutable } from "../review/executable";
+
+/** Helper Git operations run without hooks or replace objects. */
+export function git(rootDir: string, args: readonly string[]): string {
+  return execFileSync("git", ["--literal-pathspecs", ...args], {
+    cwd: rootDir,
+    env: gitEnvironment(),
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  }).replace(/\n$/u, "");
+}
+
+/** The version commit runs the project's hooks like any other commit. */
+export function commitWithHooks(rootDir: string, message: string): void {
+  const result = spawnSync("git", ["--literal-pathspecs", "commit", "-m", message], {
+    cwd: rootDir,
+    env: { ...process.env, GIT_NO_REPLACE_OBJECTS: "1" },
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  // Hook output is diagnostic; stdout is reserved for the preparation receipt.
+  process.stderr.write(result.stdout ?? "");
+  process.stderr.write(result.stderr ?? "");
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(`git commit failed (${result.signal ?? result.status}).`);
+  }
+}
+
+export function headOid(rootDir: string): string {
+  return git(rootDir, ["rev-parse", "HEAD"]);
+}
+
+export function assertHead(rootDir: string, expected: string): void {
+  if (headOid(rootDir) !== expected) {
+    throw new Error("HEAD changed during version preparation.");
+  }
+}
+
+export function changedPaths(rootDir: string): string[] {
+  return [
+    ...new Set(
+      [
+        git(rootDir, ["diff", "--name-only", "-z"]),
+        git(rootDir, ["diff", "--cached", "--name-only", "-z", "HEAD"]),
+        git(rootDir, ["ls-files", "--others", "--exclude-standard", "-z"]),
+      ].flatMap((output) => output.split("\0").filter(Boolean)),
+    ),
+  ];
+}
+
+export function assertClean(rootDir: string): void {
+  if (git(rootDir, ["status", "--porcelain", "--untracked-files=all"])) {
+    throw new Error("Version preparation requires a clean committed worktree.");
+  }
+  for (const state of [
+    "MERGE_HEAD",
+    "CHERRY_PICK_HEAD",
+    "REVERT_HEAD",
+    "rebase-merge",
+    "rebase-apply",
+  ]) {
+    const file = git(rootDir, ["rev-parse", "--git-path", state]);
+    if (existsSync(path.resolve(rootDir, file))) {
+      throw new Error(`Finish the in-progress Git operation (${state}) first.`);
+    }
+  }
+  try {
+    git(rootDir, ["symbolic-ref", "--quiet", "HEAD"]);
+  } catch {
+    throw new Error("Version preparation requires an attached branch.");
+  }
+}
+
+export function assertTracked(rootDir: string, file: string): void {
+  try {
+    git(rootDir, ["ls-files", "--error-unmatch", "--", file]);
+  } catch {
+    throw new Error(`${file} must be tracked; set versions.lockfile to null for projects without it.`);
+  }
+}
+
+export function assertAllowedPaths(
+  rootDir: string,
+  allowed: readonly string[],
+): void {
+  const unexpected = changedPaths(rootDir).filter(
+    (file) => !allowed.includes(file),
+  );
+  if (unexpected.length) {
+    throw new Error(
+      `Unexpected changes during version preparation: ${unexpected.join(", ")}`,
+    );
+  }
+}
+
+/**
+ * Run a project command found on PATH outside the repository, without a shell.
+ * Its logs are diagnostics; stdout is reserved for the preparation receipt.
+ */
+export function runProjectCommand(rootDir: string, argv: readonly string[]): void {
+  const [name, ...args] = argv;
+  const executable = outsideExecutable(name!, process.env, rootDir);
+  if (!executable) {
+    throw new Error(`${name} was not found on PATH outside the repository.`);
+  }
+  const result = spawnSync(executable.candidate, args, {
+    cwd: rootDir,
+    env: { ...process.env, GIT_NO_REPLACE_OBJECTS: "1" },
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  process.stderr.write(result.stdout ?? "");
+  process.stderr.write(result.stderr ?? "");
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(
+      `${argv.join(" ")} failed (${result.signal ?? result.status}).`,
+    );
+  }
+}