alchemy 2.0.0-beta.76 → 2.0.0-beta.78

package/src/Util/AtomicFile.ts

@@ -0,0 +1,36 @@
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type { PlatformError } from "effect/PlatformError";
+
+/**
+ * Write `contents` to `filePath` via a same-directory temp file + rename.
+ *
+ * A plain `writeFileString` truncates the target before writing, so a crash
+ * mid-write (or a concurrent reader — another CLI process, the RPC sidecar)
+ * can observe empty/partial JSON. rename(2) is atomic on the same
+ * filesystem, so readers see either the old contents or the new, never a
+ * torn write. When `mode` is given it is applied to the temp file *before*
+ * the rename, so a secret is never visible at its final path with default
+ * permissions. The temp file is removed on failure.
+ *
+ * Used for `~/.alchemy/profiles.json`, the per-provider credential files,
+ * and local state files.
+ */
+export const writeFileAtomic = (
+  fs: FileSystem.FileSystem,
+  filePath: string,
+  contents: string,
+  mode?: number,
+): Effect.Effect<void, PlatformError> =>
+  Effect.suspend(() => {
+    const tmp = `${filePath}.${process.pid}.${Math.random()
+      .toString(36)
+      .slice(2)}.tmp`;
+    return fs.writeFileString(tmp, contents).pipe(
+      Effect.flatMap(() =>
+        mode === undefined ? Effect.void : fs.chmod(tmp, mode),
+      ),
+      Effect.flatMap(() => fs.rename(tmp, filePath)),
+      Effect.tapError(() => fs.remove(tmp).pipe(Effect.ignore)),
+    );
+  });

package/src/Util/ConsoleSink.ts

@@ -0,0 +1,23 @@
+import * as Logger from "effect/Logger";
+import { ANSI_RESET, colorsEnabled } from "./Terminal.ts";
+
+/** Effect pretty prefixes with selective color and untouched message styling. */
+export const makePlainConsoleSink = (colors = colorsEnabled()) => {
+  const pretty = Logger.consolePretty({ colors });
+  if (!colors) return pretty;
+  return Logger.make<unknown, void>((options) => {
+    const messages = Array.isArray(options.message)
+      ? options.message
+      : [options.message];
+    pretty.log({
+      ...options,
+      // consolePretty applies bold cyan around the first string. Reset that
+      // wrapper before the content; any intentional ANSI inside the message
+      // still takes effect normally.
+      message: [
+        `${ANSI_RESET}${String(messages[0] ?? "")}`,
+        ...messages.slice(1),
+      ],
+    });
+  });
+};

package/src/Util/LineBuffer.ts

@@ -0,0 +1,20 @@
+/**
+ * Buffers arbitrary text chunks and emits complete lines. Call `flush` when
+ * the source closes to emit a trailing partial line.
+ */
+export const makeLineBuffer = (onLine: (line: string) => void) => {
+  let buffer = "";
+  return {
+    push(chunk: string) {
+      buffer += chunk;
+      const lines = buffer.split(/\r\n|\n|\r/);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) onLine(line);
+    },
+    flush() {
+      if (buffer === "") return;
+      onLine(buffer);
+      buffer = "";
+    },
+  };
+};

package/src/Util/Memoize.ts

@@ -0,0 +1,48 @@
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as Scope from "effect/Scope";
+
+/**
+ * A lazily evaluated, memoized effect whose computation runs in a fiber of
+ * its own, owned by `scope`.
+ *
+ * `Effect.cached` evaluates on the fiber of whichever caller gets there
+ * first. When that caller is interrupted while others are waiting — a
+ * concurrent plan cancelling sibling diffs — every waiter fails
+ * interrupt-only and the cache stays poisoned for the rest of the process.
+ * A computation that many fibers share must not have that failure mode: here
+ * it runs detached from every caller, so interrupting a waiter never touches
+ * it, and only closing `scope` cancels it (its waiters then see the
+ * interruption, as they should).
+ *
+ * Requirements are captured from the first caller, exactly as
+ * `Effect.cached` does.
+ */
+export const cachedInScope =
+  (scope: Scope.Scope) =>
+  <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+  ): Effect.Effect<Effect.Effect<A, E>, never, R> =>
+    Effect.gen(function* () {
+      const context = yield* Effect.context<R>();
+      const deferred = yield* Deferred.make<A, E>();
+      let started = false;
+      return Effect.suspend(() => {
+        if (started) return Deferred.await(deferred);
+        started = true;
+        return effect.pipe(
+          Effect.provideContext(context),
+          // `onExit` also runs on interruption, so the waiters always learn
+          // how the computation ended.
+          Effect.onExit((exit) => Deferred.done(deferred, exit)),
+          // Not a child of the caller: the caller's interruption must not
+          // reach it. The scope owns its lifetime instead.
+          Effect.forkDetach,
+          Effect.flatMap((fiber) =>
+            Scope.addFinalizer(scope, Fiber.interrupt(fiber)),
+          ),
+          Effect.andThen(Deferred.await(deferred)),
+        );
+      });
+    });

