zudojs-cli 0.1.2 → 1.1.0

package/dist/src/cliApplication/cliApplication.logger.d.ts

@@ -0,0 +1,28 @@
+/**
+ * zudojs-cli — CLI Logger
+ *
+ * A `Logger` whose output is plain terminal text.
+ *
+ * The CLI used `createDefaultLogger()` from `@zudojs/logger`, whose console
+ * transport prints the whole serialised log record. Every line a command
+ * wrote to the user came out as a multi-line object literal with a
+ * timestamp, a level, a logger name and an empty metadata block wrapped
+ * around the message. This logger keeps the `Logger` contract (commands
+ * still receive `context.logger`) and writes one line per call: info to
+ * stdout, warnings and errors to stderr.
+ *
+ * @module cliApplication/logger
+ */
+import { type Logger, type LoggerEntry } from "@zudojs/logger";
+export interface CLILoggerOptions {
+    /** Emit debug and trace lines too. Defaults to `ZUDOJS_DEBUG` being set. */
+    readonly verbose?: boolean;
+    /** Line writers, overridable for tests. */
+    readonly stdout?: (line: string) => void;
+    readonly stderr?: (line: string) => void;
+}
+/** Renders one entry as the single line the user sees. */
+export declare function formatCLILogLine(entry: LoggerEntry): string;
+/** Creates the logger handed to every command as `context.logger`. */
+export declare function createCLILogger(options?: CLILoggerOptions): Logger;
+//# sourceMappingURL=cliApplication.logger.d.ts.map

package/dist/src/cliApplication/cliApplication.logger.js

@@ -0,0 +1,68 @@
+/**
+ * zudojs-cli — CLI Logger
+ *
+ * A `Logger` whose output is plain terminal text.
+ *
+ * The CLI used `createDefaultLogger()` from `@zudojs/logger`, whose console
+ * transport prints the whole serialised log record. Every line a command
+ * wrote to the user came out as a multi-line object literal with a
+ * timestamp, a level, a logger name and an empty metadata block wrapped
+ * around the message. This logger keeps the `Logger` contract (commands
+ * still receive `context.logger`) and writes one line per call: info to
+ * stdout, warnings and errors to stderr.
+ *
+ * @module cliApplication/logger
+ */
+import { createLogger, LoggerLevel, } from "@zudojs/logger";
+/** Renders one entry as the single line the user sees. */
+export function formatCLILogLine(entry) {
+    switch (entry.levelName) {
+        case "fatal":
+        case "error":
+            return `Error: ${entry.message}`;
+        case "warn":
+            return `Warning: ${entry.message}`;
+        case "debug":
+        case "trace":
+            return `[${entry.levelName}] ${entry.message}`;
+        default:
+            return entry.message;
+    }
+}
+/** Creates the logger handed to every command as `context.logger`. */
+export function createCLILogger(options = {}) {
+    const verbose = options.verbose ??
+        (process.env["ZUDOJS_DEBUG"] !== undefined &&
+            process.env["ZUDOJS_DEBUG"] !== "" &&
+            process.env["ZUDOJS_DEBUG"] !== "0");
+    const stdout = options.stdout ?? ((line) => process.stdout.write(`${line}\n`));
+    const stderr = options.stderr ?? ((line) => process.stderr.write(`${line}\n`));
+    return createLogger({
+        name: "zudojs",
+        level: verbose ? LoggerLevel.TRACE : LoggerLevel.INFO,
+        // Writes must complete before a command returns; `process.exit` follows
+        // an error immediately.
+        asynchronous: false,
+        formatter: (entry) => formatCLILogLine(entry),
+        transports: [
+            {
+                name: "cli-stdio",
+                enabled: true,
+                write(entry) {
+                    // The formatter's output arrives as the entry message.
+                    const line = entry.message;
+                    switch (entry.levelName) {
+                        case "fatal":
+                        case "error":
+                        case "warn":
+                            stderr(line);
+                            break;
+                        default:
+                            stdout(line);
+                    }
+                },
+            },
+        ],
+    });
+}
+//# sourceMappingURL=cliApplication.logger.js.map

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

