zudojs-cli 0.1.1 → 1.0.0

package/dist/src/cliConstant/cliVersion.js

@@ -0,0 +1,57 @@
+/**
+ * zudojs-cli — Version resolution
+ *
+ * The CLI's own version, read from its `package.json` at runtime.
+ *
+ * It used to be a hand-maintained string literal duplicated in two places
+ * (`constants/index.ts` and `cliConstant.value.ts`). Both are stamped into the
+ * manifest of every generated project, so a release that bumped `package.json`
+ * without editing both copies would silently scaffold projects claiming the
+ * previous version. Reading the manifest removes the duplication entirely.
+ *
+ * @module cliConstant/cliVersion
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Package name to match, so a parent workspace manifest is never picked up. */
+const PACKAGE_NAME = "zudojs-cli";
+/** Directory levels to walk upward before giving up. */
+const MAX_LOOKUP_DEPTH = 8;
+/**
+ * Walks upward from this module looking for the CLI's own `package.json`.
+ *
+ * The compiled layout (`dist/src/cliConstant/`) sits one level deeper than the
+ * source layout (`src/cliConstant/`), so a fixed relative path would be correct
+ * in only one of them. Matching on `name` also means a parent workspace
+ * manifest cannot be mistaken for ours.
+ *
+ * @returns The version string declared in the CLI's `package.json`.
+ * @throws {Error} If the manifest cannot be located or has no string version.
+ */
+function readOwnVersion() {
+    let directory = dirname(fileURLToPath(import.meta.url));
+    for (let depth = 0; depth < MAX_LOOKUP_DEPTH; depth += 1) {
+        const manifestPath = join(directory, "package.json");
+        if (existsSync(manifestPath)) {
+            const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+            if (typeof parsed === "object" && parsed !== null) {
+                const { name, version } = parsed;
+                if (name === PACKAGE_NAME &&
+                    typeof version === "string" &&
+                    version.length > 0) {
+                    return version;
+                }
+            }
+        }
+        const parent = dirname(directory);
+        if (parent === directory) {
+            break;
+        }
+        directory = parent;
+    }
+    throw new Error(`${PACKAGE_NAME}: could not resolve its own package.json to read the version.`);
+}
+/** The CLI's version, matching its `package.json`. */
+export const CLI_VERSION = readOwnVersion();
+//# sourceMappingURL=cliVersion.js.map

package/dist/src/cliParser/cliParser.core.js

@@ -57,6 +57,13 @@ export class CLIParser {
             positional.push(token);
             index++;
         }
