zudojs-cli 1.0.0 → 1.1.1

package/dist/src/resolvers/configuration/configurationResolver.core.js

@@ -1,50 +1,89 @@
 /**
  * zudojs-cli — Configuration Resolver
  *
- * Resolves and validates project configuration from multiple sources.
+ * Resolves project configuration from the sources `zudojs create` writes.
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { resolveProjectLayout } from "../layout/projectLayout.core.js";
 export 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) {
-        const configPath = join(cwd, "zudojs.config.ts");
-        if (!existsSync(configPath)) {
+        const layout = resolveProjectLayout(cwd);
+        if (!layout)
+            return null;
+        const manifest = this.readJson(join(cwd, ".zudojs", "manifest.json"));
+        const pkg = this.readJson(join(cwd, "package.json"));
+        const legacy = this.readLegacyConfig(cwd);
+        const features = manifest?.capabilities ??
+            (Array.isArray(pkg?.zudojs?.features)
+                ? pkg.zudojs.features.filter((feature) => typeof feature === "string")
+                : undefined) ??
+            this.extractArray(legacy, "features") ??
+            [];
+        const frontendArchitecture = manifest?.frontend?.architecture ??
+            this.extractValue(legacy, "architecture", "frontend");
+        const language = this.extractValue(legacy, "language");
+        return {
+            projectName: this.extractValue(legacy, "name") ?? pkg?.name ?? "unknown",
+            projectType: layout.projectType,
+            architecture: layout.architecture,
+            packageManager: layout.packageManager,
+            database: manifest?.database?.provider ??
+                this.extractValue(legacy, "provider") ??
+                "postgresql",
+            api: manifest?.backend?.api ?? this.extractValue(legacy, "api") ?? "rest",
+            ...(layout.frontendFramework !== undefined
+                ? { frontend: layout.frontendFramework }
+                : {}),
+            ...(frontendArchitecture !== undefined ? { frontendArchitecture } : {}),
+            ...(language !== undefined ? { language } : {}),
+            features,
+        };
+    }
+    readJson(path) {
+        if (!existsSync(path))
             return null;
-        }
         try {
-            const content = readFileSync(configPath, "utf-8");
-            return {
-                projectName: this.extractValue(content, "name") ?? "unknown",
-                projectType: this.extractValue(content, "type") ?? "backend",
-                architecture: this.extractValue(content, "architecture") ?? "monolith",
-                packageManager: this.extractValue(content, "packageManager") ?? "pnpm",
-                database: this.extractValue(content, "provider") ?? "postgresql",
-                api: this.extractValue(content, "api") ?? "rest",
-                frontend: this.extractValue(content, "framework"),
-                frontendArchitecture: this.extractValue(content, "architecture", "frontend"),
-                language: this.extractValue(content, "language"),
-                features: this.extractArray(content, "features") ?? [],
-            };
+            return JSON.parse(readFileSync(path, "utf-8"));
         }
         catch {
             return null;
         }
     }
-    extractValue(content, key, section) {
-        let pattern;
-        if (section) {
-            pattern = new RegExp(`${section}[\\s\\S]*?${key}:\\s*["']([^"']+)["']`);
-        }
-        else {
-            pattern = new RegExp(`${key}:\\s*["']([^"']+)["']`);
+    readLegacyConfig(cwd) {
+        for (const name of ["zudojs.config.ts", "zudojs.config.js"]) {
+            const path = join(cwd, name);
+            if (!existsSync(path))
+                continue;
+            try {
+                return readFileSync(path, "utf-8");
+            }
+            catch {
+                return "";
+            }
         }
-        const match = content.match(pattern);
-        return match?.[1];
+        return "";
+    }
+    extractValue(content, key, section) {
+        if (content.length === 0)
+            return undefined;
+        const pattern = section
+            ? new RegExp(`${section}[\\s\\S]*?${key}:\\s*["']([^"']+)["']`)
+            : new RegExp(`(?<![\\w])${key}:\\s*["']([^"']+)["']`);
+        return content.match(pattern)?.[1];
     }
     extractArray(content, key) {
-        const pattern = new RegExp(`${key}:\\s*\\[([^\\]]+)\\]`);
-        const match = content.match(pattern);
-        if (!match || !match[1])
+        if (content.length === 0)
+            return undefined;
+        const match = content.match(new RegExp(`${key}:\\s*\\[([^\\]]+)\\]`));
+        if (!match?.[1])
             return undefined;
         return match[1]
             .split(",")

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

@@ -7,4 +7,5 @@ export { detectArchitecture } from "./architecture.resolver.js";
 export { resolveProjectPath, findProjectRoot } from "./project.resolver.js";
 export { CapabilityResolver, type CapabilityDependency, type CapabilityResolutionResult, } from "./capability/index.js";
 export { ConfigurationResolver, type ResolvedConfiguration, } from "./configuration/index.js";
+export { resolveProjectLayout, detectPackageManager, type ProjectLayout, type ProjectLayoutType, type ProjectLayoutSource, } from "./layout/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/resolvers/index.js

@@ -7,4 +7,5 @@ export { detectArchitecture } from "./architecture.resolver.js";
 export { resolveProjectPath, findProjectRoot } from "./project.resolver.js";
 export { CapabilityResolver, } from "./capability/index.js";
 export { ConfigurationResolver, } from "./configuration/index.js";
+export { resolveProjectLayout, detectPackageManager, } from "./layout/index.js";
 //# sourceMappingURL=index.js.map

package/dist/src/resolvers/layout/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * zudojs-cli — Project Layout Resolver
+ */
+export { resolveProjectLayout, detectPackageManager, type ProjectLayout, type ProjectLayoutType, type ProjectLayoutSource, } from "./projectLayout.core.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/resolvers/layout/index.js

