@cvr/stacked 0.2.0 → 0.4.0

package/src/errors/index.ts

@@ -1,15 +1,45 @@
 import { Schema } from "effect";
 
+// ============================================================================
+// Error Codes
+// ============================================================================
+
+export const ErrorCode = {
+  BRANCH_EXISTS: "BRANCH_EXISTS",
+  BRANCH_NOT_FOUND: "BRANCH_NOT_FOUND",
+  NOT_IN_STACK: "NOT_IN_STACK",
+  DIRTY_WORKTREE: "DIRTY_WORKTREE",
+  REBASE_CONFLICT: "REBASE_CONFLICT",
+  GH_NOT_INSTALLED: "GH_NOT_INSTALLED",
+  STACK_NOT_FOUND: "STACK_NOT_FOUND",
+  INVALID_BRANCH_NAME: "INVALID_BRANCH_NAME",
+  NOT_A_GIT_REPO: "NOT_A_GIT_REPO",
+  ALREADY_AT_TOP: "ALREADY_AT_TOP",
+  ALREADY_AT_BOTTOM: "ALREADY_AT_BOTTOM",
+  STACK_EMPTY: "STACK_EMPTY",
+  TRUNK_ERROR: "TRUNK_ERROR",
+  STACK_EXISTS: "STACK_EXISTS",
+} as const;
+
+export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
+
+// ============================================================================
+// Error Classes
+// ============================================================================
+
 export class GitError extends Schema.TaggedErrorClass<GitError>()("GitError", {
   message: Schema.String,
   command: Schema.optional(Schema.String),
+  code: Schema.optional(Schema.String),
 }) {}
 
 export class StackError extends Schema.TaggedErrorClass<StackError>()("StackError", {
   message: Schema.String,
+  code: Schema.optional(Schema.String),
 }) {}
 
 export class GitHubError extends Schema.TaggedErrorClass<GitHubError>()("GitHubError", {
   message: Schema.String,
   command: Schema.optional(Schema.String),
+  code: Schema.optional(Schema.String),
 }) {}

package/src/global.d.ts

@@ -0,0 +1,2 @@
+declare const __VERSION__: string;
+declare const __SKILL_CONTENT__: string;

package/src/main.ts

@@ -1,14 +1,41 @@
 #!/usr/bin/env bun
 import { Command } from "effect/unstable/cli";
 import { BunRuntime, BunServices } from "@effect/platform-bun";
-import { Effect, Layer } from "effect";
+import { Console, Effect, Layer } from "effect";
 import { command } from "./commands/index.js";
 import { GitService } from "./services/Git.js";
 import { StackService } from "./services/Stack.js";
 import { GitHubService } from "./services/GitHub.js";
