alepha 0.11.9 → 0.11.10

package/src/commands/ViteCommands.ts

@@ -0,0 +1,152 @@
+import { access, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { $command } from "@alepha/command";
+import { $inject, AlephaError, boot, t } from "@alepha/core";
+import { $logger } from "@alepha/logger";
+import { viteConfigTs } from "../assets/viteConfigTs.ts";
+import { ProcessRunner } from "../services/ProcessRunner.ts";
+import { CoreCommands } from "./CoreCommands.ts";
+
+export class ViteCommands {
+  protected readonly log = $logger();
+  protected readonly runner = $inject(ProcessRunner);
+  protected readonly core = $inject(CoreCommands);
+
+  public readonly run = $command({
+    name: "run",
+    description: "Run a TypeScript file directly",
+    flags: t.object({
+      watch: t.optional(
+        t.boolean({ description: "Watch file for changes", alias: "w" }),
+      ),
+    }),
+    summary: false,
+    args: t.text({ title: "path", description: "Filepath to run" }),
+    handler: async ({ args, flags }) => {
+      await this.core.ensureTsConfig();
+      await this.runner.exec(`tsx ${flags.watch ? "watch " : ""}${args}`);
+    },
+  });
+
+  /**
+   * Will run the project in watch mode.
+   *
+   * - If an index.html file is found in the project root, it will run Vite in dev mode.
+   * - Otherwise, it will look for a server entry file and run it with tsx in watch mode.
+   */
+  public readonly dev = $command({
+    name: "dev",
+    description: "Run the project in development mode",
+    args: t.optional(t.text({ title: "path", description: "Filepath to run" })),
+    handler: async ({ args }) => {
+      const root = process.cwd();
+      await this.core.ensureTsConfig(root);
+      await this.ensurePackageJson(root);
+      const entry = await boot.getServerEntry(root, args);
+      this.log.trace("Entry file found", { entry });
+
+      try {
+        await access(join(root, "index.html"));
+      } catch {
+        this.log.trace("No index.html found, running entry file with tsx");
+        //await this.runner.exec(`tsx watch ${entry}`);
+        //return;
+      }
+
+      const configPath = await this.configPath(root, args ? entry : undefined);
+      this.log.trace("Vite config found", { configPath });
+      await this.runner.exec(`vite -c=${configPath}`);
+    },
+  });
+
+  public readonly build = $command({
+    name: "build",
+    description: "Build the project for production",
+    args: t.optional(
+      t.text({ title: "path", description: "Filepath to build" }),
+    ),
+    flags: t.object({
+      config: t.optional(
+        t.text({ aliases: ["c"], description: "Path to config file" }),
+      ),
+      stats: t.optional(
+        t.boolean({
+          description: "Generate build stats report",
+        }),
+      ),
+    }),
+    handler: async ({ flags, args }) => {
+      const root = process.cwd();
+      await this.core.ensureTsConfig(root);
+      await this.ensurePackageJson(root);
+      const entry = await boot.getServerEntry(root, args);
+      this.log.trace("Entry file found", { entry });
+
+      await rm("dist", { recursive: true, force: true });
+
+      // DISABLED FOR NOW (waiting for vite-rolldown)
+      // if (flags.lib) {
+      //   await this.runner.exec(
+      //     `tsdown${flags.config ? ` -c=${flags.config}` : ""}`,
+      //   );
+      //   return;
+      // }
+
+      const configPath = await this.configPath(root, args ? entry : undefined);
+
+      const env: Record<string, string> = {};
+      if (flags.stats) {
+        env.ALEPHA_BUILD_STATS = "true";
+      }
+
+      await this.runner.exec(`vite build -c=${configPath}`, env);
+    },
+  });
+
+  public readonly test = $command({
+    name: "test",
+    description: "Run tests using Vitest",
+    handler: async () => {
+      await this.core.ensureTsConfig();
+
+      const configPath = await this.configPath();
+      await this.runner.exec(`vitest run -c=${configPath}`);
+    },
+  });
+
+  // -------------------------------------------------------------------------------------------------------------------
+
+  protected async configPath(
+    root = process.cwd(),
+    serverEntry?: string,
+  ): Promise<string> {
+    try {
+      const viteConfigPath = join(root, "vite.config.ts");
+      await access(viteConfigPath);
+      return viteConfigPath;
+    } catch {
+      return this.runner.writeConfigFile(
+        "vite.config.ts",
+        viteConfigTs(serverEntry),
+      );
+    }
+  }
+
+  protected async ensurePackageJson(root = process.cwd()) {
+    const packageJsonPath = join(root, "package.json");
+    try {
+      await access(packageJsonPath);
+    } catch (error) {
+      throw new AlephaError(
+        "No package.json found in project root. Run 'npx alepha init' to create one.",
+      );
+    }
+
+    const content = await readFile(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(content);
+    if (!packageJson.type || packageJson.type !== "module") {
+      packageJson.type = "module";
+      await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import "tsx";
+import { $module, Alepha, run } from "@alepha/core";
+import { BiomeCommands } from "./commands/BiomeCommands.ts";
+import { CoreCommands } from "./commands/CoreCommands.ts";
+import { DrizzleCommands } from "./commands/DrizzleCommands.ts";
+import { VerifyCommands } from "./commands/VerifyCommands.ts";
+import { ViteCommands } from "./commands/ViteCommands.ts";
+import { ProcessRunner } from "./services/ProcessRunner.ts";
+import { version } from "./version.ts";
+
+const AlephaCli = $module({
+  name: "alepha.cli",
+  services: [
+    ProcessRunner,
+    CoreCommands,
+    DrizzleCommands,
+    VerifyCommands,
+    ViteCommands,
+    BiomeCommands,
+  ],
+});
+
+const alepha = Alepha.create({
+  env: {
+    LOG_LEVEL: "alepha.core:warn,info",
+    LOG_FORMAT: "raw",
+    CLI_NAME: "alepha",
+    CLI_DESCRIPTION: `Alepha CLI v${version} - Create and manage Alepha projects.`,
+  },
+});
+
+alepha.with(AlephaCli);
+
+run(alepha);

package/src/services/ProcessRunner.ts

@@ -0,0 +1,89 @@
+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;
+  }
+}

package/src/version.ts

@@ -0,0 +1,7 @@
+import { readFileSync } from "node:fs";
+
+const packageJson = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf-8"),
+);
+
+export const version = packageJson.version;

package/api/files.cjs

@@ -1,8 +0,0 @@
-'use strict';
-var m = require('@alepha/api-files');
-Object.keys(m).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return m[k]; }
-	});
-});