@cvr/stacked 0.1.0

package/src/commands/restack.ts

@@ -0,0 +1,40 @@
+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");
+    }),
+  ),
+);

package/src/commands/submit.ts

@@ -0,0 +1,68 @@
+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 { GitHubService } from "../services/GitHub.js";
+
+const draftFlag = Flag.boolean("draft").pipe(Flag.withAlias("d"));
+const forceFlag = Flag.boolean("force").pipe(Flag.withAlias("f"));
+const dryRunFlag = Flag.boolean("dry-run");
+
+export const submit = Command.make("submit", {
+  draft: draftFlag,
+  force: forceFlag,
+  dryRun: dryRunFlag,
+}).pipe(
+  Command.withDescription("Push all stack branches and create/update PRs via gh"),
+  Command.withHandler(({ draft, force, dryRun }) =>
+    Effect.gen(function* () {
+      const git = yield* GitService;
+      const stacks = yield* StackService;
+      const gh = yield* GitHubService;
+
+      const result = yield* stacks.currentStack();
+      if (result === null) {
+        yield* Console.error("Not on a stacked branch");
+        return;
+      }
+
+      const trunk = yield* stacks.getTrunk();
+      const { branches } = result.stack;
+
+      for (let i = 0; i < branches.length; i++) {
+        const branch = branches[i];
+        if (branch === undefined) continue;
+        const base = i === 0 ? trunk : (branches[i - 1] ?? trunk);
+
+        if (dryRun) {
+          yield* Console.log(`Would push ${branch} and create/update PR (base: ${base})`);
+          continue;
+        }
+
+        yield* Console.log(`Pushing ${branch}...`);
+        yield* git.push(branch, { force });
+
+        const existingPR = yield* gh.getPR(branch);
+
+        if (existingPR !== null) {
+          if (existingPR.base !== base) {
+            yield* Console.log(`Updating PR #${existingPR.number} base to ${base}`);
+            yield* gh.updatePR({ branch, base });
+          } else {
+            yield* Console.log(`PR #${existingPR.number} already exists: ${existingPR.url}`);
+          }
+        } else {
+          const pr = yield* gh.createPR({
+            head: branch,
+            base,
+            title: branch,
+            draft,
+          });
+          yield* Console.log(`Created PR #${pr.number}: ${pr.url}`);
+        }
+      }
+
+      yield* Console.log("Done");
+    }),
+  ),
+);

package/src/commands/sync.ts

@@ -0,0 +1,42 @@
+import { Command, Flag } from "effect/unstable/cli";
+import { Console, Effect, Option } from "effect";
+import { GitService } from "../services/Git.js";
+import { StackService } from "../services/Stack.js";
+
+const trunkFlag = Flag.string("trunk").pipe(Flag.optional, Flag.withAlias("t"));
+
+export const sync = Command.make("sync", { trunk: trunkFlag }).pipe(
+  Command.withDescription("Rebase entire stack on latest trunk"),
+  Command.withHandler(({ trunk: trunkOpt }) =>
+    Effect.gen(function* () {
+      const git = yield* GitService;
+      const stacks = yield* StackService;
+
+      const trunk = Option.isSome(trunkOpt) ? trunkOpt.value : yield* stacks.getTrunk();
+      const currentBranch = yield* git.currentBranch();
+
+      yield* Console.log(`Fetching ${trunk}...`);
+      yield* git.fetch();
+
+      const result = yield* stacks.currentStack();
+      if (result === null) {
+        yield* Console.error("Not on a stacked branch");
+        return;
+      }
+
+      const { branches } = result.stack;
+
+      for (let i = 0; i < branches.length; i++) {
+        const branch = branches[i];
+        if (branch === undefined) continue;
+        const base = i === 0 ? `origin/${trunk}` : (branches[i - 1] ?? `origin/${trunk}`);
+        yield* Console.log(`Rebasing ${branch} onto ${base}...`);
+        yield* git.checkout(branch);
+        yield* git.rebase(base);
+      }
+
+      yield* git.checkout(currentBranch);
+      yield* Console.log("Stack synced");
+    }),
+  ),
+);

package/src/commands/top.ts

