alepha 0.23.0 → 0.24.0

package/src/command/__tests__/Runner.spec.ts

@@ -3,16 +3,14 @@ import {
   LogDestinationProvider,
   MemoryDestinationProvider,
 } from "alepha/logger";
-import { MemoryShellProvider } from "alepha/system";
+import {
+  MemoryShellProvider,
+  NodeShellProvider,
+  ShellProvider,
+} from "alepha/system";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { Runner } from "../index.ts";
 
-class TestRunner extends Runner {
-  public override get useDynamicLogger() {
-    return true;
-  }
-}
-
 describe("Runner", () => {
   let mockLogger: MemoryDestinationProvider;
   let mockShell: MemoryShellProvider;
@@ -37,26 +35,6 @@ describe("Runner", () => {
     vi.clearAllMocks();
   });
 
-  test("useDynamicLogger: state overrides disable the stylish UI even with LOG_FORMAT=raw", () => {
-    // env says "raw" (stylish), but a runtime state override (what the CLI
-    // `--verbose` flag sets) must win. Asserting the *false* direction is
-    // deterministic across CI/non-CI (the dynamic-on path is gated on isCI).
-    const alepha = Alepha.create({
-      env: { LOG_LEVEL: "info", LOG_FORMAT: "raw" },
-    }).with({
-      provide: LogDestinationProvider,
-      use: MemoryDestinationProvider,
-    });
-    const r = alepha.inject(Runner);
-
-    alepha.store.set("alepha.logger.format", "pretty");
-    expect(r.useDynamicLogger).toBe(false);
-
-    alepha.store.set("alepha.logger.format", undefined);
-    alepha.store.set("alepha.logger.level", "debug");
-    expect(r.useDynamicLogger).toBe(false);
-  });
-
   test("should execute a single shell command via run.sh", async () => {
     await runner.run(`echo "hello"`);
 
@@ -135,19 +113,18 @@ describe("Runner", () => {
     );
   });
 
-  test("summary() should print a formatted table of executed tasks", async () => {
+  test("end() should print a total-time summary line after tasks run", async () => {
     await runner.run(`echo "Task 1"`);
     await runner.run("A slightly longer task name", () => {});
 
+    mockLogger.clear();
     runner.end();
 
-    const logs = mockLogger.logs
-      .slice(4)
-      .map((l) => l.message)
-      .join("\n");
+    const messages = mockLogger.logs.map((l) => l.message);
+    expect(messages.some((m) => m.startsWith("Total time:"))).toBe(true);
   });
 
-  test("summary() should not print a table if no tasks were run", () => {
+  test("end() should print nothing if no tasks were run", () => {
     runner.end();
 
     const logs = mockLogger.logs.map((l) => l.message);
@@ -195,91 +172,90 @@ describe("Runner", () => {
     expect(mockLogger.logs[1].message).toMatch(/^Finished 'clean' after/);
   });
 
-  test("should reset firstTaskStarted with PrettyPrint (LOG_FORMAT=raw)", async () => {
-    // Use TestRunner to force useDynamicLogger=true (bypasses isCI check)
-    const alepha = Alepha.create({
-      env: {
-        LOG_LEVEL: "info",
-        LOG_FORMAT: "raw",
-      },
-    })
-      .with({ provide: LogDestinationProvider, use: MemoryDestinationProvider })
-      .with({ provide: Runner, use: TestRunner });
-
-    const prettyRunner = alepha.inject(Runner);
-
-    // Capture stdout to verify PrettyPrint output
-    const output: string[] = [];
-    const originalWrite = process.stdout.write.bind(process.stdout);
-    process.stdout.write = (chunk: any) => {
-      output.push(String(chunk));
-      return true;
-    };
+  test("should log start and finish for duplicate task names in one command", async () => {
+    runner.startCommand("cli", "verify");
+    await runner.run("clean", () => {});
+    await runner.run("lint", () => {});
+    await runner.run("typecheck", () => {});
+    await runner.run("clean", () => {}); // Same name as first task
+    runner.end();
 
-    try {
-      // Run command A
-      prettyRunner.startCommand("cli", "commandA");
-      await prettyRunner.run("task A", () => {});
-      prettyRunner.end();
+    const messages = mockLogger.logs.map((l) => l.message).join("\n");
+    const cleanStarts = messages.match(/Starting 'clean'/g) ?? [];
+    expect(cleanStarts.length).toBe(2);
+    expect(messages).toContain("Starting 'lint' ...");
+    expect(messages).toContain("Starting 'typecheck' ...");
+  });
 
-      // Verify command A header was printed
-      expect(output.some((line) => line.includes("cli commandA"))).toBe(true);
+  describe("sub-process output gating", () => {
+    const build = (level: string) => {
+      const alepha = Alepha.create({ env: { LOG_LEVEL: level } }).with({
+        provide: LogDestinationProvider,
+        use: MemoryDestinationProvider,
+      });
+      return {
+        runner: alepha.inject(Runner),
+        shell: alepha.inject(MemoryShellProvider),
+      };
+    };
 
-      // Clear output for command B
-      output.length = 0;
+    test("captures child output (capture:true) when below DEBUG", async () => {
+      const { runner, shell } = build("info");
+      await runner.run("echo hi");
+      expect(shell.calls[0].options.capture).toBe(true);
+    });
+
+    test("streams child output (capture:false) when DEBUG is enabled", async () => {
+      const { runner, shell } = build("debug");
+      await runner.run("echo hi");
+      expect(shell.calls[0].options.capture).toBe(false);
+    });
 
-      // Run command B - should get its own header
-      prettyRunner.startCommand("cli", "commandB");
-      await prettyRunner.run("task B", () => {});
-      prettyRunner.end();
+    test("streams child output (capture:false) at trace level too", async () => {
+      const { runner, shell } = build("trace");
+      await runner.run("echo hi");
+      expect(shell.calls[0].options.capture).toBe(false);
+    });
 
-      // Verify command B header was printed (not reusing A's state)
-      expect(output.some((line) => line.includes("cli commandB"))).toBe(true);
-    } finally {
-      process.stdout.write = originalWrite;
-    }
+    test("surfaces captured stdout and stderr when a task fails", async () => {
+      const failing = () => {
+        throw Object.assign(new Error("boom"), {
+          stdout: "OUT_TEXT",
+          stderr: "ERR_TEXT",
+        });
+      };
+
+      await expect(runner.run("failing", failing)).rejects.toThrow(
+        "Task 'failing' failed",
+      );
+
+      const messages = mockLogger.logs.map((l) => l.message).join("\n");
+      expect(messages).toContain("OUT_TEXT");
+      expect(messages).toContain("ERR_TEXT");
+    });
   });
 
-  test("should display duplicate task names in same command with PrettyPrint", async () => {
-    // Use TestRunner to force useDynamicLogger=true (bypasses isCI check)
-    const alepha = Alepha.create({
-      env: {
-        LOG_LEVEL: "info",
-        LOG_FORMAT: "raw",
-      },
-    })
-      .with({ provide: LogDestinationProvider, use: MemoryDestinationProvider })
-      .with({ provide: Runner, use: TestRunner });
-
-    const prettyRunner = alepha.inject(Runner);
-
-    // Capture stdout to verify PrettyPrint output
-    const output: string[] = [];
-    const originalWrite = process.stdout.write.bind(process.stdout);
-    process.stdout.write = (chunk: any) => {
-      output.push(String(chunk));
-      return true;
+  describe("sub-process output gating (integration, real shell)", () => {
+    const build = (level: string) => {
+      const alepha = Alepha.create({ env: { LOG_LEVEL: level } })
+        .with({
+          provide: LogDestinationProvider,
+          use: MemoryDestinationProvider,
+        })
+        .with({ provide: ShellProvider, use: NodeShellProvider });
+      return alepha.inject(Runner);
     };
 
-    try {
-      // Run command with duplicate task names (like "alepha verify" does with "clean")
-      prettyRunner.startCommand("cli", "verify");
-      await prettyRunner.run("clean", () => {});
-      await prettyRunner.run("lint", () => {});
-      await prettyRunner.run("typecheck", () => {});
-      await prettyRunner.run("clean", () => {}); // Same name as first task
-      prettyRunner.end();
-
-      // Count occurrences of "clean" in output (should appear twice)
-      const fullOutput = output.join("");
-      const cleanMatches = fullOutput.match(/clean/g) || [];
-      expect(cleanMatches.length).toBeGreaterThanOrEqual(2);
-
-      // Verify all tasks were logged
-      expect(fullOutput).toContain("lint");
-      expect(fullOutput).toContain("typecheck");
-    } finally {
-      process.stdout.write = originalWrite;
-    }
+    test("captures and returns child stdout when below DEBUG", async () => {
+      const runner = build("info");
+      const out = await runner.run("echo MARKER_INFO");
+      expect(out).toContain("MARKER_INFO");
+    });
+
+    test("streams child output (returns empty) when DEBUG is enabled", async () => {
+      const runner = build("debug");
+      const out = await runner.run("echo MARKER_DEBUG");
+      expect(out).toBe("");
+    });
   });
 });

package/src/command/helpers/Asker.ts

@@ -4,29 +4,29 @@ import {
   $inject,
   Alepha,
   AlephaError,
+  coerceScalar,
   type Static,
   type TSchema,
   type TString,
-  t,
+  z,
 } from "alepha";
 import { $logger } from "alepha/logger";
-import { PrettyAsker } from "./PrettyAsker.ts";
 
 export interface AskOptions<T extends TSchema = TString> {
   /**
    * Response schema expected.
    *
    * Recommended schemas:
-   * - t.text() - for free text input
-   * - t.number() - for numeric input
-   * - t.boolean() - for yes/no input (accepts "true", "false", "1", "0")
-   * - t.enum(["option1", "option2"]) - for predefined options
+   * - z.text() - for free text input
+   * - z.number() - for numeric input
+   * - z.boolean() - for yes/no input (accepts "true", "false", "1", "0")
+   * - z.enum(["option1", "option2"]) - for predefined options
    *
    * You can use schema.default to provide a default value.
    *
    * @example
    * ```ts
-   * ask("What is your name?", { schema: t.text({ default: "John Doe" }) })
+   * ask("What is your name?", { schema: z.text({ default: "John Doe" }) })
    * ```
    *
    * @default TString
@@ -51,11 +51,18 @@ export interface AskMethod {
   outro: (message: string) => void;
 }
 
+/**
+ * Reads interactive input from the terminal using plain readline prompts.
+ *
+ * One straightforward code path: questions are printed through the logger
+ * and answers are read with Node's `readline`. No raw-mode cursor control,
+ * no ANSI framing — output stays greppable and works the same in a TTY,
+ * under CI, or when piped.
+ */
 export class Asker {
   protected readonly log = $logger();
   public readonly ask: AskMethod;
   protected readonly alepha = $inject(Alepha);
-  protected readonly pretty = $inject(PrettyAsker);
 
   constructor() {
     this.ask = this.createAskMethod();
@@ -70,25 +77,18 @@ export class Asker {
     };
 
     askFn.permission = async (question: string) => {
-      if (this.pretty.enabled) {
-        return this.pretty.confirm(question);
-      }
       const response = await this.prompt(`${question} [Y/n]`, {
-        schema: t.enum(["Y", "y", "n", "no", "yes"], { default: "Y" }),
+        schema: z.enum(["Y", "y", "n", "no", "yes"]).default("Y"),
       });
       return response.charAt(0).toLowerCase() === "y";
     };
 
     askFn.intro = (title: string) => {
-      if (this.pretty.enabled) {
-        this.pretty.intro(title);
-      }
+      this.log.info(title);
     };
 
     askFn.outro = (message: string) => {
-      if (this.pretty.enabled) {
-        this.pretty.outro(message);
-      }
+      if (message) this.log.info(message);
     };
 
     return askFn;
@@ -97,45 +97,6 @@ export class Asker {
   protected async prompt<T extends TSchema = TString>(
     question: string,
     options: AskOptions<T>,
-  ): Promise<Static<T>> {
-    if (this.pretty.enabled) {
-      return this.prettyPrompt(question, options);
-    }
-    return this.plainPrompt(question, options);
-  }
-
-  /**
-   * Pretty mode: delegate to PrettyAsker based on schema type.
-   */
-  protected async prettyPrompt<T extends TSchema = TString>(
-    question: string,
-    options: AskOptions<T>,
-  ): Promise<Static<T>> {
-    const schema = options.schema as any;
-
-    // Enum schema → arrow-key select
-    if (schema?.enum && Array.isArray(schema.enum)) {
-      const value = await this.pretty.select(question, schema.enum);
-      if (options.validate) {
-        options.validate(value as Static<T>);
-      }
-      return value as Static<T>;
-    }
-
-    // Text/other schema → text input
-    const value = await this.pretty.text(question, schema);
-    if (options.validate) {
-      options.validate(value as Static<T>);
-    }
-    return value as Static<T>;
-  }
-
-  /**
-   * Plain mode: readline-based prompts (CI, Claude Code, debug).
-   */
-  protected async plainPrompt<T extends TSchema = TString>(
-    question: string,
-    options: AskOptions<T>,
   ): Promise<Static<T>> {
     const rl = this.createPromptInterface();
     let value: any;
@@ -145,9 +106,13 @@ export class Asker {
           this.log.info(question);
           const answer = await rl.question("> ");
           if (options.schema) {
+            // The terminal is a string-only boundary (like HTTP query/env), so
+            // coerce the answer to the schema's scalar type before strict
+            // decoding — otherwise `z.number()` would reject the string "41".
+            const raw = answer ? answer.trim() : undefined;
             value = this.alepha.codec.decode(
               options.schema,
-              answer ? answer.trim() : undefined,
+              raw === undefined ? undefined : coerceScalar(options.schema, raw),
             );
           } else {
             value = String(answer.trim());

package/src/command/helpers/Runner.ts

@@ -4,7 +4,6 @@ import { DateTimeProvider } from "alepha/datetime";
 import { $logger } from "alepha/logger";
 import { ShellProvider } from "alepha/system";
 import { CommandError } from "../errors/CommandError.ts";
-import { PrettyPrint } from "./PrettyPrint.ts";
 
 export type Task = {
   name: string;
@@ -43,80 +42,43 @@ export interface RunnerMethod {
    * > But can be called manually if needed to print more stuff before the command ends.
    */
   end: () => void;
-
-  /**
-   * Pause the spinner so external processes can write to stdout directly.
-   */
-  pause: () => void;
-
-  /**
-   * Resume the spinner after a pause.
-   */
-  resume: () => void;
 }
 
+/**
+ * Runs CLI tasks (shell commands or functions) and logs their lifecycle.
+ *
+ * Output is intentionally plain and verbose: every task logs a
+ * `Starting …` / `Finished … after Ns` line through the standard logger,
+ * and shelled commands **stream** their stdout/stderr straight to the
+ * terminal (`capture: false`) so tool output — `vite build` warnings,
+ * Biome diagnostics, nested `alepha` subcommands — is visible live.
+ */
 export class Runner {
   protected readonly log = $logger();
   protected readonly dateTime = $inject(DateTimeProvider);
   protected timers: Timer[] = [];
   protected readonly startTime: number = this.dateTime.nowMillis();
-  protected readonly prettyPrint = $inject(PrettyPrint);
   protected readonly alepha = $inject(Alepha);
   protected readonly shell = $inject(ShellProvider);
   public readonly run: RunnerMethod;
-  protected cliName = "";
-  protected commandName = "";
-  protected firstTaskStarted = false;
-  protected taskCounter = 0;
 
   constructor() {
     this.run = this.createRunMethod();
   }
 
-  public get useDynamicLogger() {
-    if (this.alepha.isCI() || this.alepha.env.CLAUDECODE) {
-      return false;
-    }
-
-    // Runtime state overrides the env defaults (e.g. the CLI `--verbose`
-    // flag sets level=debug + format=pretty), so a flag can flip the
-    // stylish task UI off without restarting with LOG_* env vars.
-    const logLevel = String(
-      this.alepha.store.get("alepha.logger.level") ??
-        this.alepha.env.LOG_LEVEL ??
-        "",
-    ).toLowerCase();
-    if (logLevel === "debug" || logLevel === "trace") {
-      return false;
-    }
-
-    const format =
-      this.alepha.store.get("alepha.logger.format") ??
-      this.alepha.env.LOG_FORMAT;
-    return format === "raw";
-  }
-
   /**
-   * Start a new command session with header (for pretty print mode)
+   * Start a new command session.
+   *
+   * Retained for API compatibility (the CLI calls it before each command);
+   * task lifecycle is now logged statelessly, so there is nothing to reset.
    */
-  public startCommand(cliName: string, commandName: string): void {
-    this.cliName = cliName;
-    this.commandName = commandName;
-    this.firstTaskStarted = false;
-    this.taskCounter = 0;
-  }
+  public startCommand(_cliName: string, _commandName: string): void {}
 
   protected createRunMethod() {
     const runFn: RunnerMethod = async (
       cmd: string | Task | Array<string | Task>,
       options?: RunOptions | (() => any),
     ) => {
-      if (this.useDynamicLogger && !this.firstTaskStarted) {
-        this.prettyPrint.startCommand(this.cliName, this.commandName);
-      }
-
-      this.firstTaskStarted = true;
-
       const root =
         typeof options === "object" && options.root ? options.root : undefined;
 
@@ -185,12 +147,6 @@ export class Runner {
     };
 
     runFn.end = () => this.end();
-    runFn.pause = () => {
-      if (this.useDynamicLogger) this.prettyPrint.pause();
-    };
-    runFn.resume = () => {
-      if (this.useDynamicLogger) this.prettyPrint.resume();
-    };
 
     return runFn;
   }
@@ -199,7 +155,13 @@ export class Runner {
     cmd: string,
     opts: { root?: string } = {},
   ): Promise<string> {
-    return this.shell.run(cmd, { root: opts.root, capture: true });
+    // Stream child output straight to the terminal only when DEBUG (or more
+    // verbose) is enabled — i.e. under `--verbose`, an agent session
+    // (CLAUDECODE), or `LOG_LEVEL=debug`. Otherwise capture it so a quiet run
+    // (e.g. `alepha verify`) is not buried under sub-process output; captured
+    // output is surfaced on failure by {@link executeTask}.
+    const stream = this.log.isLevelEnabled("DEBUG");
+    return this.shell.run(cmd, { root: opts.root, capture: !stream });
   }
 
   /**
@@ -220,21 +182,13 @@ export class Runner {
    * Prints a summary of all executed tasks and their durations.
    */
   public end(): void {
-    if (this.useDynamicLogger && this.firstTaskStarted) {
-      this.prettyPrint.endCommand();
-      return;
-    }
-
-    // Non-dynamic mode: use logging
     if (this.timers.length === 0) return;
 
-    this.log.info("");
     const totalTime = (
       (this.dateTime.nowMillis() - this.startTime) /
       1000
     ).toFixed(1);
     this.log.info(`Total time: ${totalTime}s`);
-    this.log.info(``);
 
     // clear timers after rendering
     this.timers = [];
@@ -242,26 +196,24 @@ export class Runner {
 
   protected async executeTask(task: Task): Promise<string> {
     const now = this.dateTime.nowMillis();
-    const taskId = `task-${++this.taskCounter}`; // Use unique counter-based ID
 
-    // Setup dynamic logger
-    if (this.useDynamicLogger) {
-      this.prettyPrint.startSpinner(taskId, task.name);
-    } else {
-      this.log.info(`Starting '${task.name}' ...`);
-    }
+    this.log.info(`Starting '${task.name}' ...`);
 
     let stdout = "";
 
     try {
       stdout = String((await task.handler()) ?? "");
     } catch (error) {
-      // Clear spinner and show error
-      if (this.useDynamicLogger) {
-        this.prettyPrint.error(taskId, task.name);
-      }
-      if (error instanceof Error && "stdout" in error) {
-        this.log.info(`\n\n${error.stdout}`);
+      // Streamed tasks have already printed their output live and reject
+      // without stdout/stderr attached; this surfaces output from captured
+      // tasks (capture: true — the default below DEBUG) before throwing.
+      const err = error as { stdout?: string; stderr?: string };
+      const captured = [err?.stdout, err?.stderr]
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+      if (captured) {
+        this.log.info(`\n\n${captured}`);
       }
       throw new CommandError(`Task '${task.name}' failed`, { cause: error });
     }
@@ -272,14 +224,8 @@ export class Runner {
 
     const message =
       stdout && !stdout.includes("\n") ? stdout.trim() : undefined;
-
-    // Clear spinner and show completion
-    if (this.useDynamicLogger) {
-      this.prettyPrint.success(taskId, task.name, `${duration}s`, message);
-    } else {
-      const suffix = message ? ` - ${message}` : "";
-      this.log.info(`Finished '${task.name}' after ${duration}s${suffix}`);
-    }
+    const suffix = message ? ` - ${message}` : "";
+    this.log.info(`Finished '${task.name}' after ${duration}s${suffix}`);
 
     this.timers.push({
       name: task.name,
@@ -288,26 +234,4 @@ export class Runner {
 
     return stdout;
   }
-
-  protected renderTable(data: string[][]): void {
-    if (data.length === 0) return;
-
-    const col1Width = Math.max(...data.map(([col1]) => col1.length), 7);
-    const col2Width = Math.max(...data.map(([, col2]) => col2.length), 8);
-
-    const divider = `+${"-".repeat(col1Width + 2)}+${"-".repeat(
-      col2Width + 2,
-    )}+`;
-    this.log.info(divider);
-    this.log.info(
-      `| ${"Command".padEnd(col1Width)} | ${"Duration".padEnd(col2Width)} |`,
-    );
-    this.log.info(divider);
-    for (const [col1, col2] of data) {
-      this.log.info(
-        `| ${col1.padEnd(col1Width)} | ${col2.padEnd(col2Width)} |`,
-      );
-    }
-    this.log.info(divider);
-  }
 }

package/src/command/index.ts

@@ -1,8 +1,6 @@
 import { $module } from "alepha";
 import { Asker } from "./helpers/Asker.ts";
 import { EnvUtils } from "./helpers/EnvUtils.ts";
-import { PrettyAsker } from "./helpers/PrettyAsker.ts";
-import { PrettyPrint } from "./helpers/PrettyPrint.ts";
 import { Runner } from "./helpers/Runner.ts";
 import { $command } from "./primitives/$command.ts";
 import { CliProvider } from "./providers/CliProvider.ts";
@@ -12,8 +10,6 @@ import { CliProvider } from "./providers/CliProvider.ts";
 export * from "./errors/CommandError.ts";
 export * from "./helpers/Asker.ts";
 export * from "./helpers/EnvUtils.ts";
-export * from "./helpers/PrettyAsker.ts";
-export * from "./helpers/PrettyPrint.ts";
 export * from "./helpers/Runner.ts";
 export * from "./primitives/$command.ts";
 export * from "./providers/CliProvider.ts";
@@ -25,9 +21,8 @@ export * from "./providers/CliProvider.ts";
  *
  * **Features:**
  * - CLI command definitions
- * - Interactive CLI prompts
- * - Command execution
- * - Formatted colored output
+ * - Interactive CLI prompts (plain readline)
+ * - Command execution with streamed, verbose output
  * - Environment variable utilities
  * - Schema validation for CLI arguments
  *
@@ -36,12 +31,12 @@ export * from "./providers/CliProvider.ts";
 export const AlephaCommand = $module({
   name: "alepha.command",
   primitives: [$command],
-  services: [CliProvider, Runner, Asker, PrettyAsker, PrettyPrint, EnvUtils],
+  services: [CliProvider, Runner, Asker, EnvUtils],
 });
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-declare module "typebox" {
+declare module "alepha" {
   interface StringOptions {
     /**
      * Additional aliases for the flags.