alepha 0.15.1 → 0.15.3

package/src/cli/templates/mainServerTs.ts

@@ -0,0 +1,33 @@
+export interface MainServerTsOptions {
+  api?: boolean;
+  react?: boolean;
+}
+
+export const mainServerTs = (options: MainServerTsOptions = {}) => {
+  const { api = false, react = false } = options;
+
+  const imports: string[] = [];
+  const withs: string[] = [];
+
+  if (api) {
+    imports.push(`import { ApiModule } from "./api/index.ts";`);
+    withs.push(`alepha.with(ApiModule);`);
+  }
+
+  if (react) {
+    imports.push(`import { WebModule } from "./web/index.ts";`);
+    withs.push(`alepha.with(WebModule);`);
+  }
+
+  const importsBlock = imports.length > 0 ? `${imports.join("\n")}\n` : "";
+  const withsBlock = withs.length > 0 ? `\n${withs.join("\n")}` : "";
+
+  return `
+import { Alepha, run } from "alepha";
+${importsBlock}
+const alepha = Alepha.create();
+${withsBlock}
+
+run(alepha);
+`.trim();
+};

package/src/cli/templates/webAppRouterTs.ts

@@ -0,0 +1,74 @@
+export const webAppRouterTs = (options: {
+  api?: boolean;
+  ui?: boolean;
+  auth?: boolean;
+  admin?: boolean;
+}) => {
+  const imports: string[] = [];
+  const classMembers: string[] = [];
+
+  // UI import and setup
+  if (options.ui) {
+    imports.push('import { $ui } from "@alepha/ui";');
+  }
+
+  // Auth import
+  if (options.auth) {
+    imports.push('import { $uiAuth } from "@alepha/ui/auth";');
+  }
+
+  // Admin import
+  if (options.admin) {
+    imports.push('import { $uiAdmin } from "@alepha/ui/admin";');
+  }
+
+  // Page import
+  imports.push('import { $page } from "alepha/react/router";');
+
+  // API imports (only if api flag is set)
+  if (options.api) {
+    imports.push('import { $client } from "alepha/server/links";');
+    imports.push(
+      'import type { HelloController } from "../api/controllers/HelloController.ts";',
+    );
+    classMembers.push("  api = $client<HelloController>();");
+  }
+
+  // UI layout setup
+  if (options.ui) {
+    classMembers.push("  ui = $ui();");
+
+    if (options.auth) {
+      classMembers.push("  uiAuth = $uiAuth();");
+    }
+
+    if (options.admin) {
+      classMembers.push("  uiAdmin = $uiAdmin();");
+    }
+
+    classMembers.push(`  layout = $page({
+    parent: this.ui.root,
+    children: () => [this.home],
+  });`);
+  }
+
+  // Home page - with or without loader
+  if (options.api) {
+    classMembers.push(`  home = $page({
+    path: "/",
+    lazy: () => import("./components/Hello.tsx"),
+    loader: () => this.api.hello(),
+  });`);
+  } else {
+    classMembers.push(`  home = $page({
+    path: "/",
+    lazy: () => import("./components/Hello.tsx"),
+  });`);
+  }
+
+  return `${imports.join("\n")}
+
+export class AppRouter {
+${classMembers.join("\n\n")}
+}`;
+};

package/src/cli/templates/webHelloComponentTsx.ts

@@ -0,0 +1,30 @@
+export const webHelloComponentTsx = (options: { auth?: boolean } = {}) => {
+  const imports: string[] = [];
+
+  if (options.auth) {
+    imports.push('import { UserButton } from "@alepha/ui/auth";');
+  }
+  imports.push('import { useState } from "react";');
+
+  const userButton = options.auth ? "\n      <UserButton />" : "";
+
+  return `${imports.join("\n")}
+
+interface Props {
+  message?: string;
+}
+
+const Hello = (props: Props) => {
+  const [message, setMessage] = useState(props.message ?? "");
+  return (
+    <div>
+      <h1>{message}</h1>
+      <input value={message} onChange={(e) => setMessage(e.target.value)} />
+      <p>Edit this component in src/web/components/Hello.tsx</p>${userButton}
+    </div>
+  );
+};
+
+export default Hello;
+`;
+};

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

@@ -3,11 +3,19 @@ import {
   LogDestinationProvider,
   MemoryDestinationProvider,
 } from "alepha/logger";
+import { MemoryShellProvider } from "alepha/system";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { Runner } from "../index.ts";
 
