zudojs-cli 0.1.2 → 1.1.0

package/dist/src/commands/build.command.d.ts

@@ -4,5 +4,13 @@
  * The `zudojs build` command for building Zudojs projects.
  */
 import type { CLIContext } from "../cliType/cliType.type.js";
+import type { PackageManager } from "../types/index.js";
 export declare function runBuildCommand(context: CLIContext): Promise<void>;
+/**
+ * Arguments that run the `build` script.
+ *
+ * pnpm's `-r` is only meaningful in a workspace; a single-package project's
+ * root `build` script is the whole build.
+ */
+export declare function getBuildArgs(packageManager: PackageManager, isWorkspace: boolean): string[];
 //# sourceMappingURL=build.command.d.ts.map

package/dist/src/commands/build.command.js

@@ -3,47 +3,47 @@
  *
  * The `zudojs build` command for building Zudojs projects.
  */
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { execCommand } from "../utils/utils.exec.js";
+import { runStreaming } from "../utils/utils.exec.js";
 import { findProjectRoot } from "../resolvers/project.resolver.js";
+import { detectPackageManager, resolveProjectLayout, } from "../resolvers/layout/projectLayout.core.js";
+import { CLIGenerationError, CLINotInProjectError } from "../errors/index.js";
 export async function runBuildCommand(context) {
     const projectRoot = findProjectRoot(context.cwd);
     if (!projectRoot) {
-        context.logger.error("No Zudojs project found. Run this command from a Zudojs project directory.");
-        return;
+        // Throwing (rather than returning) is what gives the process a non-zero
+        // exit code; CI must not see a green build for a missing project.
+        throw new CLINotInProjectError();
     }
     context.logger.info(`Building project at: ${projectRoot}`);
-    const packageManager = detectPackageManager(projectRoot);
-    const buildArgs = getBuildArgs(packageManager);
+    const layout = resolveProjectLayout(projectRoot);
+    const packageManager = layout?.packageManager ?? detectPackageManager(projectRoot);
+    const buildArgs = getBuildArgs(packageManager, layout?.isWorkspace ?? false);
     try {
-        await execCommand(packageManager, buildArgs, projectRoot);
+        await runStreaming(packageManager, buildArgs, projectRoot);
         context.logger.info("Build completed successfully.");
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        context.logger.error(`Build failed: ${message}`);
+        // A failed build must fail the command so CI does not report success.
+        throw new CLIGenerationError(`Build failed: ${message}`, error);
     }
 }