@@ -0,0 +1,5 @@
+/**
+ * zudojs-cli — Project Layout Resolver
+ */
+export { resolveProjectLayout, detectPackageManager, } from "./projectLayout.core.js";
+//# sourceMappingURL=index.js.map

package/dist/src/resolvers/layout/projectLayout.core.d.ts

@@ -0,0 +1,60 @@
+/**
+ * zudojs-cli — Project Layout Resolver
+ *
+ * One place that answers "what kind of project is this directory, and where
+ * do its apps live?". Every follow-up command (`dev`, `add`, `generate`,
+ * `doctor`, `info`, `build`) used to answer that question on its own, and
+ * each answer was different: `dev` read `zudojs.config.ts` first and only
+ * fell back to the manifest, `generate` never looked past the workspace
+ * root for a fullstack project, `doctor` required a `tsconfig.json` at the
+ * root of a workspace that has none, and `add` wrote into the workspace root
+ * `package.json` where no app can import from.
+ *
+ * Resolution order:
+ *
+ *   1. `.zudojs/manifest.json` — written by `zudojs create`, machine-managed.
+ *   2. `zudojs.config.ts` / `.js` — older projects; read with a regex, never
+ *      executed.
+ *   3. the `zudojs` block in `package.json`.
+ *
+ * @module resolvers/layout
+ */
+import type { PackageManager } from "../../types/index.js";
+/** Project type recorded by `zudojs create`. */
+export type ProjectLayoutType = "backend" | "frontend" | "fullstack";
+/** Where the description of the project came from. */
+export type ProjectLayoutSource = "manifest" | "config" | "package.json";
+/** The resolved shape of a Zudojs project on disk. */
+export interface ProjectLayout {
+    /** Absolute project root: the directory holding the manifest or config. */
+    readonly root: string;
+    readonly projectType: ProjectLayoutType;
+    /** Backend architecture (`monolith`, `modular-monolith`, `microservice`). */
+    readonly architecture: string;
+    readonly packageManager: PackageManager;
+    /** Whether the root is a workspace (pnpm-workspace.yaml or `workspaces`). */
+    readonly isWorkspace: boolean;
+    /**
+     * Absolute directories that hold a backend app, each with its own
+     * `package.json`. Empty for a frontend-only project. A monolith has one
+     * (the root, or `apps/api` in a fullstack workspace); a microservice
+     * project has the gateway plus one per service.
+     */
+    readonly backendDirs: readonly string[];
+    /** Absolute directory of the frontend app, when the project has one. */
+    readonly frontendDir?: string;
+    readonly frontendFramework?: string;
+    /** Service names of a microservice project. */
+    readonly services: readonly string[];
+    readonly source: ProjectLayoutSource;
+}
+/** Detects the package manager from lock files and workspace markers. */
+export declare function detectPackageManager(root: string): PackageManager;
+/**
+ * Resolves the layout of the Zudojs project rooted at `cwd`.
+ *
+ * Returns `null` when the directory is not a Zudojs project: no manifest,
+ * no legacy config and no `zudojs` block in `package.json`.
+ */
+export declare function resolveProjectLayout(cwd: string): ProjectLayout | null;
+//# sourceMappingURL=projectLayout.core.d.ts.map

