alepha 0.23.0 → 0.24.0

package/src/cli/platform-lib/services/WranglerApi.ts

@@ -1,6 +1,5 @@
 import { $inject } from "alepha";
 import { AlephaCliUtils, PackageManagerUtils } from "alepha/cli";
-import { Runner, type RunnerMethod } from "alepha/command";
 import { $logger } from "alepha/logger";
 import { ShellProvider } from "alepha/system";
 
@@ -16,19 +15,16 @@ export class WranglerApi {
   protected readonly shell = $inject(ShellProvider);
   protected readonly utils = $inject(AlephaCliUtils);
   protected readonly pm = $inject(PackageManagerUtils);
-  protected readonly runner = $inject(Runner);
 
   protected async runShell(
     command: string,
     options: Parameters<ShellProvider["run"]>[1] = {},
   ) {
-    const capture = options.capture;
-    const output = await this.shell.run(command, {
-      ...options,
-      capture: capture ?? this.runner.useDynamicLogger,
-    });
+    const output = await this.shell.run(command, options);
 
-    if (capture && !this.runner.useDynamicLogger) {
+    // When the caller captured the output, echo it to the log so the user
+    // still sees it (uncaptured commands stream straight to the terminal).
+    if (options.capture) {
       this.log.info(output);
     }
 
@@ -42,16 +38,11 @@ export class WranglerApi {
   /**
    * Ensure wrangler is installed in the project.
    */
-  public async ensureInstalled(root: string, run: RunnerMethod): Promise<void> {
+  public async ensureInstalled(root: string): Promise<void> {
     await this.pm.ensureDependency(root, "wrangler", {
       dev: true,
       exec: async (cmd, opts) => {
-        run.pause();
-        try {
-          await this.utils.exec(cmd, opts);
-        } finally {
-          run.resume();
-        }
+        await this.utils.exec(cmd, opts);
       },
     });
   }

package/src/cli/vendor/atoms/vendorOptions.ts

@@ -1,4 +1,4 @@
-import { $atom, type Static, t } from "alepha";
+import { $atom, type Static, z } from "alepha";
 
 /**
  * Vendor configuration atom.
@@ -9,21 +9,21 @@ import { $atom, type Static, t } from "alepha";
 export const vendorOptions = $atom({
   name: "alepha.cli.vendor.options",
   description: "Vendor synchronization configuration",
-  schema: t.optional(
-    t.object({
+  schema: z
+    .object({
       /**
        * Git remote URL.
        *
        * @default "git@github.com:feunard/alepha.git"
        */
-      remote: t.optional(t.text()),
+      remote: z.text().optional(),
 
       /**
        * Branch to sync from.
        *
        * @default "main"
        */
-      branch: t.optional(t.text()),
+      branch: z.text().optional(),
 
       /**
        * Parent directory holding the vendored packages in the local project.
@@ -33,16 +33,16 @@ export const vendorOptions = $atom({
        *
        * @default ".vendor"
        */
-      dir: t.optional(t.text()),
+      dir: z.text().optional(),
 
       /**
        * Package directory names under `dir` to sync.
        *
        * @example ["alepha", "@alepha/payments-stripe"]
        */
-      packages: t.array(t.text()),
-    }),
-  ),
+      packages: z.array(z.text()),
+    })
+    .optional(),
 });
 
 /**

package/src/cli/vendor/commands/VendorCommand.ts

@@ -1,4 +1,4 @@
-import { $inject, $state, AlephaError, t } from "alepha";
+import { $inject, $state, AlephaError, z } from "alepha";
 import { PackageManagerUtils } from "alepha/cli";
 import { $command } from "alepha/command";
 import { $logger, ConsoleColorProvider } from "alepha/logger";
@@ -45,19 +45,18 @@ export class VendorCommand {
   // alepha vendor sync
   // ─────────────────────────────────────────────────────────────────────────
 
-  protected readonly syncFlags = t.object({
-    force: t.optional(
-      t.boolean({
-        aliases: ["f"],
-        description: "Skip local modification check",
-      }),
-    ),
-    remote: t.optional(
-      t.text({
+  protected readonly syncFlags = z.object({
+    force: z
+      .boolean()
+      .meta({ aliases: ["f"] })
+      .describe("Skip local modification check")
+      .optional(),
+    remote: z
+      .text({
         description:
           "Override the configured remote for this invocation. Accepts any git-clone URL, including local paths (`file:///abs/path/to/alepha`). Useful for CI canaries that need to sync against a local checkout instead of the published repo.",
-      }),
-    ),
+      })
+      .optional(),
   });
 
   protected readonly sync = $command({

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

@@ -1,4 +1,4 @@
-import { Alepha, AlephaError, t } from "alepha";
+import { Alepha, AlephaError, z } from "alepha";
 import {
   LogDestinationProvider,
   MemoryDestinationProvider,
@@ -21,20 +21,18 @@ describe("$command", () => {
       greet = $command({
         description: "A simple greeting command.",
         aliases: ["g"],
-        flags: t.object({
-          name: t.text({ description: "Name to greet." }),
-          times: t.optional(t.integer({ default: 1 })),
+        flags: z.object({
+          name: z.text({ description: "Name to greet." }),
+          times: z.integer().default(1).optional(),
         }),
         handler: mockHandlers.greet,
       });
 
       deploy = $command({
         description: "Deploys the application.",
-        flags: t.object({
-          production: t.optional(
-            t.boolean({ description: "Deploy to production." }),
-          ),
-          "api-key": t.text({
+        flags: z.object({
+          production: z.boolean().describe("Deploy to production.").optional(),
+          "api-key": z.text({
             description: "API key for deployment.",
             aliases: ["key"],
           }),
@@ -240,8 +238,8 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command",
-          flags: t.object({
-            output: t.text({ alias: "o" }),
+          flags: z.object({
+            output: z.text({ alias: "o" }),
           }),
           handler: mockHandler,
         });
@@ -263,10 +261,10 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with JSON flag",
-          flags: t.object({
-            data: t.object({
-              name: t.string(),
-              age: t.number(),
+          flags: z.object({
+            data: z.object({
+              name: z.string(),
+              age: z.number(),
             }),
           }),
           handler: mockHandler,
@@ -290,8 +288,8 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with array flag",
-          flags: t.object({
-            items: t.array(t.string()),
+          flags: z.object({
+            items: z.array(z.string()),
           }),
           handler: mockHandler,
         });
@@ -340,9 +338,12 @@ describe("$command", () => {
     });
 
     test("should throw a CommandError for invalid flag types", async () => {
+      // Strict-zod: flag values are cast + validated via parseArgumentValue
+      // (same path as positional args), which rejects non-numeric integer flags
+      // up front rather than deferring to the (typebox-style) decode message.
       await expect(() =>
         setupTestCommands(["greet", "--name=Test", "--times=not-a-number"]),
-      ).rejects.toThrow("Invalid flag: /times must be integer");
+      ).rejects.toThrow('Expected number, got "not-a-number"');
     });
   });
 
@@ -392,7 +393,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with string arg",
-          args: t.text(),
+          args: z.text(),
           handler: mockHandler,
         });
       }
@@ -412,7 +413,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with number arg",
-          args: t.number(),
+          args: z.number(),
           handler: mockHandler,
         });
       }
@@ -429,7 +430,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with integer arg",
-          args: t.integer(),
+          args: z.integer(),
           handler: mockHandler,
         });
       }
@@ -446,7 +447,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with boolean arg",
-          args: t.boolean(),
+          args: z.boolean(),
           handler: mockHandler,
         });
       }
@@ -467,7 +468,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with optional string arg",
-          args: t.optional(t.text()),
+          args: z.text().optional(),
           handler: mockHandler,
         });
       }
@@ -486,7 +487,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with optional string arg",
-          args: t.optional(t.text()),
+          args: z.text().optional(),
           handler: mockHandler,
         });
       }
@@ -503,7 +504,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with tuple args",
-          args: t.tuple([t.text(), t.number()]),
+          args: z.tuple([z.text(), z.number()]),
           handler: mockHandler,
         });
       }
@@ -522,7 +523,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with tuple containing optional arg",
-          args: t.tuple([t.text(), t.optional(t.number())]),
+          args: z.tuple([z.text(), z.number().optional()]),
           handler: mockHandler,
         });
       }
@@ -539,10 +540,10 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with args and flags",
-          flags: t.object({
-            verbose: t.optional(t.boolean()),
+          flags: z.object({
+            verbose: z.boolean().optional(),
           }),
-          args: t.tuple([t.text(), t.number()]),
+          args: z.tuple([z.text(), z.number()]),
           handler: mockHandler,
         });
       }
@@ -563,10 +564,10 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with args and space-separated flags",
-          flags: t.object({
-            output: t.text(),
+          flags: z.object({
+            output: z.text(),
           }),
-          args: t.text(),
+          args: z.text(),
           handler: mockHandler,
         });
       }
@@ -587,11 +588,11 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with tuple args and space-separated flags",
-          flags: t.object({
-            config: t.text(),
-            verbose: t.optional(t.boolean()),
+          flags: z.object({
+            config: z.text(),
+            verbose: z.boolean().optional(),
           }),
-          args: t.tuple([t.text(), t.number()]),
+          args: z.tuple([z.text(), z.number()]),
           handler: mockHandler,
         });
       }
@@ -631,7 +632,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with required arg",
-          args: t.text(),
+          args: z.text(),
           handler: vi.fn(),
         });
       }
@@ -645,7 +646,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with number arg",
-          args: t.number(),
+          args: z.number(),
           handler: vi.fn(),
         });
       }
@@ -659,7 +660,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with integer arg",
-          args: t.integer(),
+          args: z.integer(),
           handler: vi.fn(),
         });
       }
@@ -673,7 +674,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with boolean arg",
-          args: t.boolean(),
+          args: z.boolean(),
           handler: vi.fn(),
         });
       }
@@ -687,7 +688,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with tuple args",
-          args: t.tuple([t.text(), t.number()]),
+          args: z.tuple([z.text(), z.number()]),
           handler: vi.fn(),
         });
       }
@@ -706,7 +707,7 @@ describe("$command", () => {
         root = $command({
           name: "",
           description: "Root command with string arg",
-          args: t.text(),
+          args: z.text(),
           handler: mockHandler,
         });
       }
@@ -725,7 +726,7 @@ describe("$command", () => {
         root = $command({
           name: "",
           description: "Root command with optional arg",
-          args: t.optional(t.text()),
+          args: z.text().optional(),
           handler: mockHandler,
         });
       }
@@ -743,7 +744,7 @@ describe("$command", () => {
         root = $command({
           name: "",
           description: "Root command with optional arg",
-          args: t.optional(t.text()),
+          args: z.text().optional(),
           handler: mockHandler,
         });
       }
@@ -761,7 +762,7 @@ describe("$command", () => {
         root = $command({
           name: "",
           description: "Root command with tuple args",
-          args: t.tuple([t.text(), t.number()]),
+          args: z.tuple([z.text(), z.number()]),
           handler: mockHandler,
         });
       }
@@ -779,10 +780,10 @@ describe("$command", () => {
         root = $command({
           name: "",
           description: "Root command with args and flags",
-          flags: t.object({
-            verbose: t.optional(t.boolean()),
+          flags: z.object({
+            verbose: z.boolean().optional(),
           }),
-          args: t.text(),
+          args: z.text(),
           handler: mockHandler,
         });
       }
@@ -804,10 +805,10 @@ describe("$command", () => {
         root = $command({
           name: "",
           description: "Root command with space-separated flags",
-          flags: t.object({
-            config: t.text(),
+          flags: z.object({
+            config: z.text(),
           }),
-          args: t.text(),
+          args: z.text(),
           handler: mockHandler,
         });
       }
@@ -827,7 +828,7 @@ describe("$command", () => {
         root = $command({
           name: "",
           description: "Root command with required arg",
-          args: t.text(),
+          args: z.text(),
           handler: vi.fn(),
         });
       }
@@ -846,16 +847,14 @@ describe("$command", () => {
         root = $command({
           name: "",
           description: "Root command",
-          flags: t.object({
-            verbose: t.optional(
-              t.boolean({ description: "Enable verbose output." }),
-            ),
-            config: t.optional(
-              t.text({
+          flags: z.object({
+            verbose: z.boolean().describe("Enable verbose output.").optional(),
+            config: z
+              .text({
                 description: "Path to config file.",
                 alias: "c",
-              }),
-            ),
+              })
+              .optional(),
           }),
           handler: mockRootHandler,
         });
@@ -886,9 +885,9 @@ describe("$command", () => {
         root = $command({
           name: "",
           description: "Root command",
-          flags: t.object({
-            verbose: t.optional(t.boolean({ description: "Verbose mode." })),
-            output: t.text({ description: "Output file." }),
+          flags: z.object({
+            verbose: z.boolean().describe("Verbose mode.").optional(),
+            output: z.text({ description: "Output file." }),
           }),
           handler: mockRootHandler,
         });
@@ -912,7 +911,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with string arg",
-          args: t.text(),
+          args: z.text(),
           handler: vi.fn(),
         });
       }
@@ -936,7 +935,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with optional arg",
-          args: t.optional(t.text()),
+          args: z.text().optional(),
           handler: vi.fn(),
         });
       }
@@ -960,7 +959,7 @@ describe("$command", () => {
       class TestCommand {
         cmd = $command({
           description: "Test command with tuple args",
-          args: t.tuple([t.text(), t.optional(t.number())]),
+          args: z.tuple([z.text(), z.number().optional()]),
           handler: vi.fn(),
         });
       }
@@ -1081,8 +1080,8 @@ describe("$command", () => {
         child = $command({
           name: "vercel",
           description: "Deploy to Vercel",
-          flags: t.object({
-            prod: t.optional(t.boolean()),
+          flags: z.object({
+            prod: z.boolean().optional(),
           }),
           handler: mockHandler,
         });
@@ -1110,7 +1109,7 @@ describe("$command", () => {
         child = $command({
           name: "surge",
           description: "Deploy to Surge",
-          args: t.optional(t.text()),
+          args: z.text().optional(),
           handler: mockHandler,
         });
 
@@ -1250,8 +1249,8 @@ describe("$command", () => {
       class TestCommands {
         cmd = $command({
           name: "test",
-          env: t.object({
-            MY_TOKEN: t.text({ description: "API token" }),
+          env: z.object({
+            MY_TOKEN: z.text({ description: "API token" }),
           }),
           handler: ({ env }) => {
             receivedEnv = env;
@@ -1274,8 +1273,8 @@ describe("$command", () => {
       class TestCommands {
         cmd = $command({
           name: "test",
-          env: t.object({
-            REQUIRED_VAR: t.text({ description: "Required variable" }),
+          env: z.object({
+            REQUIRED_VAR: z.text({ description: "Required variable" }),
           }),
           handler: vi.fn(),
         });
@@ -1295,8 +1294,8 @@ describe("$command", () => {
       class TestCommands {
         cmd = $command({
           name: "test",
-          env: t.object({
-            OPTIONAL_VAR: t.optional(t.text({ description: "Optional" })),
+          env: z.object({
+            OPTIONAL_VAR: z.text({ description: "Optional" }).optional(),
           }),
           handler: ({ env }) => {
             receivedEnv = env;
@@ -1317,8 +1316,8 @@ describe("$command", () => {
       class TestCommands {
         cmd = $command({
           name: "test",
-          env: t.object({
-            MY_VAR: t.optional(t.text({ default: "default_value" })),
+          env: z.object({
+            MY_VAR: z.text({ default: "default_value" }).optional(),
           }),
           handler: ({ env }) => {
             receivedEnv = env;
@@ -1337,9 +1336,9 @@ describe("$command", () => {
       class TestCommands {
         cmd = $command({
           name: "test",
-          env: t.object({
-            API_TOKEN: t.text({ description: "API token for authentication" }),
-            ORG_ID: t.optional(t.text({ description: "Organization ID" })),
+          env: z.object({
+            API_TOKEN: z.text({ description: "API token for authentication" }),
+            ORG_ID: z.text({ description: "Organization ID" }).optional(),
           }),
           handler: vi.fn(),
         });
@@ -1368,9 +1367,9 @@ describe("$command", () => {
       class TestCommands {
         cmd = $command({
           name: "test",
-          env: t.object({
-            VAR_ONE: t.text(),
-            VAR_TWO: t.text(),
+          env: z.object({
+            VAR_ONE: z.text(),
+            VAR_TWO: z.text(),
           }),
           handler: vi.fn(),
         });

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

@@ -1,16 +1,10 @@
-import { Alepha, AlephaError, t } from "alepha";
+import { Alepha, AlephaError, z } from "alepha";
 import {
   LogDestinationProvider,
   MemoryDestinationProvider,
 } from "alepha/logger";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { Asker, PrettyAsker } from "../index.ts";
-
-class DisabledPrettyAsker extends PrettyAsker {
-  public override get enabled(): boolean {
-    return false;
-  }
-}
+import { Asker } from "../index.ts";
 
 describe("Asker", () => {
   let alepha: Alepha;
@@ -45,7 +39,6 @@ describe("Asker", () => {
         provide: LogDestinationProvider,
         use: MemoryDestinationProvider,
       })
-      .with({ provide: PrettyAsker, use: DisabledPrettyAsker })
       .with(Asker);
 
     asker = alepha.inject(Asker);
@@ -72,7 +65,7 @@ describe("Asker", () => {
     const { question, close } = mockPromptInterface(["abc", "41"]);
 
     const result = await asker.ask("Enter a number", {
-      schema: t.number(),
+      schema: z.number(),
     });
 
     expect(result).toBe(41);
@@ -85,7 +78,7 @@ describe("Asker", () => {
     const { question, close } = mockPromptInterface([""]);
 
     const result = await asker.ask("What is your favorite color?", {
-      schema: t.text({ default: "blue" }),
+      schema: z.text({ default: "blue" }),
     });
 
     expect(result).toBe("blue");
@@ -97,7 +90,7 @@ describe("Asker", () => {
     const { question, close } = mockPromptInterface(["wrong", "right"]);
 
     const result = await asker.ask("Provide the secret", {
-      schema: t.text(),
+      schema: z.text(),
       validate: (value) => {
         if (value !== "right") {
           throw new AlephaError("Invalid secret");
@@ -120,7 +113,7 @@ describe("Asker", () => {
 
     await expect(
       asker.ask("Trigger failure", {
-        schema: t.text(),
+        schema: z.text(),
         validate: () => {
           throw unexpectedError;
         },