@@ -0,0 +1,29 @@
+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 top = Command.make("top").pipe(
+  Command.withDescription("Checkout top branch of stack"),
+  Command.withHandler(() =>
+    Effect.gen(function* () {
+      const git = yield* GitService;
+      const stacks = yield* StackService;
+
+      const result = yield* stacks.currentStack();
+      if (result === null) {
+        yield* Console.error("Not on a stacked branch");
+        return;
+      }
+
+      const topBranch = result.stack.branches[result.stack.branches.length - 1];
+      if (topBranch === undefined) {
+        yield* Console.error("Stack is empty");
+        return;
+      }
+
+      yield* git.checkout(topBranch);
+      yield* Console.log(`Switched to ${topBranch}`);
+    }),
+  ),
+);

package/src/commands/trunk.ts

@@ -0,0 +1,21 @@
+import { Argument, Command } from "effect/unstable/cli";
+import { Console, Effect, Option } from "effect";
+import { StackService } from "../services/Stack.js";
+
+const nameArg = Argument.string("name").pipe(Argument.optional);
+
+export const trunk = Command.make("trunk", { name: nameArg }).pipe(
+  Command.withDescription("Get or set the trunk branch"),
+  Command.withHandler(({ name }) =>
+    Effect.gen(function* () {
+      const stacks = yield* StackService;
+      if (Option.isSome(name)) {
+        yield* stacks.setTrunk(name.value);
+        yield* Console.log(`Trunk set to ${name.value}`);
+      } else {
+        const current = yield* stacks.getTrunk();
+        yield* Console.log(current);
+      }
+    }),
+  ),
+);

package/src/errors/index.ts

@@ -0,0 +1,15 @@
+import { Schema } from "effect";
+
+export class GitError extends Schema.TaggedErrorClass<GitError>()("GitError", {
+  message: Schema.String,
+  command: Schema.optional(Schema.String),
+}) {}
+
+export class StackError extends Schema.TaggedErrorClass<StackError>()("StackError", {
+  message: Schema.String,
+}) {}
+
+export class GitHubError extends Schema.TaggedErrorClass<GitHubError>()("GitHubError", {
+  message: Schema.String,
+  command: Schema.optional(Schema.String),
+}) {}

package/src/main.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+import { Command } from "effect/unstable/cli";
+import { BunRuntime, BunServices } from "@effect/platform-bun";
+import { 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";
+
+const cli = Command.run(command, {
+  version: "0.1.0",
+});
+
+const ServiceLayer = StackService.layer.pipe(
+  Layer.provideMerge(GitService.layer),
+  Layer.provideMerge(GitHubService.layer),
+);
+
+const AppLayer = Layer.mergeAll(ServiceLayer, BunServices.layer);
+
+// @effect-diagnostics-next-line effect/strictEffectProvide:off
+BunRuntime.runMain(cli.pipe(Effect.provide(AppLayer)));

package/src/services/Git.ts

@@ -0,0 +1,127 @@
+import { Effect, Layer, ServiceMap } from "effect";
+import { GitError } from "../errors/index.js";
+
+export class GitService extends ServiceMap.Service<
+  GitService,
+  {
+    readonly currentBranch: () => 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 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 fetch: (remote?: 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 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({
+          message: stderr.trim() || `git ${args[0]} failed with exit code ${exitCode}`,
+          command: `git ${args.join(" ")}`,
+        });
+      }
+      return stdout.trim();
+    });
+
+    return {
+      currentBranch: () => run(["rev-parse", "--abbrev-ref", "HEAD"]),
+
+      branchExists: (name) =>
+        run(["rev-parse", "--verify", name]).pipe(
+          Effect.as(true),
+          Effect.catch(() => Effect.succeed(false)),
+        ),
+
+      createBranch: (name, from) => {
+        const args = from !== undefined ? ["checkout", "-b", name, from] : ["checkout", "-b", name];
+        return run(args).pipe(Effect.asVoid);
+      },
+
+      deleteBranch: (name, force) =>
+        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),
+
+      push: (branch, options) => {
+        const args = ["push", "-u", "origin", branch];
+        if (options?.force === true) args.splice(1, 0, "--force-with-lease");
+        return run(args).pipe(Effect.asVoid);
+      },
+
+      log: (branch, options) => {
+        const args = ["log", branch];
+        if (options?.oneline === true) args.push("--oneline");
+        if (options?.limit !== undefined) args.push("-n", `${options.limit}`);
+        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.catch(() => Effect.succeed(false)),
+        ),
+
+      remote: () => run(["remote"]),
+
+      fetch: (remote) => run(["fetch", remote ?? "origin"]).pipe(Effect.asVoid),
+    };
+  });
+
+  static layerTest = (impl: Partial<ServiceMap.Service.Shape<typeof GitService>> = {}) =>
+    Layer.succeed(GitService, {
+      currentBranch: () => Effect.succeed("main"),
+      branchExists: () => Effect.succeed(false),
+      createBranch: () => Effect.void,
+      deleteBranch: () => Effect.void,
+      checkout: () => Effect.void,
+      rebase: () => 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"),
+      fetch: () => Effect.void,
+      ...impl,
+    });
+}

