alepha 0.13.4 → 0.13.6

package/src/cli/commands/BiomeCommands.ts

@@ -1,20 +1,18 @@
 import { $inject } from "alepha";
 import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
-import { ProcessRunner } from "../services/ProcessRunner.ts";
-import { ProjectUtils } from "../services/ProjectUtils.ts";
+import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
 export class BiomeCommands {
   protected readonly log = $logger();
-  protected readonly runner = $inject(ProcessRunner);
-  protected readonly utils = $inject(ProjectUtils);
+  protected readonly utils = $inject(AlephaCliUtils);
 
   public readonly format = $command({
     name: "format",
     description: "Format the codebase using Biome",
     handler: async ({ root }) => {
       await this.utils.ensureConfig(root, { biomeJson: true });
-      await this.runner.exec(`biome format --fix`);
+      await this.utils.exec(`biome format --fix`);
     },
   });
 
@@ -23,7 +21,7 @@ export class BiomeCommands {
     description: "Run linter across the codebase using Biome",
     handler: async ({ root }) => {
       await this.utils.ensureConfig(root, { biomeJson: true });
-      await this.runner.exec(`biome check --formatter-enabled=false --fix`);
+      await this.utils.exec(`biome check --formatter-enabled=false --fix`);
     },
   });
 }

package/src/cli/commands/CoreCommands.ts

@@ -1,13 +1,13 @@
 import { $inject, t } from "alepha";
 import { $command, CliProvider } from "alepha/command";
 import { $logger } from "alepha/logger";
