alepha 0.15.2 → 0.15.4

package/src/cli/services/ProjectScaffolder.ts

@@ -7,6 +7,7 @@ import {
   type AgentMdType,
   agentMd,
 } from "../templates/agentMd.ts";
+import { apiAppSecurityTs } from "../templates/apiAppSecurityTs.ts";
 import { apiHelloControllerTs } from "../templates/apiHelloControllerTs.ts";
 import { apiIndexTs } from "../templates/apiIndexTs.ts";
 import { biomeJson } from "../templates/biomeJson.ts";
@@ -51,7 +52,7 @@ export class ProjectScaffolder {
    */
   public getAppName(root: string): string {
     const dirName = basename(root);
-    const appName = dirName.toLowerCase().replace(/[\s\-_]/g, "");
+    const appName = dirName.toLowerCase().replace(/[\s\-_.\d]/g, "");
     return appName || "app";
   }
 
@@ -227,7 +228,7 @@ export class ProjectScaffolder {
    */
   public async ensureApiProject(
     root: string,
-    opts: { force?: boolean } = {},
+    opts: { auth?: boolean; force?: boolean } = {},
   ): Promise<void> {
     const appName = this.getAppName(root);
 
@@ -240,7 +241,7 @@ export class ProjectScaffolder {
     await this.ensureFile(
       root,
       "src/api/index.ts",
-      apiIndexTs({ appName }),
+      apiIndexTs({ appName, auth: opts.auth }),
       opts.force,
     );
     await this.ensureFile(
@@ -249,6 +250,16 @@ export class ProjectScaffolder {
       apiHelloControllerTs(),
       opts.force,
     );
+
+    // Create AppSecurity if auth is enabled
+    if (opts.auth) {
+      await this.ensureFile(
+        root,
+        "src/api/AppSecurity.ts",
+        apiAppSecurityTs(),
+        opts.force,
+      );
+    }
   }
 
   // ===========================================
@@ -265,7 +276,13 @@ export class ProjectScaffolder {
    */
   public async ensureWebProject(
     root: string,
-    opts: { api?: boolean; ui?: boolean; force?: boolean } = {},
+    opts: {
+      api?: boolean;
+      ui?: boolean;
+      auth?: boolean;
+      admin?: boolean;
+      force?: boolean;
+    } = {},
   ): Promise<void> {
     const appName = this.getAppName(root);
 
@@ -292,13 +309,18 @@ export class ProjectScaffolder {
     await this.ensureFile(
       root,
       "src/web/AppRouter.ts",
-      webAppRouterTs({ api: opts.api, ui: opts.ui }),
+      webAppRouterTs({
+        api: opts.api,
+        ui: opts.ui,
+        auth: opts.auth,
+        admin: opts.admin,
+      }),
       opts.force,
     );
     await this.ensureFile(
       root,
       "src/web/components/Hello.tsx",
-      webHelloComponentTsx(),
+      webHelloComponentTsx({ auth: opts.auth }),
       opts.force,
     );
     await this.ensureFile(

package/src/cli/templates/agentMd.ts

@@ -311,6 +311,11 @@ alepha build     # Build the project
 ## Source Code Access
 
 Full framework source available at \`node_modules/alepha/src/\`.
-Read primitives directly when you need implementation details.
+
+**IMPORTANT:** When answering questions about Alepha primitives, APIs, or internals:
+1. ALWAYS read the local source code first at \`node_modules/alepha/src/\` or \`node_modules/@alepha/ui/src/\` for UI-related questions
+2. Use \`Glob\` to find relevant files: \`node_modules/alepha/src/**/primitives/$<name>.ts\`
+3. Read the implementation AND the \`.spec.ts\` test files for usage examples
+4. Use external documentation as a fallback if source code is insufficient
 `.trim();
 };

package/src/cli/templates/apiAppSecurityTs.ts

@@ -0,0 +1,11 @@
+export const apiAppSecurityTs = () => {
+  return `
+import { $realm } from "alepha/api/users";
+
+export class AppSecurity {
+  users = $realm({
+    // configure your realm here
+  });
+}
+`.trim();
+};

package/src/cli/templates/apiIndexTs.ts

@@ -1,16 +1,30 @@
 export interface ApiIndexTsOptions {
   appName?: string;
+  auth?: boolean;
 }
 
 export const apiIndexTs = (options: ApiIndexTsOptions = {}) => {
-  const { appName = "app" } = options;
+  const { appName = "app", auth = false } = options;
+
+  const imports: string[] = ['import { $module } from "alepha";'];
+  const services: string[] = [];
+
+  if (auth) {
+    imports.push('import { AppSecurity } from "./AppSecurity.ts";');
+    services.push("AppSecurity");
+  }
+
+  imports.push(
+    'import { HelloController } from "./controllers/HelloController.ts";',
+  );
+  services.push("HelloController");
+
   return `
-import { $module } from "alepha";
-import { HelloController } from "./controllers/HelloController.ts";
+${imports.join("\n")}
 
 export const ApiModule = $module({
   name: "${appName}.api",
-  services: [HelloController],
+  services: [${services.join(", ")}],
 });
 `.trim();
 };

package/src/cli/templates/webAppRouterTs.ts

@@ -1,4 +1,9 @@
-export const webAppRouterTs = (options: { api?: boolean; ui?: boolean }) => {
+export const webAppRouterTs = (options: {
+  api?: boolean;
+  ui?: boolean;
+  auth?: boolean;
+  admin?: boolean;
+}) => {
   const imports: string[] = [];
   const classMembers: string[] = [];
 
@@ -7,6 +12,16 @@ export const webAppRouterTs = (options: { api?: boolean; ui?: boolean }) => {
     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";');
 
@@ -22,6 +37,15 @@ export const webAppRouterTs = (options: { api?: boolean; ui?: boolean }) => {
   // 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],

package/src/cli/templates/webHelloComponentTsx.ts

@@ -1,5 +1,14 @@
-export const webHelloComponentTsx = () =>
-  `import { useState } from "react";
+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;
@@ -10,11 +19,12 @@ const Hello = (props: Props) => {
   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>
+      <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;
-`.trim();
+`;
+};

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

@@ -7,6 +7,12 @@ 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;
@@ -127,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

@@ -47,6 +47,7 @@ export class Runner {
   protected cliName = "";
   protected commandName = "";
   protected firstTaskStarted = false;
+  protected taskCounter = 0;
 
   constructor() {
     this.run = this.createRunMethod();
@@ -66,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() {
@@ -190,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) {