zudojs-cli 1.0.0 → 1.1.0

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

@@ -1,15 +1,85 @@
 /**
  * zudojs-cli — Dev Command
  *
- * The `zudojs dev` command.
- * Starts development servers based on project configuration.
+ * The `zudojs dev` command. Starts the development servers of the project
+ * in the current directory.
+ *
+ * Servers are started through the project's package manager (`pnpm run
+ * dev`, `npm run dev`, …) rather than by spawning `tsx` or `ng` directly:
+ * those binaries are devDependencies of the generated project and are not
+ * on the user's PATH, so the direct spawn failed with ENOENT for everyone
+ * who had not installed them globally. Running the script also means the
+ * project's own `dev` script is what runs — `tsx watch src` used to be
+ * hard-coded here, which watched `src/index.ts`, a file that only exports
+ * `createApp` and never starts the server.
  */
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { basename, join, relative } from "node:path";
 import { runStreaming } from "../utils/utils.exec.js";
 import { CLIValidationError, CLIGenerationError } from "../errors/index.js";
-import { ManifestManager } from "../manifest/manifestManager.core.js";
-import { SAFE_PATH_SEGMENT } from "../utils/utils.name.js";
+import { getRunScriptCommand } from "../installers/dependency.installer.js";
+import { resolveProjectLayout, } from "../resolvers/layout/projectLayout.core.js";
+/**
+ * Computes the servers `zudojs dev` starts for a project layout.
+ *
+ * Exported so the selection can be tested without spawning anything.
+ */
+export function planDevServers(layout, options = {}) {
+    const servers = [];
+    const env = options.port !== undefined
+        ? { ...process.env, PORT: String(options.port) }
+        : undefined;
+    if (!options.frontendOnly) {
+        for (const dir of layout.backendDirs) {
+            if (!existsSync(join(dir, "package.json")))
+                continue;
+            const [file, ...args] = getRunScriptCommand(layout.packageManager, "dev");
+            servers.push({
+                label: labelFor(layout.root, dir, "backend"),
+                cwd: dir,
+                file,
+                args,
+                ...(env ? { env } : {}),
+            });
+        }
+    }
+    if (!options.backendOnly && layout.frontendDir !== undefined) {
+        const spec = frontendServer(layout, layout.frontendDir);
+        if (spec)
+            servers.push(spec);
+    }
+    return servers;
+}
+function labelFor(root, dir, fallback) {
+    const rel = relative(root, dir);
+    return rel === "" ? fallback : basename(dir);
+}
+function frontendServer(layout, dir) {
+    const framework = layout.frontendFramework ?? "react";
+    if (framework === "none")
+        return null;
+    if (framework === "flutter") {
+        if (!existsSync(join(dir, "pubspec.yaml")))
+            return null;
+        return {
+            label: "web",
+            cwd: dir,
+            file: "flutter",
+            args: ["run", "--debug"],
+        };
+    }
+    if (!existsSync(join(dir, "package.json")))
+        return null;
+    // Angular's package.json has `start: ng serve`; React Native's has `start`.
+    const script = framework === "angular" || framework === "react-native" ? "start" : "dev";
+    const [file, ...args] = getRunScriptCommand(layout.packageManager, script);
+    return {
+        label: labelFor(layout.root, dir, "frontend"),
+        cwd: dir,
+        file,
+        args,
+    };
+}
 export async function runDevCommand(context) {
     const frontendOnly = context.values["frontend-only"] === true;
     const backendOnly = context.values["backend-only"] === true;
@@ -17,194 +87,45 @@ export async function runDevCommand(context) {
     if (frontendOnly && backendOnly) {
         throw new CLIValidationError("Cannot use --frontend-only and --backend-only together.");
     }
-    const manifest = await new ManifestManager(context.cwd).read();
-    const config = readProjectConfig(context.cwd) ?? configFromManifest(manifest);
-    if (!config) {
-        throw new CLIValidationError("No Zudojs project found. Run `zudojs create` first.");
+    const layout = resolveProjectLayout(context.cwd);
+    if (!layout) {
+        throw new CLIValidationError("No Zudojs project found in this directory. Run `zudojs create` first.");
     }
-    context.logger.info(`Starting development server for: ${config.name}`);
-    context.logger.info(`Type: ${config.type}`);
-    if (config.backend) {
-        context.logger.info(`Backend architecture: ${config.backend.architecture}`);
+    context.logger.info(`Project type: ${layout.projectType}`);
+    if (layout.backendDirs.length > 0) {
+        context.logger.info(`Backend architecture: ${layout.architecture}`);
     }
-    if (config.frontend) {
-        context.logger.info(`Frontend: ${config.frontend.framework}`);
+    if (layout.frontendFramework) {
+        context.logger.info(`Frontend: ${layout.frontendFramework}`);
     }
-    // Service names come from a manifest file on disk and are joined into
-    // filesystem paths below; a crafted entry such as "../../.." would make the
-    // dev command probe and run outside the project.
-    const services = (manifest?.services ?? []).filter((service) => {
-        if (SAFE_PATH_SEGMENT.test(service))
-            return true;
-        context.logger.warn(`Ignoring invalid service name in .zudojs/manifest.json: "${service}"`);
-        return false;
+    const servers = planDevServers(layout, {
+        frontendOnly,
+        backendOnly,
+        ...(port !== undefined ? { port } : {}),
     });
-    const processes = [];
-    if (!frontendOnly &&
-        (config.type === "backend" || config.type === "fullstack")) {
-        if (config.backend?.architecture === "microservice") {
-            processes.push(...startMicroserviceDev(context.cwd, services));
-        }
-        else {
-            processes.push(startBackendDev(context.cwd, config, port));
-        }
-    }
-    if (!backendOnly &&
-        (config.type === "frontend" || config.type === "fullstack")) {
-        if (config.frontend && config.frontend.framework !== "none") {
-            processes.push(startFrontendDev(context.cwd, config));
-        }
-    }
-    if (processes.length === 0) {
+    if (servers.length === 0) {
         context.logger.warn("No development servers to start.");
         return;
     }
-    context.logger.info("Starting development servers...");
+    for (const server of servers) {
+        context.logger.info(`Starting ${server.label}: ${server.file} ${server.args.join(" ")}`);
+    }
+    // One controller for every server: when any of them exits with an error
+    // the others are stopped too, instead of being left running detached
+    // after the command has already reported failure.
+    const controller = new AbortController();
+    const runs = servers.map((server) => runStreaming(server.file, server.args, server.cwd, {
+        signal: controller.signal,
+        ...(server.env ? { env: server.env } : {}),
+    }).catch((error) => {
+        controller.abort();
+        throw error;
+    }));
     try {
-        await Promise.all(processes);
+        await Promise.all(runs);
     }
     catch (error) {
         throw new CLIGenerationError("Development server failed to start.", error);
     }
 }
-function configFromManifest(manifest) {
-    if (!manifest)
-        return null;
-    return {
-        name: "zudojs-project",
-        type: manifest.projectType ?? "backend",
-        backend: manifest.backend
-            ? { architecture: manifest.backend.architecture }
-            : { architecture: manifest.architecture },
-        frontend: manifest.frontend
-            ? { framework: manifest.frontend.framework }
-            : undefined,
-    };
-}
-function readProjectConfig(cwd) {
-    const configPath = join(cwd, "zudojs.config.ts");
-    const configPathJs = join(cwd, "zudojs.config.js");
-    if (existsSync(configPath)) {
-        const content = readFileSync(configPath, "utf-8");
-        return parseConfigContent(content, cwd);
-    }
-    if (existsSync(configPathJs)) {
-        const content = readFileSync(configPathJs, "utf-8");
-        return parseConfigContent(content, cwd);
-    }
-    const pkgPath = join(cwd, "package.json");
-    if (existsSync(pkgPath)) {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        if (pkg.zudojs) {
-            return {
-                name: pkg.name ?? "unknown",
-                type: pkg.zudojs.projectType ?? "backend",
-                backend: pkg.zudojs.architecture
-                    ? { architecture: pkg.zudojs.architecture }
-                    : undefined,
-                frontend: pkg.zudojs.frontend
-                    ? { framework: pkg.zudojs.frontend }
-                    : undefined,
-            };
-        }
-    }
-    return null;
-}
-function parseConfigContent(content, cwd) {
-    const nameMatch = content.match(/name:\s*["']([^"']+)["']/);
-    const typeMatch = content.match(/projectType:\s*["'](\w+)["']/);
-    const architectureMatch = content.match(/architecture:\s*["'](\w+)["']/);
-    const frontendMatch = content.match(/frontend:\s*\{[\s\S]*?framework:\s*["']([^"']+)["']/);
-    const pkgPath = join(cwd, "package.json");
-    let name = "unknown";
-    if (existsSync(pkgPath)) {
-        try {
-            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-            name = pkg.name ?? name;
-        }
-        catch {
-            // ignore
-        }
-    }
-    return {
-        name: nameMatch?.[1] ?? name,
-        type: typeMatch?.[1] ?? "backend",
-        backend: architectureMatch?.[1]
-            ? { architecture: architectureMatch[1] }
-            : undefined,
-        frontend: frontendMatch?.[1] ? { framework: frontendMatch[1] } : undefined,
-    };
-}
-async function startBackendDev(cwd, config, port) {
-    // `--port=N` was appended to the tsx argv, where it became an argument of
-    // the watched script and was ignored. Generated servers read PORT from the
-    // environment, so that is where the option has to land.
-    const options = port !== undefined
-        ? { env: { ...process.env, PORT: String(port) } }
-        : undefined;
-    const entry = config.backend?.architecture === "microservice"
-        ? "apps/gateway/src"
-        : "src";
-    await runStreaming("tsx", ["watch", entry], cwd, options);
-}
-function startMicroserviceDev(cwd, services) {
-    const serviceDirs = services.map((service) => {
-        const nested = join(cwd, "apps", "services", service);
-        return existsSync(join(nested, "src"))
-            ? nested
-            : join(cwd, "apps", service);
-    });
-    const promises = [];
-    const gatewayDir = join(cwd, "apps", "gateway");
-    if (existsSync(join(gatewayDir, "src"))) {
-        promises.push(runStreaming("tsx", ["watch", "src"], gatewayDir));
-    }
-    for (const dir of serviceDirs) {
-        if (existsSync(join(dir, "src"))) {
-            promises.push(runStreaming("tsx", ["watch", "src"], dir));
-        }
-    }
-    return promises;
-}
-async function startFrontendDev(cwd, config) {
-    const framework = config.frontend?.framework ?? "react";
-    const frontendDir = join(cwd, "apps", "web");
-    switch (framework) {
-        case "react":
-            await runStreaming("npm", ["run", "dev"], frontendDir);
-            break;
-        case "next":
-            await runStreaming("npm", ["run", "dev"], frontendDir);
-            break;
-        case "vue":
-            await runStreaming("npm", ["run", "dev"], frontendDir);
-            break;
-        case "nuxt":
-            await runStreaming("npm", ["run", "dev"], frontendDir);
-            break;
-        case "angular":
-            await runStreaming("ng", ["serve"], frontendDir);
-            break;
-        case "svelte":
-            await runStreaming("npm", ["run", "dev"], frontendDir);
-            break;
-        case "sveltekit":
-            await runStreaming("npm", ["run", "dev"], frontendDir);
-            break;
-        case "astro":
-            await runStreaming("npm", ["run", "dev"], frontendDir);
-            break;
-        case "vanilla":
-            await runStreaming("npm", ["run", "dev"], frontendDir);
-            break;
-        case "flutter":
-            await runStreaming("flutter", ["run", "--debug"], frontendDir);
-            break;
-        case "react-native":
-            await runStreaming("npx", ["react-native", "start"], frontendDir);
-            break;
-        default:
-            await runStreaming("npm", ["run", "dev"], frontendDir);
-    }
-}
 //# sourceMappingURL=dev.command.js.map

package/dist/src/commands/doctor.command.d.ts

@@ -4,5 +4,23 @@
  * The `zudojs doctor` command for project diagnostics.
  */
 import type { CLIContext } from "../cliType/cliType.type.js";
+export interface DoctorCheck {
+    readonly name: string;
+    readonly passed: boolean;
+    readonly message: string;
+    /**
+     * Whether a failed check is fatal. Advisory checks (a missing lock file in
+     * a project created with `--no-install`, for example) are reported as
+     * warnings and do not fail the command.
+     */
+    readonly severity: "error" | "warning";
+}
+/**
+ * Runs every diagnostic for the project at `cwd`.
+ *
+ * Exported so the checks can be run against a scaffolded directory in tests
+ * without going through the logger.
+ */
+export declare function runDoctorChecks(cwd: string): DoctorCheck[];
 export declare function runDoctorCommand(context: CLIContext): Promise<void>;
 //# sourceMappingURL=doctor.command.d.ts.map

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

@@ -4,22 +4,33 @@
  * The `zudojs doctor` command for project diagnostics.
  */
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { CLIValidationError } from "../errors/index.js";
+import { FEATURE_PACKAGES } from "../constants/index.js";
+import { resolveProjectLayout, } from "../resolvers/layout/projectLayout.core.js";
+/**
+ * Runs every diagnostic for the project at `cwd`.
+ *
+ * Exported so the checks can be run against a scaffolded directory in tests
+ * without going through the logger.
+ */
+export function runDoctorChecks(cwd) {
+    const layout = resolveProjectLayout(cwd);
+    const checks = [checkNodeVersion(), checkProject(layout)];
+    if (!layout) {
+        return checks;
+    }
+    checks.push(checkPackageManager(layout), checkInstalled(layout), checkTypeScriptConfig(layout), checkDependencies(layout), checkFeatures(layout));
+    return checks;
+}
 export async function runDoctorCommand(context) {
-    const checks = [];
+    const checks = runDoctorChecks(context.cwd);
     const warnings = [];
     const errors = [];
-    checks.push(checkNodeVersion());
-    checks.push(checkPackageManager(context.cwd));
-    checks.push(checkTypeScriptConfig(context.cwd));
-    checks.push(checkZudojsConfig(context.cwd));
-    checks.push(checkDependencies(context));
-    checks.push(checkArchitectureViolations(context.cwd));
     context.logger.info("Zudojs Doctor - Project Diagnostics");
     context.logger.info("");
     for (const check of checks) {
-        const symbol = check.passed ? "✔" : "✖";
+        const symbol = check.passed ? "✔" : check.severity === "error" ? "✖" : "⚠";
         context.logger.info(`${symbol} ${check.name}: ${check.message}`);
         if (!check.passed) {
             if (check.severity === "warning") {
@@ -61,153 +72,170 @@ function checkNodeVersion() {
         severity: "error",
         passed,
         message: passed
-            ? `Node.js ${version} (✓ meets minimum v24)`
-            : `Node.js ${version} (✗ requires >= v24)`,
+            ? `Node.js ${version} (meets minimum v24)`
+            : `Node.js ${version} (requires >= v24)`,
     };
 }
-function checkPackageManager(cwd) {
-    const hasPnpm = existsSync(join(cwd, "pnpm-lock.yaml"));
-    const hasNpm = existsSync(join(cwd, "package-lock.json"));
-    const hasYarn = existsSync(join(cwd, "yarn.lock"));
-    const passed = hasPnpm || hasNpm || hasYarn;
-    const manager = hasPnpm ? "pnpm" : hasNpm ? "npm" : hasYarn ? "yarn" : "none";
+function checkProject(layout) {
+    if (!layout) {
+        return {
+            name: "Zudojs project",
+            severity: "error",
+            passed: false,
+            message: "No Zudojs project found (no .zudojs/manifest.json, zudojs.config.ts or zudojs block in package.json)",
+        };
+    }
+    const source = layout.source === "manifest"
+        ? ".zudojs/manifest.json"
+        : layout.source === "config"
+            ? "zudojs.config.ts"
+            : "package.json#zudojs";
+    return {
+        name: "Zudojs project",
+        severity: "error",
+        passed: true,
+        message: `${layout.projectType} (${layout.architecture}) from ${source}`,
+    };
+}
+function checkPackageManager(layout) {
+    const lockFiles = {
+        pnpm: ["pnpm-lock.yaml"],
+        npm: ["package-lock.json"],
+        yarn: ["yarn.lock"],
+        bun: ["bun.lock", "bun.lockb"],
+    };
+    const expected = lockFiles[layout.packageManager] ?? [];
+    const passed = expected.some((file) => existsSync(join(layout.root, file)));
     return {
         name: "Package manager",
         severity: "warning",
         passed,
-        message: passed ? `Detected: ${manager}` : "No lock file found",
+        message: passed
+            ? `${layout.packageManager} (lock file present)`
+            : `${layout.packageManager} configured but no lock file found; run "${layout.packageManager} install"`,
     };
 }
-function checkTypeScriptConfig(cwd) {
-    const passed = existsSync(join(cwd, "tsconfig.json")) ||
-        existsSync(join(cwd, "tsconfig.base.json"));
+function checkInstalled(layout) {
+    const passed = existsSync(join(layout.root, "node_modules"));
     return {
-        name: "TypeScript configuration",
-        severity: "error",
+        name: "Dependencies installed",
+        severity: "warning",
         passed,
-        message: passed ? "tsconfig.json found" : "No tsconfig.json found",
+        message: passed
+            ? "node_modules present"
+            : `node_modules missing; run "${layout.packageManager} install"`,
     };
 }
-function checkZudojsConfig(cwd) {
-    const hasPkgConfig = checkZudojsInPackageJson(cwd);
-    const hasConfig = existsSync(join(cwd, "zudojs.config.ts")) ||
-        existsSync(join(cwd, "zudojs.config.js"));
-    const passed = hasPkgConfig || hasConfig;
-    let message = "No Zudojs configuration found.";
-    if (passed) {
-        message = hasPkgConfig
-            ? "Zudojs config in package.json"
-            : hasConfig
-                ? "zudojs.config.ts found"
-                : "Zudojs config in package.json";
+/** Directories that must each carry a tsconfig.json. */
+function appDirs(layout) {
+    const dirs = [...layout.backendDirs];
+    if (layout.frontendDir !== undefined &&
+        layout.frontendFramework !== "flutter" &&
+        existsSync(join(layout.frontendDir, "package.json"))) {
+        dirs.push(layout.frontendDir);
     }
+    return dirs;
+}
+function describe(layout, dir) {
+    const rel = relative(layout.root, dir);
+    return rel === "" ? "." : rel;
+}
+/**
+ * A workspace root has no tsconfig.json of its own — the apps do. This
+ * check used to look only at the root, so every fullstack and microservice
+ * project failed the doctor the moment it was created.
+ */
+function checkTypeScriptConfig(layout) {
+    const missing = appDirs(layout).filter((dir) => !existsSync(join(dir, "tsconfig.json")) &&
+        !existsSync(join(dir, "tsconfig.base.json")));
+    const passed = missing.length === 0;
     return {
-        name: "Zudojs configuration",
+        name: "TypeScript configuration",
         severity: "error",
         passed,
-        message,
+        message: passed
+            ? "tsconfig.json found in every app"
+            : `No tsconfig.json in: ${missing.map((d) => describe(layout, d)).join(", ")}`,
     };
 }
-function checkZudojsInPackageJson(cwd) {
+function readPackageJson(dir) {
     try {
-        const pkgPath = join(cwd, "package.json");
-        if (!existsSync(pkgPath))
-            return false;
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        return typeof pkg.zudojs === "object" && pkg.zudojs !== null;
+        return JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
     }
     catch {
-        return false;
+        return null;
     }
 }
-function checkDependencies(context) {
-    const pkgPath = join(context.cwd, "package.json");
-    if (!existsSync(pkgPath)) {
-        return {
-            name: "Dependencies",
-            severity: "error",
-            passed: false,
-            message: "No package.json found",
-        };
-    }
-    try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        const zudojsDeps = Object.keys(pkg.dependencies ?? {}).filter((d) => d.startsWith("@zudojs/"));
-        const passed = zudojsDeps.length > 0;
+function checkDependencies(layout) {
+    if (layout.backendDirs.length === 0) {
         return {
             name: "Zudojs dependencies",
             severity: "warning",
-            passed,
-            message: passed
-                ? `${zudojsDeps.length} Zudojs packages installed`
-                : "No Zudojs packages found",
+            passed: true,
+            message: "Frontend-only project; no framework packages expected",
         };
     }
-    catch {
+    const found = new Set();
+    const unreadable = [];
+    for (const dir of layout.backendDirs) {
+        const pkg = readPackageJson(dir);
+        if (!pkg) {
+            unreadable.push(describe(layout, dir));
+            continue;
+        }
+        for (const name of Object.keys(pkg.dependencies ?? {})) {
+            if (name.startsWith("@zudojs/"))
+                found.add(name);
+        }
+    }
+    if (unreadable.length > 0) {
         return {
-            name: "Dependencies",
+            name: "Zudojs dependencies",
             severity: "error",
             passed: false,
-            message: "Failed to read package.json",
+            message: `Failed to read package.json in: ${unreadable.join(", ")}`,
         };
     }
+    const passed = found.size > 0;
+    return {
+        name: "Zudojs dependencies",
+        severity: "warning",
+        passed,
+        message: passed
+            ? `${found.size} Zudojs package(s) declared`
+            : "No @zudojs/* packages declared",
+    };
 }
-function checkArchitectureViolations(cwd) {
-    const srcDir = join(cwd, "src");
+/**
+ * Every feature recorded in a backend package.json must be backed by the
+ * package `zudojs add` installs for it.
+ */
+function checkFeatures(layout) {
     const violations = [];
-    if (!existsSync(srcDir)) {
-        return {
-            name: "Architecture",
-            severity: "warning",
-            passed: true,
-            message: "No src/ directory (not a Zudojs project?)",
-        };
-    }
-    const configPath = join(cwd, "zudojs.config.ts");
-    let architecture = "monolith";
-    if (existsSync(configPath)) {
-        const configContent = readFileSync(configPath, "utf-8");
-        const archMatch = configContent.match(/architecture:\s*["'](\w[\w-]*)["']/);
-        if (archMatch?.[1]) {
-            architecture = archMatch[1];
-        }
-    }
-    if (architecture === "modular-monolith" || architecture === "microservice") {
-        const servicesDir = join(srcDir, "services");
-        if (existsSync(servicesDir)) {
-            violations.push("src/services/ should be split into modules/ (modular-monolith) or apps/services/ (microservice)");
-        }
-    }
-    if (architecture === "monolith") {
-        const modulesDir = join(srcDir, "modules");
-        if (existsSync(modulesDir)) {
-            violations.push("src/modules/ found in monolith architecture — consider modular-monolith or microservice architecture");
-        }
-    }
-    const pkgPath = join(cwd, "package.json");
-    if (existsSync(pkgPath)) {
-        try {
-            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-            const features = pkg.zudojs?.features ?? [];
-            const deps = Object.keys(pkg.dependencies ?? {});
-            for (const feature of features) {
-                const pkgName = `@zudojs/${feature}`;
-                if (!deps.includes(pkgName)) {
-                    violations.push(`Feature "${feature}" declared in package.json#zudojs.features but ${pkgName} not in dependencies`);
+    for (const dir of layout.backendDirs) {
+        const pkg = readPackageJson(dir);
+        if (!pkg)
+            continue;
+        const features = Array.isArray(pkg.zudojs?.features)
+            ? pkg.zudojs.features.filter((f) => typeof f === "string")
+            : [];
+        const deps = Object.keys(pkg.dependencies ?? {});
+        for (const feature of features) {
+            const required = FEATURE_PACKAGES[feature] ?? [`@zudojs/${feature}`];
+            for (const name of required) {
+                if (!deps.includes(name)) {
+                    violations.push(`${describe(layout, dir)}: feature "${feature}" declared but ${name} is not a dependency`);
                 }
             }
         }
-        catch {
-            // ignore parse errors
-        }
     }
     return {
-        name: "Architecture",
+        name: "Features",
         severity: "warning",
         passed: violations.length === 0,
         message: violations.length === 0
-            ? "No violations detected"
-            : `${violations.length} potential violation(s): ${violations.join("; ")}`,
+            ? "Every declared feature has its package"
+            : violations.join("; "),
     };
 }
 //# sourceMappingURL=doctor.command.js.map

package/dist/src/commands/generate.command.d.ts

@@ -2,7 +2,8 @@
  * 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 type { CLIContext } from "../cliType/cliType.type.js";
 export declare function runGenerateCommand(context: CLIContext): Promise<void>;