alepha 0.15.0 → 0.15.2

package/src/cli/commands/init.ts

@@ -1,6 +1,6 @@
 import { $inject, t } from "alepha";
 import { $command } from "alepha/command";
-import { FileSystemProvider } from "alepha/file";
+import { FileSystemProvider } from "alepha/system";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 import { PackageManagerUtils } from "../services/PackageManagerUtils.ts";
 import { ProjectScaffolder } from "../services/ProjectScaffolder.ts";
@@ -29,107 +29,150 @@ export class InitCommand {
       agent: t.optional(
         t.boolean({
           aliases: ["a"],
-          description: "Add CLAUDE.md for Claude Code AI assistant",
+          description:
+            "Add AI agent instructions (CLAUDE.md if claude CLI installed, else AGENTS.md)",
         }),
       ),
-      // 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
-      web: t.optional(
+      pm: t.optional(
+        t.enum(["yarn", "npm", "pnpm", "bun"], {
+          description: "Package manager to use",
+        }),
+      ),
+      // choose which modules to scaffold
+      api: t.optional(
+        t.boolean({
+          description: "Include API module structure (src/api/)",
+        }),
+      ),
+      react: t.optional(
         t.boolean({
           aliases: ["r"],
-          description: "Include Alepha React dependencies",
+          description: "Include React dependencies and web module (src/web/)",
         }),
       ),
-      admin: t.optional(
-        t.boolean({ description: "Include Alepha UI dependencies" }),
+      ui: t.optional(
+        t.boolean({
+          description:
+            "Include @alepha/ui (components, auth portal, admin portal)",
+        }),
       ),
       test: t.optional(
         t.boolean({ description: "Include Vitest and create test directory" }),
       ),
+      force: t.optional(
+        t.boolean({
+          aliases: ["f"],
+          description: "Override existing files",
+        }),
+      ),
     }),
     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);
       }
 
+      if (flags.ui) {
+        flags.react = true;
+      }
+
+      // Detect workspace context (are we inside packages/ or apps/ of a monorepo?)
+      const workspace = await this.pm.getWorkspaceContext(root);
+
+      // Detect agent type: claude CLI → CLAUDE.md, else → AGENTS.md
+      let agentType: "claude" | "agents" | false = false;
+      if (flags.agent) {
+        const hasClaudeCli = await this.utils.isInstalledAsync("claude");
+        agentType = hasClaudeCli ? "claude" : "agents";
+      }
+
       const isExpo = await this.pm.hasExpo(root);
 
+      const force = !!flags.force;
+
       await run({
         name: "ensuring configuration files",
         handler: async () => {
           await this.scaffolder.ensureConfig(root, {
-            tsconfigJson: true,
-            packageJson: flags,
-            biomeJson: true,
-            editorconfig: true,
-            indexHtml: !!flags.web && !isExpo,
-            claudeMd: flags.agent
-              ? { react: !!flags.web, ui: !!flags.admin }
+            force,
+            tsconfigJson: !workspace.config.tsconfigJson,
+            packageJson: { ...flags, isPackage: workspace.isPackage },
+            // Skip workspace-level configs if they exist at workspace root
+            biomeJson: !workspace.config.biomeJson,
+            editorconfig: !workspace.config.editorconfig,
+            agentMd: agentType
+              ? { type: agentType, react: !!flags.react, ui: !!flags.ui }
               : false,
           });
 
-          // Create API project structure if not React
-          if (!flags.web) {
-            await this.scaffolder.ensureApiProject(root);
+          // Create project structure based on flags
+          await this.scaffolder.ensureMainServerTs(root, {
+            api: !!flags.api,
+            react: !!flags.react && !isExpo,
+            force,
+          });
+          if (flags.api) {
+            await this.scaffolder.ensureApiProject(root, { force });
+          }
+          if (flags.react && !isExpo) {
+            await this.scaffolder.ensureWebProject(root, {
+              api: !!flags.api,
+              ui: !!flags.ui,
+              force,
+            });
           }
         },
       });
 
-      // TODO: check if all alepha dependencies are same version
+      // Use workspace PM if detected, otherwise detect from current root
+      const pmName = await this.pm.getPackageManager(
+        workspace.workspaceRoot ?? root,
+        flags.pm ?? workspace.packageManager ?? undefined,
+      );
 
-      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.pm.ensureNpm(root);
+      // Only setup PM files if not in a workspace package
+      if (!workspace.isPackage) {
+        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.pm.ensureNpm(root);
+        }
       }
 
