effective-progress 0.4.2 → 0.5.0

package/src/ink-renderer/layout.ts

@@ -0,0 +1,145 @@
+import { formatAmount, formatElapsed, formatEta } from "./format";
+import { renderTreePrefix } from "./tree";
+import type { TaskRowModel } from "./types";
+
+export const DEFAULT_BAR_WIDTH = 20;
+const MIN_DESCRIPTION_WIDTH = 8;
+const MIN_BAR_WIDTH = 8;
+const MIN_ELAPSED_WIDTH = 3;
+const MIN_AMOUNT_WIDTH = 1;
+const BASELINE_ROW_WIDTH = 100;
+export const MIN_DESCRIPTION_COLUMNS_FOR_TREE = 24;
+const RESERVED_ELAPSED_WIDTH_UP_TO_ONE_HOUR = Array.from("59m 59s").length;
+const RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR = Array.from("ETA: 59m 59s").length;
+
+const textWidth = (text: string): number => Array.from(text).length;
+
+export interface SharedColumnWidths {
+  readonly row: number;
+  readonly description: number;
+  readonly bar: number;
+  readonly amount: number;
+  readonly elapsed: number;
+  readonly eta: number;
+  readonly showTree: boolean;
+}
+
+const computeWidths = (
+  rows: ReadonlyArray<TaskRowModel>,
+  now: number,
+  tick: number,
+  terminalColumns?: number,
+  includeTree = true,
+): Omit<SharedColumnWidths, "showTree"> => {
+  let hasDeterminate = false;
+  let description = MIN_DESCRIPTION_WIDTH;
+  let amount = 1;
+  let elapsed = RESERVED_ELAPSED_WIDTH_UP_TO_ONE_HOUR;
+  let eta = RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR;
+
+  for (const row of rows) {
+    const { task, tree } = row;
+    const treePrefix = includeTree ? renderTreePrefix(tree) : "";
+    description = Math.max(description, textWidth(`${treePrefix}${task.description}`));
+
+    if (task.units._tag === "DeterminateTaskUnits") {
+      hasDeterminate = true;
+    }
+
+    amount = Math.max(amount, textWidth(formatAmount(task, tick)));
+    elapsed = Math.max(elapsed, textWidth(formatElapsed(task, now)));
+
+    if (task.status === "running" && task.units._tag === "DeterminateTaskUnits") {
+      const etaValue = formatEta(task, now);
+      const etaText = `ETA: ${etaValue.length > 0 ? etaValue : "--"}`;
+      eta = Math.max(eta, textWidth(etaText));
+    }
+  }
+
+  const bar = hasDeterminate ? DEFAULT_BAR_WIDTH : 0;
+  let widths = {
+    description,
+    bar,
+    amount,
+    elapsed,
+    eta,
+  };
+
+  const visible = (w: typeof widths): Array<number> =>
+    [w.description, w.bar, w.amount, w.elapsed, w.eta].filter((width) => width > 0);
+  const total = (w: typeof widths): number => {
+    const cols = visible(w);
+    return cols.reduce((sum, width) => sum + width, 0) + Math.max(0, cols.length - 1);
+  };
+
+  const baselineTarget = Math.max(BASELINE_ROW_WIDTH, total(widths));
+  const target =
+    terminalColumns === undefined
+      ? baselineTarget
+      : Math.max(1, Math.min(Math.max(1, Math.floor(terminalColumns)), baselineTarget));
+
+  if (total(widths) < target) {
+    widths.description += target - total(widths);
+  } else if (total(widths) > target) {
+    let overflow = total(widths) - target;
+
+    const reduceBy = (key: keyof typeof widths, min: number) => {
+      if (overflow <= 0) {
+        return;
+      }
+      const current = widths[key];
+      if (current <= min) {
+        return;
+      }
+      const reducible = current - min;
+      const delta = Math.min(reducible, overflow);
+      widths = { ...widths, [key]: current - delta };
+      overflow -= delta;
+    };
+
+    // Compress the description first, then optional columns.
+    reduceBy("description", MIN_DESCRIPTION_WIDTH);
+    reduceBy("eta", 0);
+    reduceBy("bar", MIN_BAR_WIDTH);
+    reduceBy("bar", 0);
+    reduceBy("elapsed", MIN_ELAPSED_WIDTH);
+    reduceBy("amount", MIN_AMOUNT_WIDTH);
+    reduceBy("description", 0);
+
+    if (total(widths) < target) {
+      widths.description += target - total(widths);
+    }
+  }
+
+  const rowWidth = total(widths);
+
+  return {
+    row: rowWidth,
+    description: widths.description,
+    bar: widths.bar,
+    amount: widths.amount,
+    elapsed: widths.elapsed,
+    eta: widths.eta,
+  };
+};
+
+export const computeSharedColumnWidths = (
+  rows: ReadonlyArray<TaskRowModel>,
+  now: number,
+  tick: number,
+  terminalColumns?: number,
+): SharedColumnWidths => {
+  const withTree = computeWidths(rows, now, tick, terminalColumns, true);
+  if (withTree.description >= MIN_DESCRIPTION_COLUMNS_FOR_TREE) {
+    return {
+      ...withTree,
+      showTree: true,
+    };
+  }
+
+  const withoutTree = computeWidths(rows, now, tick, terminalColumns, false);
+  return {
+    ...withoutTree,
+    showTree: false,
+  };
+};