-import { ProjectUtils } from "../services/ProjectUtils.ts";
+import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 import { version } from "../version.ts";
 
 export class CoreCommands {
   protected readonly log = $logger();
   protected readonly cli = $inject(CliProvider);
-  protected readonly utils = $inject(ProjectUtils);
+  protected readonly utils = $inject(AlephaCliUtils);
 
   /**
    * Called when no command is provided

package/src/cli/commands/DrizzleCommands.ts

@@ -4,8 +4,7 @@ import { $inject, AlephaError, t } from "alepha";
 import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
 import type { DrizzleKitProvider, RepositoryProvider } from "alepha/orm";
-import { ProcessRunner } from "../services/ProcessRunner.ts";
-import { ProjectUtils } from "../services/ProjectUtils.ts";
+import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
 const drizzleCommandFlags = t.object({
   provider: t.optional(
@@ -18,8 +17,7 @@ const drizzleCommandFlags = t.object({
 
 export class DrizzleCommands {
   log = $logger();
-  runner = $inject(ProcessRunner);
-  utils = $inject(ProjectUtils);
+  utils = $inject(AlephaCliUtils);
 
   /**
    * Check if database migrations are up to date.
@@ -256,78 +254,78 @@ export class DrizzleCommands {
     },
   });
 
-  /**
-   * Drop database schema (development only)
-   *
-   * @experimental
-   */
-  drop = $command({
-    name: "db:drop",
-    description: "Drop database schema (development only)",
-    summary: false,
-    args: t.optional(
-      t.text({
-        title: "path",
-        description: "Path to the Alepha server entry file",
-      }),
-    ),
-    flags: drizzleCommandFlags,
-    handler: async ({ flags }) => {
-      // TODO: Implement db:drop
-      this.log.warn("db:drop is not yet implemented");
-      if (flags.provider) {
-        this.log.info(`Provider filter: ${flags.provider}`);
-      }
-    },
-  });
-
-  /**
-   * Seed database with initial data
-   *
-   * @experimental
-   */
-  seed = $command({
-    name: "db:seed",
-    description: "Seed database with initial data",
-    summary: false,
-    args: t.optional(
-      t.text({
-        title: "path",
-        description: "Path to the Alepha server entry file",
-      }),
-    ),
-    flags: drizzleCommandFlags,
-    handler: async ({ flags }) => {
-      // TODO: Implement db:seed
-      this.log.warn("db:seed is not yet implemented");
-      if (flags.provider) {
-        this.log.info(`Provider filter: ${flags.provider}`);
-      }
-    },
-  });
-
-  /**
-   * Show pending database migrations status
-   *
-   * @experimental
-   */
-  status = $command({
-    name: "db:status",
-    description: "Show pending database migrations status",
-    summary: false,
-    args: t.optional(
-      t.text({
-        title: "path",
-        description: "Path to the Alepha server entry file",
-      }),
-    ),
-    flags: drizzleCommandFlags,
-    handler: async ({ flags }) => {
-      // TODO: Implement db:status
-      this.log.warn("db:status is not yet implemented");
-      if (flags.provider) {
-        this.log.info(`Provider filter: ${flags.provider}`);
-      }
-    },
-  });
+  // /**
+  //  * Drop database schema (development only)
+  //  *
+  //  * @experimental
+  //  */
+  // drop = $command({
+  //   name: "db:drop",
+  //   description: "Drop database schema (development only)",
+  //   summary: false,
+  //   args: t.optional(
+  //     t.text({
+  //       title: "path",
+  //       description: "Path to the Alepha server entry file",
+  //     }),
+  //   ),
+  //   flags: drizzleCommandFlags,
+  //   handler: async ({ flags }) => {
+  //     // TODO: Implement db:drop
+  //     this.log.warn("db:drop is not yet implemented");
+  //     if (flags.provider) {
+  //       this.log.info(`Provider filter: ${flags.provider}`);
+  //     }
+  //   },
+  // });
+  //
+  // /**
+  //  * Seed database with initial data
+  //  *
+  //  * @experimental
+  //  */
+  // seed = $command({
+  //   name: "db:seed",
+  //   description: "Seed database with initial data",
+  //   summary: false,
+  //   args: t.optional(
+  //     t.text({
+  //       title: "path",
+  //       description: "Path to the Alepha server entry file",
+  //     }),
+  //   ),
+  //   flags: drizzleCommandFlags,
+  //   handler: async ({ flags }) => {
+  //     // TODO: Implement db:seed
+  //     this.log.warn("db:seed is not yet implemented");
+  //     if (flags.provider) {
+  //       this.log.info(`Provider filter: ${flags.provider}`);
+  //     }
+  //   },
+  // });
+  //
+  // /**
+  //  * Show pending database migrations status
+  //  *
+  //  * @experimental
+  //  */
+  // status = $command({
+  //   name: "db:status",
+  //   description: "Show pending database migrations status",
+  //   summary: false,
+  //   args: t.optional(
+  //     t.text({
+  //       title: "path",
+  //       description: "Path to the Alepha server entry file",
+  //     }),
+  //   ),
+  //   flags: drizzleCommandFlags,
+  //   handler: async ({ flags }) => {
+  //     // TODO: Implement db:status
+  //     this.log.warn("db:status is not yet implemented");
+  //     if (flags.provider) {
+  //       this.log.info(`Provider filter: ${flags.provider}`);
+  //     }
+  //   },
+  // });
 }

package/src/cli/commands/VerifyCommands.ts

@@ -1,11 +1,9 @@
 import { $inject } from "alepha";
 import { $command } from "alepha/command";
