alepha 0.15.1 → 0.15.3

package/src/cli/services/AlephaCliUtils.ts

@@ -1,9 +1,12 @@
-import { spawn } from "node:child_process";
-import { $inject, Alepha, AlephaError } from "alepha";
+import { $inject, type Alepha } from "alepha";
 import { EnvUtils } from "alepha/command";
-import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
-import { AppEntryProvider } from "../providers/AppEntryProvider.ts";
+import { FileSystemProvider, ShellProvider } from "alepha/system";
+import {
+  type AppEntry,
+  AppEntryProvider,
+} from "../providers/AppEntryProvider.ts";
+import { ViteUtils } from "./ViteUtils.ts";
 
 /**
  * Core utility service for CLI commands.
@@ -19,6 +22,8 @@ export class AlephaCliUtils {
   protected readonly fs = $inject(FileSystemProvider);
   protected readonly envUtils = $inject(EnvUtils);
   protected readonly boot = $inject(AppEntryProvider);
+  protected readonly shell = $inject(ShellProvider);
+  protected readonly viteUtils = $inject(ViteUtils);
 
   // ===========================================
   // Command Execution
@@ -26,6 +31,11 @@ export class AlephaCliUtils {
 
   /**
    * Execute a command with inherited stdio.
+   *
+   * @param command - The command to execute
+   * @param options.root - Working directory
+   * @param options.env - Additional environment variables
+   * @param options.global - If true, run command directly without resolving from node_modules
    */
   public async exec(
     command: string,
@@ -35,71 +45,12 @@ export class AlephaCliUtils {
       global?: boolean;
     } = {},
   ): Promise<void> {
-    const root = options.root ?? process.cwd();
-    this.log.debug(`Executing command: ${command}`, { cwd: root });
-
-    const runExec = async (app: string, args: string[]) => {
-      const prog = spawn(app, args, {
-        stdio: "inherit",
-        cwd: root,
-        env: {
-          ...process.env,
-          ...options.env,
-        },
-      });
-
-      await new Promise<void>((resolve) =>
-        prog.on("exit", () => {
-          resolve();
-        }),
-      );
-    };
-
-    if (options.global) {
-      const [app, ...args] = command.split(" ");
-      await runExec(app, args);
-      return;
-    }
-
-    const suffix = process.platform === "win32" ? ".cmd" : "";
-    const [app, ...args] = command.split(" ");
-
-    // find executable inside project node_modules
-    let execPath = await this.checkFileExists(
-      root,
-      `node_modules/.bin/${app}${suffix}`,
-    );
-
-    // or, find executable inside alepha package node_modules (pnpm style)
-    if (!execPath) {
-      execPath = await this.checkFileExists(
-        root,
-        `node_modules/alepha/node_modules/.bin/${app}${suffix}`,
-      );
-    }
-
-    // check if parent folder (monorepo) has the executable (check 3 times)
-    if (!execPath) {
-      let parentDir = this.fs.join(root, "..");
-      for (let i = 0; i < 3; i++) {
-        execPath = await this.checkFileExists(
-          parentDir,
-          `node_modules/.bin/${app}${suffix}`,
-        );
-        if (execPath) {
-          break;
-        }
-        parentDir = this.fs.join(parentDir, "..");
-      }
-    }
-
-    if (!execPath) {
-      throw new AlephaError(
-        `Could not find executable for command '${app}'. Make sure the package is installed.`,
-      );
-    }
-
-    await runExec(execPath, args);
+    await this.shell.run(command, {
+      root: options.root,
+      env: options.env,
+      resolve: !options.global,
+      capture: false,
+    });
   }
 
   /**
@@ -122,55 +73,22 @@ export class AlephaCliUtils {
     return path;
   }
 
-  /**
-   * Load Alepha instance from a server entry file.
-   */
   public async loadAlephaFromServerEntryFile(
-    rootDir?: string,
-    explicitEntry?: string,
-  ): Promise<{
-    alepha: Alepha;
-    entry: string;
-  }> {
-    process.env.ALEPHA_CLI_IMPORT = "true";
-
-    const root = rootDir ?? process.cwd();
-    let entry: string;
-
-    if (explicitEntry) {
-      // Explicit entry provided
-      entry = this.fs.join(root, explicitEntry);
-      if (!(await this.fs.exists(entry))) {
-        throw new AlephaError(
-          `Explicit server entry file "${explicitEntry}" not found.`,
-        );
-      }
+    opts: {
+      mode: "production" | "development";
+    } & ({ entry: AppEntry } | { root: string }),
+  ): Promise<Alepha> {
+    let entry: AppEntry;
+    if ("root" in opts) {
+      entry = await this.boot.getAppEntry(opts.root);
     } else {
-      // Auto-discover entry
-      const appEntry = await this.boot.getAppEntry(root);
-      entry = this.fs.join(root, appEntry.server);
-    }
-
-    delete (global as any).__alepha;
-
-    const mod = await import(entry);
-
-    this.log.debug(`Load entry: ${entry}`);
-
-    // check if alepha is correctly exported
-    if (mod.default instanceof Alepha) {
-      return { alepha: mod.default, entry };
+      entry = opts.entry;
     }
 
-    // else, try with global variable
-    const g: any = global;
-    if (g.__alepha) {
-      return { alepha: g.__alepha, entry };
-    }
-
-    throw new AlephaError(
-      `Could not find Alepha instance in entry file: ${entry}`,
-    );
+    return await this.viteUtils.runAlepha({
+      entry,
+      mode: opts.mode,
+    });
   }
 
   // ===========================================
@@ -221,13 +139,26 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
     return this.fs.exists(this.fs.join(root, path));
   }
 
