zudojs-cli 0.1.2 → 1.1.0

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/rollback/rollbackManager.core.js

@@ -5,7 +5,6 @@
  */
 import { existsSync } from "node:fs";
 import { rm } from "node:fs/promises";
-import { join } from "node:path";
 export class RollbackManager {
     entries = [];
     trackFile(path) {

package/dist/src/runners/process/processRunner.core.d.ts

@@ -6,6 +6,10 @@
 export interface ProcessOptions {
     readonly cwd: string;
     readonly env?: Record<string, string>;
+    /**
+     * Child stdio mode. Only meaningful for {@link ProcessRunner.runBackground};
+     * {@link ProcessRunner.run} always buffers output so it can return it.
+     */
     readonly stdio?: "inherit" | "pipe" | "ignore";
 }
 export declare class ProcessRunner {

package/dist/src/runners/process/processRunner.core.js

@@ -7,12 +7,26 @@ import { execCommand } from "../../utils/utils.exec.js";
 export class ProcessRunner {
     async run(command, args, options) {
         try {
-            await execCommand(command, Array.from(args), options.cwd);
-            return { stdout: "", stderr: "", exitCode: 0 };
+            // The buffered output used to be thrown away and every caller got
+            // empty strings, making the documented `stdout`/`stderr` fields
+            // useless. `options.env` was ignored here too.
+            const result = await execCommand(command, Array.from(args), options.cwd, {
+                ...(options.env ? { env: { ...process.env, ...options.env } } : {}),
+            });
+            return { stdout: result.stdout, stderr: result.stderr, exitCode: 0 };
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            return { stdout: "", stderr: message, exitCode: 1 };
+            const stdout = typeof error.stdout === "string"
+                ? error.stdout
+                : "";
+            const stderr = typeof error.stderr === "string"
+                ? error.stderr
+                : message;
+            const exitCode = typeof error.code === "number"
+                ? error.code
+                : 1;
+            return { stdout, stderr, exitCode };
         }
     }
     async runBackground(command, args, options) {

package/dist/src/scaffolders/framework.scaffolder.js

@@ -7,7 +7,10 @@ import { execCommand } from "../utils/utils.exec.js";
 export class FrameworkScaffolder {
     async scaffold(targetPath) {
         try {
-            await execCommand(this.command, this.args, targetPath);
+            await execCommand(this.command, this.args, targetPath, {
+                // Suppress interactive prompts from create-* tools.
+                env: { ...process.env, CI: "1" },
+            });
             return { success: true, path: targetPath };
         }
         catch (error) {
@@ -19,12 +22,12 @@ export class FrameworkScaffolder {
 export class ViteReactScaffolder extends FrameworkScaffolder {
     name = "react-vite";
     command = "npm";
-    args = ["create", "vite@latest", ".", "--template", "react-ts"];
+    args = ["create", "vite@latest", ".", "--", "--template", "react-ts"];
 }
 export class ViteVueScaffolder extends FrameworkScaffolder {
     name = "vue-vite";
     command = "npm";
-    args = ["create", "vite@latest", ".", "--template", "vue-ts"];
+    args = ["create", "vite@latest", ".", "--", "--template", "vue-ts"];
 }
 export class NextScaffolder extends FrameworkScaffolder {
     name = "next";
@@ -61,12 +64,12 @@ export class AngularScaffolder extends FrameworkScaffolder {
 export class AstroScaffolder extends FrameworkScaffolder {
     name = "astro";
     command = "npm";
-    args = ["create", "astro@latest", ".", "--template", "minimal"];
+    args = ["create", "astro@latest", ".", "--", "--template", "minimal"];
 }
 export class SvelteScaffolder extends FrameworkScaffolder {
     name = "svelte";
     command = "npm";
-    args = ["create", "svite@latest", ".", "--template", "ts"];
+    args = ["create", "vite@latest", ".", "--", "--template", "svelte-ts"];
 }
 export class SvelteKitScaffolder extends FrameworkScaffolder {
     name = "sveltekit";
@@ -76,7 +79,7 @@ export class SvelteKitScaffolder extends FrameworkScaffolder {
 export class VanillaScaffolder extends FrameworkScaffolder {
     name = "vanilla";
     command = "npm";
-    args = ["create", "vite@latest", ".", "--template", "vanilla-ts"];
+    args = ["create", "vite@latest", ".", "--", "--template", "vanilla-ts"];
 }
 export class FlutterScaffolder extends FrameworkScaffolder {
     name = "flutter";

package/dist/src/scaffolders/scaffolder.helper.js

@@ -7,10 +7,15 @@ import { execCommand } from "../utils/utils.exec.js";
 import { writeFileTree } from "../utils/utils.fileSystem.js";
 export async function scaffoldWithFallback(options) {
     try {
-        await execCommand(options.command, Array.from(options.args), options.targetPath);
+        await execCommand(options.command, Array.from(options.args), options.targetPath, {
+            // Suppress interactive prompts from create-* tools.
+            env: { ...process.env, CI: "1" },
+        });
         return true;
     }
-    catch {
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`Warning: official scaffolder "${options.command} ${options.args.join(" ")}" failed (${message.split("\n")[0]}). Using built-in fallback template.`);
         await writeFileTree(options.targetPath, options.fallbackFiles);
         return false;
     }

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

@@ -1,5 +1,5 @@
 /**
  * zudojs-cli — Microservice Template Index
  */
-export { generateMicroserviceFiles } from "./microservice.template.js";
+export { generateMicroserviceFiles, resolveMicroserviceServices, DEFAULT_MICROSERVICE_SERVICES, RESERVED_MICROSERVICE_APP_NAMES, } from "./microservice.template.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,5 +1,5 @@
 /**
  * zudojs-cli — Microservice Template Index
  */
-export { generateMicroserviceFiles } from "./microservice.template.js";
+export { generateMicroserviceFiles, resolveMicroserviceServices, DEFAULT_MICROSERVICE_SERVICES, RESERVED_MICROSERVICE_APP_NAMES, } from "./microservice.template.js";
 //# sourceMappingURL=index.js.map

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

@@ -22,5 +22,19 @@
  * ```
  */
 import type { ScaffoldOptions } from "../../types/index.js";
+/** Default service names used when none are provided. */
+export declare const DEFAULT_MICROSERVICE_SERVICES: readonly ["identity", "enrollment", "assessment", "notification"];
+/**
+ * The gateway app is always generated at `apps/gateway`, so "gateway" is a
+ * reserved name: a service called `gateway` would produce a second, competing
+ * gateway at `apps/services/gateway`.
+ */
+export declare const RESERVED_MICROSERVICE_APP_NAMES: readonly ["gateway"];
+/**
+ * Normalizes a requested service list into the service apps generated under
+ * `apps/services/`. Reserved names and duplicates are dropped; an empty list
+ * falls back to DEFAULT_MICROSERVICE_SERVICES.
+ */
+export declare function resolveMicroserviceServices(requested: readonly string[]): readonly string[];
 export declare function generateMicroserviceFiles(options: ScaffoldOptions): Record<string, string>;
 //# sourceMappingURL=microservice.template.d.ts.map