package/src/Util/Node.ts

@@ -14,6 +14,15 @@ import * as NodeNet from "node:net";
  */
 export const initialCwd: string = process.cwd();
 
+/**
+ * The extension of alchemy's own modules next to `importMetaUrl`: `.ts`
+ * when running from `src/` (Bun, or Node under the dev loader), `.js`
+ * from the compiled `lib/`. The dev loader namespaces file URLs with a
+ * query, so only the pathname is consulted.
+ */
+export const moduleExtension = (importMetaUrl: string) =>
+  new URL(importMetaUrl).pathname.endsWith(".ts") ? ".ts" : ".js";
+
 /**
  * Opt out of cross-spawn's temporary `process.chdir` dance.
  *
@@ -46,24 +55,45 @@ export const disableCrossSpawnChdir = (): void => {
   (process.chdir as { disabled?: boolean }).disabled = true;
 };
 
-export const isTransformTypesSupported = (
-  version = process.versions.node,
-): boolean => {
-  const [major, minor] = version.split(".").map(Number);
-  return (major === 22 && minor >= 7) || (major >= 23 && major < 26);
-};
+/**
+ * Node arguments that install alchemy's Oxc loader in a child process, the
+ * same way `bin/cli.js` installs it for the CLI itself. Every `.ts`/`.tsx`
+ * a Node process loads — alchemy's own source in a checkout, the user's
+ * stack everywhere — goes through it; nothing relies on Node's built-in
+ * TypeScript support (strip-only, and Node 26 removed the transform flag).
+ *
+ * A `.ts` entry means a checkout: `bin/register-dev-mode.js` adds the
+ * src-condition resolution for workspace packages on top of the loader.
+ * A `.js` entry means a published install: `bin/register-oxc.js` is the
+ * loader alone.
+ */
+export const nodeLoaderArgs = (entry: string): string[] => [
+  "--import",
+  import.meta.resolve(
+    /\.[cm]?tsx?$/.test(entry)
+      ? "../../bin/register-dev-mode.js"
+      : "../../bin/register-oxc.js",
+  ),
+];
 
 /**
- * Node CLI flags that transparently transform TypeScript types so `.ts`
- * entry points work the same way they do under Bun. Empty when the running
- * Node doesn't support (or no longer needs) the experimental flag.
+ * Whether this Node supports the synchronous in-thread loader hooks
+ * (`module.registerHooks`, v22.15 / v23.5) that `bin/register-dev-mode.js`
+ * needs. This is THE capability gate for running the CLI from source under
+ * node: with the hooks installed, the Oxc loader handles every `.ts`/`.tsx`
+ * file regardless of Node's own TypeScript support.
+ *
+ * `bin/cli.js` mirrors this predicate inline — it must run under plain node
+ * before any `.ts` can load. Keep the two in sync.
  */
