zudojs-cli 1.0.0 → 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";
@@ -21,6 +20,7 @@ import { generateDto } from "../generators/dto/dto.generator.js";
 import { generateValidator } from "../generators/validator/validator.generator.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",
@@ -82,41 +82,20 @@ function getArchitectureRoot(architecture, schematic, serviceName) {
             return "src";
     }
 }
-function readZudojsArchitecture(cwd) {
-    for (const configFile of ["zudojs.config.ts", "zudojs.config.js"]) {
-        const configPath = join(cwd, configFile);
-        if (existsSync(configPath)) {
-            const content = readFileSync(configPath, "utf-8");
-            const match = content.match(/architecture:\s*["'](\w[\w-]*)["']/);
-            if (match?.[1])
-                return match[1];
-        }
-    }
-    // Fall back to the machine-managed manifest written by `zudojs create`.
-    const manifestPath = join(cwd, ".zudojs", "manifest.json");
-    if (existsSync(manifestPath)) {
-        try {
-            const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
-            if (manifest.architecture)
-                return manifest.architecture;
-        }
-        catch {
-            // ignore malformed manifest
-        }
-    }
-    // Fall back to the zudojs field in package.json.
-    const pkgPath = join(cwd, "package.json");
-    if (existsSync(pkgPath)) {
-        try {
-            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-            if (pkg.zudojs?.architecture)
-                return pkg.zudojs.architecture;
-        }
-        catch {
-            // ignore malformed package.json
-        }
+/**
+ * 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 null;
+    return "";
 }
 export async function runGenerateCommand(context) {
     const schematic = context.values.schematic;
@@ -143,12 +122,13 @@ export async function runGenerateCommand(context) {
         assertSafePathSegment(moduleName, "--module");
     }
     const cwd = context.cwd;
-    const architecture = readZudojsArchitecture(cwd);
-    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 project detected (no zudojs.config.ts, .zudojs/manifest.json " +
+        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") {
@@ -175,7 +155,8 @@ export async function runGenerateCommand(context) {
 }
 async function runSchematic(schematic, name, options, cwd) {
     try {
-        const basePath = getBasePath(options.architecture, schematic, options.module, options.service);
+        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.

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

@@ -4,8 +4,24 @@
  * Constants used by the CLI scaffolding system.
  */
 export { CLI_VERSION } from "../cliConstant/cliVersion.js";
-/** Published version of all @zudojs/* framework packages. */
-export declare const ZUDOJS_PACKAGES_VERSION: "1.0.0";
+/**
+ * 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

@@ -4,8 +4,37 @@
  * Constants used by the CLI scaffolding system.
  */
 export { CLI_VERSION } from "../cliConstant/cliVersion.js";
-/** Published version of all @zudojs/* framework packages. */
-export const ZUDOJS_PACKAGES_VERSION = "1.0.0";
+/**
+ * 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/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

@@ -8,6 +8,8 @@ import { PackageManagerRegistry } from "../../registries/adapter/packageManagerR
 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.
  */
@@ -40,10 +42,19 @@ export class FrontendGenerator {
                 linting: true,
                 formatting: true,
             },
+            ...(options.installDeps === false ? { skipInstall: true } : {}),
         };
         const files = [];
         const errors = [];
         try {
+            // 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);

package/dist/src/generators/frontend/frontendPipeline.js

@@ -10,6 +10,9 @@
  *
  * @module generators/frontend/pipeline
  */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileTree } from "../../utils/utils.fileSystem.js";
 /**
  * Rejects package names a package manager would read as a flag.
  *
@@ -65,9 +68,14 @@ export async function runFrontendPipeline(adapter, context, packageManagerRegist
     }
     // 5. Install BOTH runtime and dev dependencies. Only devDependencies used
     //    to be installed, so every runtime package an adapter declared was
-    //    resolved and then dropped on the floor.
+    //    resolved and then dropped on the floor. With `--no-install` the
+    //    dependencies are written to package.json for a later install.
     const packageManager = packageManagerRegistry.get(context.packageManager);
-    if (packageManager) {
+    if (context.skipInstall === true) {
+        await recordDependencies(context.projectPath, resolution.dependencies, resolution.devDependencies);
+        files.push("dependencies");
+    }
+    else if (packageManager) {
         const deps = resolution.dependencies.map((d) => d.name);
         const devDeps = resolution.devDependencies.map((d) => d.name);
         assertSafePackageNames(deps);
@@ -90,4 +98,39 @@ export async function runFrontendPipeline(adapter, context, packageManagerRegist
     }
     return { files, errors };
 }
+/**
+ * Adds the resolved dependencies to the project's package.json without
+ * running a package manager. Existing entries win: the adapter's own
+ * template may already pin a version.
+ */
+async function recordDependencies(projectPath, dependencies, devDependencies) {
+    const pkgPath = join(projectPath, "package.json");
+    let pkg = {};
+    if (existsSync(pkgPath)) {
+        try {
+            pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        }
+        catch {
+            pkg = {};
+        }
+    }
+    const merge = (target, entries) => {
+        const merged = { ...(target ?? {}) };
+        for (const entry of entries) {
+            if (!(entry.name in merged)) {
+                merged[entry.name] = entry.version || "latest";
+            }
+        }
+        return merged;
+    };
+    if (dependencies.length > 0) {
+        pkg.dependencies = merge(pkg.dependencies, dependencies);
+    }
+    if (devDependencies.length > 0) {
+        pkg.devDependencies = merge(pkg.devDependencies, devDependencies);
+    }
+    await writeFileTree(projectPath, {
+        "package.json": JSON.stringify(pkg, null, 2) + "\n",
+    });
+}
 //# sourceMappingURL=frontendPipeline.js.map

package/dist/src/generators/fullstack/fullstackComposer.core.d.ts

@@ -12,6 +12,8 @@ import type { ProjectConfiguration } from "../../types/projectConfiguration.type
 export interface FullstackGenerationContext {
     readonly project: ProjectConfiguration;
     readonly projectPath: string;
+    /** `false` records frontend dependencies instead of installing them. */
+    readonly installDeps?: boolean;
 }
 /**
  * Fullstack generation result.

package/dist/src/generators/fullstack/fullstackComposer.core.js

@@ -12,6 +12,7 @@ import { PackageManagerRegistry } from "../../registries/adapter/packageManagerR
 import { DependencyResolver } from "../../resolvers/dependency/dependencyResolver.core.js";
 import { runFrontendPipeline } from "../frontend/frontendPipeline.js";
 import { writeFileTree } from "../../utils/utils.fileSystem.js";
+import { renderPnpmWorkspaceFile } from "../../templates/shared/pnpm.template.js";
 /**
  * Composes fullstack projects by orchestrating multiple generators.
  */
@@ -33,7 +34,7 @@ export class FullstackComposer {
         try {
             // 1. Create workspace structure
             await this.createWorkspace(context);
-            files.push("package.json", "zudojs.config.ts");
+            files.push("package.json");
             if (this.getPackageManager(context) === "pnpm") {
                 files.push("pnpm-workspace.yaml");
             }
@@ -90,31 +91,15 @@ export class FullstackComposer {
                 typescript: "^5.0.0",
             },
         };
-        // Project and framework names reach this template from user input. They
-        // are emitted as JSON string literals (valid JS) so a quote, backslash,
-        // newline or `";` sequence cannot break out of the literal and inject
-        // code into the generated zudojs.config.ts.
-        const literal = (value) => JSON.stringify(value);
-        const frontendBlock = context.project.frontend
-            ? `
-  frontend: {
-    framework: ${literal(context.project.frontend.framework)},
-  },`
-            : "";
-        const zudojsConfig = `export default {
-  name: ${literal(context.project.name)},
-  projectType: "fullstack",
-  architecture: ${literal(context.project.backend?.architecture ?? "monolith")},${frontendBlock}
-};
-`;
+        // The project's type, architecture and frontend are recorded in
+        // .zudojs/manifest.json by the create command; no zudojs.config.ts is
+        // written. The name reaches package.json through JSON.stringify, so a
+        // quote or newline in it stays data.
         const files = {
             "package.json": JSON.stringify(rootPackageJson, null, 2) + "\n",
-            "zudojs.config.ts": zudojsConfig,
         };
         if (packageManager === "pnpm") {
-            files["pnpm-workspace.yaml"] = `packages:
-${workspaceGlobs.map((g) => `  - "${g}"`).join("\n")}
-`;
+            files["pnpm-workspace.yaml"] = renderPnpmWorkspaceFile(workspaceGlobs);
         }
         await writeFileTree(context.projectPath, files);
     }
@@ -172,6 +157,7 @@ export type Timestamp = string;
                 formatting: true,
                 envValidation: true,
             },
+            ...(context.installDeps === false ? { skipInstall: true } : {}),
         };
         // The same pipeline the frontend-only path uses: availability check,
         // scaffold, structure, integration, dependency resolution + install, and

package/dist/src/index.d.ts

@@ -23,8 +23,8 @@ export { CLI_NAME, CLI_DEFAULTS, CLI_COMMANDS, CLI_ALIASES, CLI_OPTION_PREFIXES,
 export { CLIError, isCLIError, normalizeCLIError, getCLIExitCode, getCLIErrorCode, type CLIErrorOptions, CommandNotFoundError, DuplicateCommandError, InvalidCommandNameError, InvalidArgumentsError, MissingArgumentError, InvalidOptionError, InvalidOptionNameError, MissingOptionValueError, DuplicateOptionError, CLIExecutionError, CLIPermissionError, CLIInterruptedError, CLIConfigurationError, } from "./cliError/index.js";
 export { CLICommandRegistry, CLICommandBuilder, createCommand, command, executeCommand, validateCommand, isCLICommand, sortCommands, } from "./cliCommand/index.js";
 export { CLIParser, type CLIParserOptions, parseCLIArguments, parseOptionValue, parseBoolean, isOption, isLongOption, isShortOption, resolveCommand, normalizeCLIValue, } from "./cliParser/index.js";
-export { ZudojsCLI, createCLI, createCLIWriter, registerCLIInterruptHandler, } from "./cliApplication/index.js";
-export { getCLIVersion, formatCLIVersion, getVersionString, isValidVersion, compareVersions, parseVersion, isCompatibleVersion, type CLIVersionInfo, } from "./cliVersion/index.js";
+export { ZudojsCLI, createCLI, createCLIWriter, createCLILogger, formatCLILogLine, registerCLIInterruptHandler, type CLILoggerOptions, } from "./cliApplication/index.js";
+export { getCLIVersion, formatCLIVersion, getVersionString, isValidVersion, compareVersions, parseVersion, isCompatibleVersion, checkForNewerVersion, isUpdateCheckDisabled, type CLIVersionInfo, type UpdateCheckOptions, type UpdateCheckResult, } from "./cliVersion/index.js";
 export type { FrontendAdapter, FrontendGenerationContext, FrontendFeatures, DependencyRequirement, ValidationResult, } from "./adapters/frontend/index.js";
 export { ReactAdapter, NextAdapter, VueAdapter, NuxtAdapter, AngularAdapter, SvelteAdapter, SvelteKitAdapter, AstroAdapter, VanillaAdapter, FlutterAdapter, ReactNativeAdapter, } from "./adapters/frontend/index.js";
 export { PnpmAdapter, NpmAdapter, YarnAdapter, BunAdapter, } from "./adapters/package-managers/index.js";
@@ -34,6 +34,7 @@ export { detectArchitecture } from "./resolvers/index.js";
 export { resolveProjectPath, findProjectRoot, } from "./resolvers/project.resolver.js";
 export { CapabilityResolver, type CapabilityDependency, type CapabilityResolutionResult, } from "./resolvers/capability/index.js";
 export { ConfigurationResolver, type ResolvedConfiguration, } from "./resolvers/configuration/index.js";
+export { resolveProjectLayout, detectPackageManager, type ProjectLayout, type ProjectLayoutType, type ProjectLayoutSource, } from "./resolvers/layout/index.js";
 export { EnvironmentValidator, type EnvironmentCheck, type EnvironmentValidationResult, } from "./validators/index.js";
 export { ProjectValidator, type ProjectCheck, type ProjectValidationResult, } from "./validators/index.js";
 export { CompatibilityValidator, type CompatibilityCheck, type CompatibilityResult, } from "./validators/compatibility/index.js";

package/dist/src/index.js

@@ -27,9 +27,9 @@ export { CLICommandRegistry, CLICommandBuilder, createCommand, command, executeC
 // Parser
 export { CLIParser, parseCLIArguments, parseOptionValue, parseBoolean, isOption, isLongOption, isShortOption, resolveCommand, normalizeCLIValue, } from "./cliParser/index.js";
 // Application
-export { ZudojsCLI, createCLI, createCLIWriter, registerCLIInterruptHandler, } from "./cliApplication/index.js";
+export { ZudojsCLI, createCLI, createCLIWriter, createCLILogger, formatCLILogLine, registerCLIInterruptHandler, } from "./cliApplication/index.js";
 // Version
-export { getCLIVersion, formatCLIVersion, getVersionString, isValidVersion, compareVersions, parseVersion, isCompatibleVersion, } from "./cliVersion/index.js";
+export { getCLIVersion, formatCLIVersion, getVersionString, isValidVersion, compareVersions, parseVersion, isCompatibleVersion, checkForNewerVersion, isUpdateCheckDisabled, } from "./cliVersion/index.js";
 export { ReactAdapter, NextAdapter, VueAdapter, NuxtAdapter, AngularAdapter, SvelteAdapter, SvelteKitAdapter, AstroAdapter, VanillaAdapter, FlutterAdapter, ReactNativeAdapter, } from "./adapters/frontend/index.js";
 export { PnpmAdapter, NpmAdapter, YarnAdapter, BunAdapter, } from "./adapters/package-managers/index.js";
 export { PostgresAdapter, MySqlAdapter, SqliteAdapter, } from "./adapters/databases/index.js";
@@ -39,6 +39,7 @@ export { detectArchitecture } from "./resolvers/index.js";
 export { resolveProjectPath, findProjectRoot, } from "./resolvers/project.resolver.js";
 export { CapabilityResolver, } from "./resolvers/capability/index.js";
 export { ConfigurationResolver, } from "./resolvers/configuration/index.js";
+export { resolveProjectLayout, detectPackageManager, } from "./resolvers/layout/index.js";
 // Validators
 export { EnvironmentValidator, } from "./validators/index.js";
 export { ProjectValidator, } from "./validators/index.js";

package/dist/src/installers/dependency.installer.d.ts

@@ -1,5 +1,14 @@
 import type { PackageManager } from "../types/index.js";
 export declare function getInstallCommand(packageManager: PackageManager): [string, ...string[]];
 export declare function getAddCommand(packageManager: PackageManager, pkg: string): [string, ...string[]];
+/**
+ * The command that runs a `package.json` script with the given manager.
+ *
+ * Generated projects declare their dev/build tooling (`tsx`, `vite`, `ng`)
+ * as devDependencies, so the binaries live in `node_modules/.bin` and are
+ * not on the user's PATH. Running the script through the package manager is
+ * what puts them there.
+ */
+export declare function getRunScriptCommand(packageManager: PackageManager, script: string): [string, ...string[]];
 export declare function installDependencies(packageManager: PackageManager, cwd: string): Promise<void>;
 //# sourceMappingURL=dependency.installer.d.ts.map

package/dist/src/installers/dependency.installer.js

@@ -27,6 +27,27 @@ export function getAddCommand(packageManager, pkg) {
             return ["pnpm", "add", pkg];
     }
 }
+/**
+ * The command that runs a `package.json` script with the given manager.
+ *
+ * Generated projects declare their dev/build tooling (`tsx`, `vite`, `ng`)
+ * as devDependencies, so the binaries live in `node_modules/.bin` and are
+ * not on the user's PATH. Running the script through the package manager is
+ * what puts them there.
+ */
+export function getRunScriptCommand(packageManager, script) {
+    switch (packageManager) {
+        case "npm":
+            return ["npm", "run", script];
+        case "yarn":
+            return ["yarn", "run", script];
+        case "bun":
+            return ["bun", "run", script];
+        case "pnpm":
+        default:
+            return ["pnpm", "run", script];
+    }
+}
 export async function installDependencies(packageManager, cwd) {
     const [file, ...args] = getInstallCommand(packageManager);
     await runStreaming(file, args, cwd);

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

@@ -1,7 +1,5 @@
 /**
  * zudojs-cli — Installers
- *
- * Dependency installation utilities.
  */
-export { installDependencies, getInstallCommand, } from "./dependency.installer.js";
+export { getInstallCommand, getAddCommand, getRunScriptCommand, installDependencies, } from "./dependency.installer.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/installers/index.js

@@ -1,7 +1,5 @@
 /**
  * zudojs-cli — Installers
- *
- * Dependency installation utilities.
  */
-export { installDependencies, getInstallCommand, } from "./dependency.installer.js";
+export { getInstallCommand, getAddCommand, getRunScriptCommand, installDependencies, } from "./dependency.installer.js";
 //# sourceMappingURL=index.js.map

package/dist/src/resolvers/architecture.resolver.d.ts

@@ -1,2 +1,12 @@
-export declare function detectArchitecture(cwd: string): Promise<"monolith" | "modular-monolith" | "microservice" | null>;
+declare const ARCHITECTURES: readonly ["monolith", "modular-monolith", "microservice"];
+type Architecture = (typeof ARCHITECTURES)[number];
+/**
+ * Detects the backend architecture of the project at `cwd`.
+ *
+ * Reads the manifest (then the legacy config, then package.json) through the
+ * shared layout resolver and falls back to directory heuristics for projects
+ * that were not created by the CLI.
+ */
+export declare function detectArchitecture(cwd: string): Promise<Architecture | null>;
+export {};
 //# sourceMappingURL=architecture.resolver.d.ts.map

package/dist/src/resolvers/architecture.resolver.js

@@ -1,19 +1,18 @@
-import { readFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+import { resolveProjectLayout } from "./layout/projectLayout.core.js";
+const ARCHITECTURES = ["monolith", "modular-monolith", "microservice"];
+/**
+ * Detects the backend architecture of the project at `cwd`.
+ *
+ * Reads the manifest (then the legacy config, then package.json) through the
+ * shared layout resolver and falls back to directory heuristics for projects
+ * that were not created by the CLI.
+ */
 export async function detectArchitecture(cwd) {
-    const configPath = join(cwd, "zudojs.config.ts");
-    if (existsSync(configPath)) {
-        try {
-            const content = await readFile(configPath, "utf-8");
-            const match = content.match(/architecture:\s*["'](monolith|modular-monolith|microservice)["']/);
-            if (match) {
-                return match[1];
-            }
-        }
-        catch {
-            // fall through
-        }
+    const recorded = resolveProjectLayout(cwd)?.architecture;
+    if (recorded && ARCHITECTURES.includes(recorded)) {
+        return recorded;
     }
     if (existsSync(join(cwd, "pnpm-workspace.yaml"))) {
         const gateway = existsSync(join(cwd, "apps/gateway"));

package/dist/src/resolvers/configuration/configurationResolver.core.d.ts

@@ -1,7 +1,7 @@
 /**
  * zudojs-cli — Configuration Resolver
  *
- * Resolves and validates project configuration from multiple sources.
+ * Resolves project configuration from the sources `zudojs create` writes.
  */
 export interface ResolvedConfiguration {
     readonly projectName: string;
@@ -16,7 +16,16 @@ export interface ResolvedConfiguration {
     readonly features: readonly string[];
 }
 export declare class ConfigurationResolver {
+    /**
+     * Resolves the configuration of the project at `cwd`, or `null` when the
+     * directory is not a Zudojs project.
+     *
+     * Only `zudojs.config.ts` used to be consulted, so every project created
+     * since the manifest became the source of truth resolved to `null`.
+     */
     resolve(cwd: string): ResolvedConfiguration | null;
+    private readJson;
+    private readLegacyConfig;
     private extractValue;
     private extractArray;
 }