+class TestRunner extends Runner {
+  protected override get useDynamicLogger() {
+    return true;
+  }
+}
+
 describe("Runner", () => {
   let mockLogger: MemoryDestinationProvider;
+  let mockShell: MemoryShellProvider;
   let runner: Runner;
 
   beforeEach(async () => {
@@ -22,6 +30,7 @@ describe("Runner", () => {
     // Create a new MockLogger and Runner for each test to ensure isolation
     runner = alepha.inject(Runner);
     mockLogger = alepha.inject(MemoryDestinationProvider);
+    mockShell = alepha.inject(MemoryShellProvider);
   });
 
   afterEach(() => {
@@ -91,6 +100,7 @@ describe("Runner", () => {
   });
 
   test("should throw and log an error for a failing shell command", async () => {
+    mockShell.errors.set("exit 1", "Command failed with exit code 1");
     await expect(runner.run(`exit 1`)).rejects.toThrow("Task 'exit 1' failed");
   });
 
@@ -123,4 +133,133 @@ describe("Runner", () => {
     const logs = mockLogger.logs.map((l) => l.message);
     expect(logs.length).toBe(0);
   });
+
+  test("should reset firstTaskStarted when starting a new command", async () => {
+    // Simulate running command A
+    runner.startCommand("cli", "commandA");
+    await runner.run("task A1", () => {});
+    await runner.run("task A2", () => {});
+    runner.end();
+
+    const logsAfterA = mockLogger.logs.length;
+    expect(logsAfterA).toBeGreaterThan(0);
+
+    // Clear logs for next command
+    mockLogger.clear();
+
+    // Simulate running command B (should get fresh start)
+    runner.startCommand("cli", "commandB");
+    await runner.run("task B1", () => {});
+    runner.end();
+
+    // Verify command B also logged properly (not reusing A's state)
+    expect(mockLogger.logs.length).toBeGreaterThan(0);
+    expect(mockLogger.logs[0].message).toBe("Starting 'task B1' ...");
+  });
+
+  test("should handle running same task name in different commands", async () => {
+    // Run command with task "clean"
+    runner.startCommand("cli", "build");
+    await runner.run("clean", () => {});
+    runner.end();
+
+    mockLogger.clear();
+
+    // Run another command with same task name "clean"
+    runner.startCommand("cli", "verify");
+    await runner.run("clean", () => {});
+    runner.end();
+
+    // Both should have executed and logged independently
+    expect(mockLogger.logs[0].message).toBe("Starting 'clean' ...");
+    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;
+    };
+
+    try {
+      // Run command A
+      prettyRunner.startCommand("cli", "commandA");
+      await prettyRunner.run("task A", () => {});
+      prettyRunner.end();
+
+      // Verify command A header was printed
+      expect(output.some((line) => line.includes("cli commandA"))).toBe(true);
+
+      // Clear output for command B
+      output.length = 0;
+
+      // Run command B - should get its own header
+      prettyRunner.startCommand("cli", "commandB");
+      await prettyRunner.run("task B", () => {});
+      prettyRunner.end();
+
+      // 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("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;
+    };
+
+    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;
+    }
+  });
 });

package/src/command/helpers/Runner.ts

@@ -1,7 +1,7 @@
-import { exec } from "node:child_process";
 import { cp, glob, rm } from "node:fs/promises";
 import { $inject, Alepha } from "alepha";
 import { $logger } from "alepha/logger";
+import { ShellProvider } from "alepha/system";
 import { CommandError } from "../errors/CommandError.ts";
 import { PrettyPrint } from "./PrettyPrint.ts";
 
@@ -42,10 +42,12 @@ export class Runner {
   protected readonly startTime: number = Date.now();
   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();
@@ -65,6 +67,8 @@ export class Runner {
   public startCommand(cliName: string, commandName: string): void {
     this.cliName = cliName;
     this.commandName = commandName;
+    this.firstTaskStarted = false;
+    this.taskCounter = 0;
   }
 
   protected createRunMethod() {
@@ -152,26 +156,7 @@ export class Runner {
     cmd: string,
     opts: { root?: string } = {},
   ): Promise<string> {
-    return await new Promise<string>((resolve, reject) => {
-      exec(
-        cmd,
-        {
-          cwd: opts.root,
-          env: {
-            ...process.env,
-            LOG_FORMAT: "pretty",
-          },
-        },
-        (err, stdout) => {
-          if (err) {
-            err.stdout = stdout;
-            reject(err);
-          } else {
-            resolve(stdout);
-          }
-        },
-      );
-    });
+    return this.shell.run(cmd, { root: opts.root, capture: true });
   }
 
   /**
@@ -208,7 +193,7 @@ export class Runner {
 
   protected async executeTask(task: Task): Promise<string> {
     const now = Date.now();
-    const taskId = task.name; // Use task name as unique ID
+    const taskId = `task-${++this.taskCounter}`; // Use unique counter-based ID
 
     // Setup dynamic logger
     if (this.useDynamicLogger) {

package/src/command/index.ts

@@ -19,12 +19,20 @@ export * from "./providers/CliProvider.ts";
 // ---------------------------------------------------------------------------------------------------------------------
 
 /**
- * This module provides a powerful way to build command-line interfaces
- * directly within your Alepha application, using declarative primitives.
+ * | type | quality | stability |
+ * |------|---------|-----------|
+ * | tooling | rare | stable |
  *
- * It allows you to define commands using the `$command` primitive.
+ * Declarative CLI command framework.
+ *
+ * **Features:**
+ * - CLI command definitions
+ * - Interactive CLI prompts
+ * - Command execution
+ * - Formatted colored output
+ * - Environment variable utilities
+ * - Schema validation for CLI arguments
  *
- * @see {@link $command}
  * @module alepha.command
  */
 export const AlephaCommand = $module({