alepha 0.14.4 → 0.15.0

package/src/cli/commands/dev.ts

@@ -1,14 +1,18 @@
-import { access } from "node:fs/promises";
-import { join } from "node:path";
 import { $inject, Alepha, t } from "alepha";
 import { $command } from "alepha/command";
+import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
 import { boot, devServer } from "alepha/vite";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+import { PackageManagerUtils } from "../services/PackageManagerUtils.ts";
+import { ProjectScaffolder } from "../services/ProjectScaffolder.ts";
 
 export class DevCommand {
   protected readonly log = $logger();
+  protected readonly fs = $inject(FileSystemProvider);
   protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly pm = $inject(PackageManagerUtils);
+  protected readonly scaffolder = $inject(ProjectScaffolder);
   protected readonly alepha = $inject(Alepha);
 
   /**
@@ -22,9 +26,9 @@ export class DevCommand {
     description: "Run the project in development mode",
     args: t.optional(t.text({ title: "path", description: "Filepath to run" })),
     handler: async ({ args, root }) => {
-      const expo = await this.utils.hasExpo(root);
+      const expo = await this.pm.hasExpo(root);
 
-      await this.utils.ensureConfig(root, {
+      await this.scaffolder.ensureConfig(root, {
         tsconfigJson: true,
       });
 
@@ -52,7 +56,9 @@ export class DevCommand {
       }
 
       // Ensure vite is installed before running
-      await this.utils.ensureDependency(root, "vite");
+      await this.pm.ensureDependency(root, "vite", {
+        exec: (cmd, opts) => this.utils.exec(cmd, opts),
+      });
 
       await devServer();
     },
@@ -62,20 +68,10 @@ export class DevCommand {
     if (this.alepha.isBun()) {
       return true;
     }
-    try {
-      await access(join(root, "bun.lock"));
-      return true;
-    } catch {
-      return false;
-    }
+    return this.fs.exists(this.fs.join(root, "bun.lock"));
   }
 
   protected async isFullstackProject(root: string): Promise<boolean> {
-    try {
-      await access(join(root, "index.html"));
-      return true;
-    } catch {
-      return false;
-    }
+    return this.fs.exists(this.fs.join(root, "index.html"));
   }
 }

package/src/cli/commands/format.ts

@@ -1,16 +1,22 @@
 import { $inject } from "alepha";
 import { $command } from "alepha/command";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+import { PackageManagerUtils } from "../services/PackageManagerUtils.ts";
+import { ProjectScaffolder } from "../services/ProjectScaffolder.ts";
 
 export class FormatCommand {
   protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly pm = $inject(PackageManagerUtils);
+  protected readonly scaffolder = $inject(ProjectScaffolder);
 
   public readonly format = $command({
     name: "format",
     description: "Format the codebase using Biome",
     handler: async ({ root }) => {
-      await this.utils.ensureConfig(root, { biomeJson: true });
-      await this.utils.ensureDependency(root, "@biomejs/biome");
+      await this.scaffolder.ensureConfig(root, { biomeJson: true });
+      await this.pm.ensureDependency(root, "@biomejs/biome", {
+        exec: (cmd, opts) => this.utils.exec(cmd, opts),
+      });
       await this.utils.exec("biome format --fix");
     },
   });

package/src/cli/commands/init.ts

@@ -1,9 +1,15 @@
 import { $inject, t } from "alepha";
 import { $command } from "alepha/command";
+import { FileSystemProvider } from "alepha/file";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+import { PackageManagerUtils } from "../services/PackageManagerUtils.ts";
+import { ProjectScaffolder } from "../services/ProjectScaffolder.ts";
 
 export class InitCommand {
   protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly pm = $inject(PackageManagerUtils);
+  protected readonly scaffolder = $inject(ProjectScaffolder);
+  protected readonly fs = $inject(FileSystemProvider);
 
   /**
    * Ensure the project has the necessary Alepha configuration files.
@@ -12,79 +18,118 @@ export class InitCommand {
   public readonly init = $command({
     name: "init",
     description: "Add missing Alepha configuration files to the project",
+    args: t.optional(
+      t.text({
+        title: "path",
+        trim: true,
+        lowercase: true,
+      }),
+    ),
     flags: t.object({
+      agent: t.optional(
+        t.boolean({
+          aliases: ["a"],
+          description: "Add CLAUDE.md for Claude Code AI assistant",
+        }),
+      ),
       // choose package manager
       yarn: t.optional(t.boolean({ description: "Use Yarn package manager" })),
       pnpm: t.optional(t.boolean({ description: "Use pnpm package manager" })),
       npm: t.optional(t.boolean({ description: "Use npm package manager" })),
       bun: t.optional(t.boolean({ description: "Use Bun package manager" })),
       // choose which dependencies to add
-      react: t.optional(
-        t.boolean({ description: "Include Alepha React dependencies" }),
+      web: t.optional(
+        t.boolean({
+          aliases: ["r"],
+          description: "Include Alepha React dependencies",
+        }),
       ),
-      ui: t.optional(
+      admin: t.optional(
         t.boolean({ description: "Include Alepha UI dependencies" }),
       ),
       test: t.optional(
         t.boolean({ description: "Include Vitest and create test directory" }),
       ),
     }),
-    handler: async ({ run, flags, root }) => {
-      if (flags.ui) {
-        flags.react = true;
+    handler: async ({ run, flags, root, args }) => {
+      if (flags.admin) {
+        flags.web = true;
+      }
+
+      if (args) {
+        root = this.fs.join(root, args);
+        await this.fs.mkdir(root);
       }
 
-      const isExpo = await this.utils.hasExpo(root);
+      const isExpo = await this.pm.hasExpo(root);
 
       await run({
         name: "ensuring configuration files",
         handler: async () => {
-          await this.utils.ensureConfig(root, {
+          await this.scaffolder.ensureConfig(root, {
             tsconfigJson: true,
             packageJson: flags,
             biomeJson: true,
             editorconfig: true,
-            indexHtml: !!flags.react && !isExpo,
+            indexHtml: !!flags.web && !isExpo,
+            claudeMd: flags.agent
+              ? { react: !!flags.web, ui: !!flags.admin }
+              : false,
           });
 
-          // Create src/main.ts if src directory is empty or doesn't exist
-          if (!flags.react) {
-            await this.utils.ensureSrcMain(root);
+          // Create API project structure if not React
+          if (!flags.web) {
+            await this.scaffolder.ensureApiProject(root);
           }
         },
       });
 
       // TODO: check if all alepha dependencies are same version
 
-      const pm = await this.utils.getPackageManager(root, flags);
-      if (pm === "yarn") {
-        await this.utils.ensureYarn(root);
-        await run("yarn set version stable");
-      } else if (pm === "bun") {
-        await this.utils.ensureBun(root);
-      } else if (pm === "pnpm") {
-        await this.utils.ensurePnpm(root);
+      const pmName = await this.pm.getPackageManager(root, flags);
+      if (pmName === "yarn") {
+        await this.pm.ensureYarn(root);
+        await run("yarn set version stable", { root });
+      } else if (pmName === "bun") {
+        await this.pm.ensureBun(root);
+      } else if (pmName === "pnpm") {
+        await this.pm.ensurePnpm(root);
       } else {
-        await this.utils.ensureNpm(root);
+        await this.pm.ensureNpm(root);
       }
 
-      await run(`${pm} install`, {
-        alias: `installing dependencies with ${pm}`,
+      await run(`${pmName} install`, {
+        alias: `installing dependencies with ${pmName}`,
+        root,
       });
 
       if (!isExpo) {
-        await this.utils.ensureDependency(root, "vite", { run });
+        await this.pm.ensureDependency(root, "vite", {
+          run,
+          exec: (cmd, opts) => this.utils.exec(cmd, opts),
+        });
       }
 
-      await this.utils.ensureDependency(root, "@biomejs/biome", { run });
+      await this.pm.ensureDependency(root, "@biomejs/biome", {
+        run,
+        exec: (cmd, opts) => this.utils.exec(cmd, opts),
+      });
 
       // Install vitest and create test directory if --test flag is set
       if (flags.test) {
-        await this.utils.ensureTestDir(root);
-        await run(`${pm} ${pm === "yarn" ? "add" : "install"} -D vitest`, {
-          alias: "setup testing with Vitest",
-        });
+        await this.scaffolder.ensureTestDir(root);
+        await run(
+          `${pmName} ${pmName === "yarn" ? "add" : "install"} -D vitest`,
+          {
+            alias: "setup testing with Vitest",
+          },
+        );
       }
+
+      await run(`${pmName} run lint`, {
+        alias: "running linter",
+        root,
+      });
     },
   });
 }

package/src/cli/commands/lint.ts

@@ -1,16 +1,22 @@
 import { $inject } from "alepha";
 import { $command } from "alepha/command";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+import { PackageManagerUtils } from "../services/PackageManagerUtils.ts";
+import { ProjectScaffolder } from "../services/ProjectScaffolder.ts";
 
 export class LintCommand {
   protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly pm = $inject(PackageManagerUtils);
+  protected readonly scaffolder = $inject(ProjectScaffolder);
 
   public readonly lint = $command({
     name: "lint",
     description: "Run linter across the codebase using Biome",
     handler: async ({ root }) => {
-      await this.utils.ensureConfig(root, { biomeJson: true });
-      await this.utils.ensureDependency(root, "@biomejs/biome");
+      await this.scaffolder.ensureConfig(root, { biomeJson: true });
+      await this.pm.ensureDependency(root, "@biomejs/biome", {
+        exec: (cmd, opts) => this.utils.exec(cmd, opts),
+      });
       await this.utils.exec("biome check --formatter-enabled=false --fix");
     },
   });

package/src/cli/commands/test.ts

@@ -1,9 +1,13 @@
 import { $inject, t } from "alepha";
 import { $command } from "alepha/command";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+import { PackageManagerUtils } from "../services/PackageManagerUtils.ts";
+import { ProjectScaffolder } from "../services/ProjectScaffolder.ts";
 
 export class TestCommand {
   protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly pm = $inject(PackageManagerUtils);
+  protected readonly scaffolder = $inject(ProjectScaffolder);
 
   public readonly test = $command({
     name: "test",
@@ -26,12 +30,14 @@ export class TestCommand {
       ),
     }),
     handler: async ({ root, flags, env }) => {
-      await this.utils.ensureConfig(root, {
+      await this.scaffolder.ensureConfig(root, {
         tsconfigJson: true,
       });
 
       // Ensure vitest is installed before running
-      await this.utils.ensureDependency(root, "vitest");
+      await this.pm.ensureDependency(root, "vitest", {
+        exec: (cmd, opts) => this.utils.exec(cmd, opts),
+      });
 
       const config = flags.config ? `--config=${flags.config}` : "";
 

package/src/cli/commands/typecheck.ts

@@ -2,9 +2,11 @@ import { $inject } from "alepha";
 import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+import { PackageManagerUtils } from "../services/PackageManagerUtils.ts";
 
 export class TypecheckCommand {
   protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly pm = $inject(PackageManagerUtils);
   protected readonly log = $logger();
 
   /**
@@ -16,7 +18,9 @@ export class TypecheckCommand {
     description: "Check TypeScript types across the codebase",
     handler: async ({ root }) => {
       this.log.info("Starting TypeScript type checking...");
-      await this.utils.ensureDependency(root, "typescript");
+      await this.pm.ensureDependency(root, "typescript", {
+        exec: (cmd, opts) => this.utils.exec(cmd, opts),
+      });
       await this.utils.exec("tsc --noEmit");
       this.log.info("TypeScript type checking completed successfully.");
     },

package/src/cli/commands/verify.ts

@@ -1,9 +1,11 @@
 import { $inject } from "alepha";
 import { $command } from "alepha/command";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
+import { PackageManagerUtils } from "../services/PackageManagerUtils.ts";
 
 export class VerifyCommand {
   protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly pm = $inject(PackageManagerUtils);
 
   /**
    * Run a series of verification commands to ensure code quality and correctness.
@@ -28,7 +30,7 @@ export class VerifyCommand {
 
       await run("alepha typecheck");
 
-      const pkg = await this.utils.readPackageJson(root);
+      const pkg = await this.pm.readPackageJson(root);
       if (pkg.devDependencies?.vitest) {
         await run("alepha test");
       }
@@ -37,7 +39,7 @@ export class VerifyCommand {
         await run("alepha db check-migrations");
       }
 
-      const isExpo = await this.utils.hasExpo(root);
+      const isExpo = await this.pm.hasExpo(root);
       if (!isExpo) {
         await run("alepha build");
       }