@cvr/stacked 0.4.2 → 0.4.4

package/src/commands/detect.ts

@@ -5,6 +5,8 @@ import { StackService } from "../services/Stack.js";
 import { success, warn, info } from "../ui.js";
 import { detectLimitConfig, limitUntrackedBranches } from "./helpers/detect.js";
 
+const DETECT_COMMIT_LIMIT = 2048;
+
 const dryRunFlag = Flag.boolean("dry-run").pipe(
   Flag.withDescription("Show what would be detected without making changes"),
 );
@@ -26,8 +28,11 @@ export const detect = Command.make("detect", { dryRun: dryRunFlag, json: jsonFla
       const candidates = allBranches.filter((b) => b !== trunk);
 
       const data = yield* stacks.load();
-      const alreadyTracked = new Set(Object.values(data.stacks).flatMap((s) => [...s.branches]));
-      const untrackedAll = candidates.filter((b) => !alreadyTracked.has(b));
+      const alreadyTracked = new Set(Object.keys(data.branches));
+      const mergedBranches = new Set(data.mergedBranches);
+      const untrackedAll = candidates.filter(
+        (b) => !alreadyTracked.has(b) && !mergedBranches.has(b),
+      );
       const detectLimit = yield* detectLimitConfig;
       const { untracked, skipped } = limitUntrackedBranches(untrackedAll, detectLimit);
 
@@ -42,42 +47,63 @@ export const detect = Command.make("detect", { dryRun: dryRunFlag, json: jsonFla
         );
       }
 
-      // Build parent map: for each branch, find its direct parent among other branches
-      // A parent is the closest ancestor — i.e., an ancestor that is not an ancestor of another ancestor
       const childOf = new Map<string, string>();
+      const unclassified: string[] = [];
+
+      const tipResults = yield* Effect.forEach(
+        untracked,
+        (branch) =>
+          git.revParse(branch).pipe(
+            Effect.map((oid) => [branch, oid] as const),
+            Effect.catchTag("GitError", () => Effect.succeed(null)),
+          ),
+        { concurrency: 5 },
+      );
+
+      const tipOwners = new Map<string, string[]>();
+      for (const result of tipResults) {
+        if (result === null) continue;
+        const [branch, oid] = result;
+        const owners = tipOwners.get(oid) ?? [];
+        owners.push(branch);
+        tipOwners.set(oid, owners);
+      }
 
       yield* Effect.forEach(
         untracked,
         (branch) =>
           Effect.gen(function* () {
-            // Check all potential ancestors (trunk + other untracked) in parallel
-            const potentialAncestors = [trunk, ...untracked.filter((b) => b !== branch)];
-            const ancestryResults = yield* Effect.forEach(
-              potentialAncestors,
-              (other) =>
-                git.isAncestor(other, branch).pipe(
-                  Effect.catchTag("GitError", () => Effect.succeed(false)),
-                  Effect.map((is) => [other, is] as const),
-                ),
-              { concurrency: 5 },
-            );
-
-            const ancestors = ancestryResults.filter(([_, is]) => is).map(([name]) => name);
-
-            if (ancestors.length === 0) return;
-
-            // Find the closest ancestor — the one that is a descendant of all others
-            let closest = ancestors[0] ?? trunk;
-            for (let i = 1; i < ancestors.length; i++) {
-              const candidate = ancestors[i];
-              if (candidate === undefined) continue;
-              const candidateIsCloser = yield* git
-                .isAncestor(closest, candidate)
-                .pipe(Effect.catchTag("GitError", () => Effect.succeed(false)));
-              if (candidateIsCloser) closest = candidate;
+            const commits = yield* git
+              .firstParentUniqueCommits(branch, trunk, { limit: DETECT_COMMIT_LIMIT })
+              .pipe(Effect.catchTag("GitError", () => Effect.succeed([])));
+
+            if (commits.length === 0) {
+              unclassified.push(branch);
+              return;
+            }
+
+            let parent: string | null = null;
+            let ambiguous = false;
+
+            for (const oid of commits) {
+              const owners = (tipOwners.get(oid) ?? []).filter((owner) => owner !== branch);
+              if (owners.length > 1) {
+                ambiguous = true;
+                break;
+              }
+              const [owner] = owners;
+              if (owner !== undefined) {
+                parent = owner;
+                break;
+              }
+            }
+
+            if (ambiguous || (commits.length >= DETECT_COMMIT_LIMIT && parent === null)) {
+              unclassified.push(branch);
+              return;
             }
 
-            childOf.set(branch, closest);
+            childOf.set(branch, parent ?? trunk);
           }),
         { concurrency: 5 },
       );
@@ -137,8 +163,8 @@ export const detect = Command.make("detect", { dryRun: dryRunFlag, json: jsonFla
       for (const chain of chains) {
         const name = chain[0];
         if (name === undefined) continue;
-        const currentData = yield* stacks.load();
-        if (currentData.stacks[name] !== undefined) {
+        const existing = yield* stacks.getStack(name);
+        if (existing !== null) {
           yield* warn(`Stack "${name}" already exists, skipping: ${chain.join(" → ")}`);
           continue;
         }
@@ -162,6 +188,12 @@ export const detect = Command.make("detect", { dryRun: dryRunFlag, json: jsonFla
           yield* Console.error(`  ${fork.branch} → ${fork.children.join(", ")}`);
         }
       }
+
+      if (unclassified.length > 0 && !json) {
+        yield* warn(
+          `Skipped ${unclassified.length} unclassified branch${unclassified.length === 1 ? "" : "es"}: ${unclassified.join(", ")}`,
+        );
+      }
     }),
   ),
 );

package/src/commands/doctor.ts

@@ -26,6 +26,14 @@ export const doctor = Command.make("doctor", { fix: fixFlag, json: jsonFlag }).p
 
       const data = yield* stacks.load();
       const findings: Finding[] = [];
+      const stackEntries = yield* stacks.listStacks().pipe(
+        Effect.catchTag("StackError", (error) =>
+          Effect.sync(() => {
+            findings.push({ type: "parse_error", message: error.message, fixed: false });
+            return [] as const;
+          }),
+        ),
+      );
 
       // Check 1: trunk branch exists
       const trunkExists = yield* git
@@ -58,14 +66,14 @@ export const doctor = Command.make("doctor", { fix: fixFlag, json: jsonFlag }).p
       }
 
       // Check 2: all tracked branches exist in git
-      for (const [stackName, stack] of Object.entries(data.stacks)) {
+      for (const { name: stackName, stack } of stackEntries) {
         for (const branch of stack.branches) {
           const exists = yield* git
             .branchExists(branch)
             .pipe(Effect.catchTag("GitError", () => Effect.succeed(false)));
           if (!exists) {
             if (fix) {
-              yield* stacks.removeBranch(stackName, branch);
+              yield* stacks.removeBranch(branch);
               findings.push({
                 type: "stale_branch",
                 message: `Removed stale branch "${branch}" from stack "${stackName}"`,
@@ -84,12 +92,10 @@ export const doctor = Command.make("doctor", { fix: fixFlag, json: jsonFlag }).p
 
       // Check 3: no branches in multiple stacks
       const branchToStacks = new Map<string, string[]>();
-      for (const [stackName, stack] of Object.entries(data.stacks)) {
-        for (const branch of stack.branches) {
-          const existing = branchToStacks.get(branch) ?? [];
-          existing.push(stackName);
-          branchToStacks.set(branch, existing);
-        }
+      for (const [branch, record] of Object.entries(data.branches)) {
+        const existing = branchToStacks.get(branch) ?? [];
+        existing.push(record.stack);
+        branchToStacks.set(branch, existing);
       }
       for (const [branch, stackNames] of branchToStacks) {
         if (stackNames.length > 1) {

package/src/commands/helpers/pr-metadata.ts

@@ -0,0 +1,131 @@
+import type { ServiceMap } from "effect";
+import { Effect } from "effect";
+import type { GitHubService } from "../../services/GitHub.js";
+
+const STACKED_MARKER_START = "<!-- stacked -->";
+const STACKED_MARKER_END = "<!-- /stacked -->";
+
+type PullRequest = {
+  number: number;
+  url: string;
+  state: string;
+  body?: string | null;
+} | null;
+
+type GitHubApi = ServiceMap.Service.Shape<typeof GitHubService>;
+
+export const generateStackMetadata = (
+  branches: readonly string[],
+  prMap: Map<string, PullRequest>,
+  currentIdx: number,
+  stackName: string,
+): string => {
+  const rows = branches.map((branch, i) => {
+    const pr = prMap.get(branch) ?? null;
+    const isCurrent = i === currentIdx;
+    const branchCol = isCurrent ? `**\`${branch}\`**` : `\`${branch}\``;
+    const numCol = i + 1;
+    const numStr = isCurrent ? `**${numCol}**` : `${numCol}`;
+
+    let prCol: string;
+    if (pr === null) {
+      prCol = "—";
+    } else if (pr.state === "MERGED") {
+      prCol = `[#${pr.number}](${pr.url}) ✅`;
+    } else if (isCurrent) {
+      prCol = `**#${pr.number} ← you are here**`;
+    } else {
+      prCol = `[#${pr.number}](${pr.url})`;
+    }
+
+    return `| ${numStr} | ${branchCol} | ${prCol} |`;
+  });
+
+  return [
+    STACKED_MARKER_START,
+    `**Stack: \`${stackName}\`** (${currentIdx + 1} of ${branches.length})`,
+    "",
+    "| # | Branch | PR |",
+    "|---|--------|----|",
+    ...rows,
+    STACKED_MARKER_END,
+  ].join("\n");
+};
+
+export const composePRBody = (userBody: string | undefined, metadata: string): string => {
+  if (userBody !== undefined) {
+    return `${userBody}\n\n---\n\n${metadata}`;
+  }
+  return metadata;
+};
+
+export const updatePRBody = (
+  existingBody: string | undefined,
+  userBody: string | undefined,
+  metadata: string,
+): string => {
+  if (userBody !== undefined) {
+    return composePRBody(userBody, metadata);
+  }
+
+  if (existingBody !== undefined) {
+    const startIdx = existingBody.indexOf(STACKED_MARKER_START);
+    if (startIdx !== -1) {
+      const prefix = existingBody.substring(0, startIdx).replace(/\n*---\n*$/, "");
+      if (prefix.trim().length > 0) {
+        return `${prefix.trim()}\n\n---\n\n${metadata}`;
+      }
+      return metadata;
+    }
+    return `${existingBody.trim()}\n\n---\n\n${metadata}`;
+  }
+
+  return metadata;
+};
+
+export const refreshStackedPRBodies = ({
+  branches,
+  stackName,
+  gh,
+  initialPrMap,
+  shouldUpdateBranch,
+  getUserBody,
+}: {
+  branches: readonly string[];
+  stackName: string;
+  gh: GitHubApi;
+  initialPrMap?: Map<string, PullRequest>;
+  shouldUpdateBranch?: (branch: string) => boolean;
+  getUserBody?: (branch: string, idx: number) => string | undefined;
+}) =>
+  Effect.gen(function* () {
+    const prEntries = yield* Effect.all(
+      branches.map((branch) => {
+        const existing = initialPrMap?.get(branch);
+        if (existing !== undefined) {
+          return Effect.succeed([branch, existing] as const);
+        }
+        return gh.getPR(branch).pipe(Effect.map((pr) => [branch, pr] as const));
+      }),
+    );
+    const prMap = new Map(prEntries);
+
+    for (let i = 0; i < branches.length; i++) {
+      const branch = branches[i];
+      if (branch === undefined) continue;
+      if (shouldUpdateBranch !== undefined && !shouldUpdateBranch(branch)) continue;
+
+      const existingPrData = prMap.get(branch) ?? null;
+      if (existingPrData === null || existingPrData.state !== "OPEN") continue;
+
+      const metadata = generateStackMetadata(branches, prMap, i, stackName);
+      const body = updatePRBody(
+        existingPrData.body ?? undefined,
+        getUserBody?.(branch, i),
+        metadata,
+      );
+      yield* gh.updatePR({ branch, body });
+    }
+
+    return prMap;
+  });

package/src/commands/list.ts

@@ -25,15 +25,14 @@ export const list = Command.make("list", { stackName: stackNameArg, json: jsonFl
       const stacks = yield* StackService;
 
       const currentBranch = yield* git.currentBranch();
-      const data = yield* stacks.load();
-      const trunk = data.trunk;
+      const trunk = yield* stacks.getTrunk();
 
       let targetStackName: string | null = null;
       let targetStack: { readonly branches: readonly string[] } | null = null;
 
       if (Option.isSome(stackName)) {
-        const s = data.stacks[stackName.value];
-        if (s === undefined) {
+        const s = yield* stacks.getStack(stackName.value);
+        if (s === null) {
           return yield* new StackError({
             code: ErrorCode.STACK_NOT_FOUND,
             message: `Stack "${stackName.value}" not found`,

package/src/commands/rename.ts

@@ -16,27 +16,23 @@ export const rename = Command.make("rename", { old: oldArg, new: newArg, json: j
   Command.withHandler(({ old: oldName, new: newName, json }) =>
     Effect.gen(function* () {
       const stacks = yield* StackService;
-
-      const data = yield* stacks.load();
-
-      if (data.stacks[oldName] === undefined) {
+      const existing = yield* stacks.getStack(oldName);
+      if (existing === null) {
         return yield* new StackError({
           code: ErrorCode.STACK_NOT_FOUND,
           message: `Stack "${oldName}" not found`,
         });
       }
 
-      if (data.stacks[newName] !== undefined) {
+      const collision = yield* stacks.getStack(newName);
+      if (collision !== null) {
         return yield* new StackError({
           code: ErrorCode.STACK_EXISTS,
           message: `Stack "${newName}" already exists`,
         });
       }
 
-      const stack = data.stacks[oldName];
-      if (stack === undefined) return;
-      const { [oldName]: _, ...rest } = data.stacks;
-      yield* stacks.save({ ...data, stacks: { ...rest, [newName]: stack } });
+      yield* stacks.renameStack(oldName, newName);
 
       if (json) {
         // @effect-diagnostics-next-line effect/preferSchemaOverJson:off

package/src/commands/reorder.ts

@@ -74,28 +74,22 @@ export const reorder = Command.make("reorder", {
         });
       }
 
-      // Remove from current position
-      branches.splice(currentIdx, 1);
-
-      // Insert at target position
-      const newTargetIdx = branches.indexOf(target);
-      if (Option.isSome(before)) {
-        branches.splice(newTargetIdx, 0, branch);
-      } else {
-        branches.splice(newTargetIdx + 1, 0, branch);
-      }
-
-      const data = yield* stacks.load();
-      yield* stacks.save({
-        ...data,
-        stacks: { ...data.stacks, [stackName]: { branches } },
+      const updated = yield* stacks.reorderBranch(branch, {
+        before: Option.getOrUndefined(before),
+        after: Option.getOrUndefined(after),
       });
 
       if (json) {
         // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
-        yield* Console.log(JSON.stringify({ branch, stack: stackName, branches }, null, 2));
+        yield* Console.log(
+          JSON.stringify(
+            { branch, stack: updated.name, branches: [...updated.stack.branches] },
+            null,
+            2,
+          ),
+        );
       } else {
-        yield* success(`Moved "${branch}" in stack "${stackName}"`);
+        yield* success(`Moved "${branch}" in stack "${updated.name}"`);
         yield* warn("Run 'stacked sync' to rebase branches in new order");
       }
     }),

package/src/commands/split.ts

@@ -35,17 +35,9 @@ export const split = Command.make("split", {
       }
 
       const { name: stackName, stack } = result;
-      const branches = [...stack.branches];
-      const splitIdx = branches.indexOf(branch);
-
-      if (splitIdx === 0) {
-        return yield* new StackError({
-          message: `Branch "${branch}" is at the bottom of the stack — nothing to split`,
-        });
-      }
-
-      const below = branches.slice(0, splitIdx);
-      const above = branches.slice(splitIdx);
+      const splitIdx = stack.branches.indexOf(branch);
+      const below = stack.branches.slice(0, splitIdx);
+      const above = stack.branches.slice(splitIdx);
       const newStackName = branch;
 
       if (dryRun) {
@@ -68,23 +60,7 @@ export const split = Command.make("split", {
         return;
       }
 
-      const data = yield* stacks.load();
-
-      if (data.stacks[newStackName] !== undefined) {
-        return yield* new StackError({
-          code: ErrorCode.STACK_EXISTS,
-          message: `Stack "${newStackName}" already exists — choose a different split point or rename it first`,
-        });
-      }
-
-      yield* stacks.save({
-        ...data,
-        stacks: {
-          ...data.stacks,
-          [stackName]: { branches: below },
-          [newStackName]: { branches: above },
-        },
-      });
+      yield* stacks.splitStack(branch);
 
       if (json) {
         // @effect-diagnostics-next-line effect/preferSchemaOverJson:off

package/src/commands/stacks.ts

@@ -18,9 +18,7 @@ export const stacks = Command.make("stacks", { json: jsonFlag }).pipe(
       const stackService = yield* StackService;
 
       const currentBranch = yield* git.currentBranch();
-      const data = yield* stackService.load();
-
-      const entries = Object.entries(data.stacks);
+      const entries = yield* stackService.listStacks();
       if (entries.length === 0) {
         if (json) {
           // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
@@ -32,7 +30,7 @@ export const stacks = Command.make("stacks", { json: jsonFlag }).pipe(
       }
 
       if (json) {
-        const stackList = entries.map(([name, stack]) => ({
+        const stackList = entries.map(({ name, stack }) => ({
           name,
           branches: stack.branches.length,
           current: stack.branches.includes(currentBranch),
@@ -43,7 +41,7 @@ export const stacks = Command.make("stacks", { json: jsonFlag }).pipe(
       }
 
       const lines: string[] = [];
-      for (const [name, stack] of entries) {
+      for (const { name, stack } of entries) {
         const isCurrent = stack.branches.includes(currentBranch);
         const marker = isCurrent ? yield* stdout.green("* ") : "  ";
         const label = isCurrent ? yield* stdout.bold(name) : name;

package/src/commands/submit.ts

@@ -4,6 +4,11 @@ import { GitService } from "../services/Git.js";
 import { StackService } from "../services/Stack.js";
 import { GitHubService } from "../services/GitHub.js";
 import { ErrorCode, StackError } from "../errors/index.js";
+import {
+  composePRBody,
+  generateStackMetadata,
+  refreshStackedPRBodies,
+} from "./helpers/pr-metadata.js";
 import { withSpinner, success } from "../ui.js";
 
 const draftFlag = Flag.boolean("draft").pipe(
@@ -38,78 +43,6 @@ interface SubmitResult {
   action: "created" | "updated" | "unchanged" | "would-create" | "would-update" | "would-unchanged";
 }
 
-const STACKED_MARKER_START = "<!-- stacked -->";
-const STACKED_MARKER_END = "<!-- /stacked -->";
-
-const generateStackMetadata = (
-  branches: readonly string[],
-  prMap: Map<string, { number: number; url: string; state: string } | null>,
-  currentIdx: number,
-  stackName: string,
-): string => {
-  const rows = branches.map((branch, i) => {
-    const pr = prMap.get(branch) ?? null;
-    const isCurrent = i === currentIdx;
-    const branchCol = isCurrent ? `**\`${branch}\`**` : `\`${branch}\``;
-    const numCol = i + 1;
-    const numStr = isCurrent ? `**${numCol}**` : `${numCol}`;
-
-    let prCol: string;
-    if (pr === null) {
-      prCol = "—";
-    } else if (pr.state === "MERGED") {
-      prCol = `[#${pr.number}](${pr.url}) ✅`;
-    } else if (isCurrent) {
-      prCol = `**#${pr.number} ← you are here**`;
-    } else {
-      prCol = `[#${pr.number}](${pr.url})`;
-    }
-
-    return `| ${numStr} | ${branchCol} | ${prCol} |`;
-  });
-
-  return [
-    STACKED_MARKER_START,
-    `**Stack: \`${stackName}\`** (${currentIdx + 1} of ${branches.length})`,
-    "",
-    "| # | Branch | PR |",
-    "|---|--------|----|",
-    ...rows,
-    STACKED_MARKER_END,
-  ].join("\n");
-};
-
-const composePRBody = (userBody: string | undefined, metadata: string): string => {
-  if (userBody !== undefined) {
-    return `${userBody}\n\n---\n\n${metadata}`;
-  }
-  return metadata;
-};
-
-const updatePRBody = (
-  existingBody: string | undefined,
-  userBody: string | undefined,
-  metadata: string,
-): string => {
-  if (userBody !== undefined) {
-    return composePRBody(userBody, metadata);
-  }
-
-  if (existingBody !== undefined) {
-    const startIdx = existingBody.indexOf(STACKED_MARKER_START);
-    if (startIdx !== -1) {
-      const prefix = existingBody.substring(0, startIdx).replace(/\n*---\n*$/, "");
-      if (prefix.trim().length > 0) {
-        return `${prefix.trim()}\n\n---\n\n${metadata}`;
-      }
-      return metadata;
-    }
-    return `${existingBody.trim()}\n\n---\n\n${metadata}`;
-  }
-
-  return metadata;
-};
-
 const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"));
 
 export const submit = Command.make("submit", {
@@ -294,21 +227,16 @@ export const submit = Command.make("submit", {
 
       // Update all processed PRs with complete stack metadata.
       // This includes newly created PRs so placeholders get replaced in one submit run.
-      for (let i = 0; i < branches.length; i++) {
-        const branch = branches[i];
-        if (branch === undefined) continue;
-        if (only && branch !== currentBranch) continue;
-
-        const entry = results.find((x) => x.branch === branch);
-        if (entry === undefined) continue;
-
-        const metadata = generateStackMetadata(branches, prMap, i, result.name);
-        const existingPrData = prMap.get(branch) ?? null;
-        const existingBody = existingPrData?.body ?? undefined;
-        const userBody = getBodyForBranch(branch, i);
-        const body = updatePRBody(existingBody, userBody, metadata);
-        yield* gh.updatePR({ branch, body });
-      }
+      yield* refreshStackedPRBodies({
+        branches,
+        stackName: result.name,
+        gh,
+        initialPrMap: prMap,
+        shouldUpdateBranch: (branch) =>
+          (!only || branch === currentBranch) && results.some((entry) => entry.branch === branch),
+        getUserBody: getBodyForBranch,
+      });
+      yield* stacks.unmarkMergedBranches(branches);
 
       // Print structured output to stdout
       if (json) {