@cvr/stacked 0.1.0 → 0.3.0

package/README.md

@@ -25,17 +25,23 @@ stacked create feat-auth-ui
 # See the stack
 stacked list
 
+# See a specific stack by name
+stacked list feat-auth
+
+# List all stacks in the repo
+stacked stacks
+
 # Navigate
 stacked top
 stacked bottom
 stacked checkout feat-auth
 
-# After editing mid-stack, rebase children
-stacked restack
-
 # Sync entire stack with latest trunk
 stacked sync
 
+# After editing mid-stack, rebase only children
+stacked sync --from feat-auth
+
 # Push all branches + create/update PRs
 stacked submit
 stacked submit --draft
@@ -47,26 +53,36 @@ stacked adopt existing-branch --after feat-auth
 # View commits per branch
 stacked log
 
+# Detect existing branch chains and register as stacks
+stacked detect
+stacked detect --dry-run
+
+# Remove merged branches from stacks
+stacked clean
+stacked clean --dry-run
+
 # Remove a branch from the stack
 stacked delete feat-auth-ui
 ```
 
 ## Commands
 
-| Command           | Description                              |
-| ----------------- | ---------------------------------------- |
-| `trunk [name]`    | Get/set trunk branch                     |
-| `create <name>`   | Create branch on top of current          |
-| `list`            | Show stack with current branch indicator |
-| `checkout <name>` | Switch to branch                         |
-| `top`             | Jump to top of stack                     |
-| `bottom`          | Jump to bottom of stack                  |
-| `sync`            | Fetch + rebase entire stack on trunk     |
-| `restack`         | Rebase children after mid-stack edits    |
-| `delete <name>`   | Remove branch from stack + git           |
-| `submit`          | Push all + create/update PRs via `gh`    |
-| `adopt <branch>`  | Add existing branch to stack             |
-| `log`             | Show commits grouped by branch           |
+| Command           | Description                                                   |
+| ----------------- | ------------------------------------------------------------- |
+| `trunk [name]`    | Get/set trunk branch                                          |
+| `create <name>`   | Create branch on top of current                               |
+| `list [stack]`    | Show stack branches (defaults to current stack)               |
+| `stacks`          | List all stacks in the repo                                   |
+| `checkout <name>` | Switch to branch                                              |
+| `top`             | Jump to top of stack                                          |
+| `bottom`          | Jump to bottom of stack                                       |
+| `sync`            | Fetch + rebase stack on trunk (--from to start from a branch) |
+| `detect`          | Detect branch chains and register as stacks (--dry-run)       |
+| `clean`           | Remove merged branches from stacks (--dry-run to preview)     |
+| `delete <name>`   | Remove branch from stack + git                                |
+| `submit`          | Push all + create/update PRs via `gh`                         |
+| `adopt <branch>`  | Add existing branch to stack                                  |
+| `log`             | Show commits grouped by branch                                |
 
 ## Data Model
 

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@cvr/stacked",
-  "version": "0.1.0",
+  "version": "0.3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cevr/stacked"
+  },
   "bin": {
     "stacked": "./bin/stacked"
   },

package/skills/stacked/SKILL.md

@@ -20,26 +20,30 @@ What do you need?
 ├─ Rebase after changes       → §Rebasing
 ├─ Push + create PRs          → §Submitting
 ├─ Adopt existing branches    → §Adopting Branches
+├─ Detect existing branches   → §Detecting Existing Branches
+├─ Clean up merged branches   → §Cleaning Up Merged Branches
 ├─ Remove a branch            → §Deleting
 └─ Troubleshooting            → §Gotchas
 ```
 
 ## Quick Reference
 
