zudojs-cli 0.1.2 → 1.1.0

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

@@ -2,10 +2,9 @@
  * zudojs-cli — Generate Command
  *
  * The `zudojs generate` (alias: `g`) command.
- * Reads zudojs.config.ts to determine project architecture.
+ * Reads the project manifest to determine the architecture and where the
+ * backend lives, then places the schematic accordingly.
  */
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
 import { generateService } from "../generators/service/service.generator.js";
 import { generateModule } from "../generators/module/module.generator.js";
 import { generateCommand } from "../generators/command/command.generator.js";
@@ -19,8 +18,9 @@ import { generateRoute } from "../generators/route/route.generator.js";
 import { generateModel } from "../generators/model/model.generator.js";
 import { generateDto } from "../generators/dto/dto.generator.js";
 import { generateValidator } from "../generators/validator/validator.generator.js";
-import { ManifestManager } from "../manifest/manifestManager.core.js";
 import { CLIGenerationError, CLIValidationError } from "../errors/index.js";
+import { assertGeneratableName, assertSafePathSegment, } from "../utils/utils.name.js";
+import { resolveProjectLayout } from "../resolvers/layout/projectLayout.core.js";
 const VALID_SCHEMATICS = [
     "service",
     "module",
@@ -36,7 +36,28 @@ const VALID_SCHEMATICS = [
     "dto",
     "validator",
 ];
-function getBasePath(architecture, schematic) {
+/**
+ * Resolves the directory a schematic is generated into.
+ *
+ * `moduleName` comes from `--module`, which was previously accepted,
+ * documented and then never read by any schematic. It is validated as a
+ * single safe path segment by the caller before it reaches here.
+ */
+function getBasePath(architecture, schematic, moduleName, serviceName) {
+    const root = getArchitectureRoot(architecture, schematic, serviceName);
+    if (moduleName !== undefined && schematic !== "module") {
+        return `${root}/modules/${moduleName}`;
+    }
+    return root;
+}
+/**
+ * Resolves the directory a schematic is generated into for an architecture.
+ *
+ * The microservice layout produced by `zudojs create` is
+ * `apps/gateway/src` plus `apps/services/<name>/src`; the previous
+ * `apps/default` root matched no directory the scaffolder ever writes.
+ */
+function getArchitectureRoot(architecture, schematic, serviceName) {
     switch (architecture) {
         case "modular-monolith":
             if (schematic === "module") {
@@ -45,9 +66,14 @@ function getBasePath(architecture, schematic) {
             return "src";
         case "microservice":
             if (schematic === "service") {
-                return "apps";
+                // A new service is a new app in the workspace.
+                return "apps/services";
             }
-            return "apps/default";
+            // `--service <name>` selects which app the schematic belongs to.
+            // Without it the gateway app — the one app always generated — is used.
+            return serviceName !== undefined
+                ? `apps/services/${serviceName}/src`
+                : "apps/gateway/src";
         case "monolith":
         default:
             if (schematic === "module") {
@@ -56,19 +82,20 @@ function getBasePath(architecture, schematic) {
             return "src";
     }
 }
-function readZudojsArchitecture(cwd) {
-    const configPath = join(cwd, "zudojs.config.ts");
-    if (!existsSync(configPath)) {
-        const configPathJs = join(cwd, "zudojs.config.js");
-        if (!existsSync(configPathJs))
-            return null;
-        const content = readFileSync(configPathJs, "utf-8");
-        const match = content.match(/architecture:\s*["'](\w[\w-]*)["']/);
-        return match?.[1] ?? null;
-    }
-    const content = readFileSync(configPath, "utf-8");
-    const match = content.match(/architecture:\s*["'](\w[\w-]*)["']/);
-    return match?.[1] ?? null;
+/**
+ * Prefix under which backend schematics are generated.
+ *
+ * A fullstack project keeps its backend in `apps/api`; generating into the
+ * workspace root's `src/` produced files no app compiled. Microservice apps
+ * are addressed inside getArchitectureRoot, relative to that prefix.
+ */
+function backendPrefix(cwd) {
+    const layout = resolveProjectLayout(cwd);
+    const [first] = layout?.backendDirs ?? [];
+    if (layout?.projectType === "fullstack" && first !== undefined && first !== cwd) {
+        return "apps/api/";
+    }
+    return "";
 }
 export async function runGenerateCommand(context) {
     const schematic = context.values.schematic;
@@ -83,14 +110,26 @@ export async function runGenerateCommand(context) {
     if (!name) {
         throw new CLIValidationError("Resource name is required.");
     }
+    // Reject names that normalize to nothing (`zudojs generate event "..."`
+    // wrote src/events/.event.ts with an anonymous export), and reject option
+    // values that are interpolated verbatim into a generated path. `--service ..`
+    // used to place files outside the schematic's base directory.
+    assertGeneratableName(name, "resource name");
+    if (service !== undefined) {
+        assertSafePathSegment(service, "--service");
+    }
+    if (moduleName !== undefined) {
+        assertSafePathSegment(moduleName, "--module");
+    }
     const cwd = context.cwd;
-    const architecture = readZudojsArchitecture(cwd);
-    const manifest = await new ManifestManager(cwd).read();
-    if (architecture) {
-        context.logger.info(`Detected architecture: ${architecture}`);
+    const layout = resolveProjectLayout(cwd);
+    const architecture = layout?.architecture ?? null;
+    if (layout) {
+        context.logger.info(`Detected architecture: ${layout.architecture}`);
     }
     else {
-        context.logger.warn("No zudojs.config.ts found. Run `zudojs create` first to scaffold a Zudojs project.");
+        context.logger.warn("No Zudojs project detected (no .zudojs/manifest.json, zudojs.config.ts " +
+            "or `zudojs` field in package.json). Run `zudojs create` first.");
     }
     if (architecture === "microservice" && schematic === "service") {
         context.logger.warn('In microservice architecture, prefer "zudojs generate module" — services are top-level apps.');
@@ -104,42 +143,53 @@ export async function runGenerateCommand(context) {
         dryRun,
         architecture: architecture ?? undefined,
     }, cwd);
-    context.logger.info(`Generated ${result.length} files:`);
+    if (dryRun) {
+        context.logger.info(`Dry run: ${result.length} files would be generated (nothing written):`);
+    }
+    else {
+        context.logger.info(`Generated ${result.length} files:`);
+    }
     for (const file of result) {
         context.logger.info(`  - ${file}`);
     }
 }
 async function runSchematic(schematic, name, options, cwd) {
     try {
-        const basePath = getBasePath(options.architecture, schematic);
-        const moduleName = options.module ?? name;
+        const basePath = backendPrefix(cwd) +
+            getBasePath(options.architecture, schematic, options.module, options.service);
+        const dryRun = options.dryRun;
+        // In the microservice layout `--service` selected the owning app and is
+        // already part of basePath, so it must not nest the schematic again.
+        const cqrsService = options.architecture === "microservice"
+            ? undefined
+            : (options.service ?? "default");
         switch (schematic) {
             case "service":
-                return await generateService({ name, basePath }, cwd);
+                return await generateService({ name, basePath, dryRun }, cwd);
             case "module":
-                return await generateModule({ name, feature: true, basePath }, cwd);
+                return await generateModule({ name, feature: true, basePath, dryRun }, cwd);
             case "command":
-                return await generateCommand({ name, service: options.service ?? "default", basePath }, cwd);
+                return await generateCommand({ name, ...(cqrsService ? { service: cqrsService } : {}), basePath, dryRun }, cwd);
             case "query":
-                return await generateQuery({ name, service: options.service ?? "default", basePath }, cwd);
+                return await generateQuery({ name, ...(cqrsService ? { service: cqrsService } : {}), basePath, dryRun }, cwd);
             case "controller":
-                return await generateController({ name, basePath }, cwd);
+                return await generateController({ name, basePath, dryRun }, cwd);
             case "repository":
-                return await generateRepository({ name, basePath }, cwd);
+                return await generateRepository({ name, basePath, dryRun }, cwd);
             case "middleware":
-                return await generateMiddleware({ name, basePath }, cwd);
+                return await generateMiddleware({ name, basePath, dryRun }, cwd);
             case "event":
-                return await generateEvent({ name, basePath }, cwd);
+                return await generateEvent({ name, basePath, dryRun }, cwd);
             case "job":
-                return await generateJob({ name, basePath }, cwd);
+                return await generateJob({ name, basePath, dryRun }, cwd);
             case "route":
-                return await generateRoute({ name, basePath }, cwd);
+                return await generateRoute({ name, basePath, dryRun }, cwd);
             case "model":
-                return await generateModel({ name, basePath }, cwd);
+                return await generateModel({ name, basePath, dryRun }, cwd);
             case "dto":
-                return await generateDto({ name, basePath }, cwd);
+                return await generateDto({ name, basePath, dryRun }, cwd);
             case "validator":
-                return await generateValidator({ name, basePath }, cwd);
+                return await generateValidator({ name, basePath, dryRun }, cwd);
             default:
                 throw new CLIValidationError(`Unknown schematic: "${schematic}". Available: ${VALID_SCHEMATICS.join(", ")}.`);
         }

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

@@ -3,42 +3,73 @@
  *
  * The `zudojs info` command.
  */
-import { readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
+import { readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { CLI_VERSION } from "../constants/index.js";
+import { checkForNewerVersion } from "../cliVersion/cliVersion.update.js";
+import { resolveProjectLayout } from "../resolvers/layout/projectLayout.core.js";
 export async function runInfoCommand(context) {
-    const pkgPath = join(context.cwd, "package.json");
+    context.logger.info("Zudojs CLI");
+    context.logger.info(`  Version: ${CLI_VERSION}`);
+    context.logger.info(`  Node.js: ${process.version}`);
+    const update = await checkForNewerVersion(CLI_VERSION, { env: context.env });
+    if (update.latest) {
+        context.logger.info(`  Update available: ${update.latest} (npm install -g zudojs-cli@latest)`);
+    }
+    context.logger.info("");
+    const layout = resolveProjectLayout(context.cwd);
+    if (!layout) {
+        context.logger.info("Not in a Zudojs project directory.");
+        context.logger.info("Run `zudojs create <project-name>` to create a new project.");
+        return;
+    }
     let projectName = "unknown";
+    let projectVersion = "0.0.0";
     try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        projectName = pkg.name ?? "unknown";
-        const zudojsDeps = Object.entries(pkg.dependencies ?? {})
-            .filter(([name]) => name.startsWith("@zudojs/"))
-            .sort(([a], [b]) => a.localeCompare(b));
-        context.logger.info("Zudojs Project Info");
-        context.logger.info("");
-        context.logger.info(`Project: ${projectName}`);
-        context.logger.info(`Version: ${pkg.version ?? "0.0.0"}`);
-        const hasPnpm = existsSync(join(context.cwd, "pnpm-lock.yaml"));
-        const hasYarn = existsSync(join(context.cwd, "yarn.lock"));
-        const packageManager = hasPnpm ? "pnpm" : hasYarn ? "yarn" : "npm";
-        context.logger.info(`Package Manager: ${packageManager}`);
-        context.logger.info("");
-        context.logger.info("Zudojs Dependencies:");
-        if (zudojsDeps.length === 0) {
-            context.logger.info("  (none)");
-        }
-        else {
-            for (const [name, version] of zudojsDeps) {
-                context.logger.info(`  ${name}: ${version}`);
+        const pkg = JSON.parse(readFileSync(join(layout.root, "package.json"), "utf-8"));
+        projectName = pkg.name ?? projectName;
+        projectVersion = pkg.version ?? projectVersion;
+    }
+    catch {
+        // A project without a root package.json still has a manifest.
+    }
+    context.logger.info("Project");
+    context.logger.info(`  Name: ${projectName}`);
+    context.logger.info(`  Version: ${projectVersion}`);
+    context.logger.info(`  Type: ${layout.projectType}`);
+    if (layout.backendDirs.length > 0) {
+        context.logger.info(`  Architecture: ${layout.architecture}`);
+    }
+    if (layout.frontendFramework) {
+        context.logger.info(`  Frontend: ${layout.frontendFramework}`);
+    }
+    context.logger.info(`  Package manager: ${layout.packageManager}`);
+    if (layout.services.length > 0) {
+        context.logger.info(`  Services: ${layout.services.join(", ")}`);
+    }
+    context.logger.info("");
+    context.logger.info("Zudojs dependencies");
+    const deps = new Map();
+    for (const dir of layout.backendDirs) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
+            for (const [name, version] of Object.entries(pkg.dependencies ?? {})) {
+                if (name.startsWith("@zudojs/")) {
+                    const where = relative(layout.root, dir);
+                    deps.set(where === "" ? name : `${name} (${where})`, version);
+                }
             }
         }
+        catch {
+            // Reported by `zudojs doctor`.
+        }
     }
-    catch {
-        context.logger.info("Zudojs CLI Info");
-        context.logger.info("");
-        context.logger.info("Not in a Zudojs project directory.");
-        context.logger.info("");
-        context.logger.info("Run `zudojs create <project-name>` to create a new project.");
+    if (deps.size === 0) {
+        context.logger.info("  (none)");
+        return;
+    }
+    for (const [name, version] of [...deps.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+        context.logger.info(`  ${name}: ${version}`);
     }
 }
 //# sourceMappingURL=info.command.js.map

package/dist/src/constants/index.d.ts

@@ -3,7 +3,25 @@
  *
  * Constants used by the CLI scaffolding system.
  */
-export declare const CLI_VERSION: "0.1.0";
+export { CLI_VERSION } from "../cliConstant/cliVersion.js";
+/**
+ * Version range every generated project depends on for `@zudojs/*` packages.
+ *
+ * This is a caret range, not an exact pin, on purpose. The framework
+ * packages are released independently, so at any moment their latest
+ * versions differ (`@zudojs/openapi` went to 1.1.0 while the rest stayed at
+ * 1.0.0). An exact `1.0.0` pin made `pnpm install` in every freshly created
+ * project abort with `ERR_PNPM_NO_MATCHING_VERSION` for the package that had
+ * moved on. A range resolves each package to its newest compatible release.
+ */
+export declare const ZUDOJS_PACKAGES_VERSION: "^1.0.0";
+/**
+ * Packages installed by `zudojs add <feature>`.
+ *
+ * Also used by `zudojs doctor` to verify that every feature recorded in a
+ * project is backed by its package.
+ */
+export declare const FEATURE_PACKAGES: Readonly<Record<string, readonly string[]>>;
 export declare const ARCHITECTURE_CHOICES: readonly [{
     readonly value: "monolith";
     readonly label: "Monolith";

package/dist/src/constants/index.js

@@ -3,7 +3,38 @@
  *
  * Constants used by the CLI scaffolding system.
  */
-export const CLI_VERSION = "0.1.0";
+export { CLI_VERSION } from "../cliConstant/cliVersion.js";
+/**
+ * Version range every generated project depends on for `@zudojs/*` packages.
+ *
+ * This is a caret range, not an exact pin, on purpose. The framework
+ * packages are released independently, so at any moment their latest
+ * versions differ (`@zudojs/openapi` went to 1.1.0 while the rest stayed at
+ * 1.0.0). An exact `1.0.0` pin made `pnpm install` in every freshly created
+ * project abort with `ERR_PNPM_NO_MATCHING_VERSION` for the package that had
+ * moved on. A range resolves each package to its newest compatible release.
+ */
+export const ZUDOJS_PACKAGES_VERSION = "^1.0.0";
+/**
+ * Packages installed by `zudojs add <feature>`.
+ *
+ * Also used by `zudojs doctor` to verify that every feature recorded in a
+ * project is backed by its package.
+ */
+export const FEATURE_PACKAGES = {
+    database: ["@zudojs/database"],
+    queue: ["@zudojs/queue"],
+    messaging: ["@zudojs/messaging"],
+    openapi: ["@zudojs/openapi"],
+    observability: ["@zudojs/observability"],
+    security: ["@zudojs/security"],
+    cache: ["@zudojs/cache"],
+    storage: ["@zudojs/storage"],
+    // Used to install @zudojs/queue; the scheduler package exists and is the
+    // one the feature name promises.
+    scheduler: ["@zudojs/scheduler"],
+    docs: ["@zudojs/docs"],
+};
 export const ARCHITECTURE_CHOICES = [
     { value: "monolith", label: "Monolith" },
     { value: "modular-monolith", label: "Modular Monolith" },

package/dist/src/generators/command/command.generator.d.ts

@@ -7,6 +7,7 @@ export interface GenerateCommandOptions {
     readonly name: string;
     readonly service?: string;
     readonly basePath?: string;
+    readonly dryRun?: boolean;
 }
 export declare function generateCommand(options: GenerateCommandOptions, cwd: string): Promise<string[]>;
 //# sourceMappingURL=command.generator.d.ts.map

package/dist/src/generators/command/command.generator.js

@@ -4,16 +4,19 @@
  * Generates a CQRS command with handler.
  */
 import { writeFileTree } from "../../utils/utils.fileSystem.js";
-import { CLIGenerationError, CLIValidationError } from "../../errors/index.js";
+import { CLIGenerationError } from "../../errors/index.js";
 import { normalizeName } from "../../utils/utils.name.js";
 export async function generateCommand(options, cwd) {
     const name = normalizeName(options.name);
     const nameCamel = name
         .replace(/-([a-z])/g, (_m, c) => c.toUpperCase())
         .replace(/^./, (c) => c.toUpperCase());
-    const service = options.service ?? "default";
+    const service = options.service;
     const basePath = options.basePath ?? "services";
-    const servicePath = `${basePath}/${service}`;
+    // When no service grouping is given the schematic is written directly under
+    // basePath. Callers that resolved the owning app into basePath (the
+    // microservice layout) pass no service, so the path is not nested twice.
+    const servicePath = service ? `${basePath}/${service}` : basePath;
     const files = {
         [`${servicePath}/commands/${name}/${name}.command.ts`]: `import type { BaseCommand } from "@zudojs/cqrs";
 
@@ -48,12 +51,15 @@ export class ${nameCamel}CommandHandler implements CommandHandler<${nameCamel}Co
 export { ${nameCamel}CommandHandler } from "./${name}.handler.js";
 `,
     };
+    if (options.dryRun) {
+        return Object.keys(files);
+    }
     try {
         await writeFileTree(cwd, files);
         return Object.keys(files);
     }
     catch (error) {
-        throw new CLIGenerationError(`Failed to generate command: ${name} for service: ${service}`, error);
+        throw new CLIGenerationError(`Failed to generate command: ${name} in ${servicePath}`, error);
     }
 }
 //# sourceMappingURL=command.generator.js.map

package/dist/src/generators/controller/controller.generator.d.ts

@@ -5,6 +5,7 @@ export interface GenerateControllerOptions {
     readonly name: string;
     readonly service?: string;
     readonly basePath?: string;
+    readonly dryRun?: boolean;
 }
 export declare function generateController(options: GenerateControllerOptions, cwd: string): Promise<string[]>;
 //# sourceMappingURL=controller.generator.d.ts.map

package/dist/src/generators/controller/controller.generator.js

@@ -1,17 +1,17 @@
 /**
  * zudojs-cli — Controller Generator
  */
-import { writeFileTree } from "../../utils/utils.fileSystem.js";
-import { CLIGenerationError, CLIValidationError } from "../../errors/index.js";
-import { normalizeName } from "../../utils/utils.name.js";
+import { writeFileTree, mergeBarrelExport, } from "../../utils/utils.fileSystem.js";
+import { CLIGenerationError } from "../../errors/index.js";
+import { normalizeName, toPascalCase } from "../../utils/utils.name.js";
 export async function generateController(options, cwd) {
     const name = normalizeName(options.name);
-    const nameCamel = name
-        .replace(/-([a-z])/g, (_m, c) => c.toUpperCase())
-        .replace(/^./, (c) => c.toUpperCase());
+    const nameCamel = toPascalCase(options.name);
     const basePath = options.basePath ?? "";
+    const prefix = basePath ? `${basePath}/` : "";
+    const indexPath = `${prefix}controllers/index.ts`;
     const files = {
-        [`${basePath ? `${basePath}/` : ""}controllers/${name}.controller.ts`]: `import { createLogger } from "@zudojs/logger";
+        [`${prefix}controllers/${name}.controller.ts`]: `import { createLogger } from "@zudojs/logger";
 
 export class ${nameCamel}Controller {
   private readonly logger = createLogger({ name: "${name}-controller" });
@@ -30,9 +30,12 @@ export class ${nameCamel}Controller {
   }
 }
 `,
-        [`${basePath ? `${basePath}/` : ""}controllers/index.ts`]: `export { ${nameCamel}Controller } from "./${name}.controller.js";
-`,
+        // Merge with any existing barrel content instead of overwriting it.
+        [indexPath]: mergeBarrelExport(cwd, indexPath, `export { ${nameCamel}Controller } from "./${name}.controller.js";`),
     };
+    if (options.dryRun) {
+        return Object.keys(files);
+    }
     try {
         await writeFileTree(cwd, files);
         return Object.keys(files);

package/dist/src/generators/dto/dto.generator.d.ts

@@ -6,6 +6,7 @@
 export interface GenerateDtoOptions {
     readonly name: string;
     readonly basePath: string;
+    readonly dryRun?: boolean;
 }
 export declare function generateDto(options: GenerateDtoOptions, cwd: string): Promise<string[]>;
 //# sourceMappingURL=dto.generator.d.ts.map

package/dist/src/generators/dto/dto.generator.js

@@ -4,17 +4,23 @@
  * Generates DTO files.
  */
 import { writeFileTree } from "../../utils/utils.fileSystem.js";
+import { normalizeName, toPascalCase } from "../../utils/utils.name.js";
 export async function generateDto(options, cwd) {
+    const name = normalizeName(options.name);
+    const namePascal = toPascalCase(options.name);
     const files = {
-        [`${options.basePath}/dtos/${options.name}.dto.ts`]: `/**
- * ${options.name} DTO.
+        [`${options.basePath}/dtos/${name}.dto.ts`]: `/**
+ * ${name} DTO.
  */
 
-export interface Create${options.name}Dto {
+export interface Create${namePascal}Dto {
   readonly name: string;
 }
 `,
     };
+    if (options.dryRun) {
+        return Object.keys(files);
+    }
     await writeFileTree(cwd, files);
     return Object.keys(files);
 }

package/dist/src/generators/event/event.generator.d.ts

@@ -6,6 +6,7 @@
 export interface GenerateEventOptions {
     readonly name: string;
     readonly basePath: string;
+    readonly dryRun?: boolean;
 }
 export declare function generateEvent(options: GenerateEventOptions, cwd: string): Promise<string[]>;
 //# sourceMappingURL=event.generator.d.ts.map

package/dist/src/generators/event/event.generator.js

@@ -4,18 +4,24 @@
  * Generates event files.
  */
 import { writeFileTree } from "../../utils/utils.fileSystem.js";
+import { normalizeName, toPascalCase } from "../../utils/utils.name.js";
 export async function generateEvent(options, cwd) {
+    const name = normalizeName(options.name);
+    const namePascal = toPascalCase(options.name);
     const files = {
-        [`${options.basePath}/events/${options.name}.event.ts`]: `/**
- * ${options.name} event.
+        [`${options.basePath}/events/${name}.event.ts`]: `/**
+ * ${name} event.
  */
 
-export interface ${options.name}Event {
-  readonly type: "${options.name}";
+export interface ${namePascal}Event {
+  readonly type: "${name}";
   readonly timestamp: Date;
 }
 `,
     };
+    if (options.dryRun) {
+        return Object.keys(files);
+    }
     await writeFileTree(cwd, files);
     return Object.keys(files);
 }

package/dist/src/generators/frontend/frontendGenerator.core.d.ts

@@ -14,6 +14,8 @@ export interface FrontendGenerationOptions {
     readonly architecture?: "zudojs-standard" | "feature-based" | "minimal" | "framework-default";
     readonly language?: "typescript" | "javascript";
     readonly packageManager?: "pnpm" | "npm" | "yarn" | "bun";
+    /** `false` records dependencies in package.json instead of installing. */
+    readonly installDeps?: boolean;
 }
 /**
  * Frontend generation result.

package/dist/src/generators/frontend/frontendGenerator.core.js

@@ -7,6 +7,9 @@ import { FrontendAdapterRegistry } from "../../registries/adapter/frontendAdapte
 import { PackageManagerRegistry } from "../../registries/adapter/packageManagerRegistry.core.js";
 import { DependencyResolver } from "../../resolvers/dependency/dependencyResolver.core.js";
 import { CLIGenerationError } from "../../errors/index.js";
+import { runFrontendPipeline } from "./frontendPipeline.js";
+import { writeFileTree } from "../../utils/utils.fileSystem.js";
+import { renderPnpmWorkspaceFile } from "../../templates/shared/pnpm.template.js";
 /**
  * Generates frontend projects using framework adapters.
  */
@@ -39,38 +42,22 @@ export class FrontendGenerator {
                 linting: true,
                 formatting: true,
             },
+            ...(options.installDeps === false ? { skipInstall: true } : {}),
         };
         const files = [];
         const errors = [];
         try {
-            // 1. Scaffold using official tool
-            await adapter.scaffold(context);
-            files.push("scaffold");
-            // 2. Apply Zudojs structure
-            await adapter.applyZudojsStructure(context);
-            files.push("structure");
-            // 3. Resolve and install dependencies
-            const deps = adapter.getDependencies(context);
-            const resolution = this.dependencyResolver.resolve(deps);
-            if (resolution.conflicts.length > 0) {
-                for (const conflict of resolution.conflicts) {
-                    errors.push(`Conflict: ${conflict.reason}`);
-                }
-                return { success: false, framework: options.framework, files, errors };
-            }
-            // 4. Install dependencies
-            const pmName = options.packageManager ?? "pnpm";
-            const packageManager = this.packageManagerRegistry.get(pmName);
-            if (packageManager) {
-                const devDeps = resolution.devDependencies.map((d) => d.name);
-                await packageManager.addDev(options.projectPath, devDeps);
-                files.push("dependencies");
-            }
-            // 5. Validate
-            const validation = await adapter.validate(context);
-            if (!validation.valid) {
-                errors.push(...validation.errors);
+            // A frontend-only project is its own pnpm root. Vite depends on
+            // esbuild, whose install script pnpm 10+ refuses without this list,
+            // and the pipeline installs dependencies right after scaffolding.
+            if (context.packageManager === "pnpm") {
+                await writeFileTree(context.projectPath, {
+                    "pnpm-workspace.yaml": renderPnpmWorkspaceFile(),
+                });
             }
+            const outcome = await runFrontendPipeline(adapter, context, this.packageManagerRegistry, this.dependencyResolver);
+            files.push(...outcome.files);
+            errors.push(...outcome.errors);
         }
         catch (error) {
             errors.push(error instanceof Error ? error.message : String(error));