-import { ProcessRunner } from "../services/ProcessRunner.ts";
-import { ProjectUtils } from "../services/ProjectUtils.ts";
+import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
 export class VerifyCommands {
-  protected readonly processRunner = $inject(ProcessRunner);
-  protected readonly utils = $inject(ProjectUtils);
+  protected readonly utils = $inject(AlephaCliUtils);
 
   /**
    * Run a series of verification commands to ensure code quality and correctness.
@@ -51,7 +49,7 @@ export class VerifyCommands {
     name: "typecheck",
     description: "Check TypeScript types across the codebase",
     handler: async () => {
-      await this.processRunner.exec("tsc --noEmit");
+      await this.utils.exec("tsc --noEmit");
     },
   });
 }

package/src/cli/commands/ViteCommands.ts

@@ -15,13 +15,11 @@ import {
   prerenderPages,
   type ViteAlephaBuildOptions,
 } from "alepha/vite";
-import { ProcessRunner } from "../services/ProcessRunner.ts";
-import { ProjectUtils } from "../services/ProjectUtils.ts";
+import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
 export class ViteCommands {
   protected readonly log = $logger();
-  protected readonly runner = $inject(ProcessRunner);
-  protected readonly utils = $inject(ProjectUtils);
+  protected readonly utils = $inject(AlephaCliUtils);
 
   protected readonly env = $env(
     t.object({
@@ -41,7 +39,7 @@ export class ViteCommands {
     args: t.text({ title: "path", description: "Filepath to run" }),
     handler: async ({ args, flags, root }) => {
       await this.utils.ensureTsConfig(root);
-      await this.runner.exec(`tsx ${flags.watch ? "watch " : ""}${args}`);
+      await this.utils.exec(`tsx ${flags.watch ? "watch " : ""}${args}`);
     },
   });
 
@@ -73,11 +71,11 @@ export class ViteCommands {
           cmd += ` --env-file=./.env`;
         }
         cmd += ` ${entry}`;
-        await this.runner.exec(cmd);
+        await this.utils.exec(cmd);
         return;
       }
 
-      await this.runner.exec(`vite`);
+      await this.utils.exec(`vite`);
     },
   });
 
@@ -313,7 +311,7 @@ export class ViteCommands {
         process.exit(1);
       }
 
-      await this.runner.exec(`vitest run ${this.env.VITEST_ARGS}`);
+      await this.utils.exec(`vitest run ${this.env.VITEST_ARGS}`);
     },
   });
 }

package/src/cli/index.ts

@@ -5,5 +5,5 @@ export * from "./commands/CoreCommands.ts";
 export * from "./commands/DrizzleCommands.ts";
 export * from "./commands/VerifyCommands.ts";
 export * from "./commands/ViteCommands.ts";
-export * from "./services/ProjectUtils.ts";
+export * from "./services/AlephaCliUtils.ts";
 export * from "./version.ts";

package/src/cli/services/{ProjectUtils.ts → AlephaCliUtils.ts}

@@ -1,4 +1,5 @@
-import { access, readFile, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { $inject, Alepha, AlephaError } from "alepha";
 import { FileSystemProvider } from "alepha/file";
@@ -13,7 +14,6 @@ import { mainBrowserTs } from "../assets/mainBrowserTs.ts";
 import { tsconfigJson } from "../assets/tsconfigJson.ts";
 import { viteConfigTs } from "../assets/viteConfigTs.ts";
 import { version } from "../version.ts";
-import { ProcessRunner } from "./ProcessRunner.ts";
 
 /**
  * Utility service for common project operations used by CLI commands.
@@ -25,11 +25,96 @@ import { ProcessRunner } from "./ProcessRunner.ts";
  * - Drizzle ORM/Kit utilities
  * - Alepha instance loading
  */
-export class ProjectUtils {
+export class AlephaCliUtils {
   protected readonly log = $logger();
-  protected readonly runner = $inject(ProcessRunner);
   protected readonly fs = $inject(FileSystemProvider);
 
+  /**
+   * Execute a command using npx with inherited stdio.
+   *
+   * @param command - The command to execute (will be passed to npx)
+   * @param env - Optional environment variables to set for the command
+   * @returns Promise that resolves when the process exits
+   *
+   * @example
+   * ```ts
+   * const runner = alepha.inject(ProcessRunner);
+   * await runner.exec("tsx watch src/index.ts");
+   * ```
+   */
+  public async exec(
+    command: string,
+    env: Record<string, string> = {},
+  ): Promise<void> {
+    const root = process.cwd();
+    this.log.debug(`Executing command: ${command}`, { cwd: root });
+
+    const suffix = process.platform === "win32" ? ".cmd" : "";
+    const [app, ...args] = command.split(" ");
+    const execPath = await this.checkFileExists(
+      root,
+      `node_modules/.bin/${app}${suffix}`,
+      true,
+    );
+
+    if (!execPath) {
+      throw new AlephaError(
+        `Could not find executable for command '${app}'. Make sure the package is installed.`,
+      );
+    }
+
+    const prog = spawn(execPath, args, {
+      stdio: "inherit",
+      cwd: root,
+      env: {
+        ...process.env,
+        ...env,
+        //  NODE_OPTIONS: "--import tsx",
+      },
+    });
+
+    await new Promise<void>((resolve) =>
+      prog.on("exit", () => {
+        resolve();
+      }),
+    );
+  }
+
+  /**
+   * Write a configuration file to node_modules/.alepha directory.
+   *
+   * Creates the .alepha directory if it doesn't exist and writes the file with the given content.
+   *
+   * @param name - The name of the config file to create
+   * @param content - The content to write to the file
+   * @param root - The root directory (defaults to process.cwd())
+   * @returns The absolute path to the created file
+   *
+   * @example
+   * ```ts
+   * const runner = alepha.inject(ProcessRunner);
+   * const configPath = await runner.writeConfigFile("biome.json", biomeConfig);
+   * ```
+   */
+  public async writeConfigFile(
+    name: string,
+    content: string,
+    root = process.cwd(),
+  ): Promise<string> {
+    const dir = join(root, "node_modules", ".alepha");
+
+    await mkdir(dir, {
+      recursive: true,
+    }).catch(() => null);
+
+    const path = join(dir, name);
+    await writeFile(path, content);
+
+    this.log.debug(`Config file written: ${path}`);
+
+    return path;
+  }
+
   // ===================================================================================================================
   // Package Manager & Project Setup
   // ===================================================================================================================
@@ -207,27 +292,26 @@ export class ProjectUtils {
     root: string,
     name: string,
     checkParentDirectories: boolean = false,
-  ): Promise<boolean> {
+  ): Promise<string | undefined> {
     const configPath = join(root, name);
     if (!checkParentDirectories) {
       try {
         await access(configPath);
-        return true;
+        return configPath;
       } catch {
-        return false;
+        return;
       }
     }
 
-    let found = false;
     let currentDir = root;
     const maxIterations = 10; // safety to prevent infinite loops
     let level = 0;
 
     while (level < maxIterations) {
       try {
-        await access(join(currentDir, name));
-        found = true;
-        break;
+        const maybe = join(currentDir, name);
+        await access(maybe);
+        return maybe;
       } catch {
         const parentDir = join(currentDir, "..");
         if (parentDir === currentDir) {
@@ -237,8 +321,6 @@ export class ProjectUtils {
       }
       level += 1;
     }
-
-    return found;
   }
 
   protected async ensureFileExists(
@@ -379,7 +461,7 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
       models,
     );
 
-    const entitiesJsPath = await this.runner.writeConfigFile(
+    const entitiesJsPath = await this.writeConfigFile(
       "entities.js",
       entitiesJs,
       options.rootDir,
@@ -410,7 +492,7 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
 
     const drizzleConfigJs = `export default ${JSON.stringify(config, null, 2)}`;
 
-    return await this.runner.writeConfigFile(
+    return await this.writeConfigFile(
       "drizzle.config.js",
       drizzleConfigJs,
       options.rootDir,
@@ -500,8 +582,11 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
       });
 
       const flags = options.commandFlags ? ` ${options.commandFlags}` : "";
-      await this.runner.exec(
+      await this.exec(
         `drizzle-kit ${options.command} --config=${drizzleConfigJsPath}${flags}`,
+        {
+          NODE_OPTIONS: "--import tsx",
+        },
       );
     }
   }

package/src/command/providers/CliProvider.ts

@@ -142,7 +142,11 @@ export class CliProvider {
       }
 
       const commandFlags = this.parseCommandFlags(argv, command.flags);
-      const commandArgs = this.parseCommandArgs(argv, command.options.args);
+      const commandArgs = this.parseCommandArgs(
+        argv,
+        command.options.args,
+        command.name === "",
+      );
 
       await this.alepha.context.run(async () => {
         this.log.debug(`Executing command '${command.name}'...`, {
@@ -291,15 +295,19 @@ export class CliProvider {
     return result;
   }
 
-  protected parseCommandArgs(argv: string[], schema?: TSchema): any {
+  protected parseCommandArgs(
+    argv: string[],
+    schema?: TSchema,
+    isRootCommand = false,
+  ): any {
     if (!schema) {
       return undefined;
     }
 
     // Extract positional arguments (non-flag arguments)
     const positionalArgs = argv.filter((arg) => !arg.startsWith("-"));
-    // Remove the command name from the positional args
-    const argsOnly = positionalArgs.slice(1);
+    // For root commands, there's no command name to remove; otherwise slice off the command name
+    const argsOnly = isRootCommand ? positionalArgs : positionalArgs.slice(1);
 
     try {
       if (t.schema.isOptional(schema)) {

package/src/cli/services/ProcessRunner.ts

@@ -1,89 +0,0 @@
-import { spawn } from "node:child_process";
-import { mkdir, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { $logger } from "alepha/logger";
-
-/**
- * Service for running external processes with logging support.
- *
- * This service wraps Node.js child_process functionality and provides:
- * - Automatic logging of executed commands
- * - Promise-based execution
- * - Inherited stdio for seamless output
- * - Working directory context
- * - Config file management in node_modules/.alepha
- */
-export class ProcessRunner {
-  protected readonly log = $logger();
-
-  /**
-   * Execute a command using npx with inherited stdio.
-   *
-   * @param command - The command to execute (will be passed to npx)
-   * @param env - Optional environment variables to set for the command
-   * @returns Promise that resolves when the process exits
-   *
-   * @example
-   * ```ts
-   * const runner = alepha.inject(ProcessRunner);
-   * await runner.exec("tsx watch src/index.ts");
-   * ```
-   */
-  public async exec(
-    command: string,
-    env: Record<string, string> = {},
-  ): Promise<void> {
-    this.log.debug(`Executing command: npx ${command}`, { cwd: process.cwd() });
-
-    const prog = spawn("npx", command.split(" "), {
-      stdio: "inherit",
-      cwd: process.cwd(),
-      env: {
-        ...process.env,
-        ...env,
-        NODE_OPTIONS: "--import tsx",
-      },
-    });
-
-    await new Promise<void>((resolve) =>
-      prog.on("exit", () => {
-        resolve();
-      }),
-    );
-  }
-
-  /**
-   * Write a configuration file to node_modules/.alepha directory.
-   *
-   * Creates the .alepha directory if it doesn't exist and writes the file with the given content.
-   *
-   * @param name - The name of the config file to create
-   * @param content - The content to write to the file
-   * @param root - The root directory (defaults to process.cwd())
-   * @returns The absolute path to the created file
-   *
-   * @example
-   * ```ts
-   * const runner = alepha.inject(ProcessRunner);
-   * const configPath = await runner.writeConfigFile("biome.json", biomeConfig);
-   * ```
-   */
-  public async writeConfigFile(
-    name: string,
-    content: string,
-    root = process.cwd(),
-  ): Promise<string> {
-    const dir = join(root, "node_modules", ".alepha");
-
-    await mkdir(dir, {
-      recursive: true,
-    }).catch(() => null);
-
-    const path = join(dir, name);
-    await writeFile(path, content);
-
-    this.log.debug(`Config file written: ${path}`);
-
-    return path;
-  }
-}