+import { OutputConfig } from "./ui.js";
+
+const version = typeof __VERSION__ !== "undefined" ? __VERSION__ : "dev";
+
+// ============================================================================
+// Global Flags (parsed before CLI framework, stripped from argv)
+// ============================================================================
+
+const globalFlags = new Set(["--verbose", "--quiet", "-q", "--no-color", "--yes", "-y"]);
+const flagArgs = new Set(process.argv.filter((a) => globalFlags.has(a)));
+process.argv = process.argv.filter((a) => !globalFlags.has(a));
+
+const isVerbose = flagArgs.has("--verbose");
+const isQuiet = flagArgs.has("--quiet") || flagArgs.has("-q");
+const isNoColor = flagArgs.has("--no-color");
+const isYes = flagArgs.has("--yes") || flagArgs.has("-y");
+
+if (isNoColor) process.env["NO_COLOR"] = "1";
+
+if (isVerbose && isQuiet) {
+  process.stderr.write("Error: --verbose and --quiet are mutually exclusive\n");
+  process.exitCode = 2;
+}
+
+// ============================================================================
+// CLI
+// ============================================================================
 
 const cli = Command.run(command, {
-  version: "0.1.0",
+  version,
 });
 
 const ServiceLayer = StackService.layer.pipe(
@@ -18,5 +45,45 @@ const ServiceLayer = StackService.layer.pipe(
 
 const AppLayer = Layer.mergeAll(ServiceLayer, BunServices.layer);
 
+// Usage errors (bad args, invalid state) → exit 2
+// Operational errors (git/gh failures) → exit 1
+const usageCodes = new Set([
+  "INVALID_BRANCH_NAME",
+  "BRANCH_EXISTS",
+  "NOT_IN_STACK",
+  "STACK_NOT_FOUND",
+  "STACK_EMPTY",
+  "ALREADY_AT_TOP",
+  "ALREADY_AT_BOTTOM",
+  "TRUNK_ERROR",
+  "STACK_EXISTS",
+]);
+
+const handleKnownError = (e: { message: string; code?: string | undefined }) =>
+  Console.error(e.code !== undefined ? `Error [${e.code}]: ${e.message}` : e.message).pipe(
+    Effect.andThen(
+      Effect.sync(() => {
+        process.exitCode = e.code !== undefined && usageCodes.has(e.code) ? 2 : 1;
+      }),
+    ),
+  );
+
 // @effect-diagnostics-next-line effect/strictEffectProvide:off
-BunRuntime.runMain(cli.pipe(Effect.provide(AppLayer)));
+BunRuntime.runMain(
+  cli.pipe(
+    Effect.provideService(OutputConfig, { verbose: isVerbose, quiet: isQuiet, yes: isYes }),
+    Effect.provide(AppLayer),
+    Effect.catchTags({
+      GitError: (e) => handleKnownError(e),
+      StackError: (e) => handleKnownError(e),
+      GitHubError: (e) => handleKnownError(e),
+    }),
+    Effect.catch((e) => {
+      const msg =
+        e !== null && typeof e === "object" && "message" in e
+          ? String(e.message)
+          : JSON.stringify(e, null, 2);
+      return handleKnownError({ message: `Unexpected error: ${msg}` });
+    }),
+  ),
+);

package/src/services/Git.ts

@@ -1,3 +1,4 @@
+import { existsSync } from "node:fs";
 import { Effect, Layer, ServiceMap } from "effect";
 import { GitError } from "../errors/index.js";
 
@@ -5,38 +6,69 @@ 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>;
     readonly checkout: (name: string) => Effect.Effect<void, GitError>;
     readonly rebase: (onto: string) => Effect.Effect<void, GitError>;
+    readonly rebaseOnto: (
+      branch: string,
+      newBase: string,
+      oldBase: string,
+    ) => Effect.Effect<void, GitError>;
+    readonly rebaseAbort: () => Effect.Effect<void, GitError>;
     readonly push: (branch: string, options?: { force?: boolean }) => Effect.Effect<void, GitError>;
     readonly log: (
       branch: string,
       options?: { limit?: number; oneline?: boolean },
     ) => Effect.Effect<string, GitError>;
-    readonly mergeBase: (a: string, b: string) => Effect.Effect<string, GitError>;
     readonly isClean: () => Effect.Effect<boolean, GitError>;
     readonly revParse: (ref: string) => Effect.Effect<string, GitError>;
-    readonly diff: (
-      a: string,
-      b: string,
-      options?: { stat?: boolean },
-    ) => Effect.Effect<string, GitError>;
     readonly isAncestor: (ancestor: string, descendant: string) => Effect.Effect<boolean, GitError>;
-    readonly remote: () => Effect.Effect<string, GitError>;
+    readonly mergeBase: (a: string, b: string) => Effect.Effect<string, GitError>;
+    readonly isRebaseInProgress: () => Effect.Effect<boolean>;
+    readonly commitAmend: (options?: { edit?: boolean }) => Effect.Effect<void, GitError>;
     readonly fetch: (remote?: string) => Effect.Effect<void, GitError>;
+    readonly deleteRemoteBranch: (branch: string) => Effect.Effect<void, GitError>;
   }
 >()("@cvr/stacked/services/Git/GitService") {
   static layer: Layer.Layer<GitService> = Layer.sync(GitService, () => {
     const run = Effect.fn("git.run")(function* (args: readonly string[]) {
-      const proc = Bun.spawn(["git", ...args], {
-        stdout: "pipe",
-        stderr: "pipe",
+      const proc = yield* Effect.sync(() =>
+        Bun.spawn(["git", ...args], {
+          stdout: "pipe",
+          stderr: "pipe",
+        }),
+      );
+
+      const exitCode = yield* Effect.tryPromise({
+        try: () => proc.exited,
+        catch: (e) =>
+          new GitError({ message: `Process failed: ${e}`, command: `git ${args.join(" ")}` }),
+      }).pipe(
+        Effect.onInterrupt(() =>
+          Effect.sync(() => {
+            proc.kill();
+          }),
+        ),
+      );
+      const stdout = yield* Effect.tryPromise({
+        try: () => new Response(proc.stdout).text(),
+        catch: (e) =>
+          new GitError({
+            message: `Failed to read stdout: ${e}`,
+            command: `git ${args.join(" ")}`,
+          }),
+      });
+      const stderr = yield* Effect.tryPromise({
+        try: () => new Response(proc.stderr).text(),
+        catch: (e) =>
+          new GitError({
+            message: `Failed to read stderr: ${e}`,
+            command: `git ${args.join(" ")}`,
+          }),
       });
-      const exitCode = yield* Effect.promise(() => proc.exited);
-      const stdout = yield* Effect.promise(() => new Response(proc.stdout).text());
-      const stderr = yield* Effect.promise(() => new Response(proc.stderr).text());
 
       if (exitCode !== 0) {
         return yield* new GitError({
@@ -48,12 +80,32 @@ export class GitService extends ServiceMap.Service<
     });
 
     return {
-      currentBranch: () => run(["rev-parse", "--abbrev-ref", "HEAD"]),
+      currentBranch: () =>
+        run(["rev-parse", "--abbrev-ref", "HEAD"]).pipe(
+          Effect.filterOrFail(
+            (branch) => branch !== "HEAD",
+            () =>
+              new GitError({
+                message: "HEAD is detached — checkout a branch first",
+                command: "git 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(
+        run(["rev-parse", "--verify", `refs/heads/${name}`]).pipe(
           Effect.as(true),
-          Effect.catch(() => Effect.succeed(false)),
+          Effect.catchTag("GitError", () => Effect.succeed(false)),
         ),
 
       createBranch: (name, from) => {
@@ -62,15 +114,21 @@ export class GitService extends ServiceMap.Service<
       },
 
       deleteBranch: (name, force) =>
-        run(["branch", force === true ? "-D" : "-d", name]).pipe(Effect.asVoid),
+        run(["branch", force === true ? "-D" : "-d", "--", name]).pipe(Effect.asVoid),
 
       checkout: (name) => run(["checkout", name]).pipe(Effect.asVoid),
 
       rebase: (onto) => run(["rebase", onto]).pipe(Effect.asVoid),
 
+      rebaseOnto: (branch, newBase, oldBase) =>
+        run(["rebase", "--onto", newBase, oldBase, branch]).pipe(Effect.asVoid),
+
+      rebaseAbort: () => run(["rebase", "--abort"]).pipe(Effect.asVoid),
+
       push: (branch, options) => {
-        const args = ["push", "-u", "origin", branch];
+        const args = ["push", "-u", "origin"];
         if (options?.force === true) args.splice(1, 0, "--force-with-lease");
+        args.push(branch);
         return run(args).pipe(Effect.asVoid);
       },
 
@@ -81,47 +139,61 @@ export class GitService extends ServiceMap.Service<
         return run(args);
       },
 
-      mergeBase: (a, b) => run(["merge-base", a, b]),
-
       isClean: () => run(["status", "--porcelain"]).pipe(Effect.map((r) => r === "")),
 
       revParse: (ref) => run(["rev-parse", ref]),
 
-      diff: (a, b, options) => {
-        const args = ["diff", a, b];
-        if (options?.stat === true) args.push("--stat");
-        return run(args);
-      },
-
       isAncestor: (ancestor, descendant) =>
         run(["merge-base", "--is-ancestor", ancestor, descendant]).pipe(
           Effect.as(true),
+          Effect.catchTag("GitError", () => Effect.succeed(false)),
+        ),
+
+      mergeBase: (a, b) => run(["merge-base", a, b]),
+
+      isRebaseInProgress: () =>
+        run(["rev-parse", "--git-dir"]).pipe(
+          Effect.map(
+            (gitDir) =>
+              existsSync(`${gitDir}/rebase-merge`) || existsSync(`${gitDir}/rebase-apply`),
+          ),
           Effect.catch(() => Effect.succeed(false)),
         ),
 
-      remote: () => run(["remote"]),
+      commitAmend: (options) => {
+        const args = ["commit", "--amend"];
+        if (options?.edit !== true) args.push("--no-edit");
+        return run(args).pipe(Effect.asVoid);
+      },
 
       fetch: (remote) => run(["fetch", remote ?? "origin"]).pipe(Effect.asVoid),
+
+      deleteRemoteBranch: (branch) =>
+        run(["push", "origin", "--delete", branch]).pipe(Effect.asVoid),
     };
   });
 
   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,
       checkout: () => Effect.void,
       rebase: () => Effect.void,
+      rebaseOnto: () => Effect.void,
+      rebaseAbort: () => Effect.void,
       push: () => Effect.void,
       log: () => Effect.succeed(""),
-      mergeBase: () => Effect.succeed("abc123"),
       isClean: () => Effect.succeed(true),
       revParse: () => Effect.succeed("abc123"),
-      diff: () => Effect.succeed(""),
       isAncestor: () => Effect.succeed(true),
-      remote: () => Effect.succeed("origin"),
+      mergeBase: () => Effect.succeed("abc123"),
+      isRebaseInProgress: () => Effect.succeed(false),
+      commitAmend: () => Effect.void,
       fetch: () => Effect.void,
+      deleteRemoteBranch: () => Effect.void,
       ...impl,
     });
 }

package/src/services/GitHub.ts

@@ -6,6 +6,7 @@ const GhPrResponse = Schema.Struct({
   url: Schema.String,
   state: Schema.String,
   baseRefName: Schema.String,
+  body: Schema.NullOr(Schema.String),
 });
 
 export class GitHubService extends ServiceMap.Service<
@@ -27,7 +28,7 @@ export class GitHubService extends ServiceMap.Service<
     readonly getPR: (
       branch: string,
     ) => Effect.Effect<
-      { number: number; url: string; state: string; base: string } | null,
+      { number: number; url: string; state: string; base: string; body: string | null } | null,
       GitHubError
     >;
     readonly isGhInstalled: () => Effect.Effect<boolean>;
@@ -35,13 +36,40 @@ export class GitHubService extends ServiceMap.Service<
 >()("@cvr/stacked/services/GitHub/GitHubService") {
   static layer: Layer.Layer<GitHubService> = Layer.sync(GitHubService, () => {
     const run = Effect.fn("gh.run")(function* (args: readonly string[]) {
-      const proc = Bun.spawn(["gh", ...args], {
-        stdout: "pipe",
-        stderr: "pipe",
+      const proc = yield* Effect.sync(() =>
+        Bun.spawn(["gh", ...args], {
+          stdout: "pipe",
+          stderr: "pipe",
+        }),
+      );
+
+      const exitCode = yield* Effect.tryPromise({
+        try: () => proc.exited,
+        catch: (e) =>
+          new GitHubError({ message: `Process failed: ${e}`, command: `gh ${args.join(" ")}` }),
+      }).pipe(
+        Effect.onInterrupt(() =>
+          Effect.sync(() => {
+            proc.kill();
+          }),
+        ),
+      );
+      const stdout = yield* Effect.tryPromise({
+        try: () => new Response(proc.stdout).text(),
+        catch: (e) =>
+          new GitHubError({
+            message: `Failed to read stdout: ${e}`,
+            command: `gh ${args.join(" ")}`,
+          }),
+      });
+      const stderr = yield* Effect.tryPromise({
+        try: () => new Response(proc.stderr).text(),
+        catch: (e) =>
+          new GitHubError({
+            message: `Failed to read stderr: ${e}`,
+            command: `gh ${args.join(" ")}`,
+          }),
       });
-      const exitCode = yield* Effect.promise(() => proc.exited);
-      const stdout = yield* Effect.promise(() => new Response(proc.stdout).text());
-      const stderr = yield* Effect.promise(() => new Response(proc.stderr).text());
 
       if (exitCode !== 0) {
         return yield* new GitHubError({
@@ -87,31 +115,41 @@ export class GitHubService extends ServiceMap.Service<
           "view",
           branch,
           "--json",
-          "number,url,state,baseRefName",
-        ]).pipe(Effect.catch(() => Effect.succeed(null)));
+          "number,url,state,baseRefName,body",
+        ]).pipe(Effect.catchTag("GitHubError", () => Effect.succeed(null)));
 
         if (result === null) return null;
         const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(GhPrResponse))(
           result,
-        ).pipe(Effect.catch(() => Effect.succeed(null)));
+        ).pipe(Effect.catchTag("SchemaError", () => Effect.succeed(null)));
         if (data === null) return null;
         return {
           number: data.number,
           url: data.url,
           state: data.state,
           base: data.baseRefName,
+          body: data.body,
         };
       }),
 
       isGhInstalled: () =>
-        Effect.sync(() => {
-          try {
-            Bun.spawnSync(["gh", "--version"]);
-            return true;
-          } catch {
-            return false;
-          }
-        }),
+        Effect.try({
+          try: () =>
+            Bun.spawn(["gh", "--version"], {
+              stdout: "ignore",
+              stderr: "ignore",
+            }),
+          catch: () => null,
+        }).pipe(
+          Effect.andThen((proc) => {
+            if (proc === null) return Effect.succeed(false);
+            return Effect.tryPromise({
+              try: () => proc.exited,
+              catch: () => -1,
+            }).pipe(Effect.map((code) => code === 0));
+          }),
+          Effect.catch(() => Effect.succeed(false)),
+        ),
     };
   });
 

package/src/services/Stack.ts

@@ -1,4 +1,5 @@
 import { Effect, Layer, Ref, Schema, ServiceMap } from "effect";
+import { rename } from "node:fs/promises";
 import type { GitError } from "../errors/index.js";
 import { StackError } from "../errors/index.js";
 import { GitService } from "./Git.js";
@@ -34,10 +35,11 @@ export class StackService extends ServiceMap.Service<
     ) => Effect.Effect<void, StackError>;
     readonly removeBranch: (stackName: string, branch: string) => Effect.Effect<void, StackError>;
     readonly createStack: (name: string, branches: string[]) => Effect.Effect<void, StackError>;
+    readonly findBranchStack: (
+      branch: string,
+    ) => Effect.Effect<{ name: string; stack: Stack } | null, StackError>;
     readonly getTrunk: () => Effect.Effect<string, StackError>;
     readonly setTrunk: (name: string) => Effect.Effect<void, StackError>;
-    readonly parentOf: (branch: string) => Effect.Effect<string, StackError>;
-    readonly childrenOf: (branch: string) => Effect.Effect<string[], StackError>;
   }
 >()("@cvr/stacked/services/Stack/StackService") {
   static layer: Layer.Layer<StackService, never, GitService> = Layer.effect(
@@ -47,7 +49,7 @@ export class StackService extends ServiceMap.Service<
 
       const stackFilePath = Effect.fn("stackFilePath")(function* () {
         const gitDir = yield* git
-          .revParse("--git-dir")
+          .revParse("--absolute-git-dir")
           .pipe(
             Effect.mapError(
               (e) => new StackError({ message: `Not a git repository: ${e.message}` }),
@@ -60,25 +62,64 @@ export class StackService extends ServiceMap.Service<
       const decodeStackFile = Schema.decodeUnknownEffect(StackFileJson);
       const encodeStackFile = Schema.encodeEffect(StackFileJson);
 
+      const detectTrunk = Effect.fn("StackService.detectTrunk")(function* () {
+        // Check common default branch names
+        for (const candidate of ["main", "master", "develop"]) {
+          const exists = yield* git
+            .branchExists(candidate)
+            .pipe(Effect.catchTag("GitError", () => Effect.succeed(false)));
+          if (exists) return candidate;
+        }
+        return "main";
+      });
+
       const load = Effect.fn("StackService.load")(function* () {
         const path = yield* stackFilePath();
         const file = Bun.file(path);
-        const exists = yield* Effect.promise(() => file.exists());
-        if (!exists) return emptyStackFile;
-        const text = yield* Effect.promise(() => file.text());
+        const exists = yield* Effect.tryPromise({
+          try: () => file.exists(),
+          catch: () => new StackError({ message: `Failed to check if ${path} exists` }),
+        });
+        if (!exists) {
+          const trunk = yield* detectTrunk();
+          return { ...emptyStackFile, trunk } satisfies StackFile;
+        }
+        const text = yield* Effect.tryPromise({
+          try: () => file.text(),
+          catch: () => new StackError({ message: `Failed to read ${path}` }),
+        });
         return yield* decodeStackFile(text).pipe(
-          Effect.catch(() => Effect.succeed(emptyStackFile)),
+          Effect.catchTag("SchemaError", (e) =>
+            Effect.gen(function* () {
+              const backupPath = `${path}.backup`;
+              yield* Effect.tryPromise({
+                try: () => Bun.write(backupPath, text),
+                catch: () => new StackError({ message: `Failed to write backup to ${backupPath}` }),
+              });
+              yield* Effect.logWarning(
+                `Corrupted stack file, resetting: ${e.message}\nBackup saved to ${backupPath}`,
+              );
+              const trunk = yield* detectTrunk();
+              return { ...emptyStackFile, trunk } satisfies StackFile;
+            }),
+          ),
         );
       });
 
       const save = Effect.fn("StackService.save")(function* (data: StackFile) {
         const path = yield* stackFilePath();
+        const tmpPath = `${path}.tmp`;
         const text = yield* encodeStackFile(data).pipe(
           Effect.mapError(() => new StackError({ message: `Failed to encode stack data` })),
         );
-        yield* Effect.promise(() => Bun.write(path, text + "\n")).pipe(
-          Effect.mapError(() => new StackError({ message: `Failed to write ${path}` })),
-        );
+        yield* Effect.tryPromise({
+          try: () => Bun.write(tmpPath, text + "\n"),
+          catch: () => new StackError({ message: `Failed to write ${tmpPath}` }),
+        });
+        yield* Effect.tryPromise({
+          try: () => rename(tmpPath, path),
+          catch: () => new StackError({ message: `Failed to rename ${tmpPath} to ${path}` }),
+        });
       });
 
       const findBranchStack = (data: StackFile, branch: string) => {
@@ -94,6 +135,9 @@ export class StackService extends ServiceMap.Service<
         load: () => load(),
         save: (data) => save(data),
 
+        findBranchStack: (branch: string) =>
+          load().pipe(Effect.map((data) => findBranchStack(data, branch))),
+
         currentStack: Effect.fn("StackService.currentStack")(function* () {
           const branch = yield* git.currentBranch();
           const data = yield* load();
@@ -106,6 +150,12 @@ export class StackService extends ServiceMap.Service<
           after?: string,
         ) {
           const data = yield* load();
+          const existing = findBranchStack(data, branch);
+          if (existing !== null) {
+            return yield* new StackError({
+              message: `Branch "${branch}" is already in stack "${existing.name}"`,
+            });
+          }
           const stack = data.stacks[stackName];
           if (stack === undefined) {
             return yield* new StackError({ message: `Stack "${stackName}" not found` });
@@ -172,34 +222,11 @@ export class StackService extends ServiceMap.Service<
           const data = yield* load();
           yield* save({ ...data, trunk: name });
         }),
-
-        parentOf: Effect.fn("StackService.parentOf")(function* (branch: string) {
-          const data = yield* load();
-          for (const stack of Object.values(data.stacks)) {
-            const idx = stack.branches.indexOf(branch);
-            if (idx === 0) return data.trunk;
-            if (idx > 0) return stack.branches[idx - 1] ?? data.trunk;
-          }
-          return yield* new StackError({ message: `Branch "${branch}" not found in any stack` });
-        }),
-
-        childrenOf: Effect.fn("StackService.childrenOf")(function* (branch: string) {
-          const data = yield* load();
-          const children: string[] = [];
-          for (const stack of Object.values(data.stacks)) {
-            const idx = stack.branches.indexOf(branch);
-            const child = stack.branches[idx + 1];
-            if (idx !== -1 && child !== undefined) {
-              children.push(child);
-            }
-          }
-          return children;
-        }),
       };
     }),
   );
 
-  static layerTest = (data?: StackFile) => {
+  static layerTest = (data?: StackFile, options?: { currentBranch?: string }) => {
     const initial = data ?? emptyStackFile;
     return Layer.effect(
       StackService,
@@ -219,9 +246,12 @@ export class StackService extends ServiceMap.Service<
           load: () => Ref.get(ref),
           save: (d) => Ref.set(ref, d),
 
+          findBranchStack: (branch: string) =>
+            Ref.get(ref).pipe(Effect.map((d) => findBranchStack(d, branch))),
+
           currentStack: Effect.fn("test.currentStack")(function* () {
             const d = yield* Ref.get(ref);
-            return findBranchStack(d, "test-branch");
+            return findBranchStack(d, options?.currentBranch ?? "test-branch");
           }),
 
           addBranch: Effect.fn("test.addBranch")(function* (
@@ -269,29 +299,6 @@ export class StackService extends ServiceMap.Service<
 
           getTrunk: () => Ref.get(ref).pipe(Effect.map((d) => d.trunk)),
           setTrunk: (name: string) => Ref.update(ref, (d) => ({ ...d, trunk: name })),
-
-          parentOf: Effect.fn("test.parentOf")(function* (branch: string) {
-            const d = yield* Ref.get(ref);
-            for (const stack of Object.values(d.stacks)) {
-              const idx = stack.branches.indexOf(branch);
-              if (idx === 0) return d.trunk;
-              if (idx > 0) return stack.branches[idx - 1] ?? d.trunk;
-            }
-            return yield* new StackError({ message: `Branch "${branch}" not found in any stack` });
-          }),
-
-          childrenOf: Effect.fn("test.childrenOf")(function* (branch: string) {
-            const d = yield* Ref.get(ref);
-            const children: string[] = [];
-            for (const stack of Object.values(d.stacks)) {
-              const idx = stack.branches.indexOf(branch);
-              const child = stack.branches[idx + 1];
-              if (idx !== -1 && child !== undefined) {
-                children.push(child);
-              }
-            }
-            return children;
-          }),
         };
       }),
     );