-| Command                   | What it does                                   |
-| ------------------------- | ---------------------------------------------- |
-| `stacked trunk [name]`    | Get/set trunk branch (default: main)           |
-| `stacked create <name>`   | Create branch on top of current branch         |
-| `stacked list`            | Show stack with current branch indicator       |
-| `stacked checkout <name>` | Switch to branch in stack                      |
-| `stacked top`             | Jump to top of stack                           |
-| `stacked bottom`          | Jump to bottom of stack                        |
-| `stacked sync`            | Fetch + rebase entire stack on trunk           |
-| `stacked restack`         | Rebase children after mid-stack edits          |
-| `stacked delete <name>`   | Remove branch from stack + delete git branch   |
-| `stacked submit`          | Push all branches + create/update PRs via `gh` |
-| `stacked adopt <branch>`  | Add existing git branch into the stack         |
-| `stacked log`             | Show commits grouped by branch                 |
+| Command                   | What it does                                                  |
+| ------------------------- | ------------------------------------------------------------- |
+| `stacked trunk [name]`    | Get/set trunk branch (default: main)                          |
+| `stacked create <name>`   | Create branch on top of current branch                        |
+| `stacked list [stack]`    | Show stack branches (defaults to current stack)               |
+| `stacked stacks`          | List all stacks in the repo                                   |
+| `stacked checkout <name>` | Switch to branch in stack                                     |
+| `stacked top`             | Jump to top of stack                                          |
+| `stacked bottom`          | Jump to bottom of stack                                       |
+| `stacked sync`            | Fetch + rebase stack on trunk (--from to start from a branch) |
+| `stacked detect`          | Detect branch chains and register as stacks (--dry-run)       |
+| `stacked clean`           | Remove merged branches from stacks (--dry-run to preview)     |
+| `stacked delete <name>`   | Remove branch from stack + delete git branch                  |
+| `stacked submit`          | Push all branches + create/update PRs via `gh`                |
+| `stacked adopt <branch>`  | Add existing git branch into the stack                        |
+| `stacked log`             | Show commits grouped by branch                                |
 
 ## Setup
 
@@ -74,8 +78,10 @@ stacked create hotfix --from feat-auth
 ## Viewing the Stack
 
 ```sh
-stacked list     # shows branches with ► on current
-stacked log      # shows commits grouped by branch
+stacked list              # shows current stack's branches
+stacked list feat-auth    # shows a specific stack by name
+stacked stacks            # lists all stacks in the repo
+stacked log               # shows commits grouped by branch
 ```
 
 ## Navigation
@@ -86,28 +92,22 @@ stacked top                   # jump to top of stack
 stacked bottom                # jump to bottom (trunk-adjacent)
 ```
 
-## Rebasing
+## Syncing / Rebasing
 
-### After mid-stack changes
-
-Edit a branch mid-stack, then rebase everything above it:
+Fetch latest trunk and rebase the entire stack bottom-to-top:
 
 ```sh
-stacked checkout feat-auth
-# ... make changes, commit ...
-stacked restack                # rebases feat-auth-ui and feat-auth-tests
+stacked sync
 ```
 
-### Sync with trunk
-
-Pull latest trunk and rebase the entire stack bottom-to-top:
+After mid-stack changes, rebase only the branches above a specific point:
 
 ```sh
-stacked sync
+stacked checkout feat-auth
+# ... make changes, commit ...
+stacked sync --from feat-auth    # rebases only children of feat-auth
 ```
 
-This fetches, then rebases each branch onto its parent starting from the bottom.
-
 ## Submitting
 
 Push all stack branches and create/update GitHub PRs with correct base branches:
@@ -130,6 +130,28 @@ stacked adopt existing-branch                    # append to top
 stacked adopt existing-branch --after feat-auth  # insert after specific branch
 ```
 