-  protected async checkFileExists(
-    root: string,
-    name: string,
-  ): Promise<string | undefined> {
-    const configPath = this.fs.join(root, name);
-    if (await this.fs.exists(configPath)) {
-      return configPath;
+  /**
+   * Check if a command is installed and available in the system PATH.
+   */
+  public isInstalledAsync(cmd: string): Promise<boolean> {
+    return this.shell.isInstalled(cmd);
+  }
+
+  /**
+   * Get the current git revision (commit SHA).
+   *
+   * @returns The short commit SHA or "unknown" if not in a git repo
+   */
+  public async getGitRevision(): Promise<string> {
+    try {
+      const result = await this.shell.run("git rev-parse --short HEAD", {
+        capture: true,
+      });
+      return result.trim();
+    } catch {
+      return "unknown";
     }
   }
 }

package/src/cli/services/PackageManagerUtils.ts

@@ -1,9 +1,37 @@
 import { $inject, Alepha } from "alepha";
 import type { RunnerMethod } from "alepha/command";
-import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
+import alephaPackageJson from "alepha/package.json" with { type: "json" };
+import { FileSystemProvider } from "alepha/system";
 import { version } from "../version.ts";
 
+/**
+ * Context information about a workspace root.
+ * Used when initializing a package inside a monorepo.
+ */
+export interface WorkspaceContext {
+  /**
+   * Whether we're inside a workspace package.
+   */
+  isPackage: boolean;
+  /**
+   * The workspace root directory (e.g., ../.. from packages/my-pkg).
+   */
+  workspaceRoot: string | null;
+  /**
+   * Package manager detected at workspace root.
+   */
+  packageManager: "yarn" | "pnpm" | "npm" | "bun" | null;
+  /**
+   * Config files present at workspace root.
+   */
+  config: {
+    biomeJson: boolean;
+    editorconfig: boolean;
+    tsconfigJson: boolean;
+  };
+}
+
 /**
  * Utility service for package manager operations.
  *
@@ -23,12 +51,9 @@ export class PackageManagerUtils {
    */
   public async getPackageManager(
     root: string,
-    flags?: { yarn?: boolean; pnpm?: boolean; npm?: boolean; bun?: boolean },
+    pm?: "yarn" | "pnpm" | "npm" | "bun",
   ): Promise<"yarn" | "pnpm" | "npm" | "bun"> {
-    if (flags?.yarn) return "yarn";
-    if (flags?.pnpm) return "pnpm";
-    if (flags?.npm) return "npm";
-    if (flags?.bun) return "bun";
+    if (pm) return pm;
     if (this.alepha.isBun()) return "bun";
     if (await this.fs.exists(this.fs.join(root, "bun.lock"))) return "bun";
     if (await this.fs.exists(this.fs.join(root, "yarn.lock"))) return "yarn";
@@ -37,6 +62,60 @@ export class PackageManagerUtils {
     return "npm";
   }
 
+  /**
+   * Detect workspace context when inside a monorepo package.
+   *
+   * Checks if we're inside a workspace package (e.g., packages/my-pkg or apps/my-app)
+   * by looking 2 levels up for workspace indicators like lockfiles and config files.
+   *
+   * @param root - The current package directory
+   * @returns Workspace context with root path, PM, and config presence
+   */
+  public async getWorkspaceContext(root: string): Promise<WorkspaceContext> {
+    // Workspace root is 2 levels up (e.g., packages/my-pkg → ..)
+    const workspaceRoot = this.fs.join(root, "..", "..");
+
+    // Check for lockfiles to detect PM
+    const [hasYarnLock, hasPnpmLock, hasNpmLock, hasBunLock] =
+      await Promise.all([
+        this.fs.exists(this.fs.join(workspaceRoot, "yarn.lock")),
+        this.fs.exists(this.fs.join(workspaceRoot, "pnpm-lock.yaml")),
+        this.fs.exists(this.fs.join(workspaceRoot, "package-lock.json")),
+        this.fs.exists(this.fs.join(workspaceRoot, "bun.lock")),
+      ]);
+
+    // Check for config files
+    const [hasBiome, hasEditorConfig, hasTsConfig, hasWorkspacePackageJson] =
+      await Promise.all([
+        this.fs.exists(this.fs.join(workspaceRoot, "biome.json")),
+        this.fs.exists(this.fs.join(workspaceRoot, ".editorconfig")),
+        this.fs.exists(this.fs.join(workspaceRoot, "tsconfig.json")),
+        this.fs.exists(this.fs.join(workspaceRoot, "package.json")),
+      ]);
+
+    // Determine if this looks like a workspace root
+    const hasLockfile = hasYarnLock || hasPnpmLock || hasNpmLock || hasBunLock;
+    const isPackage = hasLockfile && hasWorkspacePackageJson;
+
+    // Detect package manager from lockfile
+    let packageManager: "yarn" | "pnpm" | "npm" | "bun" | null = null;
+    if (hasYarnLock) packageManager = "yarn";
+    else if (hasPnpmLock) packageManager = "pnpm";
+    else if (hasBunLock) packageManager = "bun";
+    else if (hasNpmLock) packageManager = "npm";
+
+    return {
+      isPackage,
+      workspaceRoot: isPackage ? workspaceRoot : null,
+      packageManager,
+      config: {
+        biomeJson: hasBiome,
+        editorconfig: hasEditorConfig,
+        tsconfigJson: hasTsConfig,
+      },
+    };
+  }
+
   /**
    * Get the install command for a package.
    */
@@ -98,12 +177,17 @@ export class PackageManagerUtils {
 
   /**
    * Install a dependency if it's missing from the project.
+   * Optionally checks workspace root for the dependency in monorepo setups.
    */
   public async ensureDependency(
     root: string,
     packageName: string,
     options: {
       dev?: boolean;
+      /**
+       * Also check workspace root for the dependency (for monorepo setups).
+       */
+      checkWorkspace?: boolean;
       run?: RunnerMethod;
       exec?: (
         cmd: string,
@@ -111,13 +195,27 @@ export class PackageManagerUtils {
       ) => Promise<void>;
     } = {},
   ): Promise<void> {
-    const { dev = true } = options;
+    const { dev = true, checkWorkspace = false } = options;
 
+    // Check current package
     if (await this.hasDependency(root, packageName)) {
       this.log.debug(`Dependency '${packageName}' is already installed`);
       return;
     }
 
+    // Check workspace root (for monorepo setups)
+    if (checkWorkspace) {
+      const workspace = await this.getWorkspaceContext(root);
+      if (workspace.workspaceRoot) {
+        if (await this.hasDependency(workspace.workspaceRoot, packageName)) {
+          this.log.debug(
+            `Dependency '${packageName}' is already installed in workspace root`,
+          );
+          return;
+        }
+      }
+    }
+
     const cmd = await this.getInstallCommand(root, packageName, dev);
 
     if (options.run) {
@@ -254,12 +352,22 @@ export class PackageManagerUtils {
     scripts: Record<string, string>;
     type: "module";
   } {
+    const alephaDeps = alephaPackageJson.devDependencies;
+
     const dependencies: Record<string, string> = {
       alepha: `^${version}`,
     };
 
     const devDependencies: Record<string, string> = {};
 
+    // Add biome/vitest only if not a workspace package (workspace root has them)
+    if (!modes.isPackage) {
+      devDependencies["@biomejs/biome"] = alephaDeps["@biomejs/biome"];
+      if (modes.test) {
+        devDependencies.vitest = alephaDeps.vitest;
+      }
+    }
+
     const scripts: Record<string, string> = {
       dev: "alepha dev",
       build: "alepha build",
@@ -268,16 +376,21 @@ export class PackageManagerUtils {
       verify: "alepha verify",
     };
 
+    if (modes.test) {
+      scripts.test = "vitest run";
+    }
+
     if (modes.ui) {
       dependencies["@alepha/ui"] = `^${version}`;
       modes.react = true;
     }
 
     if (modes.react) {
-      dependencies["@alepha/react"] = `^${version}`;
-      dependencies.react = "^19.2.0";
-      dependencies["react-dom"] = "^19.2.0";
-      devDependencies["@types/react"] = "^19.2.0";
+      dependencies.react = alephaDeps.react;
+      dependencies["react-dom"] = alephaDeps["react-dom"];
+      devDependencies["@vitejs/plugin-react"] =
+        alephaDeps["@vitejs/plugin-react"];
+      devDependencies["@types/react"] = alephaDeps["@types/react"];
     }
 
     return {
@@ -305,4 +418,9 @@ export interface DependencyModes {
   react?: boolean;
   ui?: boolean;
   expo?: boolean;
+  test?: boolean;
+  /**
+   * Skip biome/vitest when inside a workspace package (they're at root).
+   */
+  isPackage?: boolean;
 }

package/src/cli/services/ProjectScaffolder.spec.ts

@@ -0,0 +1,97 @@
+import { Alepha } from "alepha";
+import {
+  FileSystemProvider,
+  MemoryFileSystemProvider,
+  MemoryShellProvider,
+  ShellProvider,
+} from "alepha/system";
+import { describe, expect, it } from "vitest";
+import { ProjectScaffolder } from "./ProjectScaffolder.ts";
+
+describe("ProjectScaffolder", () => {
+  const createTestEnv = () => {
+    const alepha = Alepha.create()
+      .with({ provide: FileSystemProvider, use: MemoryFileSystemProvider })
+      .with({ provide: ShellProvider, use: MemoryShellProvider });
+
+    const scaffolder = alepha.inject(ProjectScaffolder);
+
+    return { alepha, scaffolder };
+  };
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // getAppName
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  describe("getAppName", () => {
+    it("should return lowercase directory name", () => {
+      const { scaffolder } = createTestEnv();
+
+      expect(scaffolder.getAppName("/project/MyApp")).toBe("myapp");
+    });
+
+    it("should remove dashes from directory name", () => {
+      const { scaffolder } = createTestEnv();
+
+      expect(scaffolder.getAppName("/project/my-cool-app")).toBe("mycoolapp");
+    });
+
+    it("should remove underscores from directory name", () => {
+      const { scaffolder } = createTestEnv();
+
+      expect(scaffolder.getAppName("/project/my_cool_app")).toBe("mycoolapp");
+    });
+
+    it("should remove spaces from directory name", () => {
+      const { scaffolder } = createTestEnv();
+
+      expect(scaffolder.getAppName("/project/my cool app")).toBe("mycoolapp");
+    });
+
+    it("should remove dots from directory name", () => {
+      const { scaffolder } = createTestEnv();
+
+      expect(scaffolder.getAppName("/project/my.cool.app")).toBe("mycoolapp");
+    });
+
+    it("should remove digits from directory name", () => {
+      const { scaffolder } = createTestEnv();
+
+      expect(scaffolder.getAppName("/project/app123")).toBe("app");
+      expect(scaffolder.getAppName("/project/my2app")).toBe("myapp");
+      expect(scaffolder.getAppName("/project/v2-app")).toBe("vapp");
+    });
+
+    it("should handle combination of special characters", () => {
+      const { scaffolder } = createTestEnv();
+
+      expect(scaffolder.getAppName("/project/my-cool_app.v2")).toBe(
+        "mycoolappv",
+      );
+      expect(scaffolder.getAppName("/project/test_app-2.0")).toBe("testapp");
+    });
+
+    it("should fallback to 'app' when all characters are removed", () => {
+      const { scaffolder } = createTestEnv();
+
+      expect(scaffolder.getAppName("/project/123")).toBe("app");
+      expect(scaffolder.getAppName("/project/---")).toBe("app");
+      expect(scaffolder.getAppName("/project/1.2.3")).toBe("app");
+      expect(scaffolder.getAppName("/project/_-._")).toBe("app");
+    });
+
+    it("should handle deeply nested paths", () => {
+      const { scaffolder } = createTestEnv();
+
+      expect(scaffolder.getAppName("/workspace/packages/apps/my-app")).toBe(
+        "myapp",
+      );
+    });
+
+    it("should handle root-level directories", () => {
+      const { scaffolder } = createTestEnv();
+
+      expect(scaffolder.getAppName("/myapp")).toBe("myapp");
+    });
+  });
+});