-export const transformTypesFlags = (
+export const isRegisterHooksSupported = (
   version = process.versions.node,
-): string[] =>
-  isTransformTypesSupported(version)
-    ? ["--experimental-transform-types", "--no-warnings=ExperimentalWarning"]
-    : [];
+): boolean => {
+  const [major = 0, minor = 0] = version.split(".").map(Number);
+  return (
+    (major === 22 && minor >= 15) || (major === 23 && minor >= 5) || major >= 24
+  );
+};
 
 /**
  * Ask the OS for an unused TCP port, release it, and return its number.

package/src/Util/PlatformServices.ts

@@ -1,3 +1,5 @@
+import type { Crypto } from "effect/Crypto";
+import type { Input as DurationInput } from "effect/Duration";
 import * as Effect from "effect/Effect";
 import type { FileSystem } from "effect/FileSystem";
 import * as Layer from "effect/Layer";
@@ -47,6 +49,7 @@ export const platformLayer = <A, E, R>(constructors: {
 
 export type PlatformServices =
   | ChildProcessSpawner
+  | Crypto
   | FileSystem
   | Path
   | Stdio
@@ -134,6 +137,9 @@ export const runMain = <E, A>(
 export const httpServer = (
   port: number = 0,
   host: string = "127.0.0.1",
+  options?: {
+    readonly gracefulShutdownTimeout?: DurationInput | undefined;
+  },
 ): Layer.Layer<HttpServer, ServeError> =>
   platformLayer({
     bun: async () => {
@@ -155,6 +161,10 @@ export const httpServer = (
         ),
         import("node:http"),
       ]);
-      return NodeHttpServer.layerServer(Http.createServer, { host, port });
+      return NodeHttpServer.layerServer(Http.createServer, {
+        host,
+        port,
+        gracefulShutdownTimeout: options?.gracefulShutdownTimeout,
+      });
     },
   });

package/src/Util/ResourceOutput.ts

@@ -0,0 +1,77 @@
+import { stripVTControlCharacters } from "node:util";
+import type * as ConsoleService from "effect/Console";
+import * as Effect from "effect/Effect";
+import { makeLineBuffer } from "./LineBuffer.ts";
+import { ANSI_RESET, ansiFg, colorsEnabled } from "./Terminal.ts";
+import { theme } from "./Theme.ts";
+
+export type OutputChannel = "stdout" | "stderr";
+
+/** Sigil-themed resource attribution shared by every append-only log path. */
+export const formatResourceTag = (
+  id: string,
+  colors = colorsEnabled(),
+): string =>
+  colors ? `${ansiFg(theme.color.info)}[${id}]${ANSI_RESET}` : `[${id}]`;
+
+const EFFECT_LOG_PREFIX =
+  /^\[\d{2}:\d{2}:\d{2}\.\d{3}\] (?:ALL|TRACE|DEBUG|INFO|WARN|ERROR|FATAL|NONE) \(#\d+\)(?: [^:]+)?: /;
+
+/** Remove a pretty Effect prefix already rendered by a child process. */
+export const stripChildEffectPrefix = (line: string): string => {
+  const match = stripVTControlCharacters(line).match(EFFECT_LOG_PREFIX);
+  if (match === null) return line;
+
+  // The match is measured against visible text. Walk the original line so
+  // ANSI embedded in the child message survives while the prefix's ANSI is
+  // discarded with the prefix itself.
+  let visible = 0;
+  let offset = 0;
+  while (offset < line.length && visible < match[0].length) {
+    if (line[offset] === "\x1b") {
+      const ansi = line.slice(offset).match(/^\x1b\[[0-?]*[ -/]*[@-~]/);
+      if (ansi !== null) {
+        offset += ansi[0].length;
+        continue;
+      }
+    }
+    offset++;
+    visible++;
+  }
+  return line.slice(offset);
+};
+
+/**
+ * The single terminal-output pipeline for resource-owned processes. Dev
+ * servers, local workers, and deploy-time builders all use the same line
+ * splitting, resource prefix, color policy, and stdout/stderr severity.
+ */
+export const makeResourceOutput = (
+  id: string,
+  console: Pick<ConsoleService.Console, "log">,
+) => {
+  const prefix = formatResourceTag(id);
+  // stderr is a process transport, not a semantic failure: Vite and many
+  // other tools write warnings, progress, and ordinary diagnostics there.
+  // Sending it through Console.error makes CLIKit prepend an error glyph to
+  // every line. Both streams therefore enter the renderer as plain resource
+  // output; the child text retains its own ANSI severity styling.
+  const writeLine = (line: string) =>
+    console.log(`${prefix} ${stripChildEffectPrefix(line)}`);
+  return {
+    stdout: makeLineBuffer(writeLine),
+    stderr: makeLineBuffer(writeLine),
+  };
+};
+
+/**
+ * Effect-native output for resource-owned child processes whose streams are
+ * already consumed inside an Effect. Both process channels are transport
+ * details, not semantic severity, so they enter the configured logger at the
+ * info level. The logger remains responsible for terminal and file sinks.
+ */
+export const makeResourceLogger = (id: string) => {
+  const prefix = formatResourceTag(id);
+  return (_channel: OutputChannel, line: string) =>
+    Effect.logInfo(`${prefix} ${stripChildEffectPrefix(line)}`);
+};

package/src/Util/Terminal.ts

@@ -0,0 +1,81 @@
+/** Terminal-emulator features shared by CliKit components. */
+import {
+  detectColorLevel,
+  detectUnicodeSupport,
+} from "@alchemy.run/sigil/capabilities";
+import {
+  setClipboard,
+  setTerminalProgress,
+  stringWidth,
+  tmuxPassthrough,
+  type TerminalProgressState,
+} from "@alchemy.run/sigil/ansi";
+
+export const ANSI_RESET = "\u001B[0m";
+export const ANSI_BOLD = "\u001B[1m";
+export const ANSI_DIM = "\u001B[2m";
+
+/** Truecolor foreground escape for raw, non-layout output. */
+export const ansiFg = (hex: string) => {
+  const red = Number.parseInt(hex.slice(1, 3), 16);
+  const green = Number.parseInt(hex.slice(3, 5), 16);
+  const blue = Number.parseInt(hex.slice(5, 7), 16);
+  return `\u001B[38;2;${red};${green};${blue}m`;
+};
+
+/**
+ * The canonical color-support decision, shared by raw terminal strings and
+ * CliKit capability detection so the two can never disagree.
+ */
+export const colorsEnabled = (
+  stream: Pick<NodeJS.WriteStream, "isTTY"> = process.stdout,
+): boolean => detectColorLevel(stream) > 0;
+
+/** The canonical Unicode-support decision for raw terminal strings. */
+export const unicodeEnabled = detectUnicodeSupport;
+
+/** Environment override for child processes whose piped output returns here. */
+export const pipedColorEnv = (): Record<string, string> =>
+  colorsEnabled() ? { FORCE_COLOR: process.env.FORCE_COLOR ?? "1" } : {};
+
+export const paint = (code: string, value: string): string =>
+  colorsEnabled() ? `${code}${value}${ANSI_RESET}` : value;
+
+export const copyToClipboard = (
+  text: string,
+  stdout: Pick<NodeJS.WriteStream, "write"> = process.stdout,
+): void => {
+  let sequence = setClipboard(text);
+  if (process.env.TMUX !== undefined) {
+    sequence = tmuxPassthrough(sequence);
+  }
+  stdout.write(sequence);
+};
+
+export const setNativeProgress = (
+  state: TerminalProgressState,
+  value?: number,
+  stdout: Pick<NodeJS.WriteStream, "write" | "isTTY"> = process.stdout,
+): void => {
+  if (stdout.isTTY !== true) return;
+  let sequence = setTerminalProgress(state, value);
+  if (process.env.TMUX !== undefined) sequence = tmuxPassthrough(sequence);
+  stdout.write(sequence);
+};
+
+const truncateSegmenter = new Intl.Segmenter();
+
+/** Display-width-aware truncation (wide CJK/emoji count by rendered cells). */
+export const truncate = (value: string, width: number): string => {
+  const max = Math.max(4, width);
+  if (stringWidth(value) <= max) return value;
+  let total = 0;
+  let kept = "";
+  for (const { segment } of truncateSegmenter.segment(value)) {
+    const segmentWidth = stringWidth(segment);
+    if (total + segmentWidth > max - 1) break;
+    total += segmentWidth;
+    kept += segment;
+  }
+  return `${kept}…`;
+};

package/src/Util/Theme.ts

@@ -0,0 +1,150 @@
+import type { Paint } from "@alchemy.run/sigil/color";
+
+/**
+ * Alchemy's palette is anchored in terracotta and green. The supporting
+ * amber, olive, sage, and coral tones stay within that warm botanical range.
+ */
+const color = {
+  brand: "#e28a5b",
+  accent: "#9acb69",
+  accentBright: "#c5df8c",
+  accentMuted: "#60764b",
+  success: "#9acb69",
+  warning: "#efb85a",
+  danger: "#d96f52",
+  magenta: "#c084d6",
+  info: "#b6c77a",
+  sage: "#b8cf83",
+  olive: "#9ea85e",
+  coral: "#ef9a6a",
+  muted: "#8f887c",
+  diffAddBackground: "#263b2a",
+  diffRemoveBackground: "#422a26",
+  onAccent: "#14110d",
+  emphasis: "#f5f0e6",
+} as const;
+
+export const theme = {
+  color,
+  space: {
+    inline: 1,
+    indent: 2,
+    section: 1,
+  },
+  paint: {
+    focus: color.brand,
+    interactive: color.brand,
+    info: color.info,
+    success: color.success,
+    warning: color.warning,
+    error: color.danger,
+  },
+  glyph: {
+    section: "●",
+    /**
+     * Marks the step currently being answered — the same "active one" glyph
+     * the profile tabs use. Deliberately not a chevron so the list cursor
+     * (`pointer`) is the only chevron on screen.
+     */
+    active: "◆",
+    /** List cursor: the one focus glyph shared by every prompt and dashboard row. */
+    pointer: "❯",
+    success: "✓",
+    warning: "!",
+    error: "×",
+    info: "•",
+    selected: "◆",
+    unselected: "·",
+    checked: "✓",
+    unchecked: "·",
+    add: "+",
+    adopt: "(+)",
+    edit: "~",
+    refresh: "↻",
+    delete: "-",
+    orphan: "(-)",
+    replace: "↔",
+    run: "▶",
+    bar: "┊",
+    mask: "•",
+    bullet: "·",
+    overflowUp: "↑",
+    overflowDown: "↓",
+    overflowLeft: "‹",
+    overflowRight: "›",
+  },
+  /**
+   * Key-hint labels for KeyBar footers. Resolve through `useKeyGlyphs()`
+   * (components/Environment.tsx) so ASCII terminals get readable fallbacks
+   * instead of mojibake.
+   */
+  keyHint: {
+    enter: "↩",
+    upDown: "↑/↓",
+    leftRight: "←/→",
+    escape: "esc",
+    space: "space",
+    tab: "tab",
+    yesNo: "y/n",
+  },
+} as const;
+
+export type KeyHint = { readonly [Key in keyof typeof theme.keyHint]: string };
+export type GlyphName = keyof typeof theme.glyph;
+
+export const asciiGlyphs: { readonly [Key in GlyphName]: string } = {
+  section: "@",
+  active: "*",
+  pointer: ">",
+  success: "+",
+  warning: "!",
+  error: "x",
+  info: "i",
+  selected: "*",
+  unselected: ".",
+  checked: "x",
+  unchecked: ".",
+  add: "+",
+  adopt: "(+)",
+  edit: "~",
+  refresh: "r",
+  delete: "-",
+  orphan: "(-)",
+  replace: "~",
+  run: ">",
+  bar: ":",
+  mask: "*",
+  bullet: ".",
+  overflowUp: "^",
+  overflowDown: "v",
+  overflowLeft: "<",
+  overflowRight: ">",
+};
+
+export const glyphsFor = (unicode: boolean) =>
+  unicode ? theme.glyph : asciiGlyphs;
+
+const spinnerFrames = [
+  "⠋",
+  "⠙",
+  "⠹",
+  "⠸",
+  "⠼",
+  "⠴",
+  "⠦",
+  "⠧",
+  "⠇",
+  "⠏",
+] as const;
+const asciiSpinnerFrames = ["-", "\\", "|", "/"] as const;
+
+export const spinnerFramesFor = (unicode: boolean): readonly string[] =>
+  unicode ? spinnerFrames : asciiSpinnerFrames;
+
+export type StatusVariant = "info" | "success" | "warning" | "error";
+
+export const statusColor = (variant: StatusVariant): string =>
+  variant === "error" ? theme.color.danger : theme.color[variant];
+
+export const statusPaint = (variant: StatusVariant): Paint =>
+  theme.paint[variant];

package/src/Util/gitignore-rules-to-globs.ts

@@ -1,14 +1,14 @@
 /**
- * Converts gitignore-style rules into glob patterns for tools like fast-glob's {@link https://github.com/mrmlnc/fast-glob#ignore `ignore`} option.
+ * Converts gitignore-style rules into glob patterns for tools like tinyglobby's {@link https://superchupu.dev/tinyglobby/documentation#ignore `ignore`} option.
  *
  * Gitignore and glob differ (ordering, negation, escapes). This maps the common cases:
  *
  * - Rules with no `/` match at any depth → \`**\/name\`, \`**\/name\/\*\/`
- * - A leading `/` anchors to the ignore file's directory (use the same `cwd` in fast-glob) → `name`, `name/**`
+ * - A leading `/` anchors to the ignore file's directory (use the same `cwd` in tinyglobby) → `name`, `name/**`
  * - A `/` in the pattern (not only leading) uses path-aware matching → `a/b`, `a/b/**`
  * - A trailing `/` restricts to directories → adds `/**` as needed
  * - Lines starting with `!` (negation) are returned with a `!` prefix for use in **positive** glob
- *   lists; they are not valid in fast-glob's `ignore` array (filter them out if you only pass `ignore`)
+ *   lists; filter them out when passing only exclusion patterns to an `ignore` array
  *
  * Does not implement full gitignore escaping (e.g. `\\ ` for trailing space) or `**` edge cases
  * identical to git; escape handling can be added later if needed.