@cvr/stacked 0.3.0 → 0.4.1

package/src/services/Stack.ts

@@ -1,4 +1,5 @@
 import { Effect, Layer, Ref, Schema, ServiceMap } from "effect";
+import { rename } from "node:fs/promises";
 import type { GitError } from "../errors/index.js";
 import { StackError } from "../errors/index.js";
 import { GitService } from "./Git.js";
@@ -34,10 +35,11 @@ export class StackService extends ServiceMap.Service<
     ) => Effect.Effect<void, StackError>;
     readonly removeBranch: (stackName: string, branch: string) => Effect.Effect<void, StackError>;
     readonly createStack: (name: string, branches: string[]) => Effect.Effect<void, StackError>;
+    readonly findBranchStack: (
+      branch: string,
+    ) => Effect.Effect<{ name: string; stack: Stack } | null, StackError>;
     readonly getTrunk: () => Effect.Effect<string, StackError>;
     readonly setTrunk: (name: string) => Effect.Effect<void, StackError>;
-    readonly parentOf: (branch: string) => Effect.Effect<string, StackError>;
-    readonly childrenOf: (branch: string) => Effect.Effect<string[], StackError>;
   }
 >()("@cvr/stacked/services/Stack/StackService") {
   static layer: Layer.Layer<StackService, never, GitService> = Layer.effect(
@@ -47,7 +49,7 @@ export class StackService extends ServiceMap.Service<
 
       const stackFilePath = Effect.fn("stackFilePath")(function* () {
         const gitDir = yield* git
-          .revParse("--git-dir")
+          .revParse("--absolute-git-dir")
           .pipe(
             Effect.mapError(
               (e) => new StackError({ message: `Not a git repository: ${e.message}` }),
@@ -60,25 +62,64 @@ export class StackService extends ServiceMap.Service<
       const decodeStackFile = Schema.decodeUnknownEffect(StackFileJson);
       const encodeStackFile = Schema.encodeEffect(StackFileJson);
 
+      const detectTrunk = Effect.fn("StackService.detectTrunk")(function* () {
+        // Check common default branch names
+        for (const candidate of ["main", "master", "develop"]) {
+          const exists = yield* git
+            .branchExists(candidate)
+            .pipe(Effect.catchTag("GitError", () => Effect.succeed(false)));
+          if (exists) return candidate;
+        }
+        return "main";
+      });
+
       const load = Effect.fn("StackService.load")(function* () {
         const path = yield* stackFilePath();
         const file = Bun.file(path);
-        const exists = yield* Effect.promise(() => file.exists());
-        if (!exists) return emptyStackFile;
-        const text = yield* Effect.promise(() => file.text());
+        const exists = yield* Effect.tryPromise({
+          try: () => file.exists(),
+          catch: () => new StackError({ message: `Failed to check if ${path} exists` }),
+        });
+        if (!exists) {
+          const trunk = yield* detectTrunk();
+          return { ...emptyStackFile, trunk } satisfies StackFile;
+        }
+        const text = yield* Effect.tryPromise({
+          try: () => file.text(),
+          catch: () => new StackError({ message: `Failed to read ${path}` }),
+        });
         return yield* decodeStackFile(text).pipe(
-          Effect.catch(() => Effect.succeed(emptyStackFile)),
+          Effect.catchTag("SchemaError", (e) =>
+            Effect.gen(function* () {
+              const backupPath = `${path}.backup`;
+              yield* Effect.tryPromise({
+                try: () => Bun.write(backupPath, text),
+                catch: () => new StackError({ message: `Failed to write backup to ${backupPath}` }),
+              });
+              yield* Effect.logWarning(
+                `Corrupted stack file, resetting: ${e.message}\nBackup saved to ${backupPath}`,
+              );
+              const trunk = yield* detectTrunk();
+              return { ...emptyStackFile, trunk } satisfies StackFile;
+            }),
+          ),
         );
       });
 
       const save = Effect.fn("StackService.save")(function* (data: StackFile) {
         const path = yield* stackFilePath();
+        const tmpPath = `${path}.tmp`;
         const text = yield* encodeStackFile(data).pipe(
           Effect.mapError(() => new StackError({ message: `Failed to encode stack data` })),
         );
-        yield* Effect.promise(() => Bun.write(path, text + "\n")).pipe(
-          Effect.mapError(() => new StackError({ message: `Failed to write ${path}` })),
-        );
+        yield* Effect.tryPromise({
+          try: () => Bun.write(tmpPath, text + "\n"),
+          catch: () => new StackError({ message: `Failed to write ${tmpPath}` }),
+        });
+        yield* Effect.tryPromise({
+          try: () => rename(tmpPath, path),
+          catch: () => new StackError({ message: `Failed to rename ${tmpPath} to ${path}` }),
+        });
       });
 
       const findBranchStack = (data: StackFile, branch: string) => {
@@ -94,6 +135,9 @@ export class StackService extends ServiceMap.Service<
         load: () => load(),
         save: (data) => save(data),
 
+        findBranchStack: (branch: string) =>
+          load().pipe(Effect.map((data) => findBranchStack(data, branch))),
+
         currentStack: Effect.fn("StackService.currentStack")(function* () {
           const branch = yield* git.currentBranch();
           const data = yield* load();
@@ -106,6 +150,12 @@ export class StackService extends ServiceMap.Service<
           after?: string,
         ) {
           const data = yield* load();
+          const existing = findBranchStack(data, branch);
+          if (existing !== null) {
+            return yield* new StackError({
+              message: `Branch "${branch}" is already in stack "${existing.name}"`,
+            });
+          }
           const stack = data.stacks[stackName];
           if (stack === undefined) {
             return yield* new StackError({ message: `Stack "${stackName}" not found` });
@@ -172,34 +222,11 @@ export class StackService extends ServiceMap.Service<
           const data = yield* load();
           yield* save({ ...data, trunk: name });
         }),
-
-        parentOf: Effect.fn("StackService.parentOf")(function* (branch: string) {
-          const data = yield* load();
-          for (const stack of Object.values(data.stacks)) {
-            const idx = stack.branches.indexOf(branch);
-            if (idx === 0) return data.trunk;
-            if (idx > 0) return stack.branches[idx - 1] ?? data.trunk;
-          }
-          return yield* new StackError({ message: `Branch "${branch}" not found in any stack` });
-        }),
-
-        childrenOf: Effect.fn("StackService.childrenOf")(function* (branch: string) {
-          const data = yield* load();
-          const children: string[] = [];
-          for (const stack of Object.values(data.stacks)) {
-            const idx = stack.branches.indexOf(branch);
-            const child = stack.branches[idx + 1];
-            if (idx !== -1 && child !== undefined) {
-              children.push(child);
-            }
-          }
-          return children;
-        }),
       };
     }),
   );
 
-  static layerTest = (data?: StackFile) => {
+  static layerTest = (data?: StackFile, options?: { currentBranch?: string }) => {
     const initial = data ?? emptyStackFile;
     return Layer.effect(
       StackService,
@@ -219,9 +246,12 @@ export class StackService extends ServiceMap.Service<
           load: () => Ref.get(ref),
           save: (d) => Ref.set(ref, d),
 
+          findBranchStack: (branch: string) =>
+            Ref.get(ref).pipe(Effect.map((d) => findBranchStack(d, branch))),
+
           currentStack: Effect.fn("test.currentStack")(function* () {
             const d = yield* Ref.get(ref);
-            return findBranchStack(d, "test-branch");
+            return findBranchStack(d, options?.currentBranch ?? "test-branch");
           }),
 
           addBranch: Effect.fn("test.addBranch")(function* (
@@ -269,29 +299,6 @@ export class StackService extends ServiceMap.Service<
 
           getTrunk: () => Ref.get(ref).pipe(Effect.map((d) => d.trunk)),
           setTrunk: (name: string) => Ref.update(ref, (d) => ({ ...d, trunk: name })),
-
-          parentOf: Effect.fn("test.parentOf")(function* (branch: string) {
-            const d = yield* Ref.get(ref);
-            for (const stack of Object.values(d.stacks)) {
-              const idx = stack.branches.indexOf(branch);
-              if (idx === 0) return d.trunk;
-              if (idx > 0) return stack.branches[idx - 1] ?? d.trunk;
-            }
-            return yield* new StackError({ message: `Branch "${branch}" not found in any stack` });
-          }),
-
-          childrenOf: Effect.fn("test.childrenOf")(function* (branch: string) {
-            const d = yield* Ref.get(ref);
-            const children: string[] = [];
-            for (const stack of Object.values(d.stacks)) {
-              const idx = stack.branches.indexOf(branch);
-              const child = stack.branches[idx + 1];
-              if (idx !== -1 && child !== undefined) {
-                children.push(child);
-              }
-            }
-            return children;
-          }),
         };
       }),
     );

package/src/ui.ts

@@ -0,0 +1,247 @@
+import { createInterface } from "node:readline";
+import pc from "picocolors";
+import { Config, Effect, ServiceMap } from "effect";
+
+// ============================================================================
+// TTY & Color Detection
+// ============================================================================
+
+const stderrIsTTY = process.stderr.isTTY === true;
+const stdoutIsTTY = process.stdout.isTTY === true;
+
+// Lazy color instances — deferred so --no-color flag can set env before first use
+let _stderrColors: ReturnType<typeof pc.createColors> | null = null;
+let _stdoutColors: ReturnType<typeof pc.createColors> | null = null;
+
+const colorRuntimeConfig = Config.all({
+  noColor: Config.string("NO_COLOR").pipe(
+    Config.map(() => true),
+    Config.orElse(() => Config.succeed(false)),
+  ),
+  forceColor: Config.string("FORCE_COLOR").pipe(
+    Config.map(() => true),
+    Config.orElse(() => Config.succeed(false)),
+  ),
+  term: Config.string("TERM").pipe(Config.withDefault("")),
+});
+
+const isColorEnabled = Effect.fn("ui.isColorEnabled")(function* (isTTY: boolean) {
+  const runtime = yield* colorRuntimeConfig;
+  if (runtime.noColor) return false;
+  if (runtime.forceColor) return true;
+  if (runtime.term === "dumb") return false;
+  return isTTY;
+});
+
+const getColors = Effect.fn("ui.getColors")(function* () {
+  if (_stderrColors !== null) return _stderrColors;
+  const enabled = yield* isColorEnabled(stderrIsTTY).pipe(
+    Effect.catchTag("ConfigError", () => Effect.succeed(false)),
+  );
+  _stderrColors = enabled ? pc : pc.createColors(false);
+  return _stderrColors;
+});
+
+const getStdoutColors = Effect.fn("ui.getStdoutColors")(function* () {
+  if (_stdoutColors !== null) return _stdoutColors;
+  const enabled = yield* isColorEnabled(stdoutIsTTY).pipe(
+    Effect.catchTag("ConfigError", () => Effect.succeed(false)),
+  );
+  _stdoutColors = enabled ? pc : pc.createColors(false);
+  return _stdoutColors;
+});
+
+// ============================================================================
+// Output Config (verbose/quiet, set by global flags)
+// ============================================================================
+
+export interface OutputConfig {
+  readonly verbose: boolean;
+  readonly quiet: boolean;
+  readonly yes: boolean;
+}
+
+export const OutputConfig = ServiceMap.Reference("@cvr/stacked/OutputConfig", {
+  defaultValue: (): OutputConfig => ({ verbose: false, quiet: false, yes: false }),
+});
+
+// ============================================================================
+// Interactive Prompts
+// ============================================================================
+
+const stdinIsTTY = process.stdin.isTTY === true;
+
+export const confirm = Effect.fn("ui.confirm")(function* (message: string) {
+  const config = yield* OutputConfig;
+  if (config.yes || !stdinIsTTY) return true;
+
+  process.stderr.write(`${message} [y/N] `);
+  const answer = yield* Effect.tryPromise({
+    try: () => {
+      const rl = createInterface({ input: process.stdin, output: process.stderr });
+      return new Promise<string>((resolve) => {
+        rl.question("", (ans) => {
+          rl.close();
+          resolve(ans);
+        });
+      });
+    },
+    catch: () => "n" as const,
+  });
+  return answer.trim().toLowerCase() === "y";
+});
+
+// ============================================================================
+// Styled Output (all write to stderr)
+// ============================================================================
+
+const write = (msg: string) =>
+  Effect.sync(() => {
+    process.stderr.write(msg + "\n");
+  });
+
+export const success = Effect.fn("ui.success")(function* (msg: string) {
+  const config = yield* OutputConfig;
+  if (config.quiet) return;
+  const colors = yield* getColors();
+  yield* write(colors.green(`✓ ${msg}`));
+});
+
+export const warn = Effect.fn("ui.warn")(function* (msg: string) {
+  const config = yield* OutputConfig;
+  if (config.quiet) return;
+  const colors = yield* getColors();
+  yield* write(colors.yellow(`⚠ ${msg}`));
+});
+
+export const info = Effect.fn("ui.info")(function* (msg: string) {
+  const config = yield* OutputConfig;
+  if (config.quiet) return;
+  const colors = yield* getColors();
+  yield* write(colors.cyan(msg));
+});
+
+export const error = Effect.fn("ui.error")(function* (msg: string) {
+  const colors = yield* getColors();
+  yield* write(colors.red(msg));
+});
+
+export const verbose = Effect.fn("ui.verbose")(function* (msg: string) {
+  const config = yield* OutputConfig;
+  if (!config.verbose) return;
+  const colors = yield* getColors();
+  yield* write(colors.dim(msg));
+});
+
+// ============================================================================
+// Spinner
+// ============================================================================
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+export const withSpinner = <A, E, R>(
+  message: string,
+  effect: Effect.Effect<A, E, R>,
+): Effect.Effect<A, E, R> => {
+  if (!stderrIsTTY) {
+    return write(message).pipe(Effect.andThen(effect));
+  }
+
+  return Effect.gen(function* () {
+    const c = yield* getColors();
+    let frame = 0;
+    const interval = setInterval(() => {
+      const spinner = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+      process.stderr.write(`\r${c.cyan(spinner ?? "⠋")} ${message}`);
+      frame++;
+    }, 80);
+
+    const cleanup = (icon: string) =>
+      Effect.sync(() => {
+        clearInterval(interval);
+        process.stderr.write(`\r${icon} ${message}\n`);
+      });
+
+    const result = yield* effect.pipe(
+      Effect.tap(() => cleanup(c.green("✓"))),
+      Effect.tapError(() => cleanup(c.red("✗"))),
+      Effect.onInterrupt(() => cleanup(c.yellow("⚠"))),
+    );
+
+    return result;
+  });
+};
+
+// ============================================================================
+// Color Helpers — stderr (for tree views, status badges, etc.)
+// ============================================================================
+
+export const dim = Effect.fn("ui.dim")(function* (s: string) {
+  const colors = yield* getColors();
+  return colors.dim(s);
+});
+
+export const bold = Effect.fn("ui.bold")(function* (s: string) {
+  const colors = yield* getColors();
+  return colors.bold(s);
+});
+
+export const green = Effect.fn("ui.green")(function* (s: string) {
+  const colors = yield* getColors();
+  return colors.green(s);
+});
+
+export const yellow = Effect.fn("ui.yellow")(function* (s: string) {
+  const colors = yield* getColors();
+  return colors.yellow(s);
+});
+
+export const cyan = Effect.fn("ui.cyan")(function* (s: string) {
+  const colors = yield* getColors();
+  return colors.cyan(s);
+});
+
+export const red = Effect.fn("ui.red")(function* (s: string) {
+  const colors = yield* getColors();
+  return colors.red(s);
+});
+
+export const magenta = Effect.fn("ui.magenta")(function* (s: string) {
+  const colors = yield* getColors();
+  return colors.magenta(s);
+});
+
+// ============================================================================
+// Color Helpers — stdout (for Console.log output that may be piped)
+// ============================================================================
+
+export const stdout = {
+  dim: Effect.fn("ui.stdout.dim")(function* (s: string) {
+    const colors = yield* getStdoutColors();
+    return colors.dim(s);
+  }),
+  bold: Effect.fn("ui.stdout.bold")(function* (s: string) {
+    const colors = yield* getStdoutColors();
+    return colors.bold(s);
+  }),
+  green: Effect.fn("ui.stdout.green")(function* (s: string) {
+    const colors = yield* getStdoutColors();
+    return colors.green(s);
+  }),
+  yellow: Effect.fn("ui.stdout.yellow")(function* (s: string) {
+    const colors = yield* getStdoutColors();
+    return colors.yellow(s);
+  }),
+  cyan: Effect.fn("ui.stdout.cyan")(function* (s: string) {
+    const colors = yield* getStdoutColors();
+    return colors.cyan(s);
+  }),
+  red: Effect.fn("ui.stdout.red")(function* (s: string) {
+    const colors = yield* getStdoutColors();
+    return colors.red(s);
+  }),
+  magenta: Effect.fn("ui.stdout.magenta")(function* (s: string) {
+    const colors = yield* getStdoutColors();
+    return colors.magenta(s);
+  }),
+};