@cvr/stacked 0.4.3 → 0.4.4

package/README.md

@@ -130,7 +130,7 @@ stacked --yes clean      # skip confirmation prompts
 
 ## Data Model
 
-Stack metadata lives in `.git/stacked.json`. Each branch's parent is implied by array position — `branches[0]`'s parent is trunk, `branches[n]`'s parent is `branches[n-1]`.
+Stack metadata lives in `.git/stacked.json`. Active stacks are stored as explicit linear parent links plus a per-stack root, and older v1 metadata is auto-migrated on load. `mergedBranches` remains a skip-list so `detect` does not try to rebuild stacks around already-merged branches.
 
 Trunk is auto-detected on first use from `origin/HEAD` when available, then falls back to local `main`, `master`, or `develop`. Override with `stacked trunk <name>`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cvr/stacked",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/cevr/stacked"
@@ -25,6 +25,8 @@
     "fmt": "oxfmt",
     "fmt:check": "oxfmt --check",
     "test": "bun test",
+    "bench:git": "bun run scripts/benchmark-git.ts",
+    "bench:detect": "bun run scripts/benchmark-detect.ts",
     "gate": "concurrently -n type,lint,fmt,test,build -c blue,yellow,magenta,green,cyan \"bun run typecheck\" \"bun run lint\" \"bun run fmt\" \"bun run test\" \"bun run build\"",
     "version": "changeset version",
     "release": "changeset publish",