+      // Run install from workspace root if in a package, otherwise from current root
+      const installRoot = workspace.workspaceRoot ?? root;
       await run(`${pmName} install`, {
         alias: `installing dependencies with ${pmName}`,
-        root,
-      });
-
-      if (!isExpo) {
-        await this.pm.ensureDependency(root, "vite", {
-          run,
-          exec: (cmd, opts) => this.utils.exec(cmd, opts),
-        });
-      }
-
-      await this.pm.ensureDependency(root, "@biomejs/biome", {
-        run,
-        exec: (cmd, opts) => this.utils.exec(cmd, opts),
+        root: installRoot,
       });
 
-      // Install vitest and create test directory if --test flag is set
+      // Create test directory if --test flag is set (vitest is in package.json)
       if (flags.test) {
         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,
+        root: installRoot,
       });
+
+      // Initialize git repository if not in a workspace package
+      if (!workspace.isPackage) {
+        const gitInitialized = await this.scaffolder.ensureGitRepo(root, {
+          force,
+        });
+        if (gitInitialized) {
+          await run("git add .", {
+            alias: "staging generated files",
+            root,
+          });
+        }
+      }
     },
   });
 }

package/src/cli/commands/lint.ts

@@ -13,11 +13,17 @@ export class LintCommand {
     name: "lint",
     description: "Run linter across the codebase using Biome",
     handler: async ({ root }) => {
-      await this.scaffolder.ensureConfig(root, { biomeJson: true });
+      await this.scaffolder.ensureConfig(root, {
+        biomeJson: true,
+        checkWorkspace: true,
+      });
+
       await this.pm.ensureDependency(root, "@biomejs/biome", {
+        checkWorkspace: true,
         exec: (cmd, opts) => this.utils.exec(cmd, opts),
       });
-      await this.utils.exec("biome check --formatter-enabled=false --fix");
+
+      await this.utils.exec("biome check --fix");
     },
   });
 }

package/src/cli/commands/typecheck.ts