@@ -1,9 +1,7 @@
 /**
  * zudojs-cli — CLI Application
- *
- * Main application class, factory, built-in commands, and signal handling.
  */
 export { ZudojsCLI, createCLI } from "./cliApplication.core.js";
 export { createCLIWriter, registerCLIInterruptHandler, } from "./cliApplication.writer.js";
-export { isHelpRequest, isVersionRequest, printVersion, printHelp, } from "./cliApplication.builtins.js";
+export { createCLILogger, formatCLILogLine, type CLILoggerOptions, } from "./cliApplication.logger.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/cliApplication/index.js

@@ -1,9 +1,7 @@
 /**
  * zudojs-cli — CLI Application
- *
- * Main application class, factory, built-in commands, and signal handling.
  */
 export { ZudojsCLI, createCLI } from "./cliApplication.core.js";
 export { createCLIWriter, registerCLIInterruptHandler, } from "./cliApplication.writer.js";
-export { isHelpRequest, isVersionRequest, printVersion, printHelp, } from "./cliApplication.builtins.js";
+export { createCLILogger, formatCLILogLine, } from "./cliApplication.logger.js";
 //# sourceMappingURL=index.js.map

package/dist/src/cliConstant/cliConstant.value.d.ts

@@ -8,7 +8,7 @@ export declare const CLI_NAME = "zudojs";
 /** Default application configuration. */
 export declare const CLI_DEFAULTS: {
     readonly NAME: "zudojs";
-    readonly VERSION: "0.1.0";
+    readonly VERSION: string;
     readonly DESCRIPTION: "Command-line interface for the Zudojs framework.";
     readonly COMMAND_PREFIX: "zudojs";
     readonly DEFAULT_CWD: string;

package/dist/src/cliConstant/cliConstant.value.js

@@ -3,6 +3,7 @@
  *
  * Default values, limits, and magic strings used across the CLI package.
  */
+import { CLI_VERSION } from "./cliVersion.js";
 /* -------------------------------------------------------------------------- */
 /* Application Defaults                                                       */
 /* -------------------------------------------------------------------------- */
@@ -11,7 +12,7 @@ export const CLI_NAME = "zudojs";
 /** Default application configuration. */
 export const CLI_DEFAULTS = {
     NAME: "zudojs",
-    VERSION: "0.1.0",
+    VERSION: CLI_VERSION,
     DESCRIPTION: "Command-line interface for the Zudojs framework.",
     COMMAND_PREFIX: "zudojs",
     DEFAULT_CWD: process.cwd(),

package/dist/src/cliConstant/cliVersion.d.ts

@@ -0,0 +1,16 @@
+/**
+ * zudojs-cli — Version resolution
+ *
+ * The CLI's own version, read from its `package.json` at runtime.
+ *
+ * It used to be a hand-maintained string literal duplicated in two places
+ * (`constants/index.ts` and `cliConstant.value.ts`). Both are stamped into the
+ * manifest of every generated project, so a release that bumped `package.json`
+ * without editing both copies would silently scaffold projects claiming the
+ * previous version. Reading the manifest removes the duplication entirely.
+ *
+ * @module cliConstant/cliVersion
+ */
+/** The CLI's version, matching its `package.json`. */
+export declare const CLI_VERSION: string;
+//# sourceMappingURL=cliVersion.d.ts.map

package/dist/src/cliConstant/cliVersion.js

@@ -0,0 +1,57 @@
+/**
+ * zudojs-cli — Version resolution
+ *
+ * The CLI's own version, read from its `package.json` at runtime.
+ *
+ * It used to be a hand-maintained string literal duplicated in two places
+ * (`constants/index.ts` and `cliConstant.value.ts`). Both are stamped into the
+ * manifest of every generated project, so a release that bumped `package.json`
+ * without editing both copies would silently scaffold projects claiming the
+ * previous version. Reading the manifest removes the duplication entirely.
+ *
+ * @module cliConstant/cliVersion
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Package name to match, so a parent workspace manifest is never picked up. */
+const PACKAGE_NAME = "zudojs-cli";
+/** Directory levels to walk upward before giving up. */
+const MAX_LOOKUP_DEPTH = 8;
+/**
+ * Walks upward from this module looking for the CLI's own `package.json`.
+ *
+ * The compiled layout (`dist/src/cliConstant/`) sits one level deeper than the
+ * source layout (`src/cliConstant/`), so a fixed relative path would be correct
+ * in only one of them. Matching on `name` also means a parent workspace
+ * manifest cannot be mistaken for ours.
+ *
+ * @returns The version string declared in the CLI's `package.json`.
+ * @throws {Error} If the manifest cannot be located or has no string version.
+ */
+function readOwnVersion() {
+    let directory = dirname(fileURLToPath(import.meta.url));
+    for (let depth = 0; depth < MAX_LOOKUP_DEPTH; depth += 1) {
+        const manifestPath = join(directory, "package.json");
+        if (existsSync(manifestPath)) {
+            const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+            if (typeof parsed === "object" && parsed !== null) {
+                const { name, version } = parsed;
+                if (name === PACKAGE_NAME &&
+                    typeof version === "string" &&
+                    version.length > 0) {
+                    return version;
+                }
+            }
+        }
+        const parent = dirname(directory);
+        if (parent === directory) {
+            break;
+        }
+        directory = parent;
+    }
+    throw new Error(`${PACKAGE_NAME}: could not resolve its own package.json to read the version.`);
+}
+/** The CLI's version, matching its `package.json`. */
+export const CLI_VERSION = readOwnVersion();
+//# sourceMappingURL=cliVersion.js.map

package/dist/src/cliParser/cliParser.core.js

@@ -57,6 +57,13 @@ export class CLIParser {
             positional.push(token);
             index++;
         }
+        // Apply documented option defaults for options not provided on the CLI.
+        for (const definition of definitions) {
+            if (definition.defaultValue !== undefined &&
+                !(definition.name in options)) {
+                options[definition.name] = definition.defaultValue;
+            }
+        }
         const parsedArguments = this.parseArguments(positional, argumentsDefinitions);
         if (!this.allowUnknownCommands &&
             !command &&

package/dist/src/cliParser/cliParser.shortOption.js

@@ -5,7 +5,7 @@
  */
 import { CLI_OPTION_PREFIXES } from "../cliConstant/cliConstant.value.js";
 import { InvalidOptionError, MissingOptionValueError, } from "../cliError/cliError.option.js";
-import { findOption, assignOptionValue } from "./cliParser.longOption.js";
+import { assignOptionValue } from "./cliParser.longOption.js";
 /** Parses a short option token from the token stream. */
 export function parseShortOption(tokens, index, definitions, values, allowUnknownOptions) {
     const token = tokens[index];

package/dist/src/cliVersion/cliVersion.update.d.ts

@@ -0,0 +1,38 @@
+/**
+ * zudojs-cli — Update check
+ *
+ * Asks the npm registry whether a newer `zudojs-cli` exists.
+ *
+ * This used to run as a `postinstall` script. npm 11 and pnpm 10 no longer
+ * run install scripts of freshly added packages without explicit approval,
+ * so the check was skipped with a warning on every install and, worse, the
+ * warning made the CLI look broken before it had run once. The check now
+ * runs on demand from `zudojs info`, where a network round-trip is expected.
+ *
+ * @module cliVersion/update
+ */
+export interface UpdateCheckOptions {
+    /** Milliseconds to wait for the registry before giving up. */
+    readonly timeoutMs?: number;
+    readonly registryUrl?: string;
+    readonly packageName?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly fetchImpl?: typeof fetch;
+}
+export interface UpdateCheckResult {
+    readonly current: string;
+    /** The newer published version, or `null` when up to date or unknown. */
+    readonly latest: string | null;
+    /** Why no answer was obtained, when `latest` is `null`. */
+    readonly skipped?: "disabled" | "offline" | "unavailable";
+}
+/**
+ * Whether the update check is turned off for this environment.
+ *
+ * `ZUDOJS_NO_UPDATE_CHECK` disables it explicitly; `CI` and npm's offline
+ * mode disable it implicitly.
+ */
+export declare function isUpdateCheckDisabled(env?: NodeJS.ProcessEnv): boolean;
+/** Looks up the latest published version and compares it with `current`. */
+export declare function checkForNewerVersion(current: string, options?: UpdateCheckOptions): Promise<UpdateCheckResult>;
+//# sourceMappingURL=cliVersion.update.d.ts.map

package/dist/src/cliVersion/cliVersion.update.js

@@ -0,0 +1,63 @@
+/**
+ * zudojs-cli — Update check
+ *
+ * Asks the npm registry whether a newer `zudojs-cli` exists.
+ *
+ * This used to run as a `postinstall` script. npm 11 and pnpm 10 no longer
+ * run install scripts of freshly added packages without explicit approval,
+ * so the check was skipped with a warning on every install and, worse, the
+ * warning made the CLI look broken before it had run once. The check now
+ * runs on demand from `zudojs info`, where a network round-trip is expected.
+ *
+ * @module cliVersion/update
+ */
+import { compareVersions, isValidVersion } from "./cliVersion.core.js";
+/**
+ * Whether the update check is turned off for this environment.
+ *
+ * `ZUDOJS_NO_UPDATE_CHECK` disables it explicitly; `CI` and npm's offline
+ * mode disable it implicitly.
+ */
+export function isUpdateCheckDisabled(env = process.env) {
+    const flag = env["ZUDOJS_NO_UPDATE_CHECK"];
+    if (flag !== undefined && flag !== "" && flag !== "0")
+        return true;
+    if (env["CI"] !== undefined && env["CI"] !== "" && env["CI"] !== "false")
+        return true;
+    if (env["npm_config_offline"] === "true")
+        return true;
+    return false;
+}
+/** Looks up the latest published version and compares it with `current`. */
+export async function checkForNewerVersion(current, options = {}) {
+    if (isUpdateCheckDisabled(options.env)) {
+        return { current, latest: null, skipped: "disabled" };
+    }
+    const packageName = options.packageName ?? "zudojs-cli";
+    const registryUrl = options.registryUrl ?? "https://registry.npmjs.org";
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 3000);
+    try {
+        const response = await fetchImpl(`${registryUrl}/${encodeURIComponent(packageName)}/latest`, { signal: controller.signal });
+        if (!response.ok) {
+            return { current, latest: null, skipped: "unavailable" };
+        }
+        const data = (await response.json());
+        const latest = typeof data.version === "string" ? data.version : null;
+        if (latest === null ||
+            !isValidVersion(latest) ||
+            !isValidVersion(current) ||
+            compareVersions(latest, current) <= 0) {
+            return { current, latest: null };
+        }
+        return { current, latest };
+    }
+    catch {
+        return { current, latest: null, skipped: "offline" };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=cliVersion.update.js.map

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

@@ -1,7 +1,8 @@
 /**
  * zudojs-cli — CLI Version
  *
- * Semantic version parsing, comparison, and formatting.
+ * Semantic version parsing, comparison, formatting, and the update check.
  */
 export { getCLIVersion, formatCLIVersion, getVersionString, isValidVersion, compareVersions, parseVersion, isCompatibleVersion, type CLIVersionInfo, } from "./cliVersion.core.js";
+export { checkForNewerVersion, isUpdateCheckDisabled, type UpdateCheckOptions, type UpdateCheckResult, } from "./cliVersion.update.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/cliVersion/index.js

@@ -1,7 +1,8 @@
 /**
  * zudojs-cli — CLI Version
  *
- * Semantic version parsing, comparison, and formatting.
+ * Semantic version parsing, comparison, formatting, and the update check.
  */
 export { getCLIVersion, formatCLIVersion, getVersionString, isValidVersion, compareVersions, parseVersion, isCompatibleVersion, } from "./cliVersion.core.js";
+export { checkForNewerVersion, isUpdateCheckDisabled, } from "./cliVersion.update.js";
 //# sourceMappingURL=index.js.map

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

@@ -4,5 +4,34 @@
  * The `zudojs add` command for adding feature packages.
  */
 import type { CLIContext } from "../cliType/cliType.type.js";
+import { type ProjectLayout } from "../resolvers/layout/projectLayout.core.js";
+interface PackageJsonShape {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    zudojs?: Record<string, unknown>;
+}
+/**
+ * Picks the `package.json` files a feature is added to.
+ *
+ * The workspace root used to be the only target. In a fullstack project
+ * that root holds no application code, so `@zudojs/database` landed where
+ * nothing could import it while `apps/api` stayed without it. Features now
+ * go to every backend app (`apps/api`, or the gateway and each service of a
+ * microservice project); `--service <name>` narrows a microservice project
+ * to one app.
+ */
+export declare function selectAddTargets(layout: ProjectLayout, service: string | undefined): string[];
+/**
+ * The version written for a new `@zudojs/*` dependency.
+ *
+ * `workspace:*` was written whenever the project was a workspace. Every
+ * generated fullstack and microservice project is a workspace, and none of
+ * them contains the framework packages, so the next install failed with
+ * "not found in workspace". The protocol is now used only when the target
+ * already links a framework package that way — i.e. inside the Zudojs
+ * monorepo itself.
+ */
+export declare function versionForNewDependency(pkg: PackageJsonShape): string;
 export declare function runAddCommand(context: CLIContext): Promise<void>;
+export {};
 //# sourceMappingURL=add.command.d.ts.map

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

@@ -3,138 +3,126 @@
  *
  * The `zudojs add` command for adding feature packages.
  */
-import { join, dirname } from "node:path";
+import { join, relative } from "node:path";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { execCommand } from "../utils/utils.exec.js";
+import { runStreaming } from "../utils/utils.exec.js";
+import { assertSafePathSegment } from "../utils/utils.name.js";
 import { CLIValidationError, CLIGenerationError } from "../errors/index.js";
 import { ManifestManager } from "../manifest/manifestManager.core.js";
-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"],
-    scheduler: ["@zudojs/queue"],
-    docs: ["@zudojs/docs"],
-};
+import { getInstallCommand } from "../installers/dependency.installer.js";
+import { FEATURE_PACKAGES, ZUDOJS_PACKAGES_VERSION, } from "../constants/index.js";
+import { resolveProjectLayout, } from "../resolvers/layout/projectLayout.core.js";
+/**
+ * Picks the `package.json` files a feature is added to.
+ *
+ * The workspace root used to be the only target. In a fullstack project
+ * that root holds no application code, so `@zudojs/database` landed where
+ * nothing could import it while `apps/api` stayed without it. Features now
+ * go to every backend app (`apps/api`, or the gateway and each service of a
+ * microservice project); `--service <name>` narrows a microservice project
+ * to one app.
+ */
+export function selectAddTargets(layout, service) {
+    if (service !== undefined) {
+        if (layout.architecture !== "microservice") {
+            throw new CLIValidationError("--service only applies to microservice projects.");
+        }
+        const match = layout.backendDirs.find((dir) => dir.endsWith(`${join("apps", "services", service)}`));
+        const gateway = layout.backendDirs.find((dir) => dir.endsWith(join("apps", "gateway")));
+        const target = service === "gateway" ? gateway : match;
+        if (!target) {
+            throw new CLIValidationError(`Unknown service "${service}". Known: ${[
+                ...(gateway ? ["gateway"] : []),
+                ...layout.services,
+            ].join(", ")}`);
+        }
+        return [join(target, "package.json")];
+    }
+    return layout.backendDirs.map((dir) => join(dir, "package.json"));
+}
+/**
+ * The version written for a new `@zudojs/*` dependency.
+ *
+ * `workspace:*` was written whenever the project was a workspace. Every
+ * generated fullstack and microservice project is a workspace, and none of
+ * them contains the framework packages, so the next install failed with
+ * "not found in workspace". The protocol is now used only when the target
+ * already links a framework package that way — i.e. inside the Zudojs
+ * monorepo itself.
+ */
+export function versionForNewDependency(pkg) {
+    const linksFramework = Object.entries({
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+    }).some(([name, version]) => name.startsWith("@zudojs/") && version.startsWith("workspace:"));
+    return linksFramework ? "workspace:*" : ZUDOJS_PACKAGES_VERSION;
+}
 export async function runAddCommand(context) {
     const feature = context.values.feature;
+    const service = context.values.service;
+    const available = Object.keys(FEATURE_PACKAGES).join(", ");
     if (!feature) {
-        throw new CLIValidationError("Feature name is required. Available: database, queue, messaging, openapi, observability, security");
+        throw new CLIValidationError(`Feature name is required. Available: ${available}`);
     }
     const packages = FEATURE_PACKAGES[feature];
     if (!packages) {
-        throw new CLIValidationError(`Unknown feature: "${feature}". Available: ${Object.keys(FEATURE_PACKAGES).join(", ")}`);
+        throw new CLIValidationError(`Unknown feature: "${feature}". Available: ${available}`);
+    }
+    if (service !== undefined) {
+        assertSafePathSegment(service, "--service");
+    }
+    const layout = resolveProjectLayout(context.cwd);
+    if (!layout) {
+        throw new CLIValidationError("No Zudojs project found in this directory. Run `zudojs create` first.");
+    }
+    if (layout.projectType === "frontend") {
+        throw new CLIValidationError("Features are backend packages; this is a frontend-only project.");
+    }
+    const targets = selectAddTargets(layout, service);
+    if (targets.length === 0) {
+        throw new CLIValidationError("No backend app with a package.json was found in this project.");
     }
     context.logger.info(`Adding feature: ${feature}`);
     context.logger.info(`Packages: ${packages.join(", ")}`);
     try {
-        const { manager, rootPkg, isWorkspace } = detectPackageManager();
-        const pkgPath = join(context.cwd, rootPkg);
-        const version = isWorkspace ? "workspace:*" : readZudojsVersion();
-        if (!existsSync(pkgPath)) {
-            throw new CLIGenerationError(`Could not find package.json at ${pkgPath}`);
-        }
-        const pkgContent = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        pkgContent.dependencies ??= {};
-        pkgContent.zudojs ??= {
-            features: [],
-        };
-        const zudojsConfig = pkgContent.zudojs;
-        const features = new Set(zudojsConfig.features);
-        if (!features.has(feature)) {
+        for (const pkgPath of targets) {
+            if (!existsSync(pkgPath)) {
+                throw new CLIGenerationError(`Could not find ${pkgPath}`);
+            }
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            const version = versionForNewDependency(pkg);
+            pkg.dependencies ??= {};
+            pkg.zudojs ??= { features: [] };
+            const block = pkg.zudojs;
+            const features = new Set(Array.isArray(block.features)
+                ? block.features.filter((f) => typeof f === "string")
+                : []);
             features.add(feature);
-            zudojsConfig.features = [...features];
-        }
-        for (const pkg of packages) {
-            if (!(pkg in pkgContent.dependencies)) {
-                pkgContent.dependencies[pkg] = version;
+            block.features = [...features];
+            for (const name of packages) {
+                if (!(name in pkg.dependencies)) {
+                    pkg.dependencies[name] = version;
+                }
             }
+            writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+            context.logger.info(`Updated ${relative(context.cwd, pkgPath) || "package.json"}`);
         }
-        writeFileSync(pkgPath, JSON.stringify(pkgContent, null, 2) + "\n");
-        context.logger.info(`Updated ${rootPkg} with new dependencies.`);
-        updateZudojsConfig(context.cwd, feature);
-        const manifest = new ManifestManager(context.cwd);
-        const current = await manifest.read();
-        if (current) {
-            await manifest.addCapability(feature);
-        }
+        // The manifest records capabilities for the whole project.
+        await new ManifestManager(layout.root).addCapability(feature);
         if (context.values["skip-install"] !== true) {
-            context.logger.info(`Installing dependencies with ${manager}...`);
-            await execCommand(manager, ["install"], context.cwd);
+            const [file, ...args] = getInstallCommand(layout.packageManager);
+            context.logger.info(`Installing dependencies with ${file}...`);
+            await runStreaming(file, args, layout.root);
         }
         context.logger.info(`Feature "${feature}" added successfully.`);
-        context.logger.info(`Next steps:`);
-        context.logger.info(`  Configure in src/config/${feature}.config.ts`);
+        context.logger.info(`Import from ${packages.map((p) => `"${p}"`).join(", ")} in your modules.`);
     }
     catch (error) {
         if (error instanceof CLIValidationError) {
             throw error;
         }
         const message = error instanceof Error ? error.message : String(error);
-        context.logger.error(`Failed to add feature: ${feature} - ${message}`);
-        throw new CLIGenerationError(`Failed to add feature: ${feature}: ${message}`, error);
-    }
-}
-function detectPackageManager() {
-    if (existsSync("pnpm-workspace.yaml")) {
-        return { manager: "pnpm", rootPkg: "package.json", isWorkspace: true };
-    }
-    if (existsSync("yarn.lock")) {
-        return { manager: "yarn", rootPkg: "package.json", isWorkspace: true };
-    }
-    if (existsSync("lerna.json")) {
-        return { manager: "npm", rootPkg: "package.json", isWorkspace: true };
-    }
-    return { manager: "npm", rootPkg: "package.json", isWorkspace: false };
-}
-function readZudojsVersion() {
-    try {
-        const rootPkg = join(process.cwd(), "package.json");
-        if (existsSync(rootPkg)) {
-            const pkg = JSON.parse(readFileSync(rootPkg, "utf-8"));
-            return pkg.version ?? "latest";
-        }
-    }
-    catch {
-        // ignore
-    }
-    return "latest";
-}
-function updateZudojsConfig(cwd, feature) {
-    const configPath = join(cwd, "zudojs.config.ts");
-    if (!existsSync(configPath))
-        return;
-    let content = readFileSync(configPath, "utf-8");
-    const featureMap = {
-        database: "database",
-        queue: "queue",
-        messaging: "events",
-        openapi: "openapi",
-        observability: "observability",
-        security: "security",
-        cache: "cache",
-        storage: "storage",
-        scheduler: "scheduler",
-        docs: "docs",
-    };
-    const configKey = featureMap[feature];
-    if (!configKey)
-        return;
-    const pattern = /(export\s+default\s+defineConfig\(\{[\s\S]*?)\n\}\);/;
-    const match = content.match(pattern);
-    if (!match)
-        return;
-    const featureBlock = `\n  ${configKey}: {\n    enabled: true,\n  },`;
-    if (content.includes(`${configKey}:`)) {
-        content = content.replace(new RegExp(`${configKey}:\\s*\\{[^}]*\\}`), `${configKey}: {\n    enabled: true,\n  }`);
-    }
-    else {
-        content = content.replace(pattern, `$1${featureBlock}\n});`);
+        throw new CLIGenerationError(`Failed to add feature "${feature}": ${message}`, error);
     }
-    writeFileSync(configPath, content);
 }
 //# sourceMappingURL=add.command.js.map