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

package/src/Cli/LoggingCli.ts

@@ -1,62 +1,82 @@
-import * as Console from "effect/Console";
+import * as Clock from "effect/Clock";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import type { CRUD, Plan } from "../Plan.ts";
-import { Cli } from "./Cli.ts";
-import type { ApplyEvent, ApplyStatus } from "./Event.ts";
+import * as Prompt from "effect/unstable/cli/Prompt";
+import { inspect } from "node:util";
+import type { ActionApply, ActionDelete, CRUD, Plan } from "../Plan.ts";
+import { Cli, type PlanDisplayOptions } from "../Report.ts";
+import { canPromptOnStdin } from "../Util/interactive.ts";
+import { NonInteractiveTerminal } from "../Interaction.ts";
+import { ansiFg, colorsEnabled, theme } from "./CliKit/index.ts";
+import { formatElapsed } from "./Format.ts";
+import {
+  actionStyle,
+  applyStatusColor,
+  isTerminalStatus as isTerminal,
+} from "./components/view/statusStyle.ts";
+import type { ApplyEvent, ApplyStatus } from "../Report.ts";
 import { formatModeNote } from "./ModeTag.ts";
+import { formatResourceTag } from "../Util/ResourceOutput.ts";
+import {
+  formatDeclaredPropertyYaml,
+  matchYamlChange,
+  matchYamlKey,
+} from "./PropertyDiff.ts";
+import { actionHasPlannedWork, buildPlanSummary } from "./NamespaceTree.ts";
 
 const ESC = "\x1b[";
 const RESET = `${ESC}0m`;
-const useColor = process.stdout.hasColors?.() ?? !!process.stdout.isTTY;
+// Shared with every other non-ink output path — notably it honors
+// FORCE_COLOR, so lines emitted from the piped dev sidecar keep their color.
+const useColor = colorsEnabled();
 const c = (code: string, s: string) =>
   useColor ? `${ESC}${code}m${s}${RESET}` : s;
+const hex = (color: string) => (s: string) =>
+  useColor ? `${ansiFg(color)}${s}${RESET}` : s;
 const dim = (s: string) => c("2", s);
 const bold = (s: string) => c("1", s);
-const red = (s: string) => c("31", s);
-const green = (s: string) => c("32", s);
-const yellow = (s: string) => c("33", s);
-const blue = (s: string) => c("34", s);
-const magenta = (s: string) => c("35", s);
-const cyan = (s: string) => c("36", s);
+const red = hex(theme.color.danger);
+const green = hex(theme.color.success);
+const blue = hex(theme.color.accent);
+const cyan = hex(theme.color.info);
 
+// noop stays terminal-dim rather than brand-muted so it recedes in plain logs
 const actionColor: Record<CRUD["action"], (s: string) => string> = {
-  create: green,
-  update: yellow,
-  replace: magenta,
-  delete: red,
+  create: hex(actionStyle.create.color),
+  update: hex(actionStyle.update.color),
+  adopted: hex(actionStyle.adopted.color),
+  replace: hex(actionStyle.replace.color),
+  delete: hex(actionStyle.delete.color),
+  orphaned: hex(actionStyle.orphaned.color),
   noop: dim,
 };
 
+// muted stays terminal-dim rather than brand-muted, matching `actionColor`.
 const statusColor = (status: ApplyStatus): ((s: string) => string) => {
-  switch (status) {
-    case "created":
-    case "updated":
-    case "replaced":
-      return green;
-    case "deleted":
-      return dim;
-    case "retained":
-      return dim;
-    case "fail":
-      return red;
-    case "attaching":
-    case "post-attach":
-      return cyan;
-    default:
-      return yellow;
-  }
+  const color = applyStatusColor(status);
+  if (color === undefined || color === theme.color.muted) return dim;
+  return hex(color);
 };
 
-const tag = (id: string) => bold(`[${id}]`);
+const tag = formatResourceTag;
 