+## Detecting Existing Branches
+
+Auto-detect linear branch chains from git history and register them as stacks:
+
+```sh
+stacked detect              # scan and register branch chains
+stacked detect --dry-run    # preview what would be registered
+```
+
+Only linear chains are detected. Forked branches (one parent with multiple children) are reported but skipped. Already-tracked branches are excluded.
+
+## Cleaning Up Merged Branches
+
+After PRs are merged on GitHub, clean up the local branches and stack metadata:
+
+```sh
+stacked clean              # removes all merged branches from all stacks
+stacked clean --dry-run    # preview what would be removed
+```
+
+`list` also shows merge status per branch (`[merged]`, `[closed]`, `[#N]` for open PRs).
+
 ## Deleting
 
 ```sh
@@ -160,7 +182,7 @@ stacked create feat-auth-ui
 # 3. Need to fix something mid-stack
 stacked checkout feat-auth
 # ... fix, commit ...
-stacked restack              # rebase children
+stacked sync --from feat-auth  # rebase children
 
 # 4. Sync with latest main
 stacked sync
@@ -179,3 +201,4 @@ stacked submit
 - PRs target parent branches, not trunk — this is intentional for stacked review
 - Trunk defaults to `main` — use `stacked trunk <name>` if your default branch differs
 - Rebase conflicts mid-stack will pause the operation — resolve and re-run
+- Forked branches (one parent, multiple children) are not supported — `detect` reports them but skips

package/src/commands/clean.ts

@@ -0,0 +1,85 @@
+import { Command, Flag } from "effect/unstable/cli";
+import { Console, Effect } from "effect";
+import { GitService } from "../services/Git.js";
+import { GitHubService } from "../services/GitHub.js";
+import { StackService } from "../services/Stack.js";
+
+const dryRunFlag = Flag.boolean("dry-run");
+
+export const clean = Command.make("clean", { dryRun: dryRunFlag }).pipe(
+  Command.withDescription("Remove merged branches from stacks (bottom-up)"),
+  Command.withHandler(({ dryRun }) =>
+    Effect.gen(function* () {
+      const git = yield* GitService;
+      const gh = yield* GitHubService;
+      const stacks = yield* StackService;
+
+      const currentBranch = yield* git.currentBranch();
+      const data = yield* stacks.load();
+
+      const toRemove: Array<{ stackName: string; branch: string }> = [];
+      const skippedMerged: Array<{ stackName: string; branch: string }> = [];
+
+      for (const [stackName, stack] of Object.entries(data.stacks)) {
+        let hitNonMerged = false;
+        for (const branch of stack.branches) {
+          const pr = yield* gh.getPR(branch).pipe(Effect.catch(() => Effect.succeed(null)));
+          const isMerged = pr !== null && pr.state === "MERGED";
+
+          if (!hitNonMerged && isMerged) {
+            toRemove.push({ stackName, branch });
+          } else {
+            if (!isMerged) hitNonMerged = true;
+            if (isMerged) skippedMerged.push({ stackName, branch });
+          }
+        }
+      }
+
+      if (toRemove.length === 0) {
+        yield* Console.log("Nothing to clean");
+        if (skippedMerged.length > 0) {
+          yield* Console.log(
+            `\nNote: ${skippedMerged.length} merged branch${skippedMerged.length === 1 ? "" : "es"} skipped (non-merged branches below):`,
+          );
+          for (const { branch, stackName } of skippedMerged) {
+            yield* Console.log(`  ${branch} (${stackName})`);
+          }
+        }
+        return;
+      }
+
+      for (const { stackName, branch } of toRemove) {
+        if (dryRun) {
+          yield* Console.log(`Would remove ${branch} from ${stackName}`);
+        } else {
+          if (currentBranch === branch) {
+            const trunk = yield* stacks.getTrunk();
+            yield* git.checkout(trunk);
+          }
+          yield* stacks.removeBranch(stackName, branch);
+          yield* git.deleteBranch(branch, true).pipe(Effect.catch(() => Effect.void));
+          yield* Console.log(`Removed ${branch} from ${stackName}`);
+        }
+      }
+
+      if (dryRun) {
+        yield* Console.log(
+          `\n${toRemove.length} branch${toRemove.length === 1 ? "" : "es"} would be removed`,
+        );
+      } else {
+        yield* Console.log(
+          `\nCleaned ${toRemove.length} merged branch${toRemove.length === 1 ? "" : "es"}`,
+        );
+      }
+
+      if (skippedMerged.length > 0) {
+        yield* Console.log(
+          `\nNote: ${skippedMerged.length} merged branch${skippedMerged.length === 1 ? "" : "es"} skipped (non-merged branches below):`,
+        );
+        for (const { branch, stackName } of skippedMerged) {
+          yield* Console.log(`  ${branch} (${stackName})`);
+        }
+      }
+    }),
+  ),
+);

package/src/commands/detect.ts

@@ -0,0 +1,126 @@
+import { Command, Flag } from "effect/unstable/cli";
+import { Console, Effect } from "effect";
+import { GitService } from "../services/Git.js";
+import { StackService } from "../services/Stack.js";
+
+const dryRunFlag = Flag.boolean("dry-run");
+
+export const detect = Command.make("detect", { dryRun: dryRunFlag }).pipe(
+  Command.withDescription("Detect and register branch stacks from git history"),
+  Command.withHandler(({ dryRun }) =>
+    Effect.gen(function* () {
+      const git = yield* GitService;
+      const stacks = yield* StackService;
+
+      const trunk = yield* stacks.getTrunk();
+      const allBranches = yield* git.listBranches();
+      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 untracked = candidates.filter((b) => !alreadyTracked.has(b));
+
+      if (untracked.length === 0) {
+        yield* Console.log("No untracked branches found");
+        return;
+      }
+
+      // 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>();
+
+      for (const branch of untracked) {
+        const ancestors: string[] = [];
+
+        // Check trunk
+        const trunkIsAncestor = yield* git
+          .isAncestor(trunk, branch)
+          .pipe(Effect.catch(() => Effect.succeed(false)));
+        if (trunkIsAncestor) ancestors.push(trunk);
+
+        // Check other untracked branches
+        for (const other of untracked) {
+          if (other === branch) continue;
+          const is = yield* git
+            .isAncestor(other, branch)
+            .pipe(Effect.catch(() => Effect.succeed(false)));
+          if (is) ancestors.push(other);
+        }
+
+        if (ancestors.length === 0) continue;
+
+        // 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.catch(() => Effect.succeed(false)));
+          if (candidateIsCloser) closest = candidate;
+        }
+
+        childOf.set(branch, closest);
+      }
+
+      // Build linear chains from trunk
+      // Find branches whose parent is trunk (chain roots)
+      const chains: string[][] = [];
+      const roots = untracked.filter((b) => childOf.get(b) === trunk);
+
+      for (const root of roots) {
+        const chain = [root];
+        let current = root;
+
+        while (true) {
+          const children = untracked.filter((b) => childOf.get(b) === current);
+          const child = children[0];
+          if (children.length === 1 && child !== undefined) {
+            chain.push(child);
+            current = child;
+          } else {
+            // 0 children = end of chain, 2+ children = fork (skip)
+            break;
+          }
+        }
+
+        chains.push(chain);
+      }
+
+      if (chains.length === 0) {
+        yield* Console.log("No linear branch chains detected");
+        return;
+      }
+
+      for (const chain of chains) {
+        const name = chain[0];
+        if (name === undefined) continue;
+        if (dryRun) {
+          yield* Console.log(`Would create stack "${name}": ${chain.join(" → ")}`);
+        } else {
+          yield* stacks.createStack(name, chain);
+          yield* Console.log(`Created stack "${name}": ${chain.join(" → ")}`);
+        }
+      }
+
+      if (dryRun) {
+        yield* Console.log(
+          `\n${chains.length} stack${chains.length === 1 ? "" : "s"} would be created`,
+        );
+      }
+
+      // Report forks
+      const forkPoints = untracked.filter((b) => {
+        const children = untracked.filter((c) => childOf.get(c) === b);
+        return children.length > 1;
+      });
+      if (forkPoints.length > 0) {
+        yield* Console.log("\nNote: forked branches detected (not supported yet):");
+        for (const branch of forkPoints) {
+          const children = untracked.filter((c) => childOf.get(c) === branch);
+          yield* Console.log(`  ${branch} → ${children.join(", ")}`);
+        }
+      }
+    }),
+  ),
+);

package/src/commands/index.ts

@@ -2,15 +2,17 @@ import { Command } from "effect/unstable/cli";
 import { trunk } from "./trunk.js";
 import { create } from "./create.js";
 import { list } from "./list.js";
+import { stacks } from "./stacks.js";
 import { checkout } from "./checkout.js";
 import { top } from "./top.js";
 import { bottom } from "./bottom.js";
 import { sync } from "./sync.js";
-import { restack } from "./restack.js";
 import { deleteCmd } from "./delete.js";
 import { submit } from "./submit.js";
 import { adopt } from "./adopt.js";
 import { log } from "./log.js";
+import { clean } from "./clean.js";
+import { detect } from "./detect.js";
 
 const root = Command.make("stacked").pipe(
   Command.withDescription("Branch-based stacked PR manager"),
@@ -21,14 +23,16 @@ export const command = root.pipe(
     trunk,
     create,
     list,
+    stacks,
     checkout,
     top,
     bottom,
     sync,
-    restack,
     deleteCmd,
     submit,
     adopt,
     log,
+    clean,
+    detect,
   ]),
 );

package/src/commands/list.ts

@@ -1,47 +1,73 @@
-import { Command } from "effect/unstable/cli";
-import { Console, Effect } from "effect";
+import { Argument, Command } from "effect/unstable/cli";
+import { Console, Effect, Option } from "effect";
 import { GitService } from "../services/Git.js";
+import { GitHubService } from "../services/GitHub.js";
 import { StackService } from "../services/Stack.js";
 
-export const list = Command.make("list").pipe(
-  Command.withDescription("Show current stack with branch status"),
-  Command.withHandler(() =>
+const stackNameArg = Argument.string("stack").pipe(Argument.optional);
+
+export const list = Command.make("list", { stackName: stackNameArg }).pipe(
+  Command.withDescription("Show stack branches (defaults to current stack)"),
+  Command.withHandler(({ stackName }) =>
     Effect.gen(function* () {
       const git = yield* GitService;
+      const gh = yield* GitHubService;
       const stacks = yield* StackService;
 
       const currentBranch = yield* git.currentBranch();
       const data = yield* stacks.load();
       const trunk = data.trunk;
 
-      let currentStackName: string | null = null;
-      for (const [name, stack] of Object.entries(data.stacks)) {
-        if (stack.branches.includes(currentBranch)) {
-          currentStackName = name;
-          break;
+      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) {
+          yield* Console.error(`Stack "${stackName.value}" not found`);
+          return;
+        }
+        targetStackName = stackName.value;
+        targetStack = s;
+      } else {
+        for (const [name, stack] of Object.entries(data.stacks)) {
+          if (stack.branches.includes(currentBranch)) {
+            targetStackName = name;
+            targetStack = stack;
+            break;
+          }
         }
       }
 
-      if (currentStackName === null) {
+      if (targetStackName === null || targetStack === null) {
         yield* Console.log("Not on a stacked branch");
         return;
       }
 
-      const stack = data.stacks[currentStackName];
-      if (stack === undefined) return;
       const lines: string[] = [];
 
-      lines.push(`Stack: ${currentStackName}`);
+      lines.push(`Stack: ${targetStackName}`);
       lines.push(`Trunk: ${trunk}`);
       lines.push("");
 
-      for (let i = stack.branches.length - 1; i >= 0; i--) {
-        const branch = stack.branches[i];
+      for (let i = targetStack.branches.length - 1; i >= 0; i--) {
+        const branch = targetStack.branches[i];
         if (branch === undefined) continue;
         const isCurrent = branch === currentBranch;
         const marker = isCurrent ? "* " : "  ";
         const prefix = i === 0 ? "└─" : "├─";
-        lines.push(`${marker}${prefix} ${branch}`);
+
+        const pr = yield* gh.getPR(branch).pipe(Effect.catch(() => Effect.succeed(null)));
+        const status =
+          pr === null
+            ? ""
+            : pr.state === "MERGED"
+              ? " [merged]"
+              : pr.state === "CLOSED"
+                ? " [closed]"
+                : ` [#${pr.number}]`;
+
+        lines.push(`${marker}${prefix} ${branch}${status}`);
       }
 
       yield* Console.log(lines.join("\n"));