package/dist/src/resolvers/layout/projectLayout.core.js

@@ -0,0 +1,236 @@
+/**
+ * zudojs-cli — Project Layout Resolver
+ *
+ * One place that answers "what kind of project is this directory, and where
+ * do its apps live?". Every follow-up command (`dev`, `add`, `generate`,
+ * `doctor`, `info`, `build`) used to answer that question on its own, and
+ * each answer was different: `dev` read `zudojs.config.ts` first and only
+ * fell back to the manifest, `generate` never looked past the workspace
+ * root for a fullstack project, `doctor` required a `tsconfig.json` at the
+ * root of a workspace that has none, and `add` wrote into the workspace root
+ * `package.json` where no app can import from.
+ *
+ * Resolution order:
+ *
+ *   1. `.zudojs/manifest.json` — written by `zudojs create`, machine-managed.
+ *   2. `zudojs.config.ts` / `.js` — older projects; read with a regex, never
+ *      executed.
+ *   3. the `zudojs` block in `package.json`.
+ *
+ * @module resolvers/layout
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { SAFE_PATH_SEGMENT } from "../../utils/utils.name.js";
+const PROJECT_TYPES = [
+    "backend",
+    "frontend",
+    "fullstack",
+];
+const PACKAGE_MANAGERS = [
+    "pnpm",
+    "npm",
+    "yarn",
+    "bun",
+];
+function readJson(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        return typeof parsed === "object" && parsed !== null
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function readManifest(root) {
+    const manifest = readJson(join(root, ".zudojs", "manifest.json"));
+    if (!manifest)
+        return null;
+    const backend = manifest.backend;
+    const frontend = manifest.frontend;
+    const workspace = manifest.workspace;
+    const services = Array.isArray(manifest.services)
+        ? manifest.services.filter((service) => typeof service === "string")
+        : undefined;
+    return {
+        projectType: asString(manifest.projectType),
+        architecture: asString(backend?.architecture) ?? asString(manifest.architecture),
+        packageManager: asString(workspace?.packageManager),
+        frontendFramework: asString(frontend?.framework),
+        services,
+        source: "manifest",
+    };
+}
+/**
+ * Reads the legacy `zudojs.config.ts` with a regex. The file is user-owned
+ * TypeScript and is never executed.
+ */
+function readLegacyConfig(root) {
+    for (const name of ["zudojs.config.ts", "zudojs.config.js"]) {
+        const path = join(root, name);
+        if (!existsSync(path))
+            continue;
+        let content;
+        try {
+            content = readFileSync(path, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const projectType = content.match(/projectType:\s*["'](\w+)["']/)?.[1];
+        const architecture = content.match(/architecture:\s*["'](\w[\w-]*)["']/)?.[1];
+        const frontendFramework = content.match(/frontend:\s*\{[\s\S]*?framework:\s*["']([^"']+)["']/)?.[1];
+        return {
+            projectType,
+            architecture,
+            frontendFramework,
+            source: "config",
+        };
+    }
+    return null;
+}
+function readPackageJsonBlock(root) {
+    const pkg = readJson(join(root, "package.json"));
+    const block = pkg?.zudojs;
+    if (typeof block !== "object" || block === null)
+        return null;
+    const zudojs = block;
+    return {
+        projectType: asString(zudojs.projectType),
+        architecture: asString(zudojs.architecture),
+        frontendFramework: asString(zudojs.frontend),
+        source: "package.json",
+    };
+}
+/** Detects the package manager from lock files and workspace markers. */
+export function detectPackageManager(root) {
+    if (existsSync(join(root, "pnpm-lock.yaml")) ||
+        existsSync(join(root, "pnpm-workspace.yaml"))) {
+        return "pnpm";
+    }
+    if (existsSync(join(root, "yarn.lock")))
+        return "yarn";
+    if (existsSync(join(root, "bun.lock")) || existsSync(join(root, "bun.lockb")))
+        return "bun";
+    return "npm";
+}
+/**
+ * Whether `root` is a multi-package workspace.
+ *
+ * A `pnpm-workspace.yaml` alone is not enough: pnpm 10+ also uses that file
+ * for settings (the build-script allow-list every generated project
+ * carries), so only one that declares `packages:` makes a workspace.
+ */
+function isWorkspaceRoot(root) {
+    const workspaceFile = join(root, "pnpm-workspace.yaml");
+    if (existsSync(workspaceFile)) {
+        try {
+            if (/^packages:/m.test(readFileSync(workspaceFile, "utf-8")))
+                return true;
+        }
+        catch {
+            // unreadable: fall through to package.json
+        }
+    }
+    const pkg = readJson(join(root, "package.json"));
+    return pkg?.workspaces !== undefined;
+}
+/**
+ * Lists the service apps under `<backendRoot>/apps/services`, preferring the
+ * names recorded in the manifest and falling back to the directory listing.
+ */
+function listServiceDirs(backendRoot, recorded) {
+    const servicesRoot = join(backendRoot, "apps", "services");
+    let names;
+    if (recorded && recorded.length > 0) {
+        // Names come from a file on disk and become path segments.
+        names = recorded.filter((name) => SAFE_PATH_SEGMENT.test(name));
+    }
+    else if (existsSync(servicesRoot)) {
+        names = readdirSync(servicesRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .filter((name) => SAFE_PATH_SEGMENT.test(name));
+    }
+    else {
+        names = [];
+    }
+    const dirs = names
+        .map((name) => join(servicesRoot, name))
+        .filter((dir) => existsSync(join(dir, "package.json")));
+    return { names, dirs };
+}
+/**
+ * Resolves the layout of the Zudojs project rooted at `cwd`.
+ *
+ * Returns `null` when the directory is not a Zudojs project: no manifest,
+ * no legacy config and no `zudojs` block in `package.json`.
+ */
+export function resolveProjectLayout(cwd) {
+    const raw = readManifest(cwd) ?? readLegacyConfig(cwd) ?? readPackageJsonBlock(cwd);
+    if (!raw)
+        return null;
+    const projectType = PROJECT_TYPES.includes(raw.projectType)
+        ? raw.projectType
+        : "backend";
+    const architecture = raw.architecture ?? "monolith";
+    const packageManager = PACKAGE_MANAGERS.includes(raw.packageManager)
+        ? raw.packageManager
+        : detectPackageManager(cwd);
+    // In a fullstack workspace the backend is generated into apps/api; a
+    // backend-only project is its own backend root.
+    const fullstackApi = join(cwd, "apps", "api");
+    const backendRoot = projectType === "fullstack" &&
+        existsSync(join(fullstackApi, "package.json"))
+        ? fullstackApi
+        : cwd;
+    let backendDirs = [];
+    let services = [];
+    if (projectType !== "frontend") {
+        if (architecture === "microservice") {
+            const gateway = join(backendRoot, "apps", "gateway");
+            const listed = listServiceDirs(backendRoot, raw.services);
+            services = listed.names;
+            backendDirs = [
+                ...(existsSync(join(gateway, "package.json")) ? [gateway] : []),
+                ...listed.dirs,
+            ];
+        }
+        else {
+            backendDirs = [backendRoot];
+        }
+    }
+    let frontendDir;
+    let frontendFramework;
+    if (projectType === "frontend") {
+        const nested = join(cwd, "apps", "web");
+        frontendDir = existsSync(join(nested, "package.json")) ? nested : cwd;
+        frontendFramework = raw.frontendFramework ?? "react";
+    }
+    else if (projectType === "fullstack") {
+        frontendDir = join(cwd, "apps", "web");
+        frontendFramework = raw.frontendFramework ?? "react";
+    }
+    else if (raw.frontendFramework && raw.frontendFramework !== "none") {
+        frontendDir = join(cwd, "apps", "web");
+        frontendFramework = raw.frontendFramework;
+    }
+    return {
+        root: cwd,
+        projectType,
+        architecture,
+        packageManager,
+        isWorkspace: isWorkspaceRoot(cwd),
+        backendDirs,
+        ...(frontendDir !== undefined ? { frontendDir } : {}),
+        ...(frontendFramework !== undefined ? { frontendFramework } : {}),
+        services,
+        source: raw.source,
+    };
+}
+//# sourceMappingURL=projectLayout.core.js.map

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

@@ -1,3 +1,8 @@
+/**
+ * Walks upward from `startDir` to the nearest directory that looks like a
+ * project root: one holding a `.zudojs/manifest.json`, a legacy
+ * `zudojs.config.ts`, or a `package.json`.
+ */
 export declare function findProjectRoot(startDir?: string): string | null;
 export declare function resolveProjectPath(cwd: string, name: string): string;
 //# sourceMappingURL=project.resolver.d.ts.map

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

@@ -1,15 +1,19 @@
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
+/**
+ * Walks upward from `startDir` to the nearest directory that looks like a
+ * project root: one holding a `.zudojs/manifest.json`, a legacy
+ * `zudojs.config.ts`, or a `package.json`.
+ */
 export function findProjectRoot(startDir = process.cwd()) {
     let dir = startDir;
     while (true) {
-        if (existsSync(join(dir, "zudojs.config.ts"))) {
+        if (existsSync(join(dir, ".zudojs", "manifest.json")) ||
+            existsSync(join(dir, "zudojs.config.ts")) ||
+            existsSync(join(dir, "package.json"))) {
             return dir;
         }
-        if (existsSync(join(dir, "package.json"))) {
-            return dir;
-        }
-        const parent = join(dir, "..");
+        const parent = dirname(dir);
         if (parent === dir) {
             return null;
         }

package/dist/src/templates/microservice/microservice.template.d.ts

@@ -17,7 +17,6 @@
  * ├── infrastructure/
  * ├── package.json
  * ├── pnpm-workspace.yaml
- * ├── zudojs.config.ts
  * ├── docker-compose.yml
  * └── README.md
  * ```

package/dist/src/templates/microservice/microservice.template.js

@@ -17,14 +17,13 @@
  * ├── infrastructure/
  * ├── package.json
  * ├── pnpm-workspace.yaml
- * ├── zudojs.config.ts
  * ├── docker-compose.yml
  * └── README.md
  * ```
  */
 import { ZUDOJS_PACKAGES_VERSION } from "../../constants/index.js";
 import { normalizeName } from "../../utils/utils.name.js";
-import { RUNTIME_APP_DEPENDENCIES, moduleSpec, renderAppFile, renderModuleFile, renderServerFile, renderZudojsConfig, } from "../shared/index.js";
+import { RUNTIME_APP_DEPENDENCIES, moduleSpec, renderAppFile, renderModuleFile, renderServerFile, renderPnpmWorkspaceFile, } from "../shared/index.js";
 /** Default service names used when none are provided. */
 export const DEFAULT_MICROSERVICE_SERVICES = [
     "identity",
@@ -104,9 +103,7 @@ export function generateMicroserviceFiles(options) {
             },
         }, null, 2) + "\n";
     if (options.packageManager === "pnpm") {
-        files["pnpm-workspace.yaml"] = `packages:
-${workspaceGlobs.map((g) => `  - "${g}"`).join("\n")}
-`;
+        files["pnpm-workspace.yaml"] = renderPnpmWorkspaceFile(workspaceGlobs);
     }
     // Docker Compose — gateway on 3000, service i on 3001+i.
     let composeServices = "";
@@ -139,11 +136,6 @@ ${composeServices}
 volumes:
   ${services.map((s) => `${s}-data:`).join("\n  ")}
 `;
-    files["zudojs.config.ts"] = renderZudojsConfig({
-        projectName: nameSlug,
-        projectType: "backend",
-        architecture: "microservice",
-    });
     files[".env.example"] = `NODE_ENV=development
 PORT=3000
 `;

package/dist/src/templates/modular-monolith/modularMonolith.template.d.ts

@@ -28,7 +28,6 @@
  * ├── tests/
  * ├── package.json
  * ├── tsconfig.json
- * ├── zudojs.config.ts
  * └── README.md
  * ```
  */

package/dist/src/templates/modular-monolith/modularMonolith.template.js

@@ -28,13 +28,12 @@
  * ├── tests/
  * ├── package.json
  * ├── tsconfig.json
- * ├── zudojs.config.ts
  * └── README.md
  * ```
  */
 import { ZUDOJS_PACKAGES_VERSION } from "../../constants/index.js";
 import { normalizeName } from "../../utils/utils.name.js";
-import { RUNTIME_APP_DEPENDENCIES, moduleSpec, renderAppFile, renderModuleFile, renderServerFile, renderZudojsConfig, } from "../shared/index.js";
+import { RUNTIME_APP_DEPENDENCIES, moduleSpec, renderAppFile, renderModuleFile, renderServerFile, renderPnpmWorkspaceFile, } from "../shared/index.js";
 export function generateModularMonolithFiles(options) {
     const nameSlug = options.projectName
         .replace(/[^a-z0-9-]+/gi, "-")
@@ -103,11 +102,9 @@ export function generateModularMonolithFiles(options) {
   "exclude": ["node_modules", "dist", "**/*.test.ts"]
 }
 `;
-    files["zudojs.config.ts"] = renderZudojsConfig({
-        projectName: nameSlug,
-        projectType: "backend",
-        architecture: "modular-monolith",
-    });
+    if (options.packageManager === "pnpm") {
+        files["pnpm-workspace.yaml"] = renderPnpmWorkspaceFile();
+    }
     files[".env.example"] = `NODE_ENV=development
 PORT=3000
 DATABASE_URL=postgresql://localhost:5432/${nameSlug}

package/dist/src/templates/monolith/monolith.template.d.ts

@@ -34,7 +34,6 @@
  * ├── tests/
  * ├── package.json
  * ├── tsconfig.json
- * ├── zudojs.config.ts
  * └── README.md
  * ```
  */

package/dist/src/templates/monolith/monolith.template.js

@@ -34,13 +34,12 @@
  * ├── tests/
  * ├── package.json
  * ├── tsconfig.json
- * ├── zudojs.config.ts
  * └── README.md
  * ```
  */
 import { ZUDOJS_PACKAGES_VERSION } from "../../constants/index.js";
 import { normalizeName, toPascalCase } from "../../utils/utils.name.js";
-import { RUNTIME_APP_DEPENDENCIES, moduleSpec, renderAppFile, renderModuleFile, renderServerFile, renderServiceFile, renderZudojsConfig, } from "../shared/index.js";
+import { RUNTIME_APP_DEPENDENCIES, moduleSpec, renderAppFile, renderModuleFile, renderServerFile, renderServiceFile, renderPnpmWorkspaceFile, } from "../shared/index.js";
 export function generateMonolithFiles(options) {
     const name = options.projectName;
     const nameSlug = name.replace(/[^a-z0-9-]+/gi, "-").toLowerCase();
@@ -118,11 +117,9 @@ export function generateMonolithFiles(options) {
   "exclude": ["node_modules", "dist", "**/*.test.ts"]
 }
 `;
-    files["zudojs.config.ts"] = renderZudojsConfig({
-        projectName: nameSlug,
-        projectType: "backend",
-        architecture: "monolith",
-    });
+    if (options.packageManager === "pnpm") {
+        files["pnpm-workspace.yaml"] = renderPnpmWorkspaceFile();
+    }
     // Environment
     files[".env.example"] = `NODE_ENV=development
 PORT=3000

package/dist/src/templates/shared/appRuntime.template.d.ts

@@ -24,17 +24,6 @@ export interface RuntimeModuleSpec {
 }
 /** Builds a module spec from a raw name. */
 export declare function moduleSpec(name: string, importPath: string): RuntimeModuleSpec;
-/**
- * Renders `zudojs.config.ts`.
- *
- * The shape matches what the fullstack composer writes and what
- * `zudojs generate` parses to detect the project architecture.
- */
-export declare function renderZudojsConfig(options: {
-    readonly projectName: string;
-    readonly projectType: string;
-    readonly architecture: string;
-}): string;
 /**
  * Renders `src/app.ts`: assembles the runtime dependencies and returns a
  * started-on-demand `Runtime`.

package/dist/src/templates/shared/appRuntime.template.js

@@ -33,26 +33,6 @@ export function moduleSpec(name, importPath) {
 function literal(value) {
     return JSON.stringify(value);
 }
-/**
- * Renders `zudojs.config.ts`.
- *
- * The shape matches what the fullstack composer writes and what
- * `zudojs generate` parses to detect the project architecture.
- */
-export function renderZudojsConfig(options) {
-    return `/**
- * Zudojs project configuration.
- *
- * Read by the \`zudojs\` CLI to detect this project's architecture.
- */
-
-export default {
-  name: ${literal(options.projectName)},
-  projectType: ${literal(options.projectType)},
-  architecture: ${literal(options.architecture)},
-};
-`;
-}
 /**
  * Renders `src/app.ts`: assembles the runtime dependencies and returns a
  * started-on-demand `Runtime`.

package/dist/src/templates/shared/index.d.ts

@@ -2,4 +2,5 @@
  * zudojs-cli — Shared Template Fragments
  */
 export * from "./appRuntime.template.js";
+export * from "./pnpm.template.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/templates/shared/index.js

@@ -2,4 +2,5 @@
  * zudojs-cli — Shared Template Fragments
  */
 export * from "./appRuntime.template.js";
+export * from "./pnpm.template.js";
 //# sourceMappingURL=index.js.map