alchemy 2.0.0-beta.84 → 2.0.0-beta.85

package/src/Alchemist/routes/nuke.ts

@@ -1,131 +0,0 @@
-import * as Config from "effect/Config";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Logger from "effect/Logger";
-import * as Option from "effect/Option";
-import { MinimumLogLevel } from "effect/References";
-import * as Nuke from "../../Nuke.ts";
-import type { ProviderMode } from "../../ProviderMode.ts";
-import type { ApplyStatus } from "../../Report.ts";
-import { Progress, withSpanEvents } from "../Progress.ts";
-import { buildStackProviders, DEFAULT_ENTRYPOINT, type Target } from "../Session.ts";
-
-export interface ScanInput extends Target {
-  readonly mode: ProviderMode;
-  /** Provider-id globs to include. Omitted means every provider. */
-  readonly include?: ReadonlyArray<string>;
-  /** Provider-id globs to exclude. Applied after `include`. */
-  readonly exclude?: ReadonlyArray<string>;
-  readonly concurrency?: number | "unbounded";
-  readonly providerTimeoutSeconds?: number;
-}
-
-/** One discovered cloud object, bound to the provider that can delete it. */
-export type NukeResource = Nuke.Target;
-
-export interface NukeScan {
-  readonly mode: ProviderMode;
-  readonly resources: ReadonlyArray<NukeResource>;
-  readonly failures: ReadonlyArray<Nuke.ProviderFailure>;
-  /** The built provider context {@link execute} deletes under. */
-  readonly context: Context.Context<never>;
-}
-
-export interface ExecuteInput {
-  readonly scan: NukeScan;
-  /** The subset of `scan.resources` to delete. */
-  readonly resources: ReadonlyArray<NukeResource>;
-  readonly strategy: Nuke.Strategy;
-  readonly concurrency?: number | "unbounded";
-  readonly providerTimeoutSeconds?: number;
-}
-
-export type NukeResult = Nuke.Result;
-
-/** Enumerate everything the stack's registered providers can see. */
-export const scan = Effect.fn("Alchemist.nuke.scan")(function* (input: ScanInput) {
-  const report = withSpanEvents(yield* Progress);
-  const debug = yield* Config.String("DEBUG").pipe(
-    Config.withDefault(""),
-    Effect.map((value) => value.length > 0),
-  );
-  // Nuke needs the provider layer, not a stack instance: it deletes what
-  // the cloud has, not what state says we own.
-  const built = yield* buildStackProviders({
-    main: input.entrypoint ?? DEFAULT_ENTRYPOINT,
-    envFile: Option.fromNullishOr(input.envFile),
-    profile: input.profile,
-    logger: debug ? Logger.layer([Logger.defaultLogger]) : undefined,
-    extra: Layer.succeed(MinimumLogLevel, debug ? "Debug" : "Info"),
-  });
-  const context = built.context as Context.Context<never>;
-  const { resources, failures } = yield* Nuke.list({
-    context,
-    mode: input.mode,
-    include: input.include,
-    exclude: input.exclude,
-    concurrency: input.concurrency,
-    timeoutSeconds: input.providerTimeoutSeconds,
-    onScan: (total) => report({ _tag: "nuke.scan.started", total }),
-    onProviderStarted: (provider) => report({ _tag: "nuke.scan.provider.started", provider }),
-    onProvider: (provider, count, error) =>
-      report({
-        _tag: "nuke.scan.provider.completed",
-        provider,
-        resources: count,
-        error,
-      }),
-  });
-  return { mode: input.mode, resources, failures, context } satisfies NukeScan;
-});
-
-/**
- * Permanently delete the selected resources. Each confirmed deletion is
- * reported through {@link Progress} as `NukeResourceDeleted`.
- */
-export const execute = Effect.fn("Alchemist.nuke.execute")(function* (input: ExecuteInput) {
-  const report = withSpanEvents(yield* Progress);
-  const keys = new Map(input.resources.map((resource, index) => [resource, `nuke/${index}`]));
-  const status = (resource: Nuke.Target, status: ApplyStatus, message?: string) =>
-    report({
-      _tag: "apply.resource.status",
-      fqn: keys.get(resource)!,
-      id: resource.providerId,
-      type: resource.providerId,
-      status,
-      message,
-    });
-  return yield* Nuke.destroy({
-    targets: input.resources,
-    context: input.scan.context,
-    strategy: input.strategy,
-    concurrency: input.concurrency,
-    timeoutSeconds: input.providerTimeoutSeconds,
-    onPass: (pass) => report({ _tag: "nuke.pass.started", pass }),
-    onDeleting: (resource) => status(resource, "deleting"),
-    onHeld: (resource, blockedBy) =>
-      status(resource, "skipped", `Held back by ${blockedBy.join(", ")}`),
-    onDeleted: (resource) =>
-      status(resource, "deleted").pipe(
-        Effect.andThen(
-          report({
-            _tag: "nuke.resource.deleted",
-            provider: resource.providerId,
-            resource: resource.displayName,
-          }),
-        ),
-      ),
-    onFailed: (resource, message) =>
-      status(resource, "fail", message).pipe(
-        Effect.andThen(
-          report({
-            _tag: "nuke.resource.failed",
-            provider: resource.providerId,
-            resource: resource.displayName,
-            message,
-          }),
-        ),
-      ),
-  });
-});

