alchemy 2.0.0-beta.76 → 2.0.0-beta.77

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,
+  tmuxPassthrough,
+  type TerminalProgressState,
+} from "@alchemy.run/sigil/ansi";
+import stringWidth from "string-width";
+
+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/interactive.ts

@@ -1,32 +1,119 @@
+import * as Effect from "effect/Effect";
+
 /**
  * Returns true when the current process looks like it's being driven by a
  * coding agent, CI runner, test runner, or anything else that won't render an
  * interactive TUI / prompt well.
  *
- * Two callers rely on this:
- *  - `Cli/selectCli.ts` uses it to pick `LoggingCli` over the Ink TUI.
- *  - `Auth/Profile.ts` uses it to refuse to launch an interactive credential
- *    configure flow (and thus avoid acquiring an auth lockfile) when there's
- *    no TTY to drive the prompts.
+ * This is the process-level source of truth used by CliKit capability
+ * detection, auth configuration guards, and spawned-command stdin policy.
  *
  * Kept in `Util` (rather than `Cli`) so `Auth` can depend on it without
  * pulling in the CLI layer.
  */
+// An explicit CLI flag beats every env-based heuristic. Checked via argv
+// because capability detection runs while the CLI's service layers are
+// built, before the command parser has produced flag values. Only scan up
+// to a `--` separator so a positional argument that happens to be the
+// literal text "--no-input" is not mistaken for the flag.
+const hasNoInputFlag = (): boolean => {
+  const separator = process.argv.indexOf("--");
+  const flagArgs =
+    separator === -1 ? process.argv : process.argv.slice(0, separator);
+  return flagArgs.includes("--no-input");
+};
+
+// Known coding-agent env vars, ported from unjs/std-env (src/agents.ts).
+// Best-effort — the isTTY checks at the call sites already catch most cases
+// since agents typically pipe stdin/stdout. std-env's kiro check
+// (TERM_PROGRAM=kiro gated on no-TTY) is deliberately omitted: both call
+// sites only reach this function when stdin/stdout ARE a TTY, where that
+// check would never match.
+const isAgentEnv = (env: NodeJS.ProcessEnv): boolean =>
+  !!(
+    // explicit override supported by std-env
+    env.AI_AGENT ||
+    // claude
+    env.CLAUDECODE ||
+    env.CLAUDE_CODE ||
+    env.CLAUDE_CODE_ENTRYPOINT ||
+    // replit
+    env.REPL_ID ||
+    // gemini
+    env.GEMINI_CLI ||
+    // codex
+    env.CODEX_SANDBOX ||
+    env.CODEX_THREAD_ID ||
+    env.CODEX_CLI ||
+    // opencode
+    env.OPENCODE ||
+    // auggie
+    env.AUGMENT_AGENT ||
+    // goose
+    env.GOOSE_PROVIDER ||
+    // junie
+    env.JUNIE_DATA ||
+    env.JUNIE_SHIM_PATH ||
+    // aider
+    env.AIDER_MODEL ||
+    // pi
+    /\.pi[\\/]agent/.test(env.PATH ?? "") ||
+    // devin
+    /devin/.test(env.EDITOR ?? "") ||
+    // cursor
+    env.CURSOR_AGENT
+  );
+
 export const isNonInteractive = (): boolean => {
   const env = process.env;
+  if (hasNoInputFlag()) return true;
   if (env.ALCHEMY_PLAIN === "1" || env.ALCHEMY_NO_TUI === "1") return true;
   if (env.ALCHEMY_TUI === "1") return false;
-  if (!process.stdout.isTTY) return true;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return true;
   if (env.CI) return true;
-  // Known coding-agent env vars. These are best-effort — the isTTY check
-  // above already catches most cases since agents typically pipe stdout.
-  if (
-    env.CLAUDECODE ||
-    env.CLAUDE_CODE_ENTRYPOINT ||
-    env.CURSOR_AGENT ||
-    env.AIDER_MODEL ||
-    env.CODEX_CLI
-  )
-    return true;
+  if (isAgentEnv(env)) return true;
   return false;
 };
+
+/**
+ * Whether a plain line-based prompt can still read an answer from stdin.
+ *
+ * Distinct from {@link isNonInteractive}: `ALCHEMY_PLAIN` / `ALCHEMY_NO_TUI`
+ * turn off the TUI *rendering*, not input — a human running plain mode in a
+ * terminal can still answer a `[y/n]` question. Agents and CI pipe stdin
+ * (or set their env markers) and land `false`.
+ */
+export const canPromptOnStdin = (): boolean => {
+  const env = process.env;
+  if (hasNoInputFlag()) return false;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+  if (env.CI) return false;
+  if (isAgentEnv(env)) return false;
+  return true;
+};
+
+export interface InteractionCapabilities {
+  readonly input: boolean;
+}
+
+/** Process capabilities as an Effect so callers can replace them in tests. */
+export const processInteractionCapabilities: Effect.Effect<InteractionCapabilities> =
+  Effect.sync(() => ({ input: !isNonInteractive() }));
+
+/** Select user-facing copy from an injected capability Effect. */
+export const messageForCapabilities = <E, R>(
+  capabilities: Effect.Effect<InteractionCapabilities, E, R>,
+  interactive: string,
+  nonInteractive: string,
+): Effect.Effect<string, E, R> =>
+  Effect.map(capabilities, ({ input }) =>
+    input ? interactive : nonInteractive,
+  );
+
+/** Prefer the profile dashboard when this process can own a TUI screen. */
+export const profileCommandHint = (nonInteractiveCommand: string) =>
+  messageForCapabilities(
+    processInteractionCapabilities,
+    "alchemy profile",
+    nonInteractiveCommand,
+  );

