@cvr/stacked 0.2.0 → 0.3.0

package/README.md

@@ -53,6 +53,10 @@ 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
@@ -73,6 +77,7 @@ stacked delete feat-auth-ui
 | `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`                         |

package/package.json

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

package/skills/stacked/SKILL.md

@@ -20,6 +20,8 @@ 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
 ```
@@ -36,6 +38,7 @@ What do you need?
 | `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`                |
@@ -127,6 +130,17 @@ 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:
@@ -187,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/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

@@ -12,6 +12,7 @@ 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"),
@@ -32,5 +33,6 @@ export const command = root.pipe(
     adopt,
     log,
     clean,
+    detect,
   ]),
 );

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,