@cvr/stacked 0.4.2 → 0.4.4

package/src/commands/sync.ts

@@ -1,8 +1,10 @@
 import { Command, Flag } 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";
 import { ErrorCode, StackError } from "../errors/index.js";
+import { refreshStackedPRBodies } from "./helpers/pr-metadata.js";
 import { withSpinner, success, warn } from "../ui.js";
 
 const trunkFlag = Flag.string("trunk").pipe(
@@ -43,6 +45,7 @@ export const sync = Command.make("sync", {
   Command.withHandler(({ trunk: trunkOpt, from: fromOpt, json, dryRun }) =>
     Effect.gen(function* () {
       const git = yield* GitService;
+      const gh = yield* GitHubService;
       const stacks = yield* StackService;
 
       const trunk = Option.isSome(trunkOpt) ? trunkOpt.value : yield* stacks.getTrunk();
@@ -116,21 +119,21 @@ export const sync = Command.make("sync", {
         return;
       }
 
-      yield* withSpinner(`Fetching ${trunk}`, git.fetch());
-      yield* git.checkout(trunk);
-      yield* withSpinner(`Rebasing ${trunk} onto ${originTrunk}`, git.rebase(originTrunk)).pipe(
-        Effect.catchTag("GitError", (e) =>
-          Effect.fail(
-            new StackError({
-              code: ErrorCode.REBASE_CONFLICT,
-              message: `Rebase conflict on ${trunk}: ${e.message}\n\nResolve conflicts, then run:\n  git rebase --continue`,
-            }),
+      yield* Effect.gen(function* () {
+        yield* withSpinner(`Fetching ${trunk}`, git.fetch());
+        yield* git.checkout(trunk);
+        yield* withSpinner(`Rebasing ${trunk} onto ${originTrunk}`, git.rebase(originTrunk)).pipe(
+          Effect.catchTag("GitError", (e) =>
+            Effect.fail(
+              new StackError({
+                code: ErrorCode.REBASE_CONFLICT,
+                message: `Rebase conflict on ${trunk}: ${e.message}\n\nResolve conflicts, then run:\n  git rebase --continue`,
+              }),
+            ),
           ),
-        ),
-      );
-      results.push({ name: trunk, action: "rebased", base: originTrunk });
+        );
+        results.push({ name: trunk, action: "rebased", base: originTrunk });
 
-      yield* Effect.gen(function* () {
         for (let i = startIdx; i < branches.length; i++) {
           const branch = branches[i];
           if (branch === undefined) continue;
@@ -172,6 +175,23 @@ export const sync = Command.make("sync", {
         ),
       );
 
+      const ghInstalled = yield* gh.isGhInstalled();
+      if (ghInstalled) {
+        const prMap = yield* refreshStackedPRBodies({
+          branches,
+          stackName: result.name,
+          gh,
+        });
+        const mergedBranches = branches.filter(
+          (branch) => (prMap.get(branch)?.state ?? "") === "MERGED",
+        );
+        const activeBranches = branches.filter(
+          (branch) => (prMap.get(branch)?.state ?? "") !== "MERGED",
+        );
+        yield* stacks.markMergedBranches(mergedBranches);
+        yield* stacks.unmarkMergedBranches(activeBranches);
+      }
+
       if (json) {
         // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
         yield* Console.log(JSON.stringify({ branches: results }, null, 2));

package/src/main.ts

@@ -3,7 +3,7 @@ import { Command } from "effect/unstable/cli";
 import { BunRuntime, BunServices } from "@effect/platform-bun";
 import { Console, Effect, Layer } from "effect";
 import { command } from "./commands/index.js";
-import { GitService } from "./services/Git.js";
+import { gitBackendConfig, gitServiceLayerForBackend } from "./services/git-backend.js";
 import { StackService } from "./services/Stack.js";
 import { GitHubService } from "./services/GitHub.js";
 import { OutputConfig } from "./ui.js";
@@ -41,13 +41,6 @@ const cli = Command.run(command, {
   version,
 });
 
-const ServiceLayer = StackService.layer.pipe(
-  Layer.provideMerge(GitService.layer),
-  Layer.provideMerge(GitHubService.layer),
-);
-
-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([
@@ -73,25 +66,34 @@ const handleKnownError = (e: { message: string; code?: string | undefined }) =>
 
 // @effect-diagnostics-next-line effect/strictEffectProvide:off
 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}` });
-      },
-    ),
-  ),
+  Effect.gen(function* () {
+    const gitBackend = yield* gitBackendConfig;
+    const serviceLayer = StackService.layer.pipe(
+      Layer.provideMerge(gitServiceLayerForBackend(gitBackend)),
+      Layer.provideMerge(GitHubService.layer),
+    );
+    const appLayer = Layer.mergeAll(serviceLayer, BunServices.layer);
+
+    yield* 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

@@ -28,6 +28,11 @@ export class GitService extends ServiceMap.Service<
     readonly revParse: (ref: string) => Effect.Effect<string, GitError>;
     readonly isAncestor: (ancestor: string, descendant: string) => Effect.Effect<boolean, GitError>;
     readonly mergeBase: (a: string, b: string) => Effect.Effect<string, GitError>;
+    readonly firstParentUniqueCommits: (
+      ref: string,
+      base: string,
+      options?: { limit?: number },
+    ) => Effect.Effect<readonly string[], GitError>;
     readonly isRebaseInProgress: () => Effect.Effect<boolean>;
     readonly commitAmend: (options?: { edit?: boolean }) => Effect.Effect<void, GitError>;
     readonly fetch: (remote?: string) => Effect.Effect<void, GitError>;
@@ -163,6 +168,20 @@ export class GitService extends ServiceMap.Service<
 
       mergeBase: (a, b) => run(["merge-base", a, b]),
 
+      firstParentUniqueCommits: (ref, base, options) => {
+        const args = ["rev-list", "--first-parent"];
+        if (options?.limit !== undefined) args.push("--max-count", `${options.limit}`);
+        args.push(ref, `^${base}`);
+        return run(args).pipe(
+          Effect.map((output) =>
+            output
+              .split("\n")
+              .map((line) => line.trim())
+              .filter((line) => line.length > 0),
+          ),
+        );
+      },
+
       isRebaseInProgress: () =>
         run(["rev-parse", "--git-dir"]).pipe(
           Effect.map(
@@ -203,6 +222,7 @@ export class GitService extends ServiceMap.Service<
       revParse: () => Effect.succeed("abc123"),
       isAncestor: () => Effect.succeed(true),
       mergeBase: () => Effect.succeed("abc123"),
+      firstParentUniqueCommits: () => Effect.succeed([]),
       isRebaseInProgress: () => Effect.succeed(false),
       commitAmend: () => Effect.void,
       fetch: () => Effect.void,

package/src/services/GitEs.ts

@@ -0,0 +1,309 @@
+import { existsSync } from "node:fs";
+import { Effect, Layer, Option } from "effect";
+import { openRepository, type Repository, type SignaturePayload } from "es-git";
+import { GitError } from "../errors/index.js";
+import { GitService } from "./Git.js";
+
+const makeGitError = (command: string, error: unknown) =>
+  new GitError({
+    message: error instanceof Error ? error.message : String(error),
+    command,
+  });
+
+const resolveSignature = (repo: Repository): SignaturePayload => {
+  const config = repo.config();
+  const name =
+    process.env["GIT_COMMITTER_NAME"] ??
+    process.env["GIT_AUTHOR_NAME"] ??
+    config.findString("user.name");
+  const email =
+    process.env["GIT_COMMITTER_EMAIL"] ??
+    process.env["GIT_AUTHOR_EMAIL"] ??
+    config.findString("user.email");
+
+  if (name === null || name === undefined || email === null || email === undefined) {
+    throw makeGitError("es-git.signature", "Missing git user.name or user.email");
+  }
+
+  return { name, email };
+};
+
+const refName = (name: string) => (name.startsWith("refs/") ? name : `refs/heads/${name}`);
+
+const resolveOid = (repo: Repository, ref: string): string => {
+  if (ref === "--absolute-git-dir" || ref === "--git-dir") {
+    return repo.path();
+  }
+
+  return repo.revparseSingle(ref);
+};
+
+const performRebase = (
+  repo: Repository,
+  branchRef: string,
+  upstreamRef: string,
+  ontoRef: string,
+): void => {
+  const branch = repo.getAnnotatedCommitFromReference(repo.getReference(branchRef));
+  const upstream = repo.getAnnotatedCommit(repo.getCommit(resolveOid(repo, upstreamRef)));
+  const onto = repo.getAnnotatedCommit(repo.getCommit(resolveOid(repo, ontoRef)));
+  const signature = resolveSignature(repo);
+  const rebase = repo.rebase(branch, upstream, onto);
+  while (true) {
+    const operation = rebase.next();
+    if (operation === null) break;
+    rebase.commit({ committer: signature });
+  }
+
+  rebase.finish(signature);
+};
+
+export const GitEsLayer = Layer.effect(
+  GitService,
+  Effect.gen(function* () {
+    const cwd = process.cwd();
+    const repo = yield* Effect.tryPromise({
+      try: () => openRepository(cwd),
+      catch: (error) => makeGitError(`es-git.openRepository ${cwd}`, error),
+    });
+
+    return {
+      currentBranch: () =>
+        Effect.try({
+          try: () => {
+            const branch = repo.head().shorthand();
+            if (branch === "HEAD") {
+              throw makeGitError(
+                "es-git.currentBranch",
+                "HEAD is detached — checkout a branch first",
+              );
+            }
+            return branch;
+          },
+          catch: (error) => makeGitError("es-git.currentBranch", error),
+        }),
+
+      listBranches: () =>
+        Effect.try({
+          try: () =>
+            [...repo.branches({ type: "Local" })]
+              .map(({ name }) => ({
+                name,
+                commitTime: repo
+                  .getCommit(resolveOid(repo, refName(name)))
+                  .time()
+                  .getTime(),
+              }))
+              .sort((a, b) => b.commitTime - a.commitTime)
+              .map(({ name }) => name),
+          catch: (error) => makeGitError("es-git.listBranches", error),
+        }),
+
+      branchExists: (name) =>
+        Effect.try({
+          try: () => repo.findBranch(name, "Local") !== null,
+          catch: (error) => makeGitError(`es-git.branchExists ${name}`, error),
+        }),
+
+      remoteDefaultBranch: (remote = "origin") =>
+        Effect.try({
+          try: () => {
+            const ref = repo.findReference(`refs/remotes/${remote}/HEAD`);
+            if (ref === null) return Option.none();
+            const target = ref.resolve().shorthand();
+            return Option.some(target.replace(new RegExp(`^${remote}/`), ""));
+          },
+          catch: (error) => makeGitError(`es-git.remoteDefaultBranch ${remote}`, error),
+        }).pipe(Effect.catchTag("GitError", () => Effect.succeed(Option.none()))),
+
+      createBranch: (name, from) =>
+        Effect.try({
+          try: () => {
+            const commit = repo.getCommit(resolveOid(repo, from ?? "HEAD"));
+            repo.createBranch(name, commit);
+            repo.setHead(refName(name));
+            repo.checkoutHead();
+          },
+          catch: (error) => makeGitError(`es-git.createBranch ${name}`, error),
+        }).pipe(Effect.asVoid),
+
+      deleteBranch: (name) =>
+        Effect.try({
+          try: () => {
+            repo.getBranch(name, "Local").delete();
+          },
+          catch: (error) => makeGitError(`es-git.deleteBranch ${name}`, error),
+        }).pipe(Effect.asVoid),
+
+      checkout: (name) =>
+        Effect.try({
+          try: () => {
+            repo.setHead(refName(name));
+            repo.checkoutHead();
+          },
+          catch: (error) => makeGitError(`es-git.checkout ${name}`, error),
+        }).pipe(Effect.asVoid),
+
+      rebase: (onto) =>
+        Effect.try({
+          try: () => {
+            const headRef = repo.head().resolve();
+            const headOid = headRef.target();
+            if (headOid === null) {
+              throw makeGitError(`es-git.rebase ${onto}`, "HEAD has no target");
+            }
+
+            const ontoOid = resolveOid(repo, onto);
+            const upstreamOid = repo.getMergeBase(headOid, ontoOid);
+            performRebase(repo, headRef.name(), upstreamOid, onto);
+          },
+          catch: (error) => makeGitError(`es-git.rebase ${onto}`, error),
+        }).pipe(Effect.asVoid),
+
+      rebaseOnto: (branch, newBase, oldBase) =>
+        Effect.try({
+          try: () => {
+            performRebase(repo, refName(branch), oldBase, newBase);
+          },
+          catch: (error) =>
+            makeGitError(`es-git.rebaseOnto ${branch} ${newBase} ${oldBase}`, error),
+        }).pipe(Effect.asVoid),
+
+      rebaseAbort: () =>
+        Effect.try({
+          try: () => {
+            repo.openRebase().abort();
+          },
+          catch: (error) => makeGitError("es-git.rebaseAbort", error),
+        }).pipe(Effect.asVoid),
+
+      push: (branch, options) =>
+        Effect.tryPromise({
+          try: async () => {
+            const remote = repo.getRemote("origin");
+            const forcePrefix = options?.force === true ? "+" : "";
+            await remote.push([`${forcePrefix}refs/heads/${branch}:refs/heads/${branch}`]);
+            const localBranch = repo.findBranch(branch, "Local");
+            localBranch?.setUpstream(`origin/${branch}`);
+          },
+          catch: (error) => makeGitError(`es-git.push ${branch}`, error),
+        }).pipe(Effect.asVoid),
+
+      log: (branch, options) =>
+        Effect.try({
+          try: () => {
+            const revwalk = repo.revwalk();
+            revwalk.push(resolveOid(repo, branch));
+
+            const lines: string[] = [];
+            while (lines.length < (options?.limit ?? Number.POSITIVE_INFINITY)) {
+              const oid = revwalk.next();
+              if (oid === null) break;
+
+              if (options?.oneline === true) {
+                const summary = repo.getCommit(oid).summary() ?? "";
+                lines.push(`${oid.slice(0, 7)} ${summary}`.trim());
+              } else {
+                lines.push(oid);
+              }
+            }
+
+            return lines.join("\n");
+          },
+          catch: (error) => makeGitError(`es-git.log ${branch}`, error),
+        }),
+
+      isClean: () =>
+        Effect.try({
+          try: () => repo.statuses().isEmpty(),
+          catch: (error) => makeGitError("es-git.isClean", error),
+        }),
+
+      revParse: (ref) =>
+        Effect.try({
+          try: () => resolveOid(repo, ref),
+          catch: (error) => makeGitError(`es-git.revParse ${ref}`, error),
+        }),
+
+      isAncestor: (ancestor, descendant) =>
+        Effect.try({
+          try: () =>
+            repo.getMergeBase(resolveOid(repo, ancestor), resolveOid(repo, descendant)) ===
+            resolveOid(repo, ancestor),
+          catch: (error) => makeGitError(`es-git.isAncestor ${ancestor} ${descendant}`, error),
+        }).pipe(Effect.catchTag("GitError", () => Effect.succeed(false))),
+
+      mergeBase: (a, b) =>
+        Effect.try({
+          try: () => repo.getMergeBase(resolveOid(repo, a), resolveOid(repo, b)),
+          catch: (error) => makeGitError(`es-git.mergeBase ${a} ${b}`, error),
+        }),
+
+      firstParentUniqueCommits: (ref, base, options) =>
+        Effect.try({
+          try: () => {
+            const revwalk = repo.revwalk();
+            revwalk.simplifyFirstParent();
+            revwalk.push(resolveOid(repo, ref));
+            revwalk.hide(resolveOid(repo, base));
+
+            const commits: string[] = [];
+            const limit = options?.limit ?? Number.POSITIVE_INFINITY;
+            while (commits.length < limit) {
+              const oid = revwalk.next();
+              if (oid === null) break;
+              commits.push(oid);
+            }
+
+            return commits;
+          },
+          catch: (error) => makeGitError(`es-git.firstParentUniqueCommits ${ref} ${base}`, error),
+        }),
+
+      isRebaseInProgress: () =>
+        Effect.try({
+          try: () => {
+            const state = repo.state();
+            if (state === "Rebase" || state === "RebaseInteractive" || state === "RebaseMerge") {
+              return true;
+            }
+
+            const gitDir = repo.path();
+            return existsSync(`${gitDir}/rebase-merge`) || existsSync(`${gitDir}/rebase-apply`);
+          },
+          catch: (error) => makeGitError("es-git.isRebaseInProgress", error),
+        }).pipe(Effect.catchTag("GitError", () => Effect.succeed(false))),
+
+      commitAmend: () =>
+        Effect.try({
+          try: () => {
+            const headOid = repo.head().target();
+            if (headOid === null) {
+              throw makeGitError("es-git.commitAmend", "HEAD has no target");
+            }
+            repo.getCommit(headOid).amend({
+              updateRef: "HEAD",
+              committer: resolveSignature(repo),
+            });
+          },
+          catch: (error) => makeGitError("es-git.commitAmend", error),
+        }).pipe(Effect.asVoid),
+
+      fetch: (remote = "origin") =>
+        Effect.tryPromise({
+          try: async () => {
+            await repo.getRemote(remote).fetch([]);
+          },
+          catch: (error) => makeGitError(`es-git.fetch ${remote}`, error),
+        }).pipe(Effect.asVoid),
+
+      deleteRemoteBranch: (branch) =>
+        Effect.tryPromise({
+          try: async () => {
+            await repo.getRemote("origin").push([`:refs/heads/${branch}`]);
+          },
+          catch: (error) => makeGitError(`es-git.deleteRemoteBranch ${branch}`, error),
+        }).pipe(Effect.asVoid),
+    };
+  }),
+);