@cvr/stacked 0.3.0 → 0.4.1

package/src/commands/up.ts

@@ -0,0 +1,55 @@
+import { Command, Flag } from "effect/unstable/cli";
+import { Console, Effect } from "effect";
+import { GitService } from "../services/Git.js";
+import { StackService } from "../services/Stack.js";
+import { ErrorCode, StackError } from "../errors/index.js";
+import { success } from "../ui.js";
+
+const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"));
+
+export const up = Command.make("up", { json: jsonFlag }).pipe(
+  Command.withDescription("Move up one branch in the stack"),
+  Command.withExamples([{ command: "stacked up", description: "Move to the next branch above" }]),
+  Command.withHandler(({ json }) =>
+    Effect.gen(function* () {
+      const git = yield* GitService;
+      const stacks = yield* StackService;
+
+      const currentBranch = yield* git.currentBranch();
+      const result = yield* stacks.currentStack();
+      if (result === null) {
+        return yield* new StackError({
+          code: ErrorCode.NOT_IN_STACK,
+          message:
+            "Not on a stacked branch. Run 'stacked list' to see your stacks, or 'stacked create <name>' to start one.",
+        });
+      }
+
+      const { branches } = result.stack;
+      const idx = branches.indexOf(currentBranch);
+      if (idx === -1) {
+        return yield* new StackError({
+          code: ErrorCode.NOT_IN_STACK,
+          message: "Current branch not found in stack",
+        });
+      }
+
+      const next = branches[idx + 1];
+      if (next === undefined) {
+        return yield* new StackError({
+          code: ErrorCode.ALREADY_AT_TOP,
+          message: "Already at the top of the stack",
+        });
+      }
+
+      yield* git.checkout(next);
+
+      if (json) {
+        // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
+        yield* Console.log(JSON.stringify({ branch: next, from: currentBranch }, null, 2));
+      } else {
+        yield* success(`Switched to ${next}`);
+      }
+    }),
+  ),
+);

package/src/errors/index.ts

@@ -1,15 +1,51 @@
-import { Schema } from "effect";
+import { Runtime, 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),
 }) {}
+
+export class GlobalFlagConflictError extends Error {
+  override readonly name = "GlobalFlagConflictError";
+  override readonly [Runtime.errorExitCode] = 2;
+  override readonly [Runtime.errorReported] = false;
+}

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,44 @@
 #!/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";
+import { GlobalFlagConflictError } from "./errors/index.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";
+
+const preflight =
+  isVerbose && isQuiet
+    ? Console.error("Error: --verbose and --quiet are mutually exclusive").pipe(
+        Effect.andThen(Effect.fail(new GlobalFlagConflictError())),
+      )
+    : Effect.void;
+
+// ============================================================================
+// CLI
+// ============================================================================
 
 const cli = Command.run(command, {
-  version: "0.1.0",
+  version,
 });
 
 const ServiceLayer = StackService.layer.pipe(
@@ -18,5 +48,50 @@ 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(
+  preflight.pipe(
+    Effect.andThen(cli),
+    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.catchIf(
+      (e): e is GlobalFlagConflictError => e instanceof GlobalFlagConflictError,
+      Effect.fail,
+      (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";
 
@@ -11,33 +12,63 @@ export class GitService extends ServiceMap.Service<
     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({
@@ -49,10 +80,25 @@ 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(
+        run([
+          "for-each-ref",
+          "--sort=-committerdate",
+          "--format=%(refname:short)",
+          "refs/heads",
+        ]).pipe(
           Effect.map((output) =>
             output
               .split("\n")
@@ -62,9 +108,9 @@ export class GitService extends ServiceMap.Service<
         ),
 
       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) => {
@@ -73,15 +119,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);
       },
 
@@ -92,27 +144,37 @@ 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),
     };
   });
 
@@ -125,15 +187,18 @@ export class GitService extends ServiceMap.Service<
       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)),
+        ),
     };
   });