@cvr/stacked 0.2.0 → 0.4.0

package/src/commands/list.ts

@@ -1,14 +1,24 @@
-import { Argument, Command } from "effect/unstable/cli";
+import { Argument, 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 { stdout } from "../ui.js";
 
-const stackNameArg = Argument.string("stack").pipe(Argument.optional);
+const stackNameArg = Argument.string("stack").pipe(
+  Argument.withDescription("Stack name (defaults to current)"),
+  Argument.optional,
+);
+const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"));
 
-export const list = Command.make("list", { stackName: stackNameArg }).pipe(
+export const list = Command.make("list", { stackName: stackNameArg, json: jsonFlag }).pipe(
   Command.withDescription("Show stack branches (defaults to current stack)"),
-  Command.withHandler(({ stackName }) =>
+  Command.withExamples([
+    { command: "stacked list", description: "Show branches in current stack" },
+    { command: "stacked list my-stack --json", description: "JSON output for a specific stack" },
+  ]),
+  Command.withHandler(({ stackName, json }) =>
     Effect.gen(function* () {
       const git = yield* GitService;
       const gh = yield* GitHubService;
@@ -24,50 +34,79 @@ export const list = Command.make("list", { stackName: stackNameArg }).pipe(
       if (Option.isSome(stackName)) {
         const s = data.stacks[stackName.value];
         if (s === undefined) {
-          yield* Console.error(`Stack "${stackName.value}" not found`);
-          return;
+          return yield* new StackError({
+            code: ErrorCode.STACK_NOT_FOUND,
+            message: `Stack "${stackName.value}" not found`,
+          });
         }
         targetStackName = stackName.value;
         targetStack = s;
       } else {
-        for (const [name, stack] of Object.entries(data.stacks)) {
-          if (stack.branches.includes(currentBranch)) {
-            targetStackName = name;
-            targetStack = stack;
-            break;
-          }
+        const found = yield* stacks.findBranchStack(currentBranch);
+        if (found !== null) {
+          targetStackName = found.name;
+          targetStack = found.stack;
         }
       }
 
       if (targetStackName === null || targetStack === null) {
-        yield* Console.log("Not on a stacked branch");
+        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 prStatuses = yield* Effect.forEach(
+        targetStack.branches as readonly string[],
+        (branch) =>
+          gh.getPR(branch).pipe(
+            Effect.catchTag("GitHubError", () => Effect.succeed(null)),
+            Effect.map((pr) => [branch, pr] as const),
+          ),
+        { concurrency: 5 },
+      );
+      const prMap = new Map(prStatuses);
+
+      if (json) {
+        const branches = [...targetStack.branches].map((branch) => {
+          const pr = prMap.get(branch) ?? null;
+          return {
+            name: branch,
+            current: branch === currentBranch,
+            pr: pr !== null ? { number: pr.number, url: pr.url, state: pr.state } : null,
+          };
+        });
+        // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
+        yield* Console.log(JSON.stringify({ stack: targetStackName, trunk, branches }, null, 2));
         return;
       }
 
       const lines: string[] = [];
 
-      lines.push(`Stack: ${targetStackName}`);
-      lines.push(`Trunk: ${trunk}`);
+      lines.push(`Stack: ${stdout.bold(targetStackName)}`);
+      lines.push(`Trunk: ${stdout.dim(trunk)}`);
       lines.push("");
 
       for (let i = targetStack.branches.length - 1; i >= 0; i--) {
         const branch = targetStack.branches[i];
         if (branch === undefined) continue;
         const isCurrent = branch === currentBranch;
-        const marker = isCurrent ? "* " : "  ";
-        const prefix = i === 0 ? "└─" : "├─";
+        const marker = isCurrent ? stdout.green("* ") : "  ";
+        const prefix = stdout.dim(i === 0 ? "└─" : "├─");
+        const name = isCurrent ? stdout.bold(branch) : branch;
 
-        const pr = yield* gh.getPR(branch).pipe(Effect.catch(() => Effect.succeed(null)));
+        const pr = prMap.get(branch) ?? null;
         const status =
           pr === null
             ? ""
             : pr.state === "MERGED"
-              ? " [merged]"
+              ? stdout.green(" [merged]")
               : pr.state === "CLOSED"
-                ? " [closed]"
-                : ` [#${pr.number}]`;
+                ? stdout.dim(" [closed]")
+                : stdout.cyan(` [#${pr.number}]`);
 
-        lines.push(`${marker}${prefix} ${branch}${status}`);
+        lines.push(`${marker}${prefix} ${name}${status}`);
       }
 
       yield* Console.log(lines.join("\n"));

package/src/commands/log.ts

@@ -1,24 +1,50 @@
-import { Command } from "effect/unstable/cli";
+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";
 
-export const log = Command.make("log").pipe(
+const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"));
+
+export const log = Command.make("log", { json: jsonFlag }).pipe(
   Command.withDescription("Show commits across all branches in stack"),
-  Command.withHandler(() =>
+  Command.withExamples([
+    { command: "stacked log", description: "Show commits per branch" },
+    { command: "stacked log --json", description: "JSON output" },
+  ]),
+  Command.withHandler(({ json }) =>
     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;
+        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 trunk = yield* stacks.getTrunk();
       const { branches } = result.stack;
 
+      if (json) {
+        const entries = [];
+        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 commits = yield* git
+            .log(`${base}..${branch}`, { oneline: true })
+            .pipe(Effect.catchTag("GitError", () => Effect.succeed("")));
+          entries.push({ name: branch, base, commits: commits || "" });
+        }
+        // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
+        yield* Console.log(JSON.stringify({ branches: entries }, null, 2));
+        return;
+      }
+
       for (let i = 0; i < branches.length; i++) {
         const branch = branches[i];
         if (branch === undefined) continue;
@@ -26,7 +52,7 @@ export const log = Command.make("log").pipe(
         yield* Console.log(`\n── ${branch} ──`);
         const rangeLog = yield* git
           .log(`${base}..${branch}`, { oneline: true })
-          .pipe(Effect.catch(() => Effect.succeed("(no commits)")));
+          .pipe(Effect.catchTag("GitError", () => Effect.succeed("(no commits)")));
         yield* Console.log(rangeLog || "(no new commits)");
       }
     }),

package/src/commands/rename.ts

@@ -0,0 +1,49 @@
+import { Argument, Command, Flag } from "effect/unstable/cli";
+import { Console, Effect } from "effect";
+import { StackService } from "../services/Stack.js";
+import { ErrorCode, StackError } from "../errors/index.js";
+import { success } from "../ui.js";
+
+const oldArg = Argument.string("old").pipe(Argument.withDescription("Current stack name"));
+const newArg = Argument.string("new").pipe(Argument.withDescription("New stack name"));
+const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"));
+
+export const rename = Command.make("rename", { old: oldArg, new: newArg, json: jsonFlag }).pipe(
+  Command.withDescription("Rename a stack (not the branches, just the stack key)"),
+  Command.withExamples([
+    { command: "stacked rename old-name new-name", description: "Rename a stack" },
+  ]),
+  Command.withHandler(({ old: oldName, new: newName, json }) =>
+    Effect.gen(function* () {
+      const stacks = yield* StackService;
+
+      const data = yield* stacks.load();
+
+      if (data.stacks[oldName] === undefined) {
+        return yield* new StackError({
+          code: ErrorCode.STACK_NOT_FOUND,
+          message: `Stack "${oldName}" not found`,
+        });
+      }
+
+      if (data.stacks[newName] !== undefined) {
+        return yield* new StackError({
+          code: ErrorCode.STACK_EXISTS,
+          message: `Stack "${newName}" already exists`,
+        });
+      }
+
+      const stack = data.stacks[oldName];
+      if (stack === undefined) return;
+      const { [oldName]: _, ...rest } = data.stacks;
+      yield* stacks.save({ ...data, stacks: { ...rest, [newName]: stack } });
+
+      if (json) {
+        // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
+        yield* Console.log(JSON.stringify({ old: oldName, new: newName }, null, 2));
+      } else {
+        yield* success(`Renamed stack "${oldName}" to "${newName}"`);
+      }
+    }),
+  ),
+);

package/src/commands/reorder.ts

@@ -0,0 +1,93 @@
+import { Argument, Command, Flag } from "effect/unstable/cli";
+import { Console, Effect, Option } from "effect";
+import { StackService } from "../services/Stack.js";
+import { ErrorCode, StackError } from "../errors/index.js";
+import { success, warn } from "../ui.js";
+
+const branchArg = Argument.string("branch").pipe(Argument.withDescription("Branch to move"));
+const beforeFlag = Flag.string("before").pipe(
+  Flag.optional,
+  Flag.withDescription("Move branch before this branch"),
+);
+const afterFlag = Flag.string("after").pipe(
+  Flag.optional,
+  Flag.withDescription("Move branch after this branch"),
+);
+const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"));
+
+export const reorder = Command.make("reorder", {
+  branch: branchArg,
+  before: beforeFlag,
+  after: afterFlag,
+  json: jsonFlag,
+}).pipe(
+  Command.withDescription("Move a branch to a different position in the stack"),
+  Command.withExamples([
+    { command: "stacked reorder feat-b --before feat-a", description: "Move feat-b before feat-a" },
+    { command: "stacked reorder feat-b --after feat-c", description: "Move feat-b after feat-c" },
+  ]),
+  Command.withHandler(({ branch, before, after, json }) =>
+    Effect.gen(function* () {
+      const stacks = yield* StackService;
+
+      if (Option.isNone(before) && Option.isNone(after)) {
+        return yield* new StackError({
+          message: "Specify --before or --after to indicate target position",
+        });
+      }
+
+      if (Option.isSome(before) && Option.isSome(after)) {
+        return yield* new StackError({
+          message: "Specify either --before or --after, not both",
+        });
+      }
+
+      const result = yield* stacks.findBranchStack(branch);
+      if (result === null) {
+        return yield* new StackError({
+          code: ErrorCode.BRANCH_NOT_FOUND,
+          message: `Branch "${branch}" not found in any stack`,
+        });
+      }
+
+      const { name: stackName, stack } = result;
+      const branches = [...stack.branches];
+      const currentIdx = branches.indexOf(branch);
+      if (currentIdx === -1) return;
+
+      const target = Option.isSome(before) ? before.value : Option.getOrElse(after, () => "");
+      const targetIdx = branches.indexOf(target);
+      if (targetIdx === -1) {
+        return yield* new StackError({
+          code: ErrorCode.BRANCH_NOT_FOUND,
+          message: `Branch "${target}" not found in stack "${stackName}"`,
+        });
+      }
+
+      // 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 } },
+      });
+
+      if (json) {
+        // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
+        yield* Console.log(JSON.stringify({ branch, stack: stackName, branches }, null, 2));
+      } else {
+        yield* success(`Moved "${branch}" in stack "${stackName}"`);
+        yield* warn("Run 'stacked sync' to rebase branches in new order");
+      }
+    }),
+  ),
+);

package/src/commands/split.ts

@@ -0,0 +1,108 @@
+import { Argument, Command, Flag } from "effect/unstable/cli";
+import { Console, Effect } from "effect";
+import { StackService } from "../services/Stack.js";
+import { ErrorCode, StackError } from "../errors/index.js";
+import { success } from "../ui.js";
+
+const branchArg = Argument.string("branch").pipe(
+  Argument.withDescription("Branch at which to split the stack"),
+);
+const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"));
+const dryRunFlag = Flag.boolean("dry-run").pipe(
+  Flag.withDescription("Show what would happen without making changes"),
+);
+
+export const split = Command.make("split", {
+  branch: branchArg,
+  json: jsonFlag,
+  dryRun: dryRunFlag,
+}).pipe(
+  Command.withDescription("Split a stack at a branch — branches at and above become a new stack"),
+  Command.withExamples([
+    { command: "stacked split feat-b", description: "Split at feat-b" },
+    { command: "stacked split feat-b --dry-run", description: "Preview the split" },
+  ]),
+  Command.withHandler(({ branch, json, dryRun }) =>
+    Effect.gen(function* () {
+      const stacks = yield* StackService;
+
+      const result = yield* stacks.findBranchStack(branch);
+      if (result === null) {
+        return yield* new StackError({
+          code: ErrorCode.BRANCH_NOT_FOUND,
+          message: `Branch "${branch}" not found in any stack`,
+        });
+      }
+
+      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 newStackName = branch;
+
+      if (dryRun) {
+        if (json) {
+          // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
+          yield* Console.log(
+            JSON.stringify(
+              {
+                original: { name: stackName, branches: below },
+                new: { name: newStackName, branches: above },
+              },
+              null,
+              2,
+            ),
+          );
+        } else {
+          yield* Console.error(`Would keep "${stackName}": ${below.join(" → ")}`);
+          yield* Console.error(`Would create "${newStackName}": ${above.join(" → ")}`);
+        }
+        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 },
+        },
+      });
+
+      if (json) {
+        // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
+        yield* Console.log(
+          JSON.stringify(
+            {
+              original: { name: stackName, branches: below },
+              new: { name: newStackName, branches: above },
+            },
+            null,
+            2,
+          ),
+        );
+      } else {
+        yield* success(`Split stack "${stackName}" at "${branch}"`);
+        yield* Console.error(`  "${stackName}": ${below.join(" → ")}`);
+        yield* Console.error(`  "${newStackName}": ${above.join(" → ")}`);
+      }
+    }),
+  ),
+);

package/src/commands/stacks.ts

@@ -1,11 +1,18 @@
-import { Command } from "effect/unstable/cli";
+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";
 
-export const stacks = Command.make("stacks").pipe(
+const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"));
+
+export const stacks = Command.make("stacks", { json: jsonFlag }).pipe(
   Command.withDescription("List all stacks in the repo"),
-  Command.withHandler(() =>
+  Command.withExamples([
+    { command: "stacked stacks", description: "List all stacks" },
+    { command: "stacked stacks --json", description: "JSON output" },
+  ]),
+  Command.withHandler(({ json }) =>
     Effect.gen(function* () {
       const git = yield* GitService;
       const stackService = yield* StackService;
@@ -15,16 +22,35 @@ export const stacks = Command.make("stacks").pipe(
 
       const entries = Object.entries(data.stacks);
       if (entries.length === 0) {
-        yield* Console.log("No stacks");
+        if (json) {
+          // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
+          yield* Console.log(JSON.stringify({ stacks: [] }));
+        } else {
+          yield* Console.error("No stacks");
+        }
+        return;
+      }
+
+      if (json) {
+        const stackList = entries.map(([name, stack]) => ({
+          name,
+          branches: stack.branches.length,
+          current: stack.branches.includes(currentBranch),
+        }));
+        // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
+        yield* Console.log(JSON.stringify({ stacks: stackList }, null, 2));
         return;
       }
 
       const lines: string[] = [];
-      for (const [name, stack] of Object.entries(data.stacks)) {
+      for (const [name, stack] of entries) {
         const isCurrent = stack.branches.includes(currentBranch);
-        const marker = isCurrent ? "* " : "  ";
+        const marker = isCurrent ? stdout.green("* ") : "  ";
+        const label = isCurrent ? stdout.bold(name) : name;
         const count = stack.branches.length;
-        lines.push(`${marker}${name} (${count} branch${count === 1 ? "" : "es"})`);
+        lines.push(
+          `${marker}${label} ${stdout.dim(`(${count} branch${count === 1 ? "" : "es"})`)}`,
+        );
       }
 
       yield* Console.log(lines.join("\n"));

package/src/commands/status.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 { stdout } from "../ui.js";
+
+const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"));
+
+export const status = Command.make("status", { json: jsonFlag }).pipe(
+  Command.withDescription("Show current branch, stack position, and working tree state"),
+  Command.withExamples([
+    { command: "stacked status", description: "Show where you are in the stack" },
+    { command: "stacked status --json", description: "JSON output" },
+  ]),
+  Command.withHandler(({ json }) =>
+    Effect.gen(function* () {
+      const git = yield* GitService;
+      const stacks = yield* StackService;
+
+      const currentBranch = yield* git.currentBranch();
+      const clean = yield* git.isClean();
+      const result = yield* stacks.currentStack();
+
+      if (json) {
+        const stack =
+          result !== null
+            ? {
+                name: result.name,
+                position: result.stack.branches.indexOf(currentBranch) + 1,
+                total: result.stack.branches.length,
+              }
+            : null;
+        // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
+        yield* Console.log(JSON.stringify({ branch: currentBranch, clean, stack }, null, 2));
+        return;
+      }
+
+      const lines: string[] = [];
+      lines.push(`Branch: ${stdout.bold(currentBranch)}`);
+      lines.push(`Working tree: ${clean ? stdout.green("clean") : stdout.yellow("dirty")}`);
+
+      if (result !== null) {
+        const { branches } = result.stack;
+        const idx = branches.indexOf(currentBranch);
+        lines.push(
+          `Stack: ${stdout.bold(result.name)} ${stdout.dim(`(${idx + 1} of ${branches.length})`)}`,
+        );
+      } else {
+        lines.push(stdout.dim("Not in a stack. Run 'stacked create <name>' to start one."));
+      }
+
+      yield* Console.log(lines.join("\n"));
+    }),
+  ),
+);