-function detectPackageManager(cwd) {
-    if (existsSync(join(cwd, "pnpm-lock.yaml")))
-        return "pnpm";
-    if (existsSync(join(cwd, "yarn.lock")))
-        return "yarn";
-    if (existsSync(join(cwd, "package-lock.json")))
-        return "npm";
-    if (existsSync(join(cwd, "bun.lockb")))
-        return "bun";
-    return "npm";
-}
-function getBuildArgs(packageManager) {
+/**
+ * Arguments that run the `build` script.
+ *
+ * pnpm's `-r` is only meaningful in a workspace; a single-package project's
+ * root `build` script is the whole build.
+ */
+export function getBuildArgs(packageManager, isWorkspace) {
     switch (packageManager) {
         case "pnpm":
-            return ["-r", "run", "build"];
+            return isWorkspace ? ["-r", "run", "build"] : ["run", "build"];
         case "yarn":
-            return ["workspaces", "run", "build"];
+            // Plain `yarn run build` works on both Yarn classic and Berry without
+            // requiring the workspace-tools plugin.
+            return ["run", "build"];
         case "bun":
-            return ["-r", "run", "build"];
+            return ["run", "build"];
         default:
             return ["run", "build"];
     }

package/dist/src/commands/create.command.js

@@ -15,17 +15,25 @@ import { InfrastructureGenerator } from "../generators/infrastructure/infrastruc
 import { BackendGenerator } from "../generators/backend/backend.generator.js";
 import { RollbackManager } from "../rollback/rollbackManager.core.js";
 import { promptProjectName, promptProjectType, promptConfirmation, } from "../prompts/project/index.js";
-import { promptBackendArchitecture, promptDatabase, promptApiStyle, } from "../prompts/backend/index.js";
+import { promptBackendArchitecture, promptDatabase, promptApiStyle, promptServices, } from "../prompts/backend/index.js";
 import { promptFramework, promptFrontendArchitecture, } from "../prompts/frontend/index.js";
 import { promptPackageManager } from "../prompts/workspace/index.js";
 import { promptCapabilities } from "../prompts/capabilities/index.js";
 import { CLIValidationError, CLIGenerationError } from "../errors/index.js";
-import { execCommand } from "../utils/utils.exec.js";
+import { execCommand, runStreaming } from "../utils/utils.exec.js";
 import { writeFileTree } from "../utils/utils.fileSystem.js";
-import { generateMonolithFiles } from "../templates/monolith/index.js";
-import { generateModularMonolithFiles } from "../templates/modular-monolith/index.js";
-import { generateMicroserviceFiles } from "../templates/microservice/index.js";
+import { resolveMicroserviceServices } from "../templates/microservice/index.js";
+import { ManifestManager } from "../manifest/manifestManager.core.js";
+import { CLI_VERSION } from "../constants/index.js";
 const VALID_PROJECT_TYPES = ["backend", "frontend", "fullstack"];
+const VALID_ARCHITECTURES = [
+    "monolith",
+    "modular-monolith",
+    "microservice",
+];
+const VALID_DATABASES = ["postgresql", "mysql", "sqlite", "mongodb"];
+const VALID_PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+const SERVICE_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 const VALID_FRONTENDS = [
     "none",
     "react",
@@ -59,8 +67,54 @@ function validateProjectName(name) {
         throw new CLIValidationError("Project name must contain only alphanumeric characters, hyphens, and underscores.");
     }
 }
+/**
+ * Returns whether the user typed a flag on the command line.
+ *
+ * All the shapes the parser accepts must be recognised here, otherwise an
+ * explicitly supplied flag is silently dropped and the interactive prompt
+ * offers its own default instead:
+ *
+ *   `--type backend`  `--type=backend`  `-t backend`  `-tbackend`  `-abt`
+ */
+/**
+ * Narrows a raw CLI string to one of a fixed set of choices.
+ *
+ * The returned value is typed as the union, which is what lets the
+ * non-interactive branch build ScaffoldOptions without `as any` casts. The
+ * cast below is guarded by the membership test immediately above it.
+ */
+function validateChoice(value, allowed, label) {
+    if (!allowed.includes(value)) {
+        throw new CLIValidationError(`Invalid ${label}: ${value}. Valid: ${allowed.join(", ")}`);
+    }
+    return value;
+}
 function hasExplicitFlag(args, long, short) {
-    return args.some((arg) => arg === long || (short !== undefined && arg === short));
+    const longName = long.startsWith("--") ? long.slice(2) : long;
+    const shortName = short !== undefined && short.startsWith("-") ? short.slice(1) : short;
+    for (const arg of args) {
+        if (arg === "--")
+            break;
+        if (arg.startsWith("--")) {
+            const body = arg.slice(2);
+            const separator = body.indexOf("=");
+            const name = separator >= 0 ? body.slice(0, separator) : body;
+            // `--no-install` negates the boolean `install`; both count as explicit.
+            if (name === longName || name === `no-${longName}`)
+                return true;
+            continue;
+        }
+        if (shortName === undefined)
+            continue;
+        if (arg.startsWith("-") && arg.length > 1) {
+            // Every short flag `create` defines takes a value, so it can only be
+            // the first character of the token: `-t backend` or `-tbackend`.
+            // Matching anywhere would treat the "t" in `-fnuxt` as `--type`.
+            if (arg[1] === shortName)
+                return true;
+        }
+    }
+    return false;
 }
 export async function runCreateCommand(context) {
     const projectName = context.values["project-name"];
@@ -76,34 +130,36 @@ export async function runCreateCommand(context) {
     const noInstall = context.values["no-install"] === true;
     const noGit = context.values["no-git"] === true;
     const servicesRaw = context.values.services;
-    const services = servicesRaw
+    const servicesExplicit = hasExplicitFlag(context.args, "--services");
+    const parsedServices = servicesRaw
         ? servicesRaw
             .split(",")
             .map((s) => s.trim())
             .filter(Boolean)
         : [];
+    // The --services option only applies to microservice architecture; ignore
+    // its parser-applied default for other architectures.
+    const services = servicesExplicit || architecture === "microservice" ? parsedServices : [];
     if (projectName) {
         validateProjectName(projectName);
     }
-    if (!VALID_PROJECT_TYPES.includes(projectType)) {
-        throw new CLIValidationError(`Invalid project type: ${projectType}. Valid: ${VALID_PROJECT_TYPES.join(", ")}`);
-    }
-    if (!VALID_FRONTENDS.includes(frontend)) {
-        throw new CLIValidationError(`Invalid frontend: ${frontend}. Valid: ${VALID_FRONTENDS.join(", ")}`);
-    }
-    if (!VALID_FRONTEND_ARCHITECTURES.includes(frontendArchitecture)) {
-        throw new CLIValidationError(`Invalid frontend architecture: ${frontendArchitecture}. Valid: ${VALID_FRONTEND_ARCHITECTURES.join(", ")}`);
-    }
-    if (!VALID_LANGUAGES.includes(language)) {
-        throw new CLIValidationError(`Invalid language: ${language}. Valid: ${VALID_LANGUAGES.join(", ")}`);
-    }
-    if (!VALID_APIS.includes(api)) {
-        throw new CLIValidationError(`Invalid API style: ${api}. Valid: ${VALID_APIS.join(", ")}`);
+    const projectTypeValue = validateChoice(projectType, VALID_PROJECT_TYPES, "project type");
+    const architectureValue = validateChoice(architecture, VALID_ARCHITECTURES, "architecture");
+    const databaseValue = validateChoice(database, VALID_DATABASES, "database");
+    const packageManagerValue = validateChoice(packageManager, VALID_PACKAGE_MANAGERS, "package manager");
+    const frontendValue = validateChoice(frontend, VALID_FRONTENDS, "frontend");
+    const frontendArchitectureValue = validateChoice(frontendArchitecture, VALID_FRONTEND_ARCHITECTURES, "frontend architecture");
+    const languageValue = validateChoice(language, VALID_LANGUAGES, "language");
+    const apiValue = validateChoice(api, VALID_APIS, "API style");
+    for (const service of services) {
+        if (!SERVICE_NAME_PATTERN.test(service)) {
+            throw new CLIValidationError(`Invalid service name: "${service}". Service names must contain only alphanumeric characters, hyphens, and underscores.`);
+        }
     }
-    const resolvedFrontend = projectType === "frontend" || projectType === "fullstack"
-        ? frontend === "none"
+    const resolvedFrontend = projectTypeValue === "frontend" || projectTypeValue === "fullstack"
+        ? frontendValue === "none"
             ? "react"
-            : frontend
+            : frontendValue
         : undefined;
     const explicitOverrides = {
         projectName,
@@ -126,7 +182,7 @@ export async function runCreateCommand(context) {
     if (hasExplicitFlag(context.args, "--frontend", "-f")) {
         explicitOverrides.frontend = resolvedFrontend;
     }
-    if (hasExplicitFlag(context.args, "--frontend-architecture", "-fa")) {
+    if (hasExplicitFlag(context.args, "--frontend-architecture", "-F")) {
         explicitOverrides.frontendArchitecture = frontendArchitecture;
     }
     if (hasExplicitFlag(context.args, "--language", "-l")) {
@@ -138,9 +194,17 @@ export async function runCreateCommand(context) {
         p.intro("Zudojs");
         const name = (await promptProjectName(projectName ?? undefined));
         const type = await promptProjectType(explicitOverrides.projectType);
-        const arch = type === "backend"
+        // `architecture` is a required ScaffoldOptions field and is written to
+        // the project manifest. For a frontend-only project no prompt runs, so
+        // without this default it was `undefined` and the generated manifest
+        // came out with no architecture at all, breaking `zudojs dev` and
+        // `zudojs generate` in the new project.
+        const arch = type === "backend" || type === "fullstack"
             ? await promptBackendArchitecture(explicitOverrides.architecture)
-            : explicitOverrides.architecture;
+            : (explicitOverrides.architecture ?? architectureValue);
+        const interactiveServices = arch === "microservice"
+            ? await promptServices(servicesExplicit ? services : undefined)
+            : services;
         const db = type === "backend" || type === "fullstack"
             ? await promptDatabase(explicitOverrides.database)
             : explicitOverrides.database;
@@ -179,7 +243,7 @@ export async function runCreateCommand(context) {
             frontendPath: "apps/web",
             language: (explicitOverrides.language ??
                 "typescript"),
-            services: [],
+            services: interactiveServices,
             enableCQRS,
             enableMessaging,
             enableObservability,
@@ -194,15 +258,17 @@ export async function runCreateCommand(context) {
     else {
         answers = {
             projectName: projectName ?? "",
-            projectType: projectType,
-            architecture: architecture,
-            packageManager: packageManager,
-            database: database,
-            api: api,
-            frontend: resolvedFrontend,
-            frontendArchitecture: frontendArchitecture,
+            projectType: projectTypeValue,
+            architecture: architectureValue,
+            packageManager: packageManagerValue,
+            database: databaseValue,
+            api: apiValue,
+            ...(resolvedFrontend !== undefined
+                ? { frontend: resolvedFrontend }
+                : {}),
+            frontendArchitecture: frontendArchitectureValue,
             frontendPath: "apps/web",
-            language: language,
+            language: languageValue,
             services,
             enableCQRS: true,
             enableMessaging: true,
@@ -210,7 +276,8 @@ export async function runCreateCommand(context) {
             enableOpenAPI: true,
             enableDatabase: true,
             enableQueue: false,
-            enableDocker: false,
+            // Match the interactive branch, which enables Docker for microservices.
+            enableDocker: architectureValue === "microservice",
             installDeps: !noInstall,
             initGit: !noGit,
         };
@@ -232,7 +299,6 @@ async function createProject(options, context) {
     try {
         spinner.start("Creating project structure");
         await mkdir(targetPath, { recursive: true });
-        rollback.trackDirectory(targetPath);
         spinner.stop("Project structure created");
         if (options.projectType === "fullstack" &&
             options.frontend &&
@@ -251,9 +317,9 @@ async function createProject(options, context) {
         else {
             spinner.start("Generating backend project");
             const result = await generateProject(options, targetPath);
-            context.logger.info(`Files created: ${result.filesCreated.length}`);
-            spinner.stop("Backend project generated");
+            spinner.stop(`Backend project generated (${result.filesCreated.length} files)`);
         }
+        await writeProjectManifest(options, targetPath);
         if (options.installDeps) {
             spinner.start("Installing dependencies");
             const installFile = packageManager === "pnpm"
@@ -264,11 +330,17 @@ async function createProject(options, context) {
                         ? "bun"
                         : "npm";
             try {
-                await execCommand(installFile, ["install"], targetPath);
-                spinner.stop("Dependencies installed");
+                // Streamed with no timeout: installs can be slow and their output
+                // should reach the user.
+                spinner.stop("Installing dependencies...");
+                await runStreaming(installFile, ["install"], targetPath);
+                p.log.success("Dependencies installed");
             }
-            catch {
-                spinner.stop("Dependencies installation skipped");
+            catch (error) {
+                // The project is complete without its node_modules; say what
+                // failed and how to retry instead of a bare "skipped".
+                const reason = error instanceof Error ? error.message : String(error);
+                p.log.warn(`Dependency installation failed: ${reason}\nRun "${installFile} install" inside ${projectName} to retry.`);
             }
         }
         if (options.initGit) {
@@ -298,6 +370,58 @@ async function createProject(options, context) {
         throw new CLIGenerationError(`Failed to create project "${projectName}"`, error);
     }
 }
+/**
+ * Writes the machine-managed .zudojs/manifest.json so follow-up commands
+ * (`zudojs dev`, `generate`, `add`) recognize the project immediately.
+ */
+async function writeProjectManifest(options, targetPath) {
+    const capabilities = [];
+    if (options.enableCQRS)
+        capabilities.push("cqrs");
+    if (options.enableMessaging)
+        capabilities.push("messaging");
+    if (options.enableObservability)
+        capabilities.push("observability");
+    if (options.enableOpenAPI)
+        capabilities.push("openapi");
+    if (options.enableDatabase)
+        capabilities.push("database");
+    if (options.enableQueue)
+        capabilities.push("queue");
+    // Record the services actually generated, not the raw request: the
+    // template drops reserved names (gateway) and duplicates, and substitutes
+    // its own defaults for an empty list.
+    const services = options.architecture === "microservice"
+        ? resolveMicroserviceServices(options.services)
+        : undefined;
+    const hasFrontend = options.frontend !== undefined && options.frontend !== "none";
+    const hasBackend = options.projectType !== "frontend";
+    await new ManifestManager(targetPath).create({
+        version: CLI_VERSION,
+        projectType: options.projectType ?? "backend",
+        architecture: options.architecture,
+        ...(hasBackend
+            ? {
+                backend: {
+                    architecture: options.architecture,
+                    api: options.api ?? "rest",
+                },
+            }
+            : {}),
+        ...(hasFrontend
+            ? {
+                frontend: {
+                    framework: options.frontend,
+                    architecture: options.frontendArchitecture ?? "zudojs-standard",
+                },
+            }
+            : {}),
+        ...(options.database ? { database: { provider: options.database } } : {}),
+        workspace: { packageManager: options.packageManager },
+        capabilities,
+        ...(services ? { services: [...services] } : {}),
+    });
+}
 async function generateFullstackProject(options, projectPath, rollback) {
     const composer = new FullstackComposer();
     const result = await composer.generate({
@@ -322,21 +446,17 @@ async function generateFullstackProject(options, projectPath, rollback) {
             features: options.services,
         },
         projectPath,
+        installDeps: options.installDeps,
     });
     if (!result.success) {
         throw new CLIGenerationError(`Fullstack generation failed:\n${result.errors.join("\n")}`);
     }
-    let backendFiles;
-    switch (options.architecture) {
-        case "modular-monolith":
-            backendFiles = generateModularMonolithFiles(options);
-            break;
-        case "microservice":
-            backendFiles = generateMicroserviceFiles(options);
-            break;
-        default:
-            backendFiles = generateMonolithFiles(options);
-    }
+    // Uses the same BackendGenerator the generator registry exposes rather
+    // than a third private copy of the architecture switch.
+    const backendFiles = await new BackendGenerator().generate(options, join(projectPath, "apps/api"));
+    // The backend template may carry its own workspace definition; nested in
+    // apps/api it would create a second workspace root, so strip it.
+    delete backendFiles["pnpm-workspace.yaml"];
     await writeFileTree(join(projectPath, "apps/api"), backendFiles);
     rollback.trackDirectory(join(projectPath, "apps/api"));
     const integrationGenerator = new IntegrationGenerator();
@@ -396,6 +516,7 @@ async function generateFrontendProject(options, projectPath) {
         architecture: options.frontendArchitecture ?? "zudojs-standard",
         language: options.language ?? "typescript",
         packageManager: options.packageManager,
+        installDeps: options.installDeps,
     });
     if (!result.success) {
         throw new CLIGenerationError(`Frontend generation failed:\n${result.errors.join("\n")}`);

package/dist/src/commands/dev.command.d.ts

@@ -1,9 +1,37 @@
 /**
  * zudojs-cli — Dev Command
  *
- * The `zudojs dev` command.
- * Starts development servers based on project configuration.
+ * The `zudojs dev` command. Starts the development servers of the project
+ * in the current directory.
+ *
+ * Servers are started through the project's package manager (`pnpm run
+ * dev`, `npm run dev`, …) rather than by spawning `tsx` or `ng` directly:
+ * those binaries are devDependencies of the generated project and are not
+ * on the user's PATH, so the direct spawn failed with ENOENT for everyone
+ * who had not installed them globally. Running the script also means the
+ * project's own `dev` script is what runs — `tsx watch src` used to be
+ * hard-coded here, which watched `src/index.ts`, a file that only exports
+ * `createApp` and never starts the server.
  */
 import type { CLIContext } from "../cliType/cliType.type.js";
+import { type ProjectLayout } from "../resolvers/layout/projectLayout.core.js";
+/** One development server to start. */
+export interface DevServerSpec {
+    readonly label: string;
+    readonly cwd: string;
+    readonly file: string;
+    readonly args: readonly string[];
+    readonly env?: NodeJS.ProcessEnv;
+}
+/**
+ * Computes the servers `zudojs dev` starts for a project layout.
+ *
+ * Exported so the selection can be tested without spawning anything.
+ */
+export declare function planDevServers(layout: ProjectLayout, options?: {
+    readonly frontendOnly?: boolean;
+    readonly backendOnly?: boolean;
+    readonly port?: number;
+}): DevServerSpec[];
 export declare function runDevCommand(context: CLIContext): Promise<void>;
 //# sourceMappingURL=dev.command.d.ts.map