package/src/ink-renderer/model.ts

@@ -0,0 +1,24 @@
+import type { TaskStore } from "../types";
+import type { OrderedTask, TaskRowModel } from "./types";
+import { computeTreeInfo } from "./tree";
+
+const orderedVisibleTasks = (store: TaskStore): ReadonlyArray<OrderedTask> =>
+  store.renderOrder.flatMap((row) => {
+    const snapshot = store.tasks.get(row.id);
+    if (!snapshot || (snapshot.transient && snapshot.status !== "running")) {
+      return [];
+    }
+
+    return [
+      {
+        snapshot,
+        depth: row.depth,
+      },
+    ];
+  });
+
+export const toTaskRows = (store: TaskStore): ReadonlyArray<TaskRowModel> =>
+  computeTreeInfo(orderedVisibleTasks(store)).map((entry) => ({
+    task: entry.snapshot,
+    tree: entry.tree,
+  }));

package/src/ink-renderer/service.tsx

@@ -0,0 +1,121 @@
+import { Writable } from "node:stream";
+import { Clock, Context, Effect, Layer, Ref } from "effect";
+import { render, type Instance } from "ink";
+import type { ProgressTerminalService } from "../terminal";
+import type { TaskSnapshot, TaskStore } from "../types";
+import { ProgressApp } from "./app";
+import { toTaskRows } from "./model";
+
+const RENDER_INTERVAL_MILLIS = 100;
+
+export interface InkRendererService {
+  readonly run: (
+    storeRef: Ref.Ref<TaskStore>,
+    dirtyRef: Ref.Ref<boolean>,
+    terminal: ProgressTerminalService,
+    isTTY: boolean,
+  ) => Effect.Effect<void>;
+}
+
+const hasRunningSpinners = (tasks: ReadonlyArray<TaskSnapshot>): boolean =>
+  tasks.some(
+    (task) => task.status === "running" && task.units._tag === "IndeterminateTaskUnits",
+  );
+
+const createInkWritable = (terminal: ProgressTerminalService): Writable =>
+  new Writable({
+    write(chunk, _encoding, callback) {
+      try {
+        const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : `${chunk}`;
+        Effect.runSync(terminal.writeStderr(text));
+        callback();
+      } catch (error) {
+        callback(error as Error);
+      }
+    },
+  });
+
+const makeDefaultInkRenderer = (): InkRendererService => ({
+  run: (storeRef, dirtyRef, terminal, isTTY) =>
+    Effect.gen(function* () {
+      const output = createInkWritable(terminal);
+      let instance: Instance | undefined;
+      let tick = 0;
+      let rendererActive = false;
+
+      const renderStore = (
+        store: TaskStore,
+        now: number,
+        terminalColumns: number | undefined,
+      ) =>
+        Effect.sync(() => {
+          const app = (
+            <ProgressApp
+              rows={toTaskRows(store)}
+              now={now}
+              tick={tick}
+              isTTY={isTTY}
+              terminalColumns={terminalColumns}
+            />
+          );
+          if (instance === undefined) {
+            instance = render(app, {
+              stdout: output as unknown as NodeJS.WriteStream,
+              stderr: output as unknown as NodeJS.WriteStream,
+              patchConsole: true,
+              exitOnCtrlC: false,
+              debug: false,
+            });
+            return;
+          }
+
+          instance.rerender(app);
+        });
+
+      const renderLoop = Effect.gen(function* () {
+        rendererActive = true;
+
+        while (true) {
+          const dirty = yield* Ref.getAndSet(dirtyRef, false);
+          const store = yield* Ref.get(storeRef);
+          const tasks = Array.from(store.tasks.values()).filter(
+            (task) => !(task.transient && task.status !== "running"),
+          );
+          const shouldRender = dirty || hasRunningSpinners(tasks);
+
+          if (shouldRender) {
+            const now = yield* Clock.currentTimeMillis;
+            const terminalColumns = isTTY ? yield* terminal.stderrColumns : undefined;
+            yield* renderStore(store, now, terminalColumns);
+          }
+
+          tick += 1;
+          yield* Effect.sleep(RENDER_INTERVAL_MILLIS);
+        }
+      }).pipe(
+        Effect.ensuring(
+          Effect.gen(function* () {
+            if (rendererActive) {
+              const store = yield* Ref.get(storeRef);
+              const now = yield* Clock.currentTimeMillis;
+              const terminalColumns = isTTY ? yield* terminal.stderrColumns : undefined;
+              yield* renderStore(store, now, terminalColumns);
+            }
+
+            yield* Effect.sync(() => {
+              instance?.unmount();
+            });
+          }),
+        ),
+      );
+
+      return yield* renderLoop;
+    }),
+});
+
+export class InkRenderer extends Context.Tag("stromseng.dev/effective-progress/InkRenderer")<
+  InkRenderer,
+  InkRendererService
+>() {
+  static readonly Default = Layer.succeed(InkRenderer, InkRenderer.of(makeDefaultInkRenderer()));
+}

