@cvr/stacked 0.4.3 → 0.5.0

package/src/commands/reorder.ts

@@ -32,12 +32,14 @@ export const reorder = Command.make("reorder", {
 
       if (Option.isNone(before) && Option.isNone(after)) {
         return yield* new StackError({
+          code: ErrorCode.USAGE_ERROR,
           message: "Specify --before or --after to indicate target position",
         });
       }
 
       if (Option.isSome(before) && Option.isSome(after)) {
         return yield* new StackError({
+          code: ErrorCode.USAGE_ERROR,
           message: "Specify either --before or --after, not both",
         });
       }
@@ -74,28 +76,22 @@ export const reorder = Command.make("reorder", {
         });
       }
 
-      // Remove from current position
-      branches.splice(currentIdx, 1);
-
-      // Insert at target position
-      const newTargetIdx = branches.indexOf(target);
-      if (Option.isSome(before)) {
-        branches.splice(newTargetIdx, 0, branch);
-      } else {
-        branches.splice(newTargetIdx + 1, 0, branch);
-      }
-
-      const data = yield* stacks.load();
-      yield* stacks.save({
-        ...data,
-        stacks: { ...data.stacks, [stackName]: { branches } },
+      const updated = yield* stacks.reorderBranch(branch, {
+        before: Option.getOrUndefined(before),
+        after: Option.getOrUndefined(after),
       });
 
       if (json) {
         // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
-        yield* Console.log(JSON.stringify({ branch, stack: stackName, branches }, null, 2));
+        yield* Console.log(
+          JSON.stringify(
+            { branch, stack: updated.name, branches: [...updated.stack.branches] },
+            null,
+            2,
+          ),
+        );
       } else {
-        yield* success(`Moved "${branch}" in stack "${stackName}"`);
+        yield* success(`Moved "${branch}" in stack "${updated.name}"`);
         yield* warn("Run 'stacked sync' to rebase branches in new order");
       }
     }),

package/src/commands/split.ts

@@ -35,17 +35,9 @@ export const split = Command.make("split", {
       }
 
       const { name: stackName, stack } = result;
-      const branches = [...stack.branches];
-      const splitIdx = branches.indexOf(branch);
-
-      if (splitIdx === 0) {
-        return yield* new StackError({
-          message: `Branch "${branch}" is at the bottom of the stack — nothing to split`,
-        });
-      }
-
-      const below = branches.slice(0, splitIdx);
-      const above = branches.slice(splitIdx);
+      const splitIdx = stack.branches.indexOf(branch);
+      const below = stack.branches.slice(0, splitIdx);
+      const above = stack.branches.slice(splitIdx);
       const newStackName = branch;
 
       if (dryRun) {
@@ -68,23 +60,7 @@ export const split = Command.make("split", {
         return;
       }
 
-      const data = yield* stacks.load();
-
-      if (data.stacks[newStackName] !== undefined) {
-        return yield* new StackError({
-          code: ErrorCode.STACK_EXISTS,
-          message: `Stack "${newStackName}" already exists — choose a different split point or rename it first`,
-        });
-      }
-
-      yield* stacks.save({
-        ...data,
-        stacks: {
-          ...data.stacks,
-          [stackName]: { branches: below },
-          [newStackName]: { branches: above },
-        },
-      });
+      yield* stacks.splitStack(branch);
 
       if (json) {
         // @effect-diagnostics-next-line effect/preferSchemaOverJson:off

package/src/commands/stacks.ts

@@ -2,7 +2,7 @@ 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 { stdout } from "../ui.js";
+import { stdout, info } from "../ui.js";
 
 const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"));
 
@@ -18,21 +18,19 @@ export const stacks = Command.make("stacks", { json: jsonFlag }).pipe(
       const stackService = yield* StackService;
 
       const currentBranch = yield* git.currentBranch();
-      const data = yield* stackService.load();
-
-      const entries = Object.entries(data.stacks);
+      const entries = yield* stackService.listStacks();
       if (entries.length === 0) {
         if (json) {
           // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
           yield* Console.log(JSON.stringify({ stacks: [] }));
         } else {
-          yield* Console.error("No stacks");
+          yield* info("No stacks");
         }
         return;
       }
 
       if (json) {
-        const stackList = entries.map(([name, stack]) => ({
+        const stackList = entries.map(({ name, stack }) => ({
           name,
           branches: stack.branches.length,
           current: stack.branches.includes(currentBranch),
@@ -43,7 +41,7 @@ export const stacks = Command.make("stacks", { json: jsonFlag }).pipe(
       }
 
       const lines: string[] = [];
-      for (const [name, stack] of entries) {
+      for (const { name, stack } of entries) {
         const isCurrent = stack.branches.includes(currentBranch);
         const marker = isCurrent ? yield* stdout.green("* ") : "  ";
         const label = isCurrent ? yield* stdout.bold(name) : name;

package/src/commands/submit.ts

@@ -4,6 +4,11 @@ import { GitService } from "../services/Git.js";
 import { StackService } from "../services/Stack.js";
 import { GitHubService } from "../services/GitHub.js";
 import { ErrorCode, StackError } from "../errors/index.js";
+import {
+  composePRBody,
+  generateStackMetadata,
+  refreshStackedPRBodies,
+} from "./helpers/pr-metadata.js";
 import { withSpinner, success } from "../ui.js";
 
 const draftFlag = Flag.boolean("draft").pipe(
@@ -38,78 +43,6 @@ interface SubmitResult {
   action: "created" | "updated" | "unchanged" | "would-create" | "would-update" | "would-unchanged";
 }
 
-const STACKED_MARKER_START = "<!-- stacked -->";
-const STACKED_MARKER_END = "<!-- /stacked -->";
-
-const generateStackMetadata = (
-  branches: readonly string[],
-  prMap: Map<string, { number: number; url: string; state: string } | null>,
-  currentIdx: number,
-  stackName: string,
-): string => {
-  const rows = branches.map((branch, i) => {
-    const pr = prMap.get(branch) ?? null;
-    const isCurrent = i === currentIdx;
-    const branchCol = isCurrent ? `**\`${branch}\`**` : `\`${branch}\``;
-    const numCol = i + 1;
-    const numStr = isCurrent ? `**${numCol}**` : `${numCol}`;
-
-    let prCol: string;
-    if (pr === null) {
-      prCol = "—";
-    } else if (pr.state === "MERGED") {
-      prCol = `[#${pr.number}](${pr.url}) ✅`;
-    } else if (isCurrent) {
-      prCol = `**#${pr.number} ← you are here**`;
-    } else {
-      prCol = `[#${pr.number}](${pr.url})`;
-    }
-
-    return `| ${numStr} | ${branchCol} | ${prCol} |`;
-  });
-
-  return [
-    STACKED_MARKER_START,
-    `**Stack: \`${stackName}\`** (${currentIdx + 1} of ${branches.length})`,
-    "",
-    "| # | Branch | PR |",
-    "|---|--------|----|",
-    ...rows,
-    STACKED_MARKER_END,
-  ].join("\n");
-};
-
-const composePRBody = (userBody: string | undefined, metadata: string): string => {
-  if (userBody !== undefined) {
-    return `${userBody}\n\n---\n\n${metadata}`;
-  }
-  return metadata;
-};
-
-const updatePRBody = (
-  existingBody: string | undefined,
-  userBody: string | undefined,
-  metadata: string,
-): string => {
-  if (userBody !== undefined) {
-    return composePRBody(userBody, metadata);
-  }
-
-  if (existingBody !== undefined) {
-    const startIdx = existingBody.indexOf(STACKED_MARKER_START);
-    if (startIdx !== -1) {
-      const prefix = existingBody.substring(0, startIdx).replace(/\n*---\n*$/, "");
-      if (prefix.trim().length > 0) {
-        return `${prefix.trim()}\n\n---\n\n${metadata}`;
-      }
-      return metadata;
-    }
-    return `${existingBody.trim()}\n\n---\n\n${metadata}`;
-  }
-
-  return metadata;
-};
-
 const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"));
 
 export const submit = Command.make("submit", {
@@ -157,6 +90,17 @@ export const submit = Command.make("submit", {
       const trunk = yield* stacks.getTrunk();
       const currentBranch = yield* git.currentBranch();
       const { branches } = result.stack;
+      const data = yield* stacks.load();
+      const mergedSet = new Set(data.mergedBranches);
+
+      // Compute the effective base for a branch at index i, skipping merged branches
+      const effectiveBase = (i: number): string => {
+        for (let j = i - 1; j >= 0; j--) {
+          const candidate = branches[j];
+          if (candidate !== undefined && !mergedSet.has(candidate)) return candidate;
+        }
+        return trunk;
+      };
 
       const rawTitle = Option.isSome(titleOpt) ? titleOpt.value : undefined;
       const rawBody = Option.isSome(bodyOpt) ? bodyOpt.value : undefined;
@@ -173,11 +117,13 @@ export const submit = Command.make("submit", {
 
       if (titles !== undefined && titles.length !== branches.length) {
         return yield* new StackError({
+          code: ErrorCode.USAGE_ERROR,
           message: `--title has ${titles.length} values but stack has ${branches.length} branches`,
         });
       }
       if (bodies !== undefined && bodies.length !== branches.length) {
         return yield* new StackError({
+          code: ErrorCode.USAGE_ERROR,
           message: `--body has ${bodies.length} values but stack has ${branches.length} branches`,
         });
       }
@@ -199,19 +145,34 @@ export const submit = Command.make("submit", {
       const results: SubmitResult[] = [];
       const prMap = new Map<
         string,
-        { number: number; url: string; state: string; body?: string | null } | null
+        { number: number; url: string; state: string; base: string; body?: string | null } | null
       >();
 
+      // Pre-fetch all PR statuses in parallel
+      const activeBranches = only ? branches.filter((b) => b === currentBranch) : [...branches];
+      const prResults = yield* Effect.forEach(
+        activeBranches,
+        (branch) =>
+          gh.getPR(branch).pipe(
+            Effect.map((pr) => [branch, pr] as const),
+            Effect.catchTag("GitHubError", () => Effect.succeed([branch, null] as const)),
+          ),
+        { concurrency: 5 },
+      );
+      for (const [branch, pr] of prResults) {
+        prMap.set(branch, pr);
+      }
+
       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);
+        const base = effectiveBase(i);
 
         // --only: skip branches that aren't current
         if (only && branch !== currentBranch) continue;
 
         if (dryRun) {
-          const existingPR = yield* gh.getPR(branch);
+          const existingPR = prMap.get(branch) ?? null;
           const action =
             existingPR === null
               ? "would-create"
@@ -233,8 +194,7 @@ export const submit = Command.make("submit", {
 
         yield* withSpinner(`Pushing ${branch}`, git.push(branch, { force: !noForce }));
 
-        const existingPR = yield* gh.getPR(branch);
-        prMap.set(branch, existingPR);
+        const existingPR = prMap.get(branch) ?? null;
 
         if (existingPR !== null) {
           if (existingPR.base !== base) {
@@ -272,7 +232,7 @@ export const submit = Command.make("submit", {
             body,
             draft,
           });
-          prMap.set(branch, { number: pr.number, url: pr.url, state: "OPEN" });
+          prMap.set(branch, { number: pr.number, url: pr.url, state: "OPEN", base });
           yield* success(`Created PR #${pr.number}: ${pr.url}`);
           results.push({
             branch,
@@ -294,21 +254,16 @@ export const submit = Command.make("submit", {
 
       // Update all processed PRs with complete stack metadata.
       // This includes newly created PRs so placeholders get replaced in one submit run.
-      for (let i = 0; i < branches.length; i++) {
-        const branch = branches[i];
-        if (branch === undefined) continue;
-        if (only && branch !== currentBranch) continue;
-
-        const entry = results.find((x) => x.branch === branch);
-        if (entry === undefined) continue;
-
-        const metadata = generateStackMetadata(branches, prMap, i, result.name);
-        const existingPrData = prMap.get(branch) ?? null;
-        const existingBody = existingPrData?.body ?? undefined;
-        const userBody = getBodyForBranch(branch, i);
-        const body = updatePRBody(existingBody, userBody, metadata);
-        yield* gh.updatePR({ branch, body });
-      }
+      yield* refreshStackedPRBodies({
+        branches,
+        stackName: result.name,
+        gh,
+        initialPrMap: prMap,
+        shouldUpdateBranch: (branch) =>
+          (!only || branch === currentBranch) && results.some((entry) => entry.branch === branch),
+        getUserBody: getBodyForBranch,
+      });
+      yield* stacks.unmarkMergedBranches(branches);
 
       // Print structured output to stdout
       if (json) {

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();
@@ -69,6 +72,18 @@ export const sync = Command.make("sync", {
       }
 
       const { branches } = result.stack;
+      const data = yield* stacks.load();
+      const mergedSet = new Set(data.mergedBranches);
+
+      // Compute the effective base for a branch at index i, skipping merged branches
+      const effectiveBase = (i: number, fallback: string): string => {
+        for (let j = i - 1; j >= 0; j--) {
+          const candidate = branches[j];
+          if (candidate !== undefined && !mergedSet.has(candidate)) return candidate;
+        }
+        return fallback;
+      };
+
       const fromBranch = Option.isSome(fromOpt) ? fromOpt.value : undefined;
 
       let startIdx = 0;
@@ -98,7 +113,7 @@ export const sync = Command.make("sync", {
         for (let i = startIdx; i < branches.length; i++) {
           const branch = branches[i];
           if (branch === undefined) continue;
-          const base = i === 0 ? originTrunk : (branches[i - 1] ?? originTrunk);
+          const base = effectiveBase(i, originTrunk);
           results.push({ name: branch, action: "skipped", base });
           if (!json) {
             yield* Console.error(`Would rebase and force-push ${branch} onto ${base}`);
@@ -134,7 +149,7 @@ export const sync = Command.make("sync", {
         for (let i = startIdx; i < branches.length; i++) {
           const branch = branches[i];
           if (branch === undefined) continue;
-          const newBase = i === 0 ? originTrunk : (branches[i - 1] ?? originTrunk);
+          const newBase = effectiveBase(i, originTrunk);
 
           // Compute old base (merge-base of this branch and its parent) before rebasing
           const oldBase = yield* git
@@ -172,6 +187,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/errors/index.ts

@@ -19,6 +19,8 @@ export const ErrorCode = {
   STACK_EMPTY: "STACK_EMPTY",
   TRUNK_ERROR: "TRUNK_ERROR",
   STACK_EXISTS: "STACK_EXISTS",
+  USAGE_ERROR: "USAGE_ERROR",
+  HAS_CHILDREN: "HAS_CHILDREN",
 } as const;
 
 export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];

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";
@@ -15,11 +15,11 @@ 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 globalFlags = new Set(["--verbose", "-v", "--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 isVerbose = flagArgs.has("--verbose") || flagArgs.has("-v");
 const isQuiet = flagArgs.has("--quiet") || flagArgs.has("-q");
 const isNoColor = flagArgs.has("--no-color");
 const isYes = flagArgs.has("--yes") || flagArgs.has("-y");
@@ -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([
@@ -60,38 +53,57 @@ const usageCodes = new Set([
   "ALREADY_AT_BOTTOM",
   "TRUNK_ERROR",
   "STACK_EXISTS",
+  "USAGE_ERROR",
+  "HAS_CHILDREN",
 ]);
 
-const handleKnownError = (e: { message: string; code?: string | undefined }) =>
-  Console.error(e.code !== undefined ? `Error [${e.code}]: ${e.message}` : e.message).pipe(
+const isJson = process.argv.includes("--json");
+
+const handleKnownError = (e: { message: string; code?: string | undefined }) => {
+  const exitCode = e.code !== undefined && usageCodes.has(e.code) ? 2 : 1;
+  const errorOutput = isJson
+    ? Console.log(JSON.stringify({ error: { code: e.code ?? null, message: e.message } }))
+    : Console.error(e.code !== undefined ? `Error [${e.code}]: ${e.message}` : e.message);
+
+  return errorOutput.pipe(
     Effect.andThen(
       Effect.sync(() => {
-        process.exitCode = e.code !== undefined && usageCodes.has(e.code) ? 2 : 1;
+        process.exitCode = exitCode;
       }),
     ),
   );
+};
 
 // @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>;
@@ -116,7 +121,10 @@ export class GitService extends ServiceMap.Service<
 
       remoteDefaultBranch: (remote = "origin") =>
         run(["symbolic-ref", "--quiet", "--short", `refs/remotes/${remote}/HEAD`]).pipe(
-          Effect.map((ref) => Option.some(ref.replace(new RegExp(`^${remote}/`), ""))),
+          Effect.map((ref) => {
+            const prefix = `${remote}/`;
+            return Option.some(ref.startsWith(prefix) ? ref.slice(prefix.length) : ref);
+          }),
           Effect.catchTag("GitError", () => Effect.succeed(Option.none())),
         ),
 
@@ -163,6 +171,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(
@@ -173,9 +195,28 @@ export class GitService extends ServiceMap.Service<
         ),
 
       commitAmend: (options) => {
-        const args = ["commit", "--amend"];
-        if (options?.edit !== true) args.push("--no-edit");
-        return run(args).pipe(Effect.asVoid);
+        if (options?.edit === true) {
+          // Interactive editor needs inherited stdio, not piped
+          return Effect.tryPromise({
+            try: async () => {
+              const proc = Bun.spawn(["git", "commit", "--amend"], {
+                stdin: "inherit",
+                stdout: "inherit",
+                stderr: "inherit",
+              });
+              const exitCode = await proc.exited;
+              if (exitCode !== 0) {
+                throw new Error(`git commit --amend failed with exit code ${exitCode}`);
+              }
+            },
+            catch: (e) =>
+              new GitError({
+                message: `Process failed: ${e}`,
+                command: "git commit --amend",
+              }),
+          }).pipe(Effect.asVoid);
+        }
+        return run(["commit", "--amend", "--no-edit"]).pipe(Effect.asVoid);
       },
 
       fetch: (remote) => run(["fetch", remote ?? "origin"]).pipe(Effect.asVoid),
@@ -203,6 +244,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,