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

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/proxy-chain.ts

@@ -122,6 +122,22 @@ const replayArg = (
 export const proxyChain = <T>(cached: Effect.Effect<T, any, any>): T =>
   chain(cached) as T;
 
+/**
+ * Property reads the Effect runtime uses as *brand probes* — `symbol` keys
+ * and `~effect/...` type-id strings (`~effect/Exit`, `~effect/Effect`, …).
+ * The fiber's generator runner distinguishes a yielded Effect from an Exit
+ * with `value[ExitTypeId] !== undefined` (effect ≥ 4.0.0-rc.113; earlier
+ * releases used `in`, which the `has` trap already answers). Recording such
+ * a read as a chain step would hand back a truthy proxy, so the runner
+ * would treat every chain as an already-settled Exit and resume the
+ * generator with `proxy.value` — another proxy — instead of running it.
+ * Brand probes therefore answer `undefined` when the underlying effect
+ * lacks the key; the `has` trap keeps `in`-based probes correct too.
+ */
+const isBrandProbe = (prop: PropertyKey): boolean =>
+  typeof prop === "symbol" ||
+  (typeof prop === "string" && prop.startsWith("~effect/"));
+
 const chain = (
   cached: Effect.Effect<unknown, any, any>,
   ops: ReadonlyArray<Op> = [],
@@ -136,6 +152,9 @@ const chain = (
       if (Reflect.has(effect, prop)) {
         return Reflect.get(effect, prop);
       }
+      if (isBrandProbe(prop)) {
+        return undefined;
+      }
       return chain(cached, [...ops, { kind: "get", prop }]);
     },
     has(target, prop) {

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/Util/zip.ts

@@ -1,5 +1,6 @@
 import * as Effect from "effect/Effect";
-import type JSZip from "jszip";
+import type { Zippable } from "fflate";
+import { Buffer } from "node:buffer";
 
 export interface ZipFile {
   path: string;
@@ -11,46 +12,15 @@ export interface ZipFile {
   mode?: number;
 }
 
-const archiveDate = new Date("1980-01-01T00:00:00.000Z");
-
-/**
- * Generate the archive bytes deterministically. Nested paths make JSZip
- * synthesize the intermediate folder entries, and those are stamped with
- * `new Date()` rather than the per-file date the entries were added with.
- * Left alone, two archives built from identical bytes seconds apart differ —
- * which reads downstream as a content change.
- */
-const generateDeterministic = (zip: JSZip) =>
-  Effect.gen(function* () {
-    yield* Effect.sync(() => {
-      for (const entry of Object.values(zip.files)) {
-        entry.date = archiveDate;
-      }
-    });
-    return yield* Effect.promise(() =>
-      zip.generateAsync({
-        type: "nodebuffer",
-        compression: "DEFLATE",
-        platform: "UNIX",
-      }),
-    );
-  });
+// ZIP timestamps use local calendar fields; local midnight keeps the encoded
+// date identical in every timezone, including those west of UTC.
+const archiveDate = new Date(1980, 0, 1);
 
 export const zipCode = Effect.fn(function* (
   content: string | Uint8Array<ArrayBufferLike>,
   files?: ReadonlyArray<ZipFile>,
 ) {
-  // Create a zip buffer in memory
-  const zip = new (yield* Effect.promise(() => import("jszip"))).default();
-  zip.file("index.mjs", content, { date: archiveDate });
-  for (const file of files ?? []) {
-    zip.file(file.path, file.content, {
-      date: archiveDate,
-      unixPermissions: file.mode,
-    });
-  }
-
-  return yield* generateDeterministic(zip);
+  return yield* zipFiles([{ path: "index.mjs", content }, ...(files ?? [])]);
 });
 
 /**
@@ -59,14 +29,15 @@ export const zipCode = Effect.fn(function* (
  * identical bytes.
  */
 export const zipFiles = Effect.fn(function* (files: ReadonlyArray<ZipFile>) {
-  // Create a zip buffer in memory
-  const zip = new (yield* Effect.promise(() => import("jszip"))).default();
-  for (const file of [...files].sort((a, b) => (a.path < b.path ? -1 : 1))) {
-    zip.file(file.path, file.content, {
-      date: archiveDate,
-      unixPermissions: file.mode,
-    });
+  const { zipSync, strToU8 } = yield* Effect.promise(() => import("fflate"));
+  const entries: Zippable = Object.create(null);
+  for (const file of [...files].sort((a, b) =>
+    a.path < b.path ? -1 : a.path > b.path ? 1 : 0,
+  )) {
+    entries[file.path] = [
+      typeof file.content === "string" ? strToU8(file.content) : file.content,
+      { attrs: (file.mode ?? 0o100644) << 16 },
+    ];
   }
-
-  return yield* generateDeterministic(zip);
+  return Buffer.from(zipSync(entries, { mtime: archiveDate, os: 3 }));
 });

package/src/Utils/ip-address.ts

@@ -0,0 +1,90 @@
+/**
+ * Canonicalizes an IPv4 or IPv6 CIDR to its network address.
+ * Invalid input is returned unchanged; this function is not a validator.
+ */
+export const canonicalCidr = (cidr: string | undefined): string | undefined => {
+  if (cidr === undefined) return undefined;
+  if (/\s/.test(cidr)) return cidr;
+  const [address, prefixText, extra] = cidr.split("/");
+  if (!address || prefixText === undefined || extra !== undefined) return cidr;
+  if (!/^\d+$/.test(prefixText)) return cidr;
+
+  const ipv6 = address.includes(":");
+  const width = ipv6 ? 128 : 32;
+  const prefix = Number(prefixText);
+  if (!Number.isInteger(prefix) || prefix > width) return cidr;
+  const value = ipv6 ? parseIpv6(address) : parseIpv4(address);
+  if (value === undefined) return cidr;
+
+  const hostBits = BigInt(width - prefix);
+  const network = (value >> hostBits) << hostBits;
+  return `${ipv6 ? formatIpv6(network) : formatIpv4(network)}/${prefix}`;
+};
+
+const parseIpv4 = (address: string): bigint | undefined => {
+  const octets = address.split(".");
+  if (
+    octets.length !== 4 ||
+    octets.some(
+      (octet) => !/^(0|[1-9]\d{0,2})$/.test(octet) || Number(octet) > 255,
+    )
+  )
+    return undefined;
+  return octets.reduce((value, octet) => (value << 8n) | BigInt(octet), 0n);
+};
+
+const parseIpv6 = (address: string): bigint | undefined => {
+  if (address.includes(".")) {
+    const lastColon = address.lastIndexOf(":");
+    const ipv4 = parseIpv4(address.slice(lastColon + 1));
+    if (ipv4 === undefined) return undefined;
+    address = `${address.slice(0, lastColon + 1)}${(ipv4 >> 16n).toString(16)}:${(ipv4 & 0xffffn).toString(16)}`;
+  }
+
+  const halves = address.split("::");
+  if (halves.length > 2) return undefined;
+  const left = halves[0] ? halves[0].split(":") : [];
+  const right = halves[1] ? halves[1].split(":") : [];
+  const count = left.length + right.length;
+  if (halves.length === 1 ? count !== 8 : count >= 8) return undefined;
+  if ([...left, ...right].some((word) => !/^[0-9a-f]{1,4}$/i.test(word))) {
+    return undefined;
+  }
+
+  // A double colon must replace at least one 16-bit word.
+  const words =
+    halves.length === 1
+      ? left
+      : [...left, ...Array<string>(8 - count).fill("0"), ...right];
+  return words.reduce(
+    (value, word) => (value << 16n) | BigInt(`0x${word}`),
+    0n,
+  );
+};
+
+const formatIpv4 = (address: bigint): string =>
+  [24n, 16n, 8n, 0n]
+    .map((shift) => Number((address >> shift) & 255n))
+    .join(".");
+
+const formatIpv6 = (address: bigint): string => {
+  const words = Array.from({ length: 8 }, (_, index) =>
+    ((address >> BigInt((7 - index) * 16)) & 0xffffn).toString(16),
+  );
+  let longestStart = -1;
+  let longestLength = 1;
+  for (let index = 0; index < words.length; index++) {
+    if (words[index] !== "0") continue;
+    let end = index + 1;
+    while (end < words.length && words[end] === "0") end++;
+    // Compress the first longest run; never compress a single zero word.
+    if (end - index > longestLength) {
+      longestStart = index;
+      longestLength = end - index;
+    }
+    index = end - 1;
+  }
+  return longestStart < 0
+    ? words.join(":")
+    : `${words.slice(0, longestStart).join(":")}::${words.slice(longestStart + longestLength).join(":")}`;
+};

package/src/Website/Server.ts

@@ -10,7 +10,7 @@ import * as LocalProvider from "../Local/LocalProvider.ts";
 import * as ProviderLayer from "../Local/ProviderLayer.ts";
 import * as Provider from "../Provider.ts";
 import { Resource } from "../Resource.ts";
-import { initialCwd } from "../Util/Node.ts";
+import { initialCwd, moduleExtension } from "../Util/Node.ts";
 import { sha256Object } from "../Util/sha256.ts";
 
 /**
@@ -398,10 +398,25 @@ export const ServerProviderLive = () =>
           const built = yield* runBuild(news);
           return yield* makeOutput(news, built);
         }),
-        delete: Effect.fn(function* ({ output }) {
+        delete: Effect.fn(function* ({ olds, output }) {
           if (output.distDir === undefined) return;
+          const root = path.resolve(initialCwd, olds.root ?? ".");
           const distDir = path.resolve(initialCwd, output.distDir);
-          if (!(yield* fs.exists(distDir))) return;
+          if (!(yield* fs.exists(root)) || !(yield* fs.exists(distDir))) return;
+          // Some frameworks (Next.js) serve from the project root itself.
+          // Only dedicated output directories inside that root are disposable.
+          // Canonical paths also protect roots reached through a symlink.
+          const relative = path.relative(
+            yield* fs.realPath(root),
+            yield* fs.realPath(distDir),
+          );
+          if (
+            relative === "" ||
+            relative === ".." ||
+            relative.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(relative)
+          )
+            return;
           yield* fs.remove(distDir, { recursive: true });
         }),
       };
@@ -481,7 +496,7 @@ export const ServerProviderLocal = () =>
   LocalProvider.make(
     Server,
     import.meta.resolve(
-      import.meta.url.endsWith(".ts") ? "./ServerLocal.ts" : "./ServerLocal.js",
+      `./ServerLocal${moduleExtension(import.meta.url)}`,
       import.meta.url,
     ),
     Effect.gen(function* () {

package/src/Website/ServerLocal.ts

@@ -1,4 +1,8 @@
-import * as RpcServer from "../Local/RpcServer.ts";
+/**
+ * The `Website.Server` provider group served by the dev sidecar (see
+ * `Local/Sidecar.ts`), so a framework dev server outlives exec-child reloads.
+ */
+import type * as RpcServer from "../Local/RpcServer.ts";
 import { ServerProviderLocal } from "./Server.ts";
 
-ServerProviderLocal().pipe(RpcServer.launch);
+export default ServerProviderLocal() satisfies RpcServer.ProviderLayer;

package/src/index.ts

@@ -38,13 +38,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/AWS/Website/ServerLocal.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ServerLocal.d.ts.map

package/lib/AWS/Website/ServerLocal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ServerLocal.d.ts","sourceRoot":"","sources":["../../../src/AWS/Website/ServerLocal.ts"],"names":[],"mappings":""}

package/lib/AWS/Website/ServerLocal.js

@@ -1,4 +0,0 @@
-import * as RpcServer from "../../Local/RpcServer.js";
-import { ServerProviderLocal } from "../../Website/Server.js";
-ServerProviderLocal().pipe(RpcServer.launch);
-//# sourceMappingURL=ServerLocal.js.map

package/lib/AWS/Website/ServerLocal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ServerLocal.js","sourceRoot":"","sources":["../../../src/AWS/Website/ServerLocal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,mBAAmB,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC"}

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"}