package/src/ink-renderer/task-row.tsx

@@ -0,0 +1,53 @@
+import { Box } from "ink";
+import { DEFAULT_BAR_WIDTH, type SharedColumnWidths } from "./layout";
+import type { TaskRowModel } from "./types";
+import {
+  AmountColumn,
+  BarColumn,
+  DescriptionColumn,
+  ElapsedColumn,
+  EtaColumn,
+} from "./columns";
+
+export interface TaskRowProps {
+  readonly row: TaskRowModel;
+  readonly now: number;
+  readonly tick: number;
+  readonly isTTY: boolean;
+  readonly widths: SharedColumnWidths;
+}
+
+export const TaskRow = ({ row, now, tick, isTTY, widths }: TaskRowProps) => {
+  const props = {
+    task: row.task,
+    tree: row.tree,
+    now,
+    tick,
+    isTTY,
+    showTree: widths.showTree,
+  } as const;
+
+  return (
+    <Box flexDirection="row" minWidth={widths.row}>
+      <Box width={widths.description} flexShrink={1} marginRight={1}>
+        <DescriptionColumn {...props} />
+      </Box>
+      {widths.bar > 0 ? (
+        <Box width={widths.bar} flexShrink={0} marginRight={1}>
+          <BarColumn {...props} width={Math.max(1, Math.min(widths.bar, DEFAULT_BAR_WIDTH))} />
+        </Box>
+      ) : null}
+      <Box width={widths.amount} flexShrink={0} marginRight={1}>
+        <AmountColumn {...props} />
+      </Box>
+      <Box width={widths.elapsed} flexShrink={0} marginRight={1}>
+        <ElapsedColumn {...props} />
+      </Box>
+      {widths.eta > 0 ? (
+        <Box width={widths.eta} flexShrink={0}>
+          <EtaColumn {...props} />
+        </Box>
+      ) : null}
+    </Box>
+  );
+};