@@ -34,6 +36,7 @@
   "dependencies": {
     "@effect/platform-bun": "4.0.0-beta.27",
     "effect": "4.0.0-beta.27",
+    "es-git": "^0.6.0",
     "picocolors": "^1.1.1"
   },
   "devDependencies": {

package/scripts/benchmark-detect.ts

@@ -0,0 +1,308 @@
+// @effect-diagnostics effect/strictEffectProvide:off
+// @effect-diagnostics effect/anyUnknownInErrorContext:off
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Effect } from "effect";
+import { GitService } from "../src/services/Git.js";
+import type { GitBackend } from "../src/services/git-backend.js";
+import { gitServiceLayerForBackend } from "../src/services/git-backend.js";
+
+const DETECT_COMMIT_LIMIT = 2048;
+
+const args = new Map(
+  process.argv.slice(2).map((arg) => {
+    const [key, value] = arg.split("=");
+    return [key ?? "", value ?? ""];
+  }),
+);
+
+const iterations = Number.parseInt(args.get("--iterations") ?? "5", 10);
+
+const runCommand = async (cwd: string, command: string[]) => {
+  const proc = Bun.spawn(command, {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+
+  if (exitCode !== 0) {
+    throw new Error(stderr.trim() || `${command.join(" ")} failed`);
+  }
+
+  return stdout.trim();
+};
+
+const withCwd = async <A>(cwd: string, run: () => Promise<A>) => {
+  const previous = process.cwd();
+  process.chdir(cwd);
+  try {
+    return await run();
+  } finally {
+    process.chdir(previous);
+  }
+};
+
+const runWithBackend = async <A>(
+  cwd: string,
+  backend: GitBackend,
+  effect: Effect.Effect<A, unknown, GitService>,
+) =>
+  withCwd(cwd, async () =>
+    Effect.runPromise(effect.pipe(Effect.provide(gitServiceLayerForBackend(backend)))),
+  );
+
+const writeCommit = async (cwd: string, file: string, message: string) => {
+  await Bun.write(join(cwd, file), `${message} ${Date.now()}\n`);
+  await runCommand(cwd, ["git", "add", file]);
+  await runCommand(cwd, ["git", "commit", "-m", message]);
+};
+
+const createFixtureRepo = async (name: string) => {
+  const cwd = await mkdtemp(join(tmpdir(), `stacked-detect-${name}-`));
+  await runCommand(cwd, ["git", "init", "-b", "main"]);
+  await runCommand(cwd, ["git", "config", "user.name", "Stacked Bench"]);
+  await runCommand(cwd, ["git", "config", "user.email", "bench@example.com"]);
+  await writeCommit(cwd, "README.md", "initial");
+  return cwd;
+};
+
+const createLinearFixture = async () => {
+  const cwd = await createFixtureRepo("linear");
+  let base = "main";
+  for (let i = 1; i <= 24; i++) {
+    const branch = `linear-${i}`;
+    await runCommand(cwd, ["git", "checkout", "-b", branch, base]);
+    await writeCommit(cwd, `${branch}.txt`, branch);
+    base = branch;
+  }
+  await runCommand(cwd, ["git", "checkout", "main"]);
+  return cwd;
+};
+
+const createWideFixture = async () => {
+  const cwd = await createFixtureRepo("wide");
+  await runCommand(cwd, ["git", "checkout", "-b", "root", "main"]);
+  await writeCommit(cwd, "root.txt", "root");
+  for (let i = 1; i <= 16; i++) {
+    const branch = `child-${i}`;
+    await runCommand(cwd, ["git", "checkout", "-b", branch, "root"]);
+    await writeCommit(cwd, `${branch}.txt`, branch);
+  }
+  await runCommand(cwd, ["git", "checkout", "main"]);
+  return cwd;
+};
+
+const createMixedFixture = async () => {
+  const cwd = await createFixtureRepo("mixed");
+
+  let base = "main";
+  for (let i = 1; i <= 10; i++) {
+    const branch = `stack-a-${i}`;
+    await runCommand(cwd, ["git", "checkout", "-b", branch, base]);
+    await writeCommit(cwd, `${branch}.txt`, branch);
+    base = branch;
+  }
+
+  await runCommand(cwd, ["git", "checkout", "main"]);
+  await writeCommit(cwd, "main-advance.txt", "main advance");
+
+  await runCommand(cwd, ["git", "checkout", "-b", "fork-root", "main"]);
+  await writeCommit(cwd, "fork-root.txt", "fork-root");
+  for (let i = 1; i <= 8; i++) {
+    const branch = `fork-${i}`;
+    await runCommand(cwd, ["git", "checkout", "-b", branch, "fork-root"]);
+    await writeCommit(cwd, `${branch}.txt`, branch);
+  }
+
+  await runCommand(cwd, ["git", "checkout", "main"]);
+  for (let i = 1; i <= 12; i++) {
+    const branch = `solo-${i}`;
+    await runCommand(cwd, ["git", "checkout", "-b", branch, "main"]);
+    await writeCommit(cwd, `${branch}.txt`, branch);
+    await runCommand(cwd, ["git", "checkout", "main"]);
+  }
+
+  return cwd;
+};
+
+const oldDetect = Effect.gen(function* () {
+  const git = yield* GitService;
+  const trunk = "main";
+  const candidates = (yield* git.listBranches()).filter((branch) => branch !== trunk);
+  const childOf = new Map<string, string>();
+
+  yield* Effect.forEach(
+    candidates,
+    (branch) =>
+      Effect.gen(function* () {
+        const potentialAncestors = [trunk, ...candidates.filter((other) => other !== 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: 8 },
+        );
+
+        const ancestors = ancestryResults.filter(([_, is]) => is).map(([name]) => name);
+        if (ancestors.length === 0) return;
+
+        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;
+        }
+
+        childOf.set(branch, closest);
+      }),
+    { concurrency: 8 },
+  );
+
+  return childOf.size;
+});
+
+const newDetect = Effect.gen(function* () {
+  const git = yield* GitService;
+  const trunk = "main";
+  const candidates = (yield* git.listBranches()).filter((branch) => branch !== trunk);
+
+  const tipResults = yield* Effect.forEach(
+    candidates,
+    (branch) =>
+      git.revParse(branch).pipe(
+        Effect.map((oid) => [branch, oid] as const),
+        Effect.catchTag("GitError", () => Effect.succeed(null)),
+      ),
+    { concurrency: 8 },
+  );
+
+  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);
+  }
+
+  const childOf = new Map<string, string>();
+  yield* Effect.forEach(
+    candidates,
+    (branch) =>
+      Effect.gen(function* () {
+        const commits = yield* git
+          .firstParentUniqueCommits(branch, trunk, { limit: DETECT_COMMIT_LIMIT })
+          .pipe(Effect.catchTag("GitError", () => Effect.succeed([])));
+
+        if (commits.length === 0) 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)) {
+          return;
+        }
+
+        childOf.set(branch, parent ?? trunk);
+      }),
+    { concurrency: 8 },
+  );
+
+  return childOf.size;
+});
+
+const average = (values: readonly number[]) =>
+  values.reduce((sum, value) => sum + value, 0) / values.length;
+
+const timeEffect = async (
+  cwd: string,
+  backend: GitBackend,
+  effect: Effect.Effect<unknown, unknown, GitService>,
+) => {
+  const start = performance.now();
+  await runWithBackend(cwd, backend, effect);
+  return performance.now() - start;
+};
+
+const benchmarkFixture = async (cwd: string, backend: GitBackend) => {
+  const oldSamples: number[] = [];
+  const newSamples: number[] = [];
+
+  for (let i = 0; i < iterations; i++) {
+    oldSamples.push(await timeEffect(cwd, backend, oldDetect));
+    newSamples.push(await timeEffect(cwd, backend, newDetect));
+  }
+
+  return {
+    oldMs: average(oldSamples),
+    newMs: average(newSamples),
+  };
+};
+
+const printRow = (
+  fixture: string,
+  backend: GitBackend,
+  result: { oldMs: number; newMs: number },
+) => {
+  const faster =
+    result.oldMs === result.newMs
+      ? "tie"
+      : result.oldMs < result.newMs
+        ? `old x${(result.newMs / result.oldMs).toFixed(2)}`
+        : `new x${(result.oldMs / result.newMs).toFixed(2)}`;
+
+  console.log(
+    `${fixture.padEnd(12)} ${backend.padEnd(7)} ${result.oldMs.toFixed(2).padStart(9)} ${result.newMs.toFixed(2).padStart(9)} ${faster.padStart(10)}`,
+  );
+};
+
+const fixtures = [
+  { name: "linear", create: createLinearFixture },
+  { name: "wide", create: createWideFixture },
+  { name: "mixed", create: createMixedFixture },
+] as const;
+
+console.log(`Detect benchmark iterations: ${iterations}`);
+console.log("fixture      backend    old(ms)   new(ms)     faster");
+
+const cleanup: Array<() => Promise<void>> = [];
+
+try {
+  for (const fixture of fixtures) {
+    const cwd = await fixture.create();
+    cleanup.push(() => rm(cwd, { recursive: true, force: true }));
+
+    for (const backend of ["cli", "es-git"] satisfies readonly GitBackend[]) {
+      const result = await benchmarkFixture(cwd, backend);
+      printRow(fixture.name, backend, result);
+    }
+  }
+} finally {
+  for (const dispose of cleanup.reverse()) {
+    await dispose();
+  }
+}

