@brainervirus/workit-core 8.10.0 → 8.12.0

package/src/forge/pr-ops.ts

@@ -16,16 +16,20 @@
 // The merge call carries the head SHA (GitHub `sha=`, GitLab `sha=`), so a
 // head that moves after the gates refuses instead of merging unverified code.
 // --delete-branch deletes with a lease on that same SHA.
+// A squash with --subject/--body, or in a workspace with `trailers: false`,
+// sends its own message (the PR title and the branch's commits by default,
+// on stdin) with `Workit-Session:` lines dropped from each trailer block.
 import {
   requireGrant,
   resolveAutonomy,
   type AutonomySource,
   type DefaultEndpoint,
 } from "../autonomy";
-import { isProtectedTarget } from "../core/branch";
+import { branchKindOf, flowRoute, gitFlowOf, isProtectedTarget } from "../core/branch";
 import { vcsConfig } from "../core/vcs-config";
+import { workspaceTrailers } from "../core/workspaces";
 import { workspaceReleaseTracks } from "../core/release-tracks";
-import { deleteRemoteBranch } from "../git/ops";
+import { deleteRemoteBranch, stripSessionTrailers } from "../git/ops";
 import { spawnSync } from "node:child_process";
 import { currentBranch, fetchRefs, GIT_TIMEOUTS, remoteRefTip, resolveRef } from "../git/rev";
 import {
@@ -211,6 +215,7 @@ async function verifiedHead(
   sha: string,
   first: PrRef,
   sleep: Sleep,
+  base: string,
 ): Promise<ForgeResult<PrRef>> {
   let ref = first;
   for (const delay of [0, ...VERIFY_DELAYS_MS]) {
@@ -220,6 +225,7 @@ async function verifiedHead(
       owner: resolved.headRepo.split("/")[0] ?? null,
       projectId: resolved.headProjectId,
       sha,
+      base,
     });
     if (!found.ok) return found;
     if (found.data && found.data.number === first.number) ref = found.data;
@@ -258,10 +264,13 @@ export async function createPullRequest(
       "pass --base <branch>",
     );
 
+  // Head AND base: a release branch with an open PR into main still gets
+  // its back-merge PR into develop.
   const existing = resolved.forge.findPr(branch, {
     owner: resolved.headRepo.split("/")[0] ?? null,
     projectId: resolved.headProjectId,
     sha,
+    base: input.base,
   });
   if (!existing.ok) return existing;
   let created = false;
@@ -281,7 +290,7 @@ export async function createPullRequest(
     ref = made.data;
     created = true;
   }
-  const verified = await verifiedHead(resolved, branch, sha, ref, sleep);
+  const verified = await verifiedHead(resolved, branch, sha, ref, sleep, input.base);
   if (!verified.ok) return verified;
   const row = appendObserved(cwd, {
     type: "pr.created",
@@ -338,6 +347,9 @@ export type MergeInput = {
   expect?: { base: string; branch: string };
   /** Merge without a verdict (`merge: true` only); the reason is recorded. */
   unverified?: { reason: string };
+  /** Squash commit subject and body (`--subject`, `--body`); unset parts use the defaults. */
+  subject?: string;
+  body?: string;
 };
 
 export type MergeOutcome = {
@@ -366,13 +378,26 @@ export type MergeOutcome = {
 /**
  * The merge-back a merge into `base` owes: the track whose production branch
  * `base` is, by ownership alone (no --track, no WORKFLOW_RELEASE_TRACK, no
- * history). Best effort: a config problem never stops the pr.merged record.
+ * history); without tracks, a git-flow release/* or hotfix/* landing on the
+ * production branch owes develop. Best effort: a config problem never stops
+ * the pr.merged record.
  */
-const mergeBackFor = (cwd: string, base: string): { track: string | null; branches: string[] } => {
+const mergeBackFor = (
+  cwd: string,
+  base: string,
+  head: string,
+): { track: string | null; branches: string[] } => {
   try {
-    const owners = workspaceReleaseTracks(cwd).tracks.filter(
-      (track) => track.productionBranch === base,
-    );
+    const read = workspaceReleaseTracks(cwd);
+    if (!read.tracks.length) {
+      const flow = gitFlowOf(cwd);
+      const kind = branchKindOf(head);
+      const route = flow && kind ? flowRoute(flow, kind) : null;
+      return route?.mergeBack && route.target === base
+        ? { track: "git-flow", branches: [route.mergeBack] }
+        : { track: null, branches: [] };
+    }
+    const owners = read.tracks.filter((track) => track.productionBranch === base);
     if (owners.length !== 1) return { track: null, branches: [] };
     return {
       track: owners[0].name,
@@ -451,6 +476,90 @@ export function nextHint(next: string, number: number): string | null {
   }
 }
 
+/**
+ * The squash message workit sends, or null to leave the forge default: only a
+ * squash with --subject/--body or in a workspace with `trailers: false`.
+ * Defaults: the PR title (GitHub appends `(#n)` like its own default) and the
+ * branch's commits as GitHub lists them; Workit-Session lines never survive.
+ */
+function squashMessageFor(
+  cwd: string,
+  resolved: ResolvedForge,
+  input: MergeInput,
+  doc: PrStatusDoc,
+): ForgeResult<{ subject: string; body: string }> | null {
+  if (input.method !== "squash") return null;
+  if (input.subject === undefined && input.body === undefined && workspaceTrailers(cwd).enabled)
+    return null;
+  let subject = input.subject?.trim() ?? "";
+  if (!subject) {
+    const meta = resolved.forge.prMeta(doc.number);
+    if (!meta.ok) return meta;
+    subject =
+      resolved.forge.kind === "github" ? `${meta.data.title} (#${doc.number})` : meta.data.title;
+  }
+  // An explicit body is kept byte for byte but for its trailer block.
+  const body =
+    input.body === undefined
+      ? squashCommitList(cwd, resolved, doc.base, doc.head.sha)
+      : stripSessionTrailers(input.body, { subject: false });
+  return success({ subject, body });
+}
+
+/** Bounds of the generated squash body: a forge message, not an archive. */
+const SQUASH_LIST_MAX_COMMITS = 100;
+const SQUASH_LIST_MAX_CHARS = 60_000;
+
+/**
+ * `* subject` and body of each non-merge commit on `base..head`, oldest
+ * first, from the local clone ("" when absent); each commit loses its
+ * Workit-Session trailers, and past the bounds the rest is counted.
+ */
+function squashCommitList(
+  cwd: string,
+  resolved: ResolvedForge,
+  base: string,
+  head: string,
+): string {
+  const from =
+    resolveRef(cwd, `refs/remotes/${resolved.baseRemote}/${base}`) ??
+    resolveRef(cwd, `refs/heads/${base}`);
+  if (!from) return "";
+  const log = spawnSync(
+    "git",
+    ["log", "--reverse", "--no-merges", "--format=%B%x1e", `${from}..${head}`],
+    {
+      cwd,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUTS.local,
+      killSignal: "SIGKILL",
+      maxBuffer: 64 * 1024 * 1024,
+    },
+  );
+  if (log.status !== 0) return "";
+  const entries = log.stdout
+    .split("\x1e")
+    .map((message) => stripSessionTrailers(message.replace(/^\n+/u, ""), { subject: true }))
+    .filter((message) => message.trim())
+    .map((message) => {
+      const [subject = "", ...rest] = message.trimEnd().split("\n");
+      const body = rest.join("\n").replace(/^\n+/u, "");
+      return body ? `* ${subject}\n\n${body}` : `* ${subject}`;
+    });
+  const listed: string[] = [];
+  let size = 0;
+  for (const entry of entries) {
+    if (listed.length >= SQUASH_LIST_MAX_COMMITS || size + entry.length > SQUASH_LIST_MAX_CHARS)
+      break;
+    listed.push(entry);
+    size += entry.length + 2;
+  }
+  const more = entries.length - listed.length;
+  return [...listed, ...(more ? [`… and ${more} more commit${more === 1 ? "" : "s"}`] : [])].join(
+    "\n\n",
+  );
+}
+
 export async function mergePullRequest(
   cwd: string,
   resolved: ResolvedForge,
@@ -578,7 +687,13 @@ export async function mergePullRequest(
       { reason: "needs_verdict", verdict: summary },
     );
 
-  const merged = resolved.forge.merge(doc.number, { sha: head, method: input.method });
+  const squashMessage = squashMessageFor(cwd, resolved, input, doc);
+  if (squashMessage && !squashMessage.ok) return squashMessage;
+  const merged = resolved.forge.merge(doc.number, {
+    sha: head,
+    method: input.method,
+    ...(squashMessage ? { squashMessage: squashMessage.data } : {}),
+  });
   if (!merged.ok) return merged;
   // Post-verify: the forge must report the PR merged.
   let state = "open";
@@ -604,7 +719,7 @@ export async function mergePullRequest(
     deletedBranch =
       deleted.ok || (gone && gone.ok && gone.sha === null) ? true : { error: deleted.error };
   }
-  const mergeBack = mergeBackFor(cwd, doc.base);
+  const mergeBack = mergeBackFor(cwd, doc.base, branch);
   const row = appendObserved(cwd, {
     type: "pr.merged",
     actor: input.actor,

package/src/forge/types.ts

@@ -42,6 +42,11 @@ export type PrMatch = {
   projectId: number | null;
   /** A PR whose head is exactly this commit is ours whatever its owner. */
   sha: string | null;
+  /**
+   * Only a PR into this base: one head may have PRs into several bases (a
+   * git-flow release into main and its back-merge into develop).
+   */
+  base?: string | null;
 };
 
 /** One CI check (GitHub check run / commit status, GitLab job or bridge). */
@@ -135,6 +140,13 @@ export type CreatePrInput = {
   draft: boolean;
 };
 
+export type MergeOptions = {
+  sha: string;
+  method: MergeMethod;
+  /** Squash only: the commit message the forge writes instead of its default. */
+  squashMessage?: { subject: string; body: string };
+};
+
 export type MergeResult = {
   /** The merge (or squash/rebase tip) commit the forge reported, when it did. */
   mergeSha: string | null;
@@ -182,7 +194,7 @@ export interface Forge {
    * Merge with the head guard: the forge refuses (`blocked`, head_moved) when
    * the PR head is no longer `sha`.
    */
-  merge(n: number, options: { sha: string; method: MergeMethod }): ForgeResult<MergeResult>;
+  merge(n: number, options: MergeOptions): ForgeResult<MergeResult>;
   /** Retarget a PR/MR to another base branch (S12 stacks). */
   updateBase(n: number, base: string): ForgeResult<void>;
   /** Title, draft flag, base and state of one PR/MR. */