package/src/commands/stacks.ts

@@ -0,0 +1,33 @@
+import { Command } from "effect/unstable/cli";
+import { Console, Effect } from "effect";
+import { GitService } from "../services/Git.js";
+import { StackService } from "../services/Stack.js";
+
+export const stacks = Command.make("stacks").pipe(
+  Command.withDescription("List all stacks in the repo"),
+  Command.withHandler(() =>
+    Effect.gen(function* () {
+      const git = yield* GitService;
+      const stackService = yield* StackService;
+
+      const currentBranch = yield* git.currentBranch();
+      const data = yield* stackService.load();
+
+      const entries = Object.entries(data.stacks);
+      if (entries.length === 0) {
+        yield* Console.log("No stacks");
+        return;
+      }
+
+      const lines: string[] = [];
+      for (const [name, stack] of Object.entries(data.stacks)) {
+        const isCurrent = stack.branches.includes(currentBranch);
+        const marker = isCurrent ? "* " : "  ";
+        const count = stack.branches.length;
+        lines.push(`${marker}${name} (${count} branch${count === 1 ? "" : "es"})`);
+      }
+
+      yield* Console.log(lines.join("\n"));
+    }),
+  ),
+);

package/src/commands/sync.ts

@@ -4,10 +4,11 @@ import { GitService } from "../services/Git.js";
 import { StackService } from "../services/Stack.js";
 
 const trunkFlag = Flag.string("trunk").pipe(Flag.optional, Flag.withAlias("t"));