package/scripts/benchmark-git.ts

@@ -0,0 +1,273 @@
+// @effect-diagnostics effect/strictEffectProvide:off
+// @effect-diagnostics effect/anyUnknownInErrorContext:off
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Effect, ServiceMap } from "effect";
+import { GitService } from "../src/services/Git.js";
+import {
+  DEFAULT_GIT_BACKEND,
+  type GitBackend,
+  gitServiceLayerForBackend,
+} from "../src/services/git-backend.js";
+
+type ReadOperation = {
+  name: string;
+  run: Effect.Effect<unknown, unknown, GitService>;
+};
+
+type MutationFixture = {
+  cwd: string;
+  cleanup?: () => Promise<void>;
+};
+
+type MutationOperation = {
+  name: string;
+  setup: (sourceRepo: string) => Promise<MutationFixture>;
+  run: Effect.Effect<unknown, unknown, GitService>;
+};
+
+const args = new Map(
+  process.argv.slice(2).map((arg) => {
+    const [key, value] = arg.split("=");
+    return [key ?? "", value ?? ""];
+  }),
+);
+
+const repoPath = args.get("--repo") ?? process.cwd();
+const iterations = Number.parseInt(args.get("--iterations") ?? "5", 10);
+
+const runCommand = async (cwd: string, command: string[]) => {
+  const proc = Bun.spawn(command, {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+
+  if (exitCode !== 0) {
+    throw new Error(stderr.trim() || `${command.join(" ")} failed`);
+  }
+
+  return stdout.trim();
+};
+
+const withCwd = async <A>(cwd: string, run: () => Promise<A>) => {
+  const previous = process.cwd();
+  process.chdir(cwd);
+  try {
+    return await run();
+  } finally {
+    process.chdir(previous);
+  }
+};
+
+const runWithBackend = async <A>(
+  cwd: string,
+  backend: GitBackend,
+  effect: Effect.Effect<A, unknown, GitService>,
+) =>
+  withCwd(cwd, async () =>
+    Effect.runPromise(effect.pipe(Effect.provide(gitServiceLayerForBackend(backend)))),
+  );
+
+const timeEffect = async <A>(
+  cwd: string,
+  backend: GitBackend,
+  effect: Effect.Effect<A, unknown, GitService>,
+) => {
+  const start = performance.now();
+  await runWithBackend(cwd, backend, effect);
+  return performance.now() - start;
+};
+
+const createWorkClone = async (sourceRepo: string) => {
+  const root = await mkdtemp(join(tmpdir(), "stacked-git-bench-"));
+  const remote = join(root, "remote.git");
+  const work = join(root, "work");
+
+  await runCommand(root, ["git", "clone", "--bare", sourceRepo, remote]);
+  await runCommand(root, ["git", "clone", remote, work]);
+  await runCommand(work, ["git", "config", "user.name", "Stacked Bench"]);
+  await runCommand(work, ["git", "config", "user.email", "bench@example.com"]);
+
+  return {
+    root,
+    remote,
+    work,
+    cleanup: () => rm(root, { recursive: true, force: true }),
+  };
+};
+
+const getCurrentBranch = async (cwd: string) =>
+  runCommand(cwd, ["git", "rev-parse", "--abbrev-ref", "HEAD"]);
+
+type GitApi = ServiceMap.Service.Shape<typeof GitService>;
+
+const withGit = <A>(run: (git: GitApi) => Effect.Effect<A, unknown>) =>
+  Effect.gen(function* () {
+    const git = yield* GitService;
+    return yield* run(git);
+  });
+
+const readOperations: ReadOperation[] = [
+  { name: "currentBranch", run: withGit((git) => git.currentBranch()) },
+  { name: "listBranches", run: withGit((git) => git.listBranches()) },
+  { name: "branchExists", run: withGit((git) => git.branchExists("main")) },
+  { name: "remoteDefaultBranch", run: withGit((git) => git.remoteDefaultBranch("origin")) },
+  { name: "isClean", run: withGit((git) => git.isClean()) },
+  { name: "revParse", run: withGit((git) => git.revParse("HEAD")) },
+  { name: "mergeBase", run: withGit((git) => git.mergeBase("HEAD", "HEAD~1")) },
+  { name: "isAncestor", run: withGit((git) => git.isAncestor("HEAD~1", "HEAD")) },
+  {
+    name: "firstParentUniqueCommits",
+    run: withGit((git) => git.firstParentUniqueCommits("HEAD", "HEAD~1", { limit: 20 })),
+  },
+  { name: "log", run: withGit((git) => git.log("HEAD", { limit: 20, oneline: true })) },
+];
+
+const mutationOperations: MutationOperation[] = [
+  {
+    name: "create-delete-branch",
+    setup: async (sourceRepo) => {
+      const fixture = await createWorkClone(sourceRepo);
+      return { cwd: fixture.work, cleanup: fixture.cleanup };
+    },
+    run: Effect.gen(function* () {
+      const git = yield* GitService;
+      const base = yield* git.currentBranch();
+      yield* git.createBranch("bench-temp");
+      yield* git.checkout(base);
+      yield* git.deleteBranch("bench-temp", true);
+    }),
+  },
+  {
+    name: "checkout-roundtrip",
+    setup: async (sourceRepo) => {
+      const fixture = await createWorkClone(sourceRepo);
+      const base = await getCurrentBranch(fixture.work);
+      await runCommand(fixture.work, ["git", "checkout", "-b", "bench-checkout"]);
+      await runCommand(fixture.work, ["git", "checkout", base]);
+      return { cwd: fixture.work, cleanup: fixture.cleanup };
+    },
+    run: Effect.gen(function* () {
+      const git = yield* GitService;
+      const base = yield* git.currentBranch();
+      yield* git.checkout("bench-checkout");
+      yield* git.checkout(base);
+    }),
+  },
+  {
+    name: "fetch-origin",
+    setup: async (sourceRepo) => {
+      const fixture = await createWorkClone(sourceRepo);
+      const writer = join(fixture.root, "writer");
+      const base = await getCurrentBranch(fixture.work);
+
+      await runCommand(fixture.root, ["git", "clone", fixture.remote, writer]);
+      await runCommand(writer, ["git", "config", "user.name", "Stacked Bench"]);
+      await runCommand(writer, ["git", "config", "user.email", "bench@example.com"]);
+      await runCommand(writer, ["git", "checkout", base]);
+      await Bun.write(join(writer, "bench-fetch.txt"), `${Date.now()}\n`);
+      await runCommand(writer, ["git", "add", "bench-fetch.txt"]);
+      await runCommand(writer, ["git", "commit", "-m", "bench fetch"]);
+      await runCommand(writer, ["git", "push", "origin", base]);
+
+      return { cwd: fixture.work, cleanup: fixture.cleanup };
+    },
+    run: withGit((git) => git.fetch("origin")),
+  },
+  {
+    name: "push-delete-remote-branch",
+    setup: async (sourceRepo) => {
+      const fixture = await createWorkClone(sourceRepo);
+      await runCommand(fixture.work, ["git", "checkout", "-b", "bench-push"]);
+      await Bun.write(join(fixture.work, "bench-push.txt"), `${Date.now()}\n`);
+      await runCommand(fixture.work, ["git", "add", "bench-push.txt"]);
+      await runCommand(fixture.work, ["git", "commit", "-m", "bench push"]);
+      return { cwd: fixture.work, cleanup: fixture.cleanup };
+    },
+    run: Effect.gen(function* () {
+      const git = yield* GitService;
+      yield* git.push("bench-push", { force: true });
+      yield* git.deleteRemoteBranch("bench-push");
+    }),
+  },
+];
+
+const average = (values: readonly number[]) =>
+  values.reduce((sum, value) => sum + value, 0) / values.length;
+
+const benchmarkReads = async (backend: GitBackend) => {
+  const results: Array<{ name: string; ms: number }> = [];
+
+  for (const operation of readOperations) {
+    const samples: number[] = [];
+    for (let i = 0; i < iterations; i++) {
+      samples.push(await timeEffect(repoPath, backend, operation.run));
+    }
+    results.push({ name: operation.name, ms: average(samples) });
+  }
+
+  return results;
+};
+
+const benchmarkMutations = async (backend: GitBackend) => {
+  const results: Array<{ name: string; ms: number }> = [];
+
+  for (const operation of mutationOperations) {
+    const samples: number[] = [];
+    for (let i = 0; i < iterations; i++) {
+      const fixture = await operation.setup(repoPath);
+      try {
+        samples.push(await timeEffect(fixture.cwd, backend, operation.run));
+      } finally {
+        await fixture.cleanup?.();
+      }
+    }
+    results.push({ name: operation.name, ms: average(samples) });
+  }
+
+  return results;
+};
+
+const printTable = (
+  title: string,
+  cliResults: Array<{ name: string; ms: number }>,
+  esGitResults: Array<{ name: string; ms: number }>,
+) => {
+  console.log(`\n${title}`);
+  console.log("operation                  cli(ms)   es-git(ms)   faster");
+
+  for (const cliResult of cliResults) {
+    const esGitResult = esGitResults.find((entry) => entry.name === cliResult.name);
+    if (esGitResult === undefined) continue;
+
+    const faster =
+      cliResult.ms === esGitResult.ms
+        ? "tie"
+        : cliResult.ms < esGitResult.ms
+          ? `cli x${(esGitResult.ms / cliResult.ms).toFixed(2)}`
+          : `es-git x${(cliResult.ms / esGitResult.ms).toFixed(2)}`;
+
+    console.log(
+      `${cliResult.name.padEnd(25)} ${cliResult.ms.toFixed(2).padStart(8)} ${esGitResult.ms.toFixed(2).padStart(12)} ${faster.padStart(10)}`,
+    );
+  }
+};
+
+console.log(`Benchmark repo: ${repoPath}`);
+console.log(`Iterations: ${iterations}`);
+console.log(`Default backend: ${DEFAULT_GIT_BACKEND}`);
+
+const cliReads = await benchmarkReads("cli");
+const esGitReads = await benchmarkReads("es-git");
+printTable("Read Operations", cliReads, esGitReads);
+
+const cliMutations = await benchmarkMutations("cli");
+const esGitMutations = await benchmarkMutations("es-git");
+printTable("Mutation Operations", cliMutations, esGitMutations);

package/src/commands/clean.ts

@@ -32,11 +32,11 @@ export const clean = Command.make("clean", { dryRun: dryRunFlag, json: jsonFlag
       }
 
       let currentBranch = yield* git.currentBranch();
-      const data = yield* stacks.load();
+      const entries = yield* stacks.listStacks();
 
       // Fetch all PR statuses in parallel across all stacks
-      const allBranches = Object.entries(data.stacks).flatMap(([stackName, stack]) =>
-        stack.branches.map((branch) => ({ stackName, branch })),
+      const allBranches = entries.flatMap(({ name, stack }) =>
+        stack.branches.map((branch) => ({ stackName: name, branch })),
       );
 
       const prResults = yield* Effect.forEach(
@@ -53,7 +53,7 @@ export const clean = Command.make("clean", { dryRun: dryRunFlag, json: jsonFlag
       const toRemove: Array<{ stackName: string; branch: string }> = [];
       const skippedMerged: Array<{ stackName: string; branch: string }> = [];
 
-      for (const [stackName, stack] of Object.entries(data.stacks)) {
+      for (const { name: stackName, stack } of entries) {
         let hitNonMerged = false;
         for (const branch of stack.branches) {
           const pr = prMap.get(branch) ?? null;
@@ -129,7 +129,8 @@ export const clean = Command.make("clean", { dryRun: dryRunFlag, json: jsonFlag
               ),
             );
           if (deleted) {
-            yield* stacks.removeBranch(stackName, branch);
+            yield* stacks.removeBranch(branch);
+            yield* stacks.markMergedBranches([branch]);
             removed.push(branch);
             yield* success(`Removed ${branch} from ${stackName}`);
           }

package/src/commands/create.ts

@@ -80,20 +80,24 @@ export const create = Command.make("create", {
 
       const existing = yield* stacks.findBranchStack(baseBranch);
       let stackName = existing?.name ?? null;
+      let shouldAddBranch = true;
 
       yield* git.createBranch(name, baseBranch);
 
       if (stackName === null) {
         if (baseBranch === trunk) {
           stackName = name;
-          yield* stacks.createStack(name, []);
+          shouldAddBranch = false;
+          yield* stacks.createStack(name, [name]);
         } else {
           stackName = baseBranch;
           yield* stacks.createStack(baseBranch, [baseBranch]);
         }
       }
 
-      yield* stacks.addBranch(stackName, name, baseBranch === trunk ? undefined : baseBranch);
+      if (shouldAddBranch) {
+        yield* stacks.addBranch(stackName, name, baseBranch === trunk ? undefined : baseBranch);
+      }
 
       if (json) {
         // @effect-diagnostics-next-line effect/preferSchemaOverJson:off

package/src/commands/delete.ts

@@ -101,7 +101,7 @@ export const deleteCmd = Command.make("delete", {
       }
 
       yield* git.deleteBranch(name, force);
-      yield* stacks.removeBranch(stackName, name);
+      yield* stacks.removeBranch(name);
 
       if (willDeleteRemote) {
         yield* git.deleteRemoteBranch(name).pipe(Effect.catchTag("GitError", () => Effect.void));