@@ -3,11 +3,13 @@ import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 import { PackageManagerUtils } from "../services/PackageManagerUtils.ts";
+import { ProjectScaffolder } from "../services/ProjectScaffolder.ts";
 
 export class TypecheckCommand {
   protected readonly utils = $inject(AlephaCliUtils);
   protected readonly pm = $inject(PackageManagerUtils);
   protected readonly log = $logger();
+  protected readonly scaffolder = $inject(ProjectScaffolder);
 
   /**
    * Run TypeScript type checking across the codebase with no emit.
@@ -18,10 +20,19 @@ export class TypecheckCommand {
     description: "Check TypeScript types across the codebase",
     handler: async ({ root }) => {
       this.log.info("Starting TypeScript type checking...");
+
+      await this.scaffolder.ensureConfig(root, {
+        tsconfigJson: true,
+        checkWorkspace: true,
+      });
+
       await this.pm.ensureDependency(root, "typescript", {
+        checkWorkspace: true,
         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/defineConfig.ts

@@ -1,8 +1,13 @@
 import type { Alepha } from "alepha";
 import type { CommandPrimitive } from "alepha/command";
+import {
+  type AppEntryOptions,
+  appEntryOptions,
+} from "./atoms/appEntryOptions.ts";
 import { type BuildOptions, buildOptions } from "./atoms/buildOptions.ts";
 
 export interface AlephaCliConfig {
+  entry?: AppEntryOptions;
   /**
    * Add custom commands to the Alepha CLI.
    *
@@ -54,6 +59,10 @@ export const defineConfig = (
       alepha.set(buildOptions, config.build);
     }
 
+    if (config.entry) {
+      alepha.set(appEntryOptions, config.entry);
+    }
+
     return {
       ...config.commands,
     };

package/src/cli/index.ts

@@ -1,12 +1,12 @@
 export * from "./apps/AlephaCli.ts";
 export * from "./apps/AlephaPackageBuilderCli.ts";
+export { default as AlephaPackageBuilderCli } from "./apps/AlephaPackageBuilderCli.ts";
 export * from "./atoms/changelogOptions.ts";
 export * from "./commands/build.ts";
 export * from "./commands/clean.ts";
 export * from "./commands/db.ts";
 export * from "./commands/deploy.ts";
 export * from "./commands/dev.ts";
-export * from "./commands/format.ts";
 export * from "./commands/gen/changelog.ts";
 export * from "./commands/gen/openapi.ts";
 export * from "./commands/init.ts";
@@ -16,6 +16,7 @@ export * from "./commands/test.ts";
 export * from "./commands/typecheck.ts";
 export * from "./commands/verify.ts";
 export * from "./defineConfig.ts";
+export * from "./providers/AppEntryProvider.ts";
 export * from "./services/AlephaCliUtils.ts";
 export * from "./services/GitMessageParser.ts";
 export * from "./version.ts";

package/src/cli/providers/AppEntryProvider.ts

@@ -0,0 +1,131 @@
+import { $inject, $use, AlephaError } from "alepha";
+import { FileSystemProvider } from "alepha/system";
+import { appEntryOptions } from "../atoms/appEntryOptions.ts";
+
+/**
+ * Service for locating entry files in Alepha projects.
+ *
+ * Originally in alepha/vite, moved to CLI to avoid cli -> vite dependency.
+ */
+export class AppEntryProvider {
+  protected readonly fs = $inject(FileSystemProvider);
+  protected readonly options = $use(appEntryOptions);
+
+  protected readonly serverEntries = [
+    "main.server.ts",
+    "main.server.tsx",
+    "main.ts",
+    "main.tsx",
+  ] as const;
+
+  protected readonly browserEntries = [
+    "main.browser.ts",
+    "main.browser.tsx",
+    "main.ts",
+    "main.tsx",
+  ] as const;
+
+  protected readonly styleEntries = [
+    "main.css",
+    "styles.css",
+    "style.css",
+  ] as const;
+
+  /**
+   * Get application entry points.
+   *
+   * Server entry is required, an error is thrown if not found.
+   * Browser entry is optional.
+   *
+   * It will first check for custom entries in options, see appEntryOptions.
+   */
+  public async getAppEntry(root: string): Promise<AppEntry> {
+    const appEntry: AppEntry = {
+      root,
+      server: "",
+    };
+
+    if (this.options.server) {
+      const serverExists = await this.fs.exists(
+        this.fs.join(root, this.options.server),
+      );
+      if (!serverExists) {
+        throw new AlephaError(
+          `Custom server entry "${this.options.server}" not found.`,
+        );
+      }
+      appEntry.server = this.options.server;
+    }
+
+    if (this.options.browser) {
+      const browserExists = await this.fs.exists(
+        this.fs.join(root, this.options.browser),
+      );
+      if (!browserExists) {
+        throw new AlephaError(
+          `Custom browser entry "${this.options.browser}" not found.`,
+        );
+      }
+      appEntry.browser = this.options.browser;
+    }
+
+    if (this.options.style) {
+      const styleExists = await this.fs.exists(
+        this.fs.join(root, this.options.style),
+      );
+      if (!styleExists) {
+        throw new AlephaError(
+          `Custom style entry "${this.options.style}" not found.`,
+        );
+      }
+      appEntry.style = this.options.style;
+    }
+
+    const srcFiles = await this.fs.ls(this.fs.join(root, "src"));
+
+    if (!appEntry.server) {
+      // find in conventional locations
+      for (const entry of this.serverEntries) {
+        if (srcFiles.includes(entry)) {
+          appEntry.server = this.fs.join("src", entry);
+          break;
+        }
+      }
+    }
+
+    if (!appEntry.server) {
+      throw new AlephaError(
+        "No server entry found. Please, add a main.server.ts file in the src/ directory or configure a custom entry in alepha.config.ts.",
+      );
+    }
+
+    if (!appEntry.browser) {
+      // find in conventional locations
+      for (const entry of this.browserEntries) {
+        if (srcFiles.includes(entry)) {
+          appEntry.browser = this.fs.join("src", entry);
+          break;
+        }
+      }
+    }
+
+    if (!appEntry.style) {
+      // find in conventional locations
+      for (const entry of this.styleEntries) {
+        if (srcFiles.includes(entry)) {
+          appEntry.style = this.fs.join("src", entry);
+          break;
+        }
+      }
+    }
+
+    return appEntry;
+  }
+}
+
+export interface AppEntry {
+  root: string;
+  server: string;
+  browser?: string;
+  style?: string;
+}

package/src/cli/providers/ViteBuildProvider.ts

@@ -0,0 +1,40 @@
+import { $inject, type Alepha, AlephaError } from "alepha";
+import { ViteUtils } from "../services/ViteUtils.ts";
+import type { AppEntry } from "./AppEntryProvider.ts";
+
+export class ViteBuildProvider {
+  protected alepha?: Alepha;
+  protected appEntry?: AppEntry;
+  protected readonly viteUtils = $inject(ViteUtils);
+
+  public async init(opts: { entry: AppEntry }) {
+    const alepha = await this.viteUtils.runAlepha({
+      entry: opts.entry,
+      mode: "production",
+    });
+
+    this.alepha = alepha;
+    this.appEntry = opts.entry;
+
+    return alepha;
+  }
+
+  public hasClient(): boolean {
+    if (!this.alepha) {
+      throw new AlephaError("ViteBuildProvider not initialized");
+    }
+    try {
+      this.alepha.inject("ReactServerProvider");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  public generateIndexHtml(): string {
+    if (!this.appEntry) {
+      throw new AlephaError("ViteBuildProvider not initialized");
+    }
+    return this.viteUtils.generateIndexHtml(this.appEntry);
+  }
+}