package/src/services/GitHub.ts

@@ -0,0 +1,126 @@
+import { Effect, Layer, Schema, ServiceMap } from "effect";
+import { GitHubError } from "../errors/index.js";
+
+const GhPrResponse = Schema.Struct({
+  number: Schema.Number,
+  url: Schema.String,
+  state: Schema.String,
+  baseRefName: Schema.String,
+});
+
+export class GitHubService extends ServiceMap.Service<
+  GitHubService,
+  {
+    readonly createPR: (options: {
+      head: string;
+      base: string;
+      title: string;
+      body?: string;
+      draft?: boolean;
+    }) => Effect.Effect<{ url: string; number: number }, GitHubError>;
+    readonly updatePR: (options: {
+      branch: string;
+      base?: string;
+      title?: string;
+      body?: string;
+    }) => Effect.Effect<void, GitHubError>;
+    readonly getPR: (
+      branch: string,
+    ) => Effect.Effect<
+      { number: number; url: string; state: string; base: string } | null,
+      GitHubError
+    >;
+    readonly isGhInstalled: () => Effect.Effect<boolean>;
+  }
+>()("@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 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({
+          message: stderr.trim() || `gh ${args[0]} failed with exit code ${exitCode}`,
+          command: `gh ${args.join(" ")}`,
+        });
+      }
+      return stdout.trim();
+    });
+
+    return {
+      createPR: Effect.fn("GitHubService.createPR")(function* (options) {
+        const args = [
+          "pr",
+          "create",
+          "--head",
+          options.head,
+          "--base",
+          options.base,
+          "--title",
+          options.title,
+        ];
+        if (options.body !== undefined) args.push("--body", options.body);
+        if (options.draft === true) args.push("--draft");
+        const output = yield* run(args);
+        const url = output.trim();
+        const match = url.match(/\/(\d+)$/);
+        const number = match?.[1] !== undefined ? parseInt(match[1], 10) : 0;
+        return { url, number };
+      }),
+
+      updatePR: Effect.fn("GitHubService.updatePR")(function* (options) {
+        const args = ["pr", "edit", options.branch];
+        if (options.base !== undefined) args.push("--base", options.base);
+        if (options.title !== undefined) args.push("--title", options.title);
+        if (options.body !== undefined) args.push("--body", options.body);
+        yield* run(args);
+      }),
+
+      getPR: Effect.fn("GitHubService.getPR")(function* (branch) {
+        const result = yield* run([
+          "pr",
+          "view",
+          branch,
+          "--json",
+          "number,url,state,baseRefName",
+        ]).pipe(Effect.catch(() => Effect.succeed(null)));
+
+        if (result === null) return null;
+        const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(GhPrResponse))(
+          result,
+        ).pipe(Effect.catch(() => Effect.succeed(null)));
+        if (data === null) return null;
+        return {
+          number: data.number,
+          url: data.url,
+          state: data.state,
+          base: data.baseRefName,
+        };
+      }),
+
+      isGhInstalled: () =>
+        Effect.sync(() => {
+          try {
+            Bun.spawnSync(["gh", "--version"]);
+            return true;
+          } catch {
+            return false;
+          }
+        }),
+    };
+  });
+
+  static layerTest = (impl: Partial<ServiceMap.Service.Shape<typeof GitHubService>> = {}) =>
+    Layer.succeed(GitHubService, {
+      createPR: () => Effect.succeed({ url: "https://github.com/test/repo/pull/1", number: 1 }),
+      updatePR: () => Effect.void,
+      getPR: () => Effect.succeed(null),
+      isGhInstalled: () => Effect.succeed(true),
+      ...impl,
+    });
+}