package/src/Alchemist/routes/stack.ts

@@ -1,173 +0,0 @@
-import * as Clock from "effect/Clock";
-import * as Effect from "effect/Effect";
-import { apply as applyPlan } from "../../Apply.ts";
-import * as Plan from "../../Plan.ts";
-import type { PlannedAction, PlannedResource } from "../../Report.ts";
-import type { ResourceSelection, SelectionOutput } from "../../ResourceSelection.ts";
-import { applySession, Progress, withSpanEvents } from "../Progress.ts";
-import { open, type Session, type StackTarget } from "../Session.ts";
-
-export type { StackTarget } from "../Session.ts";
-
-export interface PlanInput {
-  readonly target: StackTarget;
-  readonly operation: "deploy" | "destroy";
-  readonly force?: boolean;
-  readonly include?: never;
-  readonly exclude?: never;
-  readonly adopt?: boolean;
-  readonly updateStateStore?: boolean;
-  /** Run local (emulated) providers instead of the real cloud. */
-  readonly dev?: boolean;
-}
-
-/** Select nodes and dependencies; declaration still runs, stack outputs are preserved. */
-export interface FilteredPlanInput
-  extends Omit<PlanInput, keyof ResourceSelection>, ResourceSelection {}
-
-/** Infer the deployed stack output from an `alchemy.run.ts` module type. */
-export type StackModuleOutput<Module> = Module extends { readonly default: infer Definition }
-  ? Definition extends Effect.Effect<any, any, any>
-    ? Effect.Success<Definition> extends { readonly output: infer Output }
-      ? Output
-      : unknown
-    : unknown
-  : unknown;
-
-export interface PlanSummary {
-  readonly create: number;
-  readonly update: number;
-  readonly adopted: number;
-  readonly replace: number;
-  readonly delete: number;
-  readonly orphaned: number;
-  readonly noop: number;
-}
-
-export interface PlanSnapshot<Output = unknown> {
-  readonly stack: { readonly name: string; readonly stage: string };
-  readonly summary: PlanSummary;
-  /**
-   * Serializable resource rows (including orphan deletions) with their
-   * bindings and provider modes — what a remote renderer shows without
-   * holding {@link PlanSnapshot.native}.
-   */
-  readonly resources: ReadonlyArray<PlannedResource>;
-  /** Serializable stack-action rows. */
-  readonly actions: ReadonlyArray<PlannedAction>;
-  /** The engine plan, as consumed by in-process renderers and {@link apply}. */
-  readonly native: Plan.Plan<Output>;
-  readonly createdAt: Date;
-  /** The session this plan was computed under; {@link apply} runs in it. */
-  readonly session: Session;
-}
-
-/** Whether a plan proposes any cloud mutations (i.e. approval-worthy work). */
-export const hasChanges = (summary: PlanSummary): boolean =>
-  summary.create +
-    summary.update +
-    summary.adopted +
-    summary.replace +
-    summary.delete +
-    summary.orphaned >
-  0;
-
-export const summarize = (plan: Plan.Plan): PlanSummary => {
-  const summary: { -readonly [K in keyof PlanSummary]: PlanSummary[K] } = {
-    create: 0,
-    update: 0,
-    adopted: 0,
-    replace: 0,
-    delete: 0,
-    orphaned: 0,
-    noop: 0,
-  };
-  for (const node of Object.values(plan.resources)) summary[node.action]++;
-  for (const node of Object.values(plan.deletions)) {
-    if (node !== undefined) summary[node.action]++;
-  }
-  return summary;
-};
-
-type PlanResult<Output> = Effect.Effect<
-  PlanSnapshot<Output>,
-  Effect.Error<ReturnType<typeof planStack>>,
-  Effect.Services<ReturnType<typeof planStack>>
->;
-
-/**
- * Import the stack, resolve its services, and compute a deploy or destroy
- * plan. Planning phases are reported through {@link Progress}; the returned
- * snapshot is what {@link apply} executes. Filtered deploys preserve stack
- * outputs and return void; the entire declaration still evaluates.
- * With an explicit module type, filter-carrying callbacks also specify the input type.
- */
-export function plan<Module = unknown>(
-  input: FilteredPlanInput &
-    ({ include: ReadonlyArray<string> } | { exclude: ReadonlyArray<string> }),
-): PlanResult<undefined>;
-export function plan<Module = unknown>(input: PlanInput): PlanResult<StackModuleOutput<Module>>;
-export function plan<Module = unknown>(
-  input: FilteredPlanInput,
-): PlanResult<StackModuleOutput<Module> | undefined>;
-export function plan<Module = unknown, Input extends FilteredPlanInput = PlanInput>(
-  input: Input,
-): PlanResult<SelectionOutput<StackModuleOutput<Module>, Input>>;
-export function plan(input: FilteredPlanInput) {
-  return planStack(input);
-}
-
-const planStack = Effect.fn("Alchemist.stack.plan")(function* (input: FilteredPlanInput) {
-  type Output = StackModuleOutput<unknown> | undefined;
-  if (
-    input.operation === "destroy" &&
-    (input.include !== undefined || input.exclude !== undefined)
-  ) {
-    return yield* Effect.die(
-      new Plan.InvalidResourceSelection({ message: "Filtered destroy is not supported." }),
-    );
-  }
-  const report = withSpanEvents(yield* Progress);
-
-  // Everything below emits into the same flat ProgressEvent channel:
-  // `open` reports importing-module / resolving-services at the real work
-  // boundaries, the engine reports loading-state / computing-plan and the
-  // per-node diff events. Re-providing the wrapped reporter is all the
-  // route does — no translation layer.
-  const session = yield* open(input.target, input).pipe(Effect.provideService(Progress, report));
-  const native = (yield* (
-    input.operation === "destroy"
-      ? Plan.destroy(session.stack)
-      : Plan.make(session.stack, {
-          force: input.force,
-          include: input.include,
-          exclude: input.exclude,
-        })
-  ).pipe(
-    Effect.provideService(Progress, report),
-    Effect.provide(session.context),
-  )) as Plan.Plan<Output>;
-  yield* report({ _tag: "plan.phase", phase: "plan-ready" });
-  return {
-    stack: { name: session.stack.name, stage: session.stack.stage },
-    summary: summarize(native),
-    ...Plan.describePlan(native),
-    native,
-    createdAt: new Date(yield* Clock.currentTimeMillis),
-    session,
-  } satisfies PlanSnapshot<Output>;
-});
-
-/**
- * Apply a computed plan. Engine apply events are reported through
- * {@link Progress} as `ApplyEvent`.
- */
-export const apply = Effect.fn("Alchemist.stack.apply")(function* <Output>(
-  snapshot: PlanSnapshot<Output>,
-) {
-  const report = withSpanEvents(yield* Progress);
-  return yield* Effect.provide(
-    applyPlan(snapshot.native, { session: applySession(report) }),
-    snapshot.session.context,
-  );
-});