+        // Apply documented option defaults for options not provided on the CLI.
+        for (const definition of definitions) {
+            if (definition.defaultValue !== undefined &&
+                !(definition.name in options)) {
+                options[definition.name] = definition.defaultValue;
+            }
+        }
         const parsedArguments = this.parseArguments(positional, argumentsDefinitions);
         if (!this.allowUnknownCommands &&
             !command &&

package/dist/src/cliParser/cliParser.shortOption.js

@@ -5,7 +5,7 @@
  */
 import { CLI_OPTION_PREFIXES } from "../cliConstant/cliConstant.value.js";
 import { InvalidOptionError, MissingOptionValueError, } from "../cliError/cliError.option.js";
-import { findOption, assignOptionValue } from "./cliParser.longOption.js";
+import { assignOptionValue } from "./cliParser.longOption.js";
 /** Parses a short option token from the token stream. */
 export function parseShortOption(tokens, index, definitions, values, allowUnknownOptions) {
     const token = tokens[index];

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

@@ -3,11 +3,12 @@
  *
  * The `zudojs add` command for adding feature packages.
  */
-import { join, dirname } from "node:path";
+import { join } from "node:path";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { execCommand } from "../utils/utils.exec.js";
+import { runStreaming } from "../utils/utils.exec.js";
 import { CLIValidationError, CLIGenerationError } from "../errors/index.js";
 import { ManifestManager } from "../manifest/manifestManager.core.js";
+import { ZUDOJS_PACKAGES_VERSION } from "../constants/index.js";
 const FEATURE_PACKAGES = {
     database: ["@zudojs/database"],
     queue: ["@zudojs/queue"],
@@ -32,9 +33,9 @@ export async function runAddCommand(context) {
     context.logger.info(`Adding feature: ${feature}`);
     context.logger.info(`Packages: ${packages.join(", ")}`);
     try {
-        const { manager, rootPkg, isWorkspace } = detectPackageManager();
+        const { manager, rootPkg, isWorkspace } = detectPackageManager(context.cwd);
         const pkgPath = join(context.cwd, rootPkg);
-        const version = isWorkspace ? "workspace:*" : readZudojsVersion();
+        const version = isWorkspace ? "workspace:*" : ZUDOJS_PACKAGES_VERSION;
         if (!existsSync(pkgPath)) {
             throw new CLIGenerationError(`Could not find package.json at ${pkgPath}`);
         }
@@ -64,7 +65,7 @@ export async function runAddCommand(context) {
         }
         if (context.values["skip-install"] !== true) {
             context.logger.info(`Installing dependencies with ${manager}...`);
-            await execCommand(manager, ["install"], context.cwd);
+            await runStreaming(manager, ["install"], context.cwd);
         }
         context.logger.info(`Feature "${feature}" added successfully.`);
         context.logger.info(`Next steps:`);
@@ -79,30 +80,32 @@ export async function runAddCommand(context) {
         throw new CLIGenerationError(`Failed to add feature: ${feature}: ${message}`, error);
     }
 }
-function detectPackageManager() {
-    if (existsSync("pnpm-workspace.yaml")) {
-        return { manager: "pnpm", rootPkg: "package.json", isWorkspace: true };
-    }
-    if (existsSync("yarn.lock")) {
-        return { manager: "yarn", rootPkg: "package.json", isWorkspace: true };
-    }
-    if (existsSync("lerna.json")) {
-        return { manager: "npm", rootPkg: "package.json", isWorkspace: true };
-    }
-    return { manager: "npm", rootPkg: "package.json", isWorkspace: false };
-}
-function readZudojsVersion() {
+function detectPackageManager(cwd) {
+    // A project is a workspace only when a workspace definition exists:
+    // pnpm-workspace.yaml or a "workspaces" field in package.json. Lock files
+    // merely indicate the package manager.
+    const hasPnpmWorkspace = existsSync(join(cwd, "pnpm-workspace.yaml"));
+    let hasWorkspacesField = false;
     try {
-        const rootPkg = join(process.cwd(), "package.json");
-        if (existsSync(rootPkg)) {
-            const pkg = JSON.parse(readFileSync(rootPkg, "utf-8"));
-            return pkg.version ?? "latest";
+        const pkgPath = join(cwd, "package.json");
+        if (existsSync(pkgPath)) {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            hasWorkspacesField = pkg.workspaces !== undefined;
         }
     }
     catch {
-        // ignore
+        // ignore malformed package.json
     }
-    return "latest";
+    const isWorkspace = hasPnpmWorkspace || hasWorkspacesField;
+    const manager = hasPnpmWorkspace || existsSync(join(cwd, "pnpm-lock.yaml"))
+        ? "pnpm"
+        : existsSync(join(cwd, "yarn.lock"))
+            ? "yarn"
+            : existsSync(join(cwd, "bun.lock")) ||
+                existsSync(join(cwd, "bun.lockb"))
+                ? "bun"
+                : "npm";
+    return { manager, rootPkg: "package.json", isWorkspace };
 }
 function updateZudojsConfig(cwd, feature) {
     const configPath = join(cwd, "zudojs.config.ts");

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

@@ -5,24 +5,28 @@
  */
 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 { 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);
     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) {
@@ -32,7 +36,7 @@ function detectPackageManager(cwd) {
         return "yarn";
     if (existsSync(join(cwd, "package-lock.json")))
         return "npm";
-    if (existsSync(join(cwd, "bun.lockb")))
+    if (existsSync(join(cwd, "bun.lock")) || existsSync(join(cwd, "bun.lockb")))
         return "bun";
     return "npm";
 }
@@ -41,9 +45,11 @@ function getBuildArgs(packageManager) {
         case "pnpm":
             return ["-r", "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

@@ -13,20 +13,27 @@ import { FullstackComposer } from "../generators/fullstack/fullstackComposer.cor
 import { IntegrationGenerator } from "../generators/integration/integrationGenerator.core.js";
 import { InfrastructureGenerator } from "../generators/infrastructure/infrastructure.generator.js";
 import { BackendGenerator } from "../generators/backend/backend.generator.js";
-import { ManifestManager } from "../manifest/manifestManager.core.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",
@@ -60,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"];
@@ -77,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,
@@ -127,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")) {
@@ -139,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;
@@ -180,7 +243,7 @@ export async function runCreateCommand(context) {
             frontendPath: "apps/web",
             language: (explicitOverrides.language ??
                 "typescript"),
-            services: [],
+            services: interactiveServices,
             enableCQRS,
             enableMessaging,
             enableObservability,
@@ -195,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,
@@ -211,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,
         };
@@ -255,37 +321,7 @@ async function createProject(options, context) {
             context.logger.info(`Files created: ${result.filesCreated.length}`);
             spinner.stop("Backend project generated");
         }
-        spinner.start("Creating manifest");
-        const manifest = new ManifestManager(targetPath);
-        await manifest.create({
-            version: "1",
-            architecture: options.architecture,
-            backend: {
-                architecture: options.architecture,
-                api: options.api ?? "rest",
-            },
-            frontend: options.frontend && options.frontend !== "none"
-                ? {
-                    framework: options.frontend,
-                    architecture: options.frontendArchitecture ?? "zudojs-standard",
-                }
-                : undefined,
-            database: {
-                provider: options.database ?? "postgresql",
-            },
-            workspace: {
-                packageManager: options.packageManager,
-            },
-            capabilities: [
-                options.enableCQRS && "cqrs",
-                options.enableMessaging && "messaging",
-                options.enableObservability && "observability",
-                options.enableOpenAPI && "openapi",
-                options.enableDatabase && "database",
-                options.enableQueue && "queue",
-            ].filter(Boolean),
-        });
-        spinner.stop("Manifest created");
+        await writeProjectManifest(options, targetPath);
         if (options.installDeps) {
             spinner.start("Installing dependencies");
             const installFile = packageManager === "pnpm"
@@ -296,11 +332,14 @@ 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");
+                p.log.warn("Dependency installation skipped");
             }
         }
         if (options.initGit) {
@@ -313,7 +352,14 @@ async function createProject(options, context) {
                 spinner.stop("Git initialization skipped");
             }
         }
-        p.note(`cd ${projectName}\n${packageManager === "pnpm" ? "pnpm" : packageManager === "yarn" ? "yarn" : packageManager === "bun" ? "bun" : "npm"} dev`, "Next steps");
+        const devCmd = packageManager === "npm"
+            ? "npm run dev"
+            : packageManager === "yarn"
+                ? "yarn dev"
+                : packageManager === "bun"
+                    ? "bun run dev"
+                    : "pnpm run dev";
+        p.note(`cd ${projectName}\n${devCmd}`, "Next steps");
         p.outro("Project created successfully.");
     }
     catch (error) {
@@ -323,6 +369,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({
@@ -351,17 +449,12 @@ async function generateFullstackProject(options, projectPath, rollback) {
     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();