-const isTerminal = (status: ApplyStatus): boolean =>
-  status === "created" ||
-  status === "updated" ||
-  status === "deleted" ||
-  status === "retained" ||
-  status === "replaced" ||
-  status === "fail";
+/**
+ * In-progress statuses that represent real cloud work. Plain output has no
+ * spinner, so these lines are the liveness signal in CI logs
+ * (CloudFormation-style IN_PROGRESS rows). Bookkeeping transitions
+ * (`pending`, `attaching`, `post-attach`) stay silent — they resolve in
+ * milliseconds and would double the log for no information.
+ */
+const isActive = (status: ApplyStatus): boolean =>
+  status === "pre-creating" ||
+  status === "creating" ||
+  status === "creating replacement" ||
+  status === "updating" ||
+  status === "adopting" ||
+  status === "deleting" ||
+  status === "orphaning" ||
+  status === "replacing" ||
+  status === "running";
 
 /**
  * Dim `(local)` / `(remote)` / `(local → live)` suffix for a resource row,
@@ -69,27 +89,48 @@ const modeSuffix = (options: Parameters<typeof formatModeNote>[0]): string => {
 };
 
 /** Exported for unit tests — pure plan-preview rendering. */
-export const formatPlanLines = (plan: Plan): string[] => {
-  const items = [
+export const formatPlanLines = (
+  plan: Plan,
+  options: PlanDisplayOptions = {},
+): string[] => {
+  const allItems = [
     ...Object.values(plan.resources),
     ...Object.values(plan.deletions),
   ] as CRUD[];
-  if (items.length === 0) return [bold("Plan:") + " no changes"];
+  const tasks = [
+    ...Object.values(plan.actions ?? {}),
+    ...Object.values(plan.actionDeletions ?? {}),
+  ]
+    .filter((task): task is ActionApply | ActionDelete => task !== undefined)
+    .filter(actionHasPlannedWork);
+  if (allItems.length === 0 && tasks.length === 0) {
+    return [`${bold("Plan:")} ${dim("no resources")}`];
+  }
 
-  const counts = items.reduce(
-    (acc, item) => ((acc[item.action] = (acc[item.action] ?? 0) + 1), acc),
-    {} as Record<CRUD["action"], number>,
-  );
-  const summary = (["create", "update", "replace", "delete", "noop"] as const)
+  const { counts, bindingChanges } = buildPlanSummary(plan);
+  const summaryParts = (
+    ["create", "update", "adopted", "replace", "delete", "orphaned"] as const
+  )
     .filter((a) => counts[a])
-    .map((a) => actionColor[a](`${counts[a]} to ${a}`))
-    .join(dim(", "));
+    .map((a) => actionColor[a](`${counts[a]} to ${a}`));
+  if (bindingChanges > 0) {
+    summaryParts.push(cyan(`${bindingChanges} binding changes`));
+  }
+  if (tasks.length > 0) {
+    summaryParts.push(cyan(`${tasks.length} tasks`));
+  }
+  const summary =
+    summaryParts.length === 0
+      ? dim("no changes")
+      : summaryParts.join(dim(", "));
 
-  const sorted = [...items].sort((a, b) =>
+  const sorted = [...allItems].sort((a, b) =>
     a.resource.LogicalId.localeCompare(b.resource.LogicalId),
   );
   const lines = [`${bold("Plan:")} ${summary}`];
-  for (const item of sorted) {
+  if (options.detailed && sorted.length > 0) lines.push("");
+  for (const [index, item] of sorted.entries()) {
+    if (options.detailed && index > 0) lines.push("");
     const action = actionColor[item.action](item.action);
     const mode = modeSuffix({
       mode: item.mode,
@@ -103,73 +144,236 @@ export const formatPlanLines = (plan: Plan): string[] => {
     // reconciles. (Only apply-side nodes can carry a rename — see
     // `ApplyNodeBase`.)
     const renamed =
-      item.action !== "delete" && item.renamedFrom?.length
+      "renamedFrom" in item && item.renamedFrom?.length
         ? ` ${dim(`(renamed from ${item.renamedFrom.join(", ")})`)}`
         : "";
-    lines.push(`${tag(item.resource.LogicalId)} ${action}${mode}${renamed}`);
-    for (const binding of item.bindings) {
-      if (binding.action === "noop") continue;
-      const bindingAction = actionColor[binding.action](binding.action);
+    lines.push(`${tag(item.resource.FQN)} ${action}${mode}${renamed}`);
+    for (const binding of [...item.bindings].sort((a, b) =>
+      a.sid.localeCompare(b.sid),
+    )) {
+      const bindingAction =
+        binding.action === "delete"
+          ? dim("unbind")
+          : actionColor[binding.action](binding.action);
       lines.push(
-        `${tag(`${item.resource.LogicalId}/${binding.sid}`)} ${bindingAction}`,
+        `${tag(`${item.resource.FQN}/${binding.sid}`)} ${bindingAction}`,
       );
     }
+    if (
+      options.detailed &&
+      (item.action === "create" ||
+        item.action === "update" ||
+        item.action === "adopted" ||
+        item.action === "replace")
+    ) {
+      const document = formatDeclaredPropertyYaml(
+        item.action === "create" ? {} : item.state.props,
+        item.props,
+        item.action === "adopted" ? "update" : item.action,
+      );
+      if (document === undefined) {
+        lines.push(`  ${dim("no declared property changes")}`);
+      } else {
+        lines.push(
+          ...document.lines.map(
+            (line) => `  ${colorYamlLine(line, document.kind)}`,
+          ),
+        );
+      }
+    }
+  }
+  for (const task of tasks.sort((a, b) =>
+    a.def.LogicalId.localeCompare(b.def.LogicalId),
+  )) {
+    lines.push(
+      `${tag(task.def.FQN)} ${cyan(task.action === "delete" ? "drop" : "run")} ${dim("[action]")}`,
+    );
   }
   return lines;
 };
 
-export const LoggingCli = Layer.succeed(
-  Cli,
-  Cli.of({
-    approvePlan: (plan) =>
-      Effect.gen(function* () {
-        for (const line of formatPlanLines(plan)) yield* Console.log(line);
-        yield* Console.log(
-          `\n${yellow("Non-interactive terminal detected.")} Pass ${bold("--yes")} to approve, or set ${bold("ALCHEMY_TUI=1")} for the interactive UI.`,
-        );
-        return false;
-      }),
-    displayPlan: (plan) =>
-      Effect.gen(function* () {
-        for (const line of formatPlanLines(plan)) yield* Console.log(line);
-      }),
-    startApplySession: (plan) =>
-      Effect.gen(function* () {
-        for (const line of formatPlanLines(plan)) yield* Console.log(line);
-        yield* Console.log("");
+const colorYamlLine = (
+  line: string,
+  kind: "create" | "change" | "drift",
+): string => {
+  const change = matchYamlChange(line);
+  if (change !== undefined) {
+    const color = change.marker === "-" ? red : green;
+    return color(`${change.marker} ${change.content}`);
+  }
+  const key = matchYamlKey(line);
+  if (key === undefined) return line;
+  const color = kind === "create" ? green : cyan;
+  return `${key.indent}${color(key.key)}${key.value}`;
+};
 
-        const counts = { ok: 0, fail: 0 };
-        return {
-          // Write through the Effect Console SERVICE (not the global
-          // `console`) so environments that override it — e.g. the
-          // alchemy-test runner's per-test buffering console — capture
-          // apply progress instead of having it leak to stdout.
-          emit: (event: ApplyEvent) =>
+export const LoggingCli = Layer.effect(
+  Cli,
+  Effect.gen(function* () {
+    // Captured at layer build so `approvePlan` keeps the CLIService signature
+    // (no requirements on the returned Effects).
+    const promptContext = yield* Effect.context<Prompt.Environment>();
+    const confirm = (options: Prompt.ConfirmOptions) =>
+      Prompt.Confirm(options).pipe(
+        Effect.catchTag("QuitError", () => Effect.succeed(false)),
+        Effect.provideContext(promptContext),
+      );
+    return Cli.of({
+      startPlanningSession: (label, _detail, title) =>
+        Effect.gen(function* () {
+          // Same information as the interactive session, one plain line per
+          // change: the title header carries the operation + stage once, each
+          // phase prints as it starts, and the settle line carries the total
+          // planning time (the spinner's implicit "how long did that take").
+          const startedAt = yield* Clock.currentTimeMillis;
+          if (title !== undefined) yield* Effect.logInfo(bold(title));
+          yield* Effect.logInfo(dim(label));
+          let closed = false;
+          let lastLabel = label;
+          const write = (nextLabel: string, _nextDetail?: string) =>
+            Effect.suspend(() => {
+              // Repeated updates within one phase (spinner detail refreshes)
+              // carry nothing new for a line-per-change log.
+              if (closed || nextLabel === lastLabel) return Effect.void;
+              lastLabel = nextLabel;
+              return Effect.logInfo(dim(nextLabel));
+            });
+          const finish = (message: string, paint: (s: string) => string) =>
             Effect.suspend(() => {
-              if (event.kind === "annotate") {
-                return Console.log(`${tag(event.id)} ${blue(event.message)}`);
-              }
-              const id = event.bindingId
-                ? `${event.id}/${event.bindingId}`
-                : event.id;
-              const status = statusColor(event.status)(event.status);
-              const mode = modeSuffix({
-                mode: event.providerMode,
-                priorMode: event.fromProviderMode,
-                defaultMode: plan.defaultMode,
-              });
-              const msg = event.message ? ` ${dim("—")} ${event.message}` : "";
-              if (isTerminal(event.status)) {
-                if (event.status === "fail") counts.fail++;
-                else counts.ok++;
-              }
-              return Console.log(`${tag(id)} ${status}${mode}${msg}`);
+              if (closed) return Effect.void;
+              closed = true;
+              return Clock.currentTimeMillis.pipe(
+                Effect.flatMap((now) =>
+                  Effect.logInfo(
+                    `${paint(message)} ${dim(`(${formatElapsed(now - startedAt)})`)}`,
+                  ),
+                ),
+              );
+            });
+          return {
+            update: write,
+            succeed: (message = "Plan ready") => finish(message, green),
+            fail: (message = "Planning failed") => finish(message, red),
+            close: Effect.sync(() => {
+              closed = true;
+            }),
+          };
+        }),
+      approvePlan: (plan, options) =>
+        Effect.gen(function* () {
+          for (const line of formatPlanLines(plan, options))
+            yield* Effect.logInfo(line);
+          if (canPromptOnStdin()) {
+            return yield* confirm(
+              plan.destroy === true
+                ? { message: "Destroy these resources?", initial: false }
+                : { message: "Apply this plan?", initial: true },
+            );
+          }
+          return yield* Effect.fail(
+            new NonInteractiveTerminal({
+              operation: "approve deployment plan",
+              message:
+                "Cannot approve this operation without terminal input. Pass --yes to continue.",
             }),
-          done: () =>
-            Console.log(
-              `\n${bold("Done:")} ${green(`${counts.ok} succeeded`)}${counts.fail ? dim(", ") + red(`${counts.fail} failed`) : ""}`,
-            ),
-        };
-      }),
+          );
+        }),
+      displayPlan: (plan, options) =>
+        Effect.gen(function* () {
+          for (const line of formatPlanLines(plan, options))
+            yield* Effect.logInfo(line);
+        }),
+      startApplySession: (plan, options) =>
+        Effect.gen(function* () {
+          for (const line of formatPlanLines(plan, options))
+            yield* Effect.logInfo(line);
+          yield* Effect.logInfo("");
+
+          const startedAt = yield* Clock.currentTimeMillis;
+          const started = new Map<string, number>();
+          const terminal = new Map<string, ApplyStatus>();
+          const notes = new Map<string, string>();
+          const statusNotes = new Map<string, string>();
+          return {
+            setOutput: (value: unknown) =>
+              Effect.logInfo(inspect(value, { colors: false })),
+            // Progress is an Effect log record, just like provider and build
+            // diagnostics, so the append-only renderer gives every line the
+            // same timestamp / level / fiber prefix.
+            emit: (event: ApplyEvent) =>
+              Clock.currentTimeMillis.pipe(
+                Effect.flatMap((now) =>
+                  Effect.suspend(() => {
+                    if (event._tag === "apply.resource.note") {
+                      // `status` notes only surface as the settle line's suffix;
+                      // everything else streams, deduping consecutive repeats.
+                      if (event.kind === "status") {
+                        statusNotes.set(event.fqn, event.message);
+                        return Effect.void;
+                      }
+                      if (notes.get(event.fqn) === event.message)
+                        return Effect.void;
+                      notes.set(event.fqn, event.message);
+                      return Effect.logInfo(
+                        `${tag(event.fqn)} ${blue(event.message)}`,
+                      );
+                    }
+                    const id = event.fqn;
+                    const mode = modeSuffix({
+                      mode: event.providerMode,
+                      priorMode: event.fromProviderMode,
+                      defaultMode: plan.defaultMode,
+                    });
+                    if (!isTerminal(event.status)) {
+                      if (!isActive(event.status)) return Effect.void;
+                      if (!started.has(id)) started.set(id, now);
+                      return Effect.logInfo(
+                        `${tag(id)} ${dim(event.status)}${mode}`,
+                      );
+                    }
+                    terminal.set(id, event.status);
+                    const status = statusColor(event.status)(event.status);
+                    const from = started.get(id);
+                    const took =
+                      from === undefined
+                        ? ""
+                        : ` ${dim(`(${formatElapsed(now - from)})`)}`;
+                    const message = event.message ?? statusNotes.get(event.fqn);
+                    // Failures carry their error as the message — paint it
+                    // red so the line reads as the error line for that
+                    // resource, without waiting for the final cause dump.
+                    const msg = message
+                      ? ` ${dim("—")} ${event.status === "fail" ? red(message) : message}`
+                      : "";
+                    return Effect.logInfo(
+                      `${tag(id)} ${status}${mode}${msg}${took}`,
+                    );
+                  }),
+                ),
+              ),
+            done: (outcome) =>
+              Clock.currentTimeMillis.pipe(
+                Effect.flatMap((now) => {
+                  const statuses = [...terminal.values()];
+                  const failed = statuses.filter((s) => s === "fail").length;
+                  const skipped = statuses.filter(
+                    (s) => s === "skipped",
+                  ).length;
+                  const succeeded = terminal.size - failed - skipped;
+                  const parts = [green(`${succeeded} succeeded`)];
+                  if (failed) parts.push(red(`${failed} failed`));
+                  if (skipped) parts.push(dim(`${skipped} skipped`));
+                  return Effect.logInfo("").pipe(
+                    Effect.andThen(
+                      Effect.logInfo(
+                        `${bold(outcome === "success" ? "Done:" : "Failed:")} ${parts.join(dim(", "))} ${dim(`(${formatElapsed(now - startedAt)})`)}`,
+                      ),
+                    ),
+                  );
+                }),
+              ),
+          };
+        }),
+    });
   }),
 );

package/src/Cli/ModeTag.ts

@@ -1,7 +1,7 @@
 import type { ProviderMode } from "../ProviderMode.ts";
 
 /**
- * Pure formatting shared by the plan/deploy renderers (Ink TUI +
+ * Pure formatting shared by the plan/deploy renderers (Sigil TUI +
  * non-interactive LoggingCli) for the local-vs-live provider-mode
  * indicator on a resource row.
  *