package/src/{renderer → ink-renderer}/tree.ts

@@ -1,10 +1,4 @@
-import type { TaskSnapshot } from "../types";
-import type { TaskTreeInfo } from "./types";
-
-export interface OrderedTreeTask {
-  readonly snapshot: TaskSnapshot;
-  readonly depth: number;
-}
+import type { OrderedTask, TaskTreeInfo } from "./types";
 
 const treeAncestorPrefix = (tree: TaskTreeInfo): string =>
   tree.ancestorHasNextSibling
@@ -22,8 +16,8 @@ export const renderTreePrefix = (tree: TaskTreeInfo): string => {
 };
 
 export const computeTreeInfo = (
-  ordered: ReadonlyArray<OrderedTreeTask>,
-): ReadonlyArray<OrderedTreeTask & { readonly tree: TaskTreeInfo }> => {
+  ordered: ReadonlyArray<OrderedTask>,
+): ReadonlyArray<OrderedTask & { readonly tree: TaskTreeInfo }> => {
   const hasNextSiblingByIndex: Array<boolean> = Array.from({ length: ordered.length }, () => false);
 
   for (let i = 0; i < ordered.length; i++) {

package/src/ink-renderer/types.ts

@@ -0,0 +1,18 @@
+import type { TaskSnapshot } from "../types";
+
+export interface TaskTreeInfo {
+  readonly depth: number;
+  readonly hasNextSibling: boolean;
+  readonly hasChildren: boolean;
+  readonly ancestorHasNextSibling: ReadonlyArray<boolean>;
+}
+
+export interface OrderedTask {
+  readonly snapshot: TaskSnapshot;
+  readonly depth: number;
+}
+
+export interface TaskRowModel {
+  readonly task: TaskSnapshot;
+  readonly tree: TaskTreeInfo;
+}

package/src/runtime.ts

@@ -1,48 +1,22 @@
 import { Clock, Context, Effect, Exit, FiberRef, Layer, Option, Ref } from "effect";
 import { dual } from "effect/Function";
-import { mergeWith } from "es-toolkit/object";
-import { formatWithOptions } from "node:util";
-import type { PartialDeep } from "type-fest";
-import { makeProgressConsole } from "./console";
-import { Columns, FrameRenderer } from "./renderer";
+import { InkRenderer } from "./ink-renderer";
 import { ProgressTerminal } from "./terminal";
 import type {
   AddTaskOptions,
   ProgressService,
   RenderRow,
-  RendererConfigShape,
   TaskStore,
   UpdateTaskOptions,
 } from "./types";
 import {
-  decodeProgressBarConfigSync,
-  decodeRendererConfigSync,
-  defaultProgressBarConfig,
-  defaultRendererConfig,
   DeterminateTaskUnits,
   IndeterminateTaskUnits,
-  ProgressBarConfig,
-  RendererConfig,
   Task,
   TaskId,
   TaskSnapshot,
 } from "./types";
 
-const mergeConfig = <T extends Record<PropertyKey, any>>(
-  base: T,
-  override: PartialDeep<T> | undefined,
-): T =>
-  mergeWith(
-    structuredClone(base),
-    (override ?? {}) as Record<PropertyKey, any>,
-    (_targetValue, sourceValue) => {
-      if (Array.isArray(sourceValue)) {
-        return sourceValue;
-      }
-      return undefined;
-    },
-  ) as T;
-
 const updatedSnapshot = (snapshot: TaskSnapshot, options: UpdateTaskOptions): TaskSnapshot => {
   const currentUnits = snapshot.units;
   const units = (() => {
@@ -82,7 +56,6 @@ const updatedSnapshot = (snapshot: TaskSnapshot, options: UpdateTaskOptions): Ta
     status: snapshot.status,
     transient: options.transient ?? snapshot.transient,
     units,
-    config: snapshot.config,
     startedAt: snapshot.startedAt,
     completedAt: snapshot.completedAt,
   });
@@ -96,7 +69,6 @@ const withTransient = (snapshot: TaskSnapshot, transient: boolean): TaskSnapshot
     status: snapshot.status,
     transient,
     units: snapshot.units,
-    config: snapshot.config,
     startedAt: snapshot.startedAt,
     completedAt: snapshot.completedAt,
   });
@@ -130,62 +102,28 @@ const removeFromRenderOrder = (
   return next;
 };
 
-const withDefaultColumns = (rendererConfig: RendererConfigShape): RendererConfigShape => ({
-  ...rendererConfig,
-  columns: rendererConfig.columns.length > 0 ? rendererConfig.columns : Columns.defaults(),
-});
-
 const makeProgressService = Effect.gen(function* () {
-  const rendererConfigOption = yield* Effect.serviceOption(RendererConfig);
-  const progressBarConfigOption = yield* Effect.serviceOption(ProgressBarConfig);
-
-  const rendererConfig = withDefaultColumns(
-    decodeRendererConfigSync(
-      mergeConfig(
-        defaultRendererConfig,
-        Option.isSome(rendererConfigOption) ? rendererConfigOption.value : undefined,
-      ),
-    ),
-  );
-
-  const progressBarConfig = decodeProgressBarConfigSync(
-    mergeConfig(
-      defaultProgressBarConfig,
-      Option.isSome(progressBarConfigOption) ? progressBarConfigOption.value : undefined,
-    ),
-  );
-
   const terminal = yield* ProgressTerminal;
-  const frameRenderer = yield* FrameRenderer;
+  const inkRenderer = yield* InkRenderer;
+  const outerConsole = yield* Effect.console;
   const isTTY = yield* terminal.isTTY;
-  const maxRetainedLogLines = Math.max(0, Math.floor(rendererConfig.maxLogLines ?? 0));
 
   const nextTaskIdRef = yield* Ref.make(0);
   const storeRef = yield* Ref.make<TaskStore>({
     tasks: new Map<TaskId, TaskSnapshot>(),
     renderOrder: [],
   });
-  const logsRef = yield* Ref.make<ReadonlyArray<string>>([]);
-  const pendingLogsRef = yield* Ref.make<ReadonlyArray<string>>([]);
   const dirtyRef = yield* Ref.make(true);
   const currentParentRef = yield* FiberRef.make(Option.none<TaskId>());
   const scope = yield* Effect.scope;
 
-  yield* Effect.forkIn(
-    frameRenderer.run(
-      storeRef,
-      logsRef,
-      pendingLogsRef,
-      dirtyRef,
-      terminal,
-      isTTY,
-      rendererConfig,
-      maxRetainedLogLines,
-    ),
-    scope,
-  );
-
   const markDirty = Ref.set(dirtyRef, true);
+  const log = (...args: ReadonlyArray<unknown>) =>
+    args.length === 0 ? Effect.void : outerConsole.log(...args);
+
+  yield* Effect.forkIn(inkRenderer.run(storeRef, dirtyRef, terminal, isTTY), scope);
+  // Let the renderer fiber start so queued logs are reliably flushed on scope teardown.
+  yield* Effect.sleep("0 millis");
 
   const addTask = (options: AddTaskOptions) =>
     Effect.gen(function* () {
@@ -202,10 +140,6 @@ const makeProgressService = Effect.gen(function* () {
       const parentSnapshot = Option.isSome(resolvedParentId)
         ? store.tasks.get(resolvedParentId.value)
         : undefined;
-      const inheritedProgressBarConfig = parentSnapshot?.config ?? progressBarConfig;
-      const resolvedProgressBarConfig = decodeProgressBarConfigSync(
-        mergeConfig(inheritedProgressBarConfig, options.progressbar),
-      );
 
       const now = yield* Clock.currentTimeMillis;
       const parentIdValue = Option.getOrNull(resolvedParentId);
@@ -216,7 +150,6 @@ const makeProgressService = Effect.gen(function* () {
         status: "running",
         transient: parentSnapshot?.transient ?? options.transient ?? false,
         units,
-        config: resolvedProgressBarConfig,
         startedAt: now,
         completedAt: null,
       });
@@ -292,7 +225,6 @@ const makeProgressService = Effect.gen(function* () {
           status: snapshot.status,
           transient: snapshot.transient,
           units,
-          config: snapshot.config,
           startedAt: snapshot.startedAt,
           completedAt: snapshot.completedAt,
         }),
@@ -332,7 +264,6 @@ const makeProgressService = Effect.gen(function* () {
                     total: snapshot.units.total,
                   })
                 : snapshot.units,
-            config: snapshot.config,
             startedAt: snapshot.startedAt,
             completedAt: now,
           }),
@@ -367,7 +298,6 @@ const makeProgressService = Effect.gen(function* () {
             status: "failed",
             transient: snapshot.transient,
             units: snapshot.units,
-            config: snapshot.config,
             startedAt: snapshot.startedAt,
             completedAt: now,
           }),
@@ -377,36 +307,6 @@ const makeProgressService = Effect.gen(function* () {
       yield* markDirty;
     });
 
-  const appendLog = (args: ReadonlyArray<unknown>) =>
-    Effect.gen(function* () {
-      if (args.length === 0) {
-        return;
-      }
-
-      const message = formatWithOptions(
-        {
-          colors: isTTY,
-          depth: 6,
-        },
-        ...args,
-      );
-
-      yield* Ref.update(pendingLogsRef, (logs) => [...logs, message]);
-      if (maxRetainedLogLines > 0) {
-        yield* Ref.update(logsRef, (logs) => {
-          const next = [...logs, message];
-          if (next.length <= maxRetainedLogLines) {
-            return next;
-          }
-          return next.slice(next.length - maxRetainedLogLines);
-        });
-      }
-
-      yield* markDirty;
-    });
-
-  const log = (...args: ReadonlyArray<unknown>) => appendLog(args);
-
   const getTask = (taskId: TaskId) =>
     Ref.get(storeRef).pipe(Effect.map((store) => Option.fromNullable(store.tasks.get(taskId))));
 
@@ -416,7 +316,6 @@ const makeProgressService = Effect.gen(function* () {
     2,
     <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions) =>
       Effect.gen(function* () {
-        const outerConsole = yield* Effect.console;
         const inheritedParentId = yield* FiberRef.get(currentParentRef);
         const resolvedParentId =
           options.parentId === undefined ? inheritedParentId : Option.some(options.parentId);
@@ -428,10 +327,7 @@ const makeProgressService = Effect.gen(function* () {
         });
 
         return yield* Effect.locally(
-          Effect.withConsole(
-            Effect.provideService(effect, Task, taskId),
-            makeProgressConsole(log, outerConsole),
-          ),
+          Effect.provideService(effect, Task, taskId),
           currentParentRef,
           Option.some(taskId),
         );
@@ -484,11 +380,11 @@ export class Progress extends Context.Tag("stromseng.dev/effective-progress/Prog
   static readonly Default = Layer.unwrapEffect(
     Effect.gen(function* () {
       const terminalOption = yield* Effect.serviceOption(ProgressTerminal);
-      const frameRendererOption = yield* Effect.serviceOption(FrameRenderer);
+      const inkRendererOption = yield* Effect.serviceOption(InkRenderer);
       let layer: Layer.Layer<Progress, never, any> = Layer.scoped(Progress, makeProgressService);
 
-      if (Option.isNone(frameRendererOption)) {
-        layer = layer.pipe(Layer.provide(FrameRenderer.Default));
+      if (Option.isNone(inkRendererOption)) {
+        layer = layer.pipe(Layer.provide(InkRenderer.Default));
       }
       if (Option.isNone(terminalOption)) {
         layer = layer.pipe(Layer.provide(ProgressTerminal.Default));