zudojs-cli 0.1.2 → 1.1.0

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

@@ -1,4 +1,4 @@
-import { execCommand } from "../utils/utils.exec.js";
+import { runStreaming } from "../utils/utils.exec.js";
 export function getInstallCommand(packageManager) {
     switch (packageManager) {
         case "pnpm":
@@ -7,6 +7,8 @@ export function getInstallCommand(packageManager) {
             return ["npm", "install"];
         case "yarn":
             return ["yarn", "install"];
+        case "bun":
+            return ["bun", "install"];
         default:
             return ["pnpm", "install"];
     }
@@ -19,12 +21,35 @@ export function getAddCommand(packageManager, pkg) {
             return ["npm", "install", pkg];
         case "yarn":
             return ["yarn", "add", pkg];
+        case "bun":
+            return ["bun", "add", pkg];
         default:
             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 execCommand(file, args, cwd);
+    await runStreaming(file, args, cwd);
 }
 //# sourceMappingURL=dependency.installer.js.map

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/manifest/manifestManager.core.d.ts

@@ -5,7 +5,10 @@
  */
 export interface ZudojsManifest {
     readonly version: string;
+    readonly projectType?: string;
     readonly architecture: string;
+    /** Service names for microservice projects. */
+    readonly services?: readonly string[];
     readonly backend?: {
         readonly architecture: string;
         readonly api: string;

package/dist/src/prompts/backend/index.d.ts

@@ -6,4 +6,5 @@
 export { promptBackendArchitecture } from "./backend-architecture.prompt.js";
 export { promptDatabase } from "./database.prompt.js";
 export { promptApiStyle } from "./api-style.prompt.js";
+export { promptServices } from "./services.prompt.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/prompts/backend/index.js

@@ -6,4 +6,5 @@
 export { promptBackendArchitecture } from "./backend-architecture.prompt.js";
 export { promptDatabase } from "./database.prompt.js";
 export { promptApiStyle } from "./api-style.prompt.js";
+export { promptServices } from "./services.prompt.js";
 //# sourceMappingURL=index.js.map

package/dist/src/prompts/backend/services.prompt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * zudojs-cli — Services Prompt
+ *
+ * Prompts for microservice service names (comma-separated).
+ */
+export declare function promptServices(overrides?: readonly string[]): Promise<string[]>;
+//# sourceMappingURL=services.prompt.d.ts.map

package/dist/src/prompts/backend/services.prompt.js

@@ -0,0 +1,39 @@
+/**
+ * zudojs-cli — Services Prompt
+ *
+ * Prompts for microservice service names (comma-separated).
+ */
+import * as p from "@clack/prompts";
+const SERVICE_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function parseServices(value) {
+    return value
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+export async function promptServices(overrides) {
+    if (overrides && overrides.length > 0) {
+        return [...overrides];
+    }
+    const value = await p.text({
+        message: "Service names (comma-separated)",
+        placeholder: "identity,billing,notification",
+        validate(input) {
+            const services = parseServices(input ?? "");
+            if (services.length === 0) {
+                return "At least one service name is required.";
+            }
+            for (const service of services) {
+                if (!SERVICE_NAME_PATTERN.test(service)) {
+                    return `Invalid service name "${service}". Only alphanumeric characters, hyphens, and underscores are allowed.`;
+                }
+            }
+        },
+    });
+    if (p.isCancel(value)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+    }
+    return parseServices(value);
+}
+//# sourceMappingURL=services.prompt.js.map

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

@@ -1,7 +1,6 @@
 /**
  * zudojs-cli — Prompts Index
  */
-export { promptCreateProject, type CreateProjectPrompts, type PromptChoice, } from "./prompts.createProject.js";
 export { promptProjectName } from "./project/project-name.prompt.js";
 export { promptProjectType } from "./project/project-type.prompt.js";
 export { promptConfirmation } from "./project/confirmation.prompt.js";

package/dist/src/prompts/index.js

@@ -1,7 +1,6 @@
 /**
  * zudojs-cli — Prompts Index
  */
-export { promptCreateProject, } from "./prompts.createProject.js";
 export { promptProjectName } from "./project/project-name.prompt.js";
 export { promptProjectType } from "./project/project-type.prompt.js";
 export { promptConfirmation } from "./project/confirmation.prompt.js";

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;
 }

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