package/src/Util/scc.ts

@@ -1,17 +1,18 @@
 /**
- * Compute the set of graph nodes that participate in a dependency cycle.
+ * Compute the strongly-connected components of a directed graph.
  *
- * A node is considered "in a cycle" iff it sits in a strongly-connected
- * component (SCC) of size > 1, or has a self-edge (size-1 SCC that loops
- * back to itself).
+ * Components are emitted in Tarjan completion order — the reverse
+ * topological order of the condensation, so a component appears before
+ * every component that has an edge into it.
  *
  * Implementation is iterative Tarjan's algorithm to avoid blowing the JS
  * call stack on very wide graphs.
  */
-export const findCycleMembers = (
-  edges: Record<string, readonly string[]>,
-): Set<string> => {
-  const cycleMembers = new Set<string>();
+export const stronglyConnectedComponents = (
+  nodes: Iterable<string>,
+  successors: (node: string) => Iterable<string>,
+): string[][] => {
+  const output: string[][] = [];
 
   let index = 0;
   const indexOf = new Map<string, number>();
@@ -19,7 +20,7 @@ export const findCycleMembers = (
   const onStack = new Set<string>();
   const stack: string[] = [];
 
-  type Frame = { node: string; childIdx: number };
+  type Frame = { node: string; children: string[]; childIdx: number };
   const callStack: Frame[] = [];
 
   const startNode = (node: string) => {
@@ -28,18 +29,17 @@ export const findCycleMembers = (
     index += 1;
     stack.push(node);
     onStack.add(node);
-    callStack.push({ node, childIdx: 0 });
+    callStack.push({ node, children: [...successors(node)], childIdx: 0 });
   };
 
-  for (const root of Object.keys(edges)) {
+  for (const root of nodes) {
     if (indexOf.has(root)) continue;
     startNode(root);
 
     while (callStack.length > 0) {
       const frame = callStack[callStack.length - 1];
-      const children = edges[frame.node] ?? [];
-      if (frame.childIdx < children.length) {
-        const child = children[frame.childIdx];
+      if (frame.childIdx < frame.children.length) {
+        const child = frame.children[frame.childIdx];
         frame.childIdx += 1;
         if (!indexOf.has(child)) {
           startNode(child);
@@ -63,15 +63,7 @@ export const findCycleMembers = (
           scc.push(w);
           if (w === frame.node) break;
         }
-        if (scc.length > 1) {
-          for (const fqn of scc) cycleMembers.add(fqn);
-        } else {
-          // Size-1 SCC: only counts as a cycle if it has a self-edge.
-          const only = scc[0];
-          if ((edges[only] ?? []).includes(only)) {
-            cycleMembers.add(only);
-          }
-        }
+        output.push(scc);
       }
 
       // Pop frame and propagate lowlink up to the parent.
@@ -85,5 +77,33 @@ export const findCycleMembers = (
     }
   }
 
+  return output;
+};
+
+/**
+ * Compute the set of graph nodes that participate in a dependency cycle.
+ *
+ * A node is considered "in a cycle" iff it sits in a strongly-connected
+ * component (SCC) of size > 1, or has a self-edge (size-1 SCC that loops
+ * back to itself).
+ */
+export const findCycleMembers = (
+  edges: Record<string, readonly string[]>,
+): Set<string> => {
+  const cycleMembers = new Set<string>();
+  for (const scc of stronglyConnectedComponents(
+    Object.keys(edges),
+    (node) => edges[node] ?? [],
+  )) {
+    if (scc.length > 1) {
+      for (const fqn of scc) cycleMembers.add(fqn);
+    } else {
+      // Size-1 SCC: only counts as a cycle if it has a self-edge.
+      const only = scc[0];
+      if ((edges[only] ?? []).includes(only)) {
+        cycleMembers.add(only);
+      }
+    }
+  }
   return cycleMembers;
 };

package/src/Util/tarGzip.ts

@@ -105,6 +105,7 @@ type WalkEntry = {
   rel: string;
   abs: string;
   dir: boolean;
+  mode: number;
 };
 
 const walkDirectory = (
@@ -123,10 +124,20 @@ const walkDirectory = (
           const posixRel = childRel.replaceAll("\\", "/");
           const stat = yield* fs.stat(abs);
           if (stat.type === "Directory") {
-            files.push({ rel: posixRel, abs, dir: true });
+            files.push({
+              rel: posixRel,
+              abs,
+              dir: true,
+              mode: stat.mode & 0o7777,
+            });
             yield* walk(abs, posixRel);
           } else if (stat.type === "File") {
-            files.push({ rel: posixRel, abs, dir: false });
+            files.push({
+              rel: posixRel,
+              abs,
+              dir: false,
+              mode: stat.mode & 0o7777,
+            });
           }
         }
       });
@@ -159,17 +170,34 @@ const fileBlocks = (
  * Pack `root` into a gzipped tar (ustar + GNU long-name). Paths are
  * relative to `root` with POSIX separators.
  */
-export const tarGzipDirectory = Effect.fn(function* (root: string) {
+export const tarGzipDirectory = Effect.fn(function* (
+  root: string,
+  options?: { preserveMode?: boolean },
+) {
   const fs = yield* FileSystem.FileSystem;
   const files = yield* walkDirectory(root);
   const chunks: Uint8Array[] = [];
   for (const file of files) {
     if (file.dir) {
-      chunks.push(...fileBlocks(`${file.rel}/`, 0, "5", 0o755));
+      chunks.push(
+        ...fileBlocks(
+          `${file.rel}/`,
+          0,
+          "5",
+          options?.preserveMode ? file.mode : 0o755,
+        ),
+      );
       continue;
     }
     const content = yield* fs.readFile(file.abs);
-    chunks.push(...fileBlocks(file.rel, content.byteLength, "0", 0o644));
+    chunks.push(
+      ...fileBlocks(
+        file.rel,
+        content.byteLength,
+        "0",
+        options?.preserveMode ? file.mode : 0o644,
+      ),
+    );
     chunks.push(content);
     const pad = pad512(content.byteLength);
     if (pad > 0) chunks.push(new Uint8Array(pad));

package/src/index.ts

@@ -7,6 +7,7 @@ export {
 export * as AdoptPolicy from "./AdoptPolicy.ts";
 export * from "./AI/index.ts";
 export * from "./AlchemyContext.ts";
+export * as Alchemist from "./Alchemist/index.ts";
 export * from "./Apply.ts";
 export {
   Service as BindingService,
@@ -38,13 +39,14 @@ export * as Serverless from "./Serverless/index.ts";
 export { Stack } from "./Stack.ts";
 export * from "./Stage.ts";
 export { inMemoryState, localState } from "./State/index.ts";
-export * as Sync from "./Sync.ts";
+export * as Drift from "./Drift.ts";
 export * as Telemetry from "./Telemetry.ts";
 
 // Re-export internal types so they can be portably named in
 // downstream `.d.ts` emissions (fixes TS2883 in user files).
 export { AuthProviders } from "./Auth/AuthProvider.ts";
-export { Cli } from "./Cli/Cli.ts";
+export { Cli } from "./Report.ts";
+export * as Report from "./Report.ts";
 export type { Dependencies } from "./Dependencies.ts";
 export type { Named } from "./Named.ts";
 export type * from "./Platform.ts";

package/lib/Cli/Cli.d.ts

@@ -1,21 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import type { Plan } from "../Plan.ts";
-import type { ApplyEvent } from "./Event.ts";
-export interface PlanStatusSession {
-    emit: (event: ApplyEvent) => Effect.Effect<void>;
-    done: () => Effect.Effect<void>;
-}
-export interface ScopedPlanStatusSession extends PlanStatusSession {
-    note: (note: string) => Effect.Effect<void>;
-}
-export interface CLIService {
-    approvePlan: <P extends Plan>(plan: P) => Effect.Effect<boolean>;
-    displayPlan: <P extends Plan>(plan: P) => Effect.Effect<void>;
-    startApplySession: <P extends Plan>(plan: P) => Effect.Effect<PlanStatusSession>;
-}
-declare const Cli_base: Context.ServiceClass<Cli, "CLI", CLIService>;
-export declare class Cli extends Cli_base {
-}
-export {};
-//# sourceMappingURL=Cli.d.ts.map

package/lib/Cli/Cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Cli.d.ts","sourceRoot":"","sources":["../../src/Cli/Cli.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjD,IAAI,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,uBAAwB,SAAQ,iBAAiB;IAChE,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,CAAC,CAAC,SAAS,IAAI,EAAE,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACjE,WAAW,EAAE,CAAC,CAAC,SAAS,IAAI,EAAE,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC9D,iBAAiB,EAAE,CAAC,CAAC,SAAS,IAAI,EAChC,IAAI,EAAE,CAAC,KACJ,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;CACvC;;AAED,qBAAa,GAAI,SAAQ,QAAyC;CAAG"}

package/lib/Cli/Cli.js

@@ -1,5 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-export class Cli extends Context.Service()("CLI") {
-}
-//# sourceMappingURL=Cli.js.map

package/lib/Cli/Cli.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Cli.js","sourceRoot":"","sources":["../../src/Cli/Cli.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAqBxC,MAAM,OAAO,GAAI,SAAQ,OAAO,CAAC,OAAO,EAAmB,CAAC,KAAK,CAAC;CAAG"}