package/src/Cli/CliKit/CliKit.ts

@@ -1,159 +0,0 @@
-import type { TerminalProgressState } from "@alchemy.run/sigil/ansi";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import type * as Scope from "effect/Scope";
-import type { NonInteractiveTerminal } from "../../Interaction.ts";
-import type {
-  ConfirmOptions,
-  CycleSelectOptions,
-  AwaitExternalOptions,
-  MessageOptions,
-  InteractionError,
-  LiveViewHandle,
-  LiveViewOptions,
-  MenuOptions,
-  MultiSelectOptions,
-  PasswordInputOptions,
-  ProgressHandle,
-  ProgressOptions,
-  RenderOptions,
-  Screen,
-  SelectOptions,
-  CliKitCapabilities,
-  TextInputOptions,
-  View,
-} from "../components/types.ts";
-
-/** The sole injected owner of terminal rendering and input for a CLI process. */
-export class CliKit extends Context.Service<
-  CliKit,
-  {
-    readonly terminal: CliKitCapabilities;
-
-    /** Terminal-emulator progress displayed outside the rendered TUI. */
-    readonly nativeProgress: {
-      readonly set: (state: TerminalProgressState, value?: number) => Effect.Effect<void>;
-    };
-
-    readonly output: {
-      /** Append a completed layout to terminal scrollback/output. */
-      readonly print: (view: View, options?: RenderOptions) => Effect.Effect<void>;
-
-      /** Render a layout without writing it. Useful for help, logs and snapshots. */
-      readonly format: (view: View, options?: RenderOptions) => string;
-
-      /** Effect form of `format`, useful when composing CLI programs. */
-      readonly render: (view: View, options?: RenderOptions) => Effect.Effect<string>;
-
-      /** Append an arbitrary visual layout. Prefer the semantic methods for logs. */
-      readonly info: (message: string | MessageOptions) => Effect.Effect<void>;
-      readonly success: (message: string | MessageOptions) => Effect.Effect<void>;
-      readonly warning: (message: string | MessageOptions) => Effect.Effect<void>;
-      readonly error: (message: string | MessageOptions) => Effect.Effect<void>;
-    };
-
-    readonly prompt: {
-      readonly text: (options: TextInputOptions) => Effect.Effect<string, InteractionError>;
-      readonly password: (options: PasswordInputOptions) => Effect.Effect<string, InteractionError>;
-      readonly confirm: (options: ConfirmOptions) => Effect.Effect<boolean, InteractionError>;
-      readonly select: <Value>(
-        options: SelectOptions<Value>,
-      ) => Effect.Effect<Value, InteractionError>;
-      readonly multiSelect: <Value>(
-        options: MultiSelectOptions<Value>,
-      ) => Effect.Effect<ReadonlyArray<Value>, InteractionError>;
-      readonly cycle: <State>(
-        options: CycleSelectOptions<State>,
-      ) => Effect.Effect<ReadonlyArray<State>, InteractionError>;
-      readonly awaitExternal: (
-        options: AwaitExternalOptions,
-      ) => Effect.Effect<string, InteractionError>;
-
-      /**
-       * Display an application menu. Each invocation replaces the current app
-       * flow, so looping back to a menu clears any prompts shown since the last
-       * selection.
-       */
-      readonly menu: <Value>(options: MenuOptions<Value>) => Effect.Effect<Value, InteractionError>;
-
-      /** Run an arbitrary interactive screen in the service's single live region. */
-      readonly custom: <Value>(screen: Screen<Value>) => Effect.Effect<Value, InteractionError>;
-    };
-
-    /** Run a sequence of prompts as one owned interaction. */
-    readonly wizard: <A, E, R>(
-      effect: Effect.Effect<A, E, R>,
-    ) => Effect.Effect<A, E | NonInteractiveTerminal, R>;
-
-    /**
-     * Keep one renderer alive while an Effect drives menus, screens and prompt
-     * flows. The application is cleared and the renderer exits when it settles.
-     */
-    readonly application: <A, E, R>(
-      effect: Effect.Effect<A, E, R>,
-    ) => Effect.Effect<A, E | NonInteractiveTerminal, R>;
-
-    readonly live: {
-      /**
-       * Add a mutable row to the live region. The handle is idempotent, and
-       * the enclosing Scope closes it as a backstop so interruption can never
-       * leave an orphaned row keeping the renderer mounted.
-       */
-      readonly progress: (
-        options: ProgressOptions,
-      ) => Effect.Effect<ProgressHandle, never, Scope.Scope>;
-      /**
-       * Mount a live layout while the scope is open. The view is immutable —
-       * dynamic content flows through a caller-owned store (`LiveStore` +
-       * `useLiveStore`) that the view's component subscribes to.
-       */
-      readonly open: (
-        view: View,
-        options?: LiveViewOptions,
-      ) => Effect.Effect<LiveViewHandle, never, Scope.Scope>;
-    };
-
-    /** Run work behind a progress row and collapse it to a final status line. */
-    readonly task: <A, E, R>(
-      options: ProgressOptions,
-      effect: Effect.Effect<A, E, R>,
-    ) => Effect.Effect<A, E, R>;
-  }
->()("Alchemy::CliKit") {}
-
-/** Effectful service accessors for code that must defer acquisition to use time. */
-export const accessors = {
-  output: {
-    info: (message: string | MessageOptions) =>
-      Effect.flatMap(CliKit, (service) => service.output.info(message)),
-    success: (message: string | MessageOptions) =>
-      Effect.flatMap(CliKit, (service) => service.output.success(message)),
-    warning: (message: string | MessageOptions) =>
-      Effect.flatMap(CliKit, (service) => service.output.warning(message)),
-    error: (message: string | MessageOptions) =>
-      Effect.flatMap(CliKit, (service) => service.output.error(message)),
-  },
-  prompt: {
-    text: (options: TextInputOptions) =>
-      Effect.flatMap(CliKit, (service) => service.prompt.text(options)),
-    password: (options: PasswordInputOptions) =>
-      Effect.flatMap(CliKit, (service) => service.prompt.password(options)),
-    confirm: (options: ConfirmOptions) =>
-      Effect.flatMap(CliKit, (service) => service.prompt.confirm(options)),
-    select: <Value>(options: SelectOptions<Value>) =>
-      Effect.flatMap(CliKit, (service) => service.prompt.select(options)),
-    multiSelect: <Value>(options: MultiSelectOptions<Value>) =>
-      Effect.flatMap(CliKit, (service) => service.prompt.multiSelect(options)),
-  },
-};
-
-export const ApplicationPresentation = Context.Reference<"inline" | "alternate">(
-  "Alchemy::CliKit/ApplicationPresentation",
-  { defaultValue: () => "inline" },
-);
-
-/** Pipeable presentation modifiers for {@link CliKit.application}. */
-export const Application = {
-  alternate: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-    effect.pipe(Effect.provideService(ApplicationPresentation, "alternate" as const)),
-};