+const fromFlag = Flag.string("from").pipe(Flag.optional, Flag.withAlias("f"));
 
-export const sync = Command.make("sync", { trunk: trunkFlag }).pipe(
-  Command.withDescription("Rebase entire stack on latest trunk"),
-  Command.withHandler(({ trunk: trunkOpt }) =>
+export const sync = Command.make("sync", { trunk: trunkFlag, from: fromFlag }).pipe(
+  Command.withDescription("Fetch and rebase stack on trunk. Use --from to start from a branch."),
+  Command.withHandler(({ trunk: trunkOpt, from: fromOpt }) =>
     Effect.gen(function* () {
       const git = yield* GitService;
       const stacks = yield* StackService;
@@ -25,8 +26,19 @@ export const sync = Command.make("sync", { trunk: trunkFlag }).pipe(
       }
 
       const { branches } = result.stack;
+      const fromBranch = Option.isSome(fromOpt) ? fromOpt.value : undefined;
+
+      let startIdx = 0;
+      if (fromBranch !== undefined) {
+        const idx = branches.indexOf(fromBranch);
+        if (idx === -1) {
+          yield* Console.error(`Branch "${fromBranch}" not found in stack`);
+          return;
+        }
+        startIdx = idx + 1;
+      }
 
-      for (let i = 0; i < branches.length; i++) {
+      for (let i = startIdx; i < branches.length; i++) {
         const branch = branches[i];
         if (branch === undefined) continue;
         const base = i === 0 ? `origin/${trunk}` : (branches[i - 1] ?? `origin/${trunk}`);

package/src/services/Git.ts

@@ -5,6 +5,7 @@ export class GitService extends ServiceMap.Service<
   GitService,
   {
     readonly currentBranch: () => Effect.Effect<string, GitError>;
+    readonly listBranches: () => Effect.Effect<string[], GitError>;
     readonly branchExists: (name: string) => Effect.Effect<boolean, GitError>;
     readonly createBranch: (name: string, from?: string) => Effect.Effect<void, GitError>;
     readonly deleteBranch: (name: string, force?: boolean) => Effect.Effect<void, GitError>;
@@ -50,6 +51,16 @@ export class GitService extends ServiceMap.Service<
     return {
       currentBranch: () => run(["rev-parse", "--abbrev-ref", "HEAD"]),
 
+      listBranches: () =>
+        run(["branch", "--format=%(refname:short)"]).pipe(
+          Effect.map((output) =>
+            output
+              .split("\n")
+              .map((b) => b.trim())
+              .filter((b) => b.length > 0),
+          ),
+        ),
+
       branchExists: (name) =>
         run(["rev-parse", "--verify", name]).pipe(
           Effect.as(true),
@@ -108,6 +119,7 @@ export class GitService extends ServiceMap.Service<
   static layerTest = (impl: Partial<ServiceMap.Service.Shape<typeof GitService>> = {}) =>
     Layer.succeed(GitService, {
       currentBranch: () => Effect.succeed("main"),
+      listBranches: () => Effect.succeed([]),
       branchExists: () => Effect.succeed(false),
       createBranch: () => Effect.void,
       deleteBranch: () => Effect.void,

package/src/commands/restack.ts

@@ -1,40 +0,0 @@
-import { Command } from "effect/unstable/cli";
-import { Console, Effect } from "effect";
-import { GitService } from "../services/Git.js";
-import { StackService } from "../services/Stack.js";
-
-export const restack = Command.make("restack").pipe(
-  Command.withDescription("Rebase children after mid-stack changes"),
-  Command.withHandler(() =>
-    Effect.gen(function* () {
-      const git = yield* GitService;
-      const stacks = yield* StackService;
-
-      const currentBranch = yield* git.currentBranch();
-      const result = yield* stacks.currentStack();
-      if (result === null) {
-        yield* Console.error("Not on a stacked branch");
-        return;
-      }
-
-      const { branches } = result.stack;
-      const idx = branches.indexOf(currentBranch);
-      if (idx === -1) {
-        yield* Console.error("Current branch not found in stack");
-        return;
-      }
-
-      for (let i = idx + 1; i < branches.length; i++) {
-        const branch = branches[i];
-        if (branch === undefined) continue;
-        const base = branches[i - 1] ?? currentBranch;
-        yield* Console.log(`Rebasing ${branch} onto ${base}...`);
-        yield* git.checkout(branch);
-        yield* git.rebase(base);
-      }
-
-      yield* git.checkout(currentBranch);
-      yield* Console.log("Stack restacked");
-    }),
-  ),
-);