package/src/Cli/CliKit/index.ts

@@ -1,41 +0,0 @@
-export { accessors, Application, CliKit } from "./CliKit.ts";
-export { layer } from "./layer.ts";
-export { CliKitInteraction } from "./interaction.ts";
-export { openUrl } from "../../Interaction.ts";
-export { BrowserOpenFailed, NonInteractiveTerminal, TerminalCancelled } from "../../Interaction.ts";
-export { glyphsFor, spinnerFramesFor, theme, type GlyphName } from "../../Util/Theme.ts";
-export {
-  ANSI_BOLD,
-  ANSI_DIM,
-  ANSI_RESET,
-  ansiFg,
-  colorsEnabled,
-  paint,
-  pipedColorEnv,
-  truncate,
-  unicodeEnabled,
-} from "../../Util/Terminal.ts";
-export {
-  Screen,
-  type Choice,
-  type AwaitExternalOptions,
-  type ConfirmOptions,
-  type CycleChoice,
-  type CycleSelectOptions,
-  type InteractionError,
-  type LiveViewHandle,
-  type LiveViewOptions,
-  type MenuOptions,
-  type MessageOptions,
-  type MultiSelectOptions,
-  type PasswordInputOptions,
-  type ProgressHandle,
-  type ProgressOptions,
-  type RenderOptions,
-  type ScreenController,
-  type SelectOptions,
-  type CliKitCapabilities,
-  type CliKitOptions,
-  type TextInputOptions,
-  type View,
-} from "../components/types.ts";

package/src/Cli/CliKit/interaction.ts

@@ -1,19 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { Interaction } from "../../Interaction.ts";
-import { CliKit } from "./CliKit.ts";
-
-/**
- * The CLI's implementation of the engine's {@link Interaction} capability,
- * backed by the full CliKit terminal runtime: messages and `task` render
- * through the live renderer, prompts run as real interactive screens.
- * Provided by the CLI entrypoints next to `CliKit.layer()`; every other
- * process uses `Interaction.layerNonInteractive` (or nothing at all —
- * children have no interaction capability in their graphs).
- */
-export const CliKitInteraction = Layer.effect(
-  Interaction,
-  // CliKit's surface is a structural superset of Interaction's — the
-  // terminal service IS the CLI's Interaction implementation.
-  Effect.map(CliKit, (cli): Interaction["Service"] => cli),
-);

package/src/Cli/CliKit/layer.ts

@@ -1,44 +0,0 @@
-import { detectCapabilities } from "@alchemy.run/sigil/capabilities";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { isNonInteractive } from "../../Util/interactive.ts";
-import type { CliKitCapabilities, CliKitOptions } from "../components/types.ts";
-import { CliKit } from "./CliKit.ts";
-
-export const resolveCapabilities = (options: CliKitOptions): CliKitCapabilities => {
-  const stdout = options.stdout ?? process.stdout;
-  const stdin = options.stdin ?? process.stdin;
-  const detected = detectCapabilities({ stdout });
-  const input =
-    options.input ?? (stdin.isTTY === true && stdout.isTTY === true && !isNonInteractive());
-  return {
-    input,
-    columns: detected.size.columns,
-    rows: detected.size.rows,
-    colors: options.colors ?? detected.supports.color,
-    unicode: options.unicode ?? detected.supports.unicode,
-    alternateScreen: detected.supports.alternateScreen,
-  };
-};
-
-// One shared import promise per process. Concurrent dynamic imports of the
-// same module (e.g. two test files building this layer at once) can race in
-// bun and hand one caller a partially-evaluated namespace, which throws a
-// TDZ ReferenceError on `makeRuntime`; funneling every build through a
-// single import() sidesteps the race.
-let sigilRuntime: Promise<typeof import("../components/view/Runtime.tsx")> | undefined;
-const loadSigilRuntime = () => (sigilRuntime ??= import("../components/view/Runtime.tsx"));
-
-/** Provides one terminal runtime for the enclosing scope. */
-export const layer = (options: CliKitOptions = {}) =>
-  Layer.effect(
-    CliKit,
-    Effect.acquireRelease(
-      Effect.promise(async () => {
-        const capabilities = resolveCapabilities(options);
-        const { makeRuntime } = await loadSigilRuntime();
-        return makeRuntime(options, capabilities);
-      }),
-      ({ dispose }) => Effect.promise(dispose),
-    ).pipe(Effect.map(({ service }) => service)),
-  );