@zero.core/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1469 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import path8 from "node:path";
+import { register as registerTypeScriptLoader } from "tsx/esm/api";
+import { fileURLToPath } from "node:url";
+
+// src/context.ts
+import { Writable } from "node:stream";
+var CliResult = class {
+  constructor(exitCode = 0) {
+    this.exitCode = exitCode;
+  }
+  exitCode;
+};
+var CliError = class extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+  exitCode;
+};
+var BufferedWritable = class extends Writable {
+  chunks = [];
+  _write(chunk, _encoding, callback) {
+    this.chunks.push(String(chunk));
+    callback();
+  }
+  text() {
+    return this.chunks.join("");
+  }
+};
+
+// src/utils/args.ts
+var ArgParser = class {
+  parse(argv) {
+    const positionals = [];
+    const options = /* @__PURE__ */ new Map();
+    for (let index = 0; index < argv.length; index += 1) {
+      const arg = argv[index];
+      if (!arg.startsWith("--")) {
+        positionals.push(arg);
+        continue;
+      }
+      const withoutPrefix = arg.slice(2);
+      const equalsIndex = withoutPrefix.indexOf("=");
+      if (equalsIndex >= 0) {
+        options.set(withoutPrefix.slice(0, equalsIndex), withoutPrefix.slice(equalsIndex + 1));
+        continue;
+      }
+      const next = argv[index + 1];
+      if (next && !next.startsWith("--")) {
+        options.set(withoutPrefix, next);
+        index += 1;
+      } else {
+        options.set(withoutPrefix, true);
+      }
+    }
+    return { positionals, options };
+  }
+};
+var OptionsReader = class {
+  constructor(args) {
+    this.args = args;
+  }
+  args;
+  string(name, fallback) {
+    const value = this.args.options.get(name);
+    if (value === void 0) return fallback;
+    if (typeof value === "boolean") return value ? "true" : "false";
+    return value;
+  }
+  requiredString(name) {
+    const value = this.string(name);
+    if (!value) throw new CliError(`Missing --${name}.`);
+    return value;
+  }
+  boolean(name, fallback = false) {
+    const value = this.args.options.get(name);
+    if (value === void 0) return fallback;
+    if (typeof value === "boolean") return value;
+    return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+  }
+  integer(name, fallback) {
+    const value = this.string(name);
+    if (value === void 0) return fallback;
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed)) throw new CliError(`--${name} must be an integer.`);
+    return parsed;
+  }
+};
+function hasHelp(argv) {
+  return argv.includes("--help") || argv.includes("-h") || argv.length === 0;
+}
+
+// src/utils/clientGenerator.ts
+var TypeScriptClientGenerator = class {
+  constructor(document, options = {}) {
+    this.document = document;
+    this.options = options;
+  }
+  document;
+  options;
+  generate() {
+    const clientName = this.options.clientName ?? "ApiClient";
+    const optionsName = this.options.optionsName ?? `${clientName}Options`;
+    const methods = this.operations().map(({ path: path9, method, operation }) => this.methodSource(path9, method, operation));
+    return `export interface ${optionsName} {
+  baseUrl: string;
+  headers?: HeadersInit;
+}
+
+export class ${clientName} {
+  constructor(private readonly options: ${optionsName}) {}
+
+  private async request(method: string, path: string, body?: unknown, init?: RequestInit) {
+    const response = await fetch(new URL(path, this.options.baseUrl), {
+      ...init,
+      method,
+      headers: {
+        ...(body === undefined ? {} : { "content-type": "application/json" }),
+        ...(this.options.headers ?? {}),
+        ...(init?.headers ?? {})
+      },
+      body: body === undefined ? undefined : JSON.stringify(body)
+    });
+    if (!response.ok) throw new Error(await response.text());
+    const contentType = response.headers.get("content-type") ?? "";
+    return contentType.includes("application/json") ? response.json() : response.blob();
+  }
+
+${methods.join(",\n")}
+
+  private buildPath(template: string, pathParams: Record<string, string | number>, query?: Record<string, string | number | boolean | undefined>) {
+    let path = template.replace(/\\{([^}]+)\\}/g, (_match, key) => encodeURIComponent(String(pathParams[key])));
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query ?? {})) {
+      if (value !== undefined) params.set(key, String(value));
+    }
+    const queryString = params.toString();
+    return queryString ? \`\${path}?\${queryString}\` : path;
+  }
+}
+`;
+  }
+  operations() {
+    return Object.entries(this.document.paths ?? {}).flatMap(
+      ([path9, pathItem]) => Object.entries(pathItem).filter((entry) => Boolean(entry[1])).map(([method, operation]) => ({ path: path9, method, operation }))
+    );
+  }
+  methodSource(path9, method, operation) {
+    const operationId = safeIdentifier(operation.operationId ?? `${method}_${path9.replace(/[^a-zA-Z0-9]+/g, "_")}`);
+    const pathParams = (operation.parameters ?? []).filter((parameter) => parameter.in === "path");
+    const queryParams = (operation.parameters ?? []).filter((parameter) => parameter.in === "query");
+    const hasBody = Boolean(operation.requestBody);
+    const args = [
+      pathParams.length ? "pathParams: Record<string, string | number>" : "",
+      queryParams.length ? "query?: Record<string, string | number | boolean | undefined>" : "",
+      hasBody ? "body?: unknown" : "",
+      "init?: RequestInit"
+    ].filter(Boolean).join(", ");
+    return `  ${operationId}(${args}) {
+    return this.request(${JSON.stringify(method.toUpperCase())}, this.buildPath(${JSON.stringify(path9)}, ${pathParams.length ? "pathParams" : "{}"}, ${queryParams.length ? "query" : "undefined"}), ${hasBody ? "body" : "undefined"}, init);
+  }`;
+  }
+};
+function safeIdentifier(value) {
+  const cleaned = value.replace(/[^a-zA-Z0-9_$]/g, "_");
+  return /^[a-zA-Z_$]/.test(cleaned) ? cleaned : `_${cleaned}`;
+}
+
+// src/utils/fs.ts
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+var WorkspaceFileSystem = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  cwd;
+  resolve(...parts) {
+    return path.resolve(this.cwd, ...parts);
+  }
+  async exists(filePath) {
+    try {
+      await stat(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async ensureDir(dir) {
+    await mkdir(dir, { recursive: true });
+  }
+  async readText(filePath) {
+    return readFile(filePath, "utf8");
+  }
+  async readJson(filePath) {
+    return JSON.parse(await this.readText(filePath));
+  }
+  async writeText(filePath, content, options = {}) {
+    if (!options.force && await this.exists(filePath)) {
+      throw new CliError(`File already exists: ${filePath}. Use --force to overwrite.`);
+    }
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, "utf8");
+  }
+  async listFiles(dir, options = {}) {
+    const fs = await import("node:fs/promises");
+    if (!await this.exists(dir)) return [];
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) return options.recursive === false ? [] : this.listFiles(fullPath, options);
+      if (!entry.isFile()) return [];
+      if (options.pattern && !options.pattern.test(entry.name)) return [];
+      return [fullPath];
+    }));
+    return files.flat().sort();
+  }
+  toFileUrl(filePath) {
+    return pathToFileURL(filePath).href;
+  }
+};
+
+// src/commands/clientCommand.ts
+async function runApiClientCommand(positionals, options, context) {
+  const [action] = positionals;
+  if (action !== "generate") throw new CliError("Usage: zerocore api client generate --input openapi.json --output src/client.ts [--name ZeroCoreClient]");
+  const reader = new OptionsReader({ positionals, options });
+  const fs = new WorkspaceFileSystem(context.cwd);
+  const input = fs.resolve(reader.requiredString("input"));
+  const output = fs.resolve(reader.requiredString("output"));
+  const clientName = reader.string("name", "ZeroCoreClient") ?? "ZeroCoreClient";
+  const optionsName = reader.string("options-name", `${clientName}Options`) ?? `${clientName}Options`;
+  const openApi = await fs.readJson(input);
+  const source = new TypeScriptClientGenerator(openApi, { clientName, optionsName }).generate();
+  await fs.writeText(output, source, { force: reader.boolean("force", true) });
+  context.stdout.write(`Generated TypeScript client at ${output}
+`);
+  return new CliResult(0);
+}
+
+// src/commands/diCommand.ts
+import path2 from "node:path";
+
+// src/utils/text.ts
+var TablePrinter = class {
+  print(stream, rows) {
+    if (!rows.length) return;
+    const widths = rows[0].map((_, index) => Math.max(...rows.map((row) => row[index]?.length ?? 0)));
+    for (const row of rows) {
+      stream.write(`${row.map((cell, index) => cell.padEnd(widths[index])).join("  ")}
+`);
+    }
+  }
+};
+function jsonLine(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+
+// src/commands/diCommand.ts
+async function runApiDiCommand(positionals, options, context) {
+  const [action] = positionals;
+  if (!["graph", "validate"].includes(action ?? "")) throw new CliError("Usage: zerocore api di <graph|validate> [--dir src] [--json]");
+  const reader = new OptionsReader({ positionals, options });
+  const fs = new WorkspaceFileSystem(context.cwd);
+  const graph = await new DiScanner(fs, fs.resolve(reader.string("dir", "src") ?? "src")).scan();
+  if (action === "graph") {
+    if (reader.boolean("json")) context.stdout.write(jsonLine(graph));
+    else new TablePrinter().print(context.stdout, [["Service", "Lifetime", "Dependencies"], ...graph.services.map((service) => [
+      service.name,
+      service.lifetime,
+      service.dependencies.join(", ") || "-"
+    ])]);
+    return new CliResult(0);
+  }
+  const report = new DiValidator(graph).validate();
+  context.stdout.write(reader.boolean("json") ? jsonLine(report) : formatDiReport(report));
+  return new CliResult(report.errors.length ? 1 : 0);
+}
+var DiScanner = class {
+  constructor(fs, root) {
+    this.fs = fs;
+    this.root = root;
+  }
+  fs;
+  root;
+  async scan() {
+    const files = await this.fs.listFiles(this.root, { pattern: /\.tsx?$/ });
+    const services = [];
+    for (const file of files) {
+      const source = await this.fs.readText(file);
+      const classes = [...source.matchAll(/export\s+class\s+([A-Za-z0-9_]+)/g)];
+      for (const classMatch of classes) {
+        const name = classMatch[1];
+        const before = source.slice(Math.max(0, classMatch.index - 500), classMatch.index);
+        const injectable = before.match(/@Injectable\s*\(([^)]*)\)/);
+        const constructorSource = constructorFor(source.slice(classMatch.index));
+        const injectDependencies = [...constructorSource.matchAll(/@Inject\s*\(\s*([A-Za-z0-9_."']+)\s*\)/g)].map((match) => cleanToken(match[1]));
+        const decoratorDependencies = injectable ? splitTokens(injectable[1]) : [];
+        const staticDependencies = staticInjectDependencies(source, name);
+        const dependencies = unique([...decoratorDependencies, ...injectDependencies, ...staticDependencies]);
+        if (injectable || dependencies.length || name.endsWith("Service") || name.endsWith("Controller")) {
+          services.push({
+            name,
+            file: path2.relative(this.fs.cwd, file),
+            lifetime: injectable ? "injectable" : "implicit",
+            dependencies,
+            hasConstructorParams: constructorSource.trim().length > 0
+          });
+        }
+      }
+    }
+    return { services: services.sort((left, right) => left.name.localeCompare(right.name)) };
+  }
+};
+var DiValidator = class {
+  constructor(graph) {
+    this.graph = graph;
+  }
+  graph;
+  validate() {
+    const errors = [];
+    const warnings = [];
+    const known = new Set(this.graph.services.map((service) => service.name));
+    for (const service of this.graph.services) {
+      if (service.hasConstructorParams && !service.dependencies.length) {
+        errors.push(`${service.name} has constructor parameters but no explicit DI metadata.`);
+      }
+      for (const dependency of service.dependencies) {
+        if (!known.has(dependency) && /^[A-Z]/.test(dependency)) {
+          warnings.push(`${service.name} depends on ${dependency}, but no matching service class was found in the scan.`);
+        }
+      }
+    }
+    for (const cycle of findCycles(this.graph)) {
+      errors.push(`Circular dependency: ${cycle.join(" -> ")}`);
+    }
+    return { errors, warnings };
+  }
+};
+function constructorFor(source) {
+  const match = source.match(/constructor\s*\(([\s\S]*?)\)\s*\{/);
+  return match?.[1] ?? "";
+}
+function staticInjectDependencies(source, className) {
+  const classBlock = source.slice(source.indexOf(`class ${className}`));
+  const match = classBlock.match(/static\s+(?:inject|dependencies)\s*=\s*\[([^\]]*)\]/);
+  return match ? splitTokens(match[1]) : [];
+}
+function splitTokens(value) {
+  return value.split(",").map((token) => cleanToken(token)).filter(Boolean);
+}
+function cleanToken(token) {
+  return token.trim().replace(/^["']|["']$/g, "");
+}
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+function findCycles(graph) {
+  const dependencies = new Map(graph.services.map((service) => [service.name, service.dependencies]));
+  const cycles = [];
+  const visit = (node, stack) => {
+    if (stack.includes(node)) {
+      cycles.push([...stack.slice(stack.indexOf(node)), node]);
+      return;
+    }
+    for (const dependency of dependencies.get(node) ?? []) {
+      if (dependencies.has(dependency)) visit(dependency, [...stack, node]);
+    }
+  };
+  for (const service of dependencies.keys()) visit(service, []);
+  return dedupeCycles(cycles);
+}
+function dedupeCycles(cycles) {
+  const seen = /* @__PURE__ */ new Set();
+  return cycles.filter((cycle) => {
+    const key = [...cycle].sort().join("|");
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function formatDiReport(report) {
+  const lines = [
+    ...report.errors.map((entry) => `error: ${entry}`),
+    ...report.warnings.map((entry) => `warning: ${entry}`),
+    report.errors.length ? "DI validation failed." : "DI validation passed."
+  ];
+  return `${lines.join("\n")}
+`;
+}
+
+// src/commands/doctorCommand.ts
+import path3 from "node:path";
+async function runDoctorCommand(positionals, options, context) {
+  const scope = positionals[0] ?? "api";
+  if (scope !== "api") throw new CliError("Only `zerocore doctor api` is implemented in this version.");
+  const reader = new OptionsReader({ positionals, options });
+  const fs = new WorkspaceFileSystem(context.cwd);
+  const report = await new ApiDoctor(fs, fs.resolve(reader.string("dir", ".") ?? ".")).run();
+  context.stdout.write(reader.boolean("json") ? jsonLine(report) : formatDoctorReport(report));
+  return new CliResult(report.diagnostics.some((diagnostic) => diagnostic.severity === "error") ? 1 : 0);
+}
+var ApiDoctor = class {
+  constructor(fs, root) {
+    this.fs = fs;
+    this.root = root;
+  }
+  fs;
+  root;
+  async run() {
+    const diagnostics = [];
+    const packagePath = path3.join(this.root, "package.json");
+    const tsconfigPath = path3.join(this.root, "tsconfig.json");
+    if (!await this.fs.exists(packagePath)) diagnostics.push({ severity: "warning", message: "package.json not found." });
+    if (!await this.fs.exists(tsconfigPath)) diagnostics.push({ severity: "warning", message: "tsconfig.json not found." });
+    const sourceRoot = await this.sourceRoot();
+    const controllerFiles = await this.fs.listFiles(path3.join(sourceRoot, "controllers"), { pattern: /Controller\.tsx?$/ });
+    const modelFiles = await this.fs.listFiles(path3.join(sourceRoot, "models"), { pattern: /\.tsx?$/ });
+    const serviceFiles = await this.fs.listFiles(path3.join(sourceRoot, "services"), { pattern: /Service\.tsx?$/ });
+    if (!controllerFiles.length) diagnostics.push({ severity: "warning", message: "No controller files found under src/controllers." });
+    for (const file of controllerFiles) {
+      const source = await this.fs.readText(file);
+      if (!source.includes("@ApiController")) diagnostics.push({ severity: "error", file, message: "Controller file is missing @ApiController." });
+      if (!source.includes("@Route")) diagnostics.push({ severity: "error", file, message: "Controller file is missing @Route." });
+      if (!source.includes("extends ControllerBase") && !source.includes("extends BaseController")) {
+        diagnostics.push({ severity: "warning", file, message: "Controller should extend ControllerBase or a project BaseController." });
+      }
+      for (const method of source.matchAll(/@(HttpGet|HttpPost|HttpPut|HttpPatch|HttpDelete|Get|Post|Put|Patch|Delete)\b[\s\S]*?\n\s*(?:async\s+)?([A-Za-z0-9_]+)\s*\(/g)) {
+        const beforeMethod = source.slice(Math.max(0, method.index - 400), method.index);
+        const routeBlock = method[0];
+        if (!beforeMethod.includes("@ProducesResponseType") && !beforeMethod.includes("@Produces(") && !routeBlock.includes("@ProducesResponseType") && !routeBlock.includes("@Produces(")) {
+          diagnostics.push({ severity: "warning", file, message: `Route method ${method[2]} has no explicit response metadata.` });
+        }
+      }
+    }
+    for (const file of modelFiles) {
+      const source = await this.fs.readText(file);
+      if (/\bclass\s+[A-Za-z0-9_]+/.test(source) && !source.includes("@ApiModel") && !source.includes("@DataContract")) {
+        diagnostics.push({ severity: "warning", file, message: "Model class file has no @ApiModel or @DataContract metadata." });
+      }
+    }
+    return {
+      diagnostics,
+      stats: {
+        controllers: controllerFiles.length,
+        models: modelFiles.length,
+        services: serviceFiles.length
+      }
+    };
+  }
+  async sourceRoot() {
+    const src = path3.join(this.root, "src");
+    return await this.fs.exists(src) ? src : this.root;
+  }
+};
+function formatDoctorReport(report) {
+  const lines = [
+    `API doctor: ${report.stats.controllers} controllers, ${report.stats.models} model files, ${report.stats.services} services`
+  ];
+  for (const diagnostic of report.diagnostics) {
+    const file = diagnostic.file ? ` ${diagnostic.file}` : "";
+    lines.push(`${diagnostic.severity}:${file} ${diagnostic.message}`);
+  }
+  if (!report.diagnostics.length) lines.push("No issues found.");
+  return `${lines.join("\n")}
+`;
+}
+
+// src/commands/apiGenerateCommand.ts
+import path4 from "node:path";
+
+// src/utils/names.ts
+var NameInflector = class {
+  classify(value) {
+    return this.words(value).map((word) => word.slice(0, 1).toUpperCase() + word.slice(1)).join("");
+  }
+  camel(value) {
+    const classified = this.classify(value);
+    return classified.slice(0, 1).toLowerCase() + classified.slice(1);
+  }
+  kebab(value) {
+    return this.words(value).join("-");
+  }
+  plural(value) {
+    const classified = this.classify(value);
+    if (classified.endsWith("y")) return `${classified.slice(0, -1)}ies`;
+    if (/(s|x|z|ch|sh)$/i.test(classified)) return `${classified}es`;
+    return `${classified}s`;
+  }
+  words(value) {
+    return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).map((word) => word.trim().toLowerCase()).filter(Boolean);
+  }
+};
+
+// src/commands/apiGenerateCommand.ts
+async function runApiGenerateCommand(positionals, options, context) {
+  const [kind, rawName] = positionals;
+  if (!kind || !rawName) throw new CliError("Usage: zerocore api generate <resource|controller|service|dto|test|subscriber> <Name> [--dir src] [--force]");
+  const reader = new OptionsReader({ positionals, options });
+  const fs = new WorkspaceFileSystem(context.cwd);
+  const generator = new ApiGenerator(fs, reader.string("dir", "src") ?? "src", reader.boolean("force"));
+  const name = new NameInflector().classify(rawName);
+  if (kind === "controller") await generator.controller(name);
+  else if (kind === "service") await generator.service(name);
+  else if (kind === "dto") await generator.dto(name);
+  else if (kind === "test") await generator.test(name);
+  else if (kind === "subscriber") await generator.subscriber(name, {
+    topic: reader.string("topic") ?? `${new NameInflector().kebab(name)}.created`,
+    provider: reader.string("provider"),
+    retries: reader.integer("retries"),
+    deadLetterTopic: reader.string("dead-letter-topic")
+  });
+  else if (kind === "resource") await generator.resource(name);
+  else throw new CliError(`Unsupported API generator: ${kind}`);
+  context.stdout.write(`Generated ${kind} ${name}
+`);
+  return new CliResult(0);
+}
+var ApiGenerator = class {
+  constructor(fs, sourceDir, force) {
+    this.fs = fs;
+    this.sourceDir = sourceDir;
+    this.force = force;
+  }
+  fs;
+  sourceDir;
+  force;
+  names = new NameInflector();
+  async resource(name) {
+    await this.dtoModels(name);
+    await this.service(name);
+    await this.controller(name);
+    await this.test(this.names.plural(name));
+  }
+  async controller(name) {
+    const baseName = name.endsWith("Controller") ? name.slice(0, -"Controller".length) : name;
+    const plural = this.names.plural(baseName);
+    await this.write(path4.join(this.sourceDir, "controllers", `${plural}Controller.ts`), controllerTemplate(baseName, plural));
+  }
+  async service(name) {
+    const baseName = name.endsWith("Service") ? name.slice(0, -"Service".length) : name;
+    await this.write(path4.join(this.sourceDir, "services", `${baseName}Service.ts`), serviceTemplate(baseName));
+  }
+  async dto(name) {
+    await this.write(path4.join(this.sourceDir, "models", `${name}.ts`), dtoTemplate(name));
+  }
+  async test(name) {
+    const baseName = name.endsWith("Controller") ? name.slice(0, -"Controller".length) : name;
+    const plural = this.names.plural(baseName);
+    await this.write(path4.join("test", `${plural}Controller.test.ts`), testTemplate(plural));
+  }
+  async subscriber(name, options) {
+    const baseName = name.endsWith("Subscriber") ? name.slice(0, -"Subscriber".length) : name;
+    await this.write(path4.join(this.sourceDir, "events", `${baseName}Subscriber.ts`), subscriberTemplate(baseName, options));
+  }
+  async dtoModels(name) {
+    await this.write(path4.join(this.sourceDir, "models", `${name}Models.ts`), resourceModelsTemplate(name));
+  }
+  async write(relativePath, content) {
+    await this.fs.writeText(this.fs.resolve(relativePath), content, { force: this.force });
+  }
+};
+function resourceModelsTemplate(name) {
+  return `import { ApiModel, ApiProperty } from "@zero.core/api-framework";
+
+@ApiModel()
+export class ${name}Dto {
+  @ApiProperty({ type: String })
+  id = "";
+
+  @ApiProperty({ type: String })
+  name = "";
+}
+
+@ApiModel()
+export class Create${name}Request {
+  @ApiProperty({ type: String })
+  name = "";
+}
+
+@ApiModel()
+export class Update${name}Request {
+  @ApiProperty({ type: String, required: false })
+  name?: string;
+}
+`;
+}
+function dtoTemplate(name) {
+  return `import { ApiModel, ApiProperty } from "@zero.core/api-framework";
+
+@ApiModel()
+export class ${name} {
+  @ApiProperty({ type: String })
+  id = "";
+}
+`;
+}
+function serviceTemplate(name) {
+  const variable = new NameInflector().camel(name);
+  return `import { randomUUID } from "node:crypto";
+import { ApiError, Injectable } from "@zero.core/api-framework";
+import { Create${name}Request, ${name}Dto, Update${name}Request } from "../models/${name}Models";
+
+@Injectable()
+export class ${name}Service {
+  private readonly ${variable}s = new Map<string, ${name}Dto>();
+
+  list(): ${name}Dto[] {
+    return [...this.${variable}s.values()];
+  }
+
+  get(id: string): ${name}Dto {
+    const item = this.${variable}s.get(id);
+    if (!item) throw ApiError.notFound("${name} not found.", "${variable}_not_found");
+    return item;
+  }
+
+  create(request: Create${name}Request): ${name}Dto {
+    const item = Object.assign(new ${name}Dto(), {
+      id: randomUUID(),
+      name: request.name
+    });
+    this.${variable}s.set(item.id, item);
+    return item;
+  }
+
+  update(id: string, request: Update${name}Request): ${name}Dto {
+    const item = this.get(id);
+    if (request.name !== undefined) item.name = request.name;
+    return item;
+  }
+
+  delete(id: string): void {
+    this.${variable}s.delete(id);
+  }
+}
+`;
+}
+function controllerTemplate(name, plural) {
+  const variable = new NameInflector().camel(name);
+  return `import {
+  ApiController,
+  ControllerBase,
+  FromBody,
+  FromRoute,
+  HttpDelete,
+  HttpGet,
+  HttpPatch,
+  HttpPost,
+  Inject,
+  ProducesResponseType,
+  Route,
+  SuccessResponse
+} from "@zero.core/api-framework";
+import { Create${name}Request, ${name}Dto, Update${name}Request } from "../models/${name}Models";
+import { ${name}Service } from "../services/${name}Service";
+
+@ApiController({ tags: ["${plural}"] })
+@Route("/api/${new NameInflector().kebab(plural)}")
+export class ${plural}Controller extends ControllerBase {
+  constructor(@Inject(${name}Service) private readonly ${variable}s: ${name}Service) {
+    super();
+  }
+
+  @HttpGet("/")
+  @ProducesResponseType(${name}Dto, { isArray: true })
+  list(): ${name}Dto[] {
+    return this.${variable}s.list();
+  }
+
+  @HttpGet("/:id")
+  @ProducesResponseType(${name}Dto)
+  get(@FromRoute("id") id: string): ${name}Dto {
+    return this.${variable}s.get(id);
+  }
+
+  @HttpPost("/")
+  @SuccessResponse(201)
+  @ProducesResponseType(${name}Dto, 201)
+  create(@FromBody(Create${name}Request, { transform: true, stripUnknown: true }) request: Create${name}Request): ${name}Dto {
+    return this.${variable}s.create(request);
+  }
+
+  @HttpPatch("/:id")
+  @ProducesResponseType(${name}Dto)
+  update(
+    @FromRoute("id") id: string,
+    @FromBody(Update${name}Request, { transform: true, stripUnknown: true }) request: Update${name}Request
+  ): ${name}Dto {
+    return this.${variable}s.update(id, request);
+  }
+
+  @HttpDelete("/:id")
+  @SuccessResponse(204)
+  delete(@FromRoute("id") id: string): void {
+    this.${variable}s.delete(id);
+  }
+}
+`;
+}
+function testTemplate(plural) {
+  return `import assert from "node:assert/strict";
+import test from "node:test";
+
+test("${plural}Controller exposes generated resource routes", () => {
+  assert.equal("${plural}Controller".endsWith("Controller"), true);
+});
+`;
+}
+function subscriberTemplate(name, options) {
+  const methodName = `handle${name}`;
+  return `import {
+  Injectable,
+  MessageBody,
+  MessageEnvelope,
+  Subscribe
+} from "@zero.core/api-framework";
+import type { PubSubEnvelope } from "@zero.core/api-framework";
+
+export interface ${name}Message {
+  id: string;
+  occurredAt: string;
+}
+
+@Injectable()
+export class ${name}Subscriber {
+  @Subscribe("${options.topic}", ${subscriberOptions(options)})
+  ${methodName}(
+    @MessageBody() message: ${name}Message,
+    @MessageEnvelope() envelope: PubSubEnvelope<${name}Message>
+  ): void {
+    void message;
+    void envelope;
+  }
+}
+`;
+}
+function subscriberOptions(options) {
+  const entries = [
+    `name: "${new NameInflector().kebab(options.topic)}-subscriber"`,
+    options.provider ? `provider: "${options.provider}"` : void 0,
+    options.retries !== void 0 ? `retries: ${options.retries}` : void 0,
+    options.deadLetterTopic ? `deadLetterTopic: "${options.deadLetterTopic}"` : void 0
+  ].filter(Boolean);
+  return `{
+    ${entries.join(",\n    ")}
+  }`;
+}
+
+// src/commands/newCommand.ts
+import path5 from "node:path";
+async function runNewCommand(positionals, options, context) {
+  const [kind, name] = positionals;
+  if (!kind || !name) throw new CliError("Usage: zerocore new <api|app|package> <name> [--dir <path>] [--force]");
+  if (!["api", "app", "package"].includes(kind)) throw new CliError(`Unsupported project kind: ${kind}`);
+  const reader = new OptionsReader({ positionals, options });
+  const fs = new WorkspaceFileSystem(context.cwd);
+  const targetRoot = fs.resolve(reader.string("dir", ".") ?? ".", new NameInflector().kebab(name));
+  const force = reader.boolean("force");
+  if (kind === "api") await new ProjectScaffolder(fs, targetRoot, name, force).api();
+  if (kind === "app") await new ProjectScaffolder(fs, targetRoot, name, force).app();
+  if (kind === "package") await new ProjectScaffolder(fs, targetRoot, name, force).package();
+  context.stdout.write(`Created ${kind} project at ${path5.relative(context.cwd, targetRoot)}
+`);
+  return new CliResult(0);
+}
+var ProjectScaffolder = class {
+  constructor(fs, root, name, force) {
+    this.fs = fs;
+    this.root = root;
+    this.name = name;
+    this.force = force;
+  }
+  fs;
+  root;
+  name;
+  force;
+  names = new NameInflector();
+  async api() {
+    const packageName = this.names.kebab(this.name);
+    await this.write("package.json", JSON.stringify({
+      name: packageName,
+      version: "0.1.0",
+      private: true,
+      type: "module",
+      scripts: {
+        dev: "tsx src/index.ts",
+        typecheck: "tsc --noEmit -p tsconfig.json"
+      },
+      dependencies: {
+        "@zero.core/api-framework": "1.0.0",
+        express: "^5.1.0"
+      },
+      devDependencies: {
+        "@types/express": "^5.0.0",
+        tsx: "^4.19.0",
+        typescript: "^5.7.0"
+      }
+    }, null, 2));
+    await this.write("tsconfig.json", tsconfig());
+    await this.write("README.md", `# ${this.names.classify(this.name)} API
+
+Generated with ZeroCore CLI.
+`);
+    await this.write("src/index.ts", apiIndexTemplate());
+    await this.write("src/models/HealthDto.ts", healthDtoTemplate());
+    await this.write("src/services/HealthService.ts", healthServiceTemplate());
+    await this.write("src/controllers/HealthController.ts", healthControllerTemplate());
+  }
+  async app() {
+    const packageName = this.names.kebab(this.name);
+    await this.write("package.json", JSON.stringify({
+      name: packageName,
+      version: "0.1.0",
+      private: true,
+      type: "module",
+      scripts: {
+        dev: "tsx src/index.ts",
+        typecheck: "tsc --noEmit -p tsconfig.json"
+      },
+      devDependencies: {
+        tsx: "^4.19.0",
+        typescript: "^5.7.0"
+      }
+    }, null, 2));
+    await this.write("tsconfig.json", tsconfig());
+    await this.write("README.md", `# ${this.names.classify(this.name)}
+
+Generated with ZeroCore CLI.
+`);
+    await this.write("src/index.ts", `export const appName = "${packageName}";
+
+console.log(\`Started \${appName}\`);
+`);
+  }
+  async package() {
+    const packageName = this.names.kebab(this.name);
+    await this.write("package.json", JSON.stringify({
+      name: packageName,
+      version: "0.1.0",
+      private: true,
+      type: "module",
+      exports: {
+        ".": "./src/index.ts"
+      },
+      scripts: {
+        typecheck: "tsc --noEmit -p tsconfig.json"
+      },
+      devDependencies: {
+        typescript: "^5.7.0"
+      }
+    }, null, 2));
+    await this.write("tsconfig.json", tsconfig());
+    await this.write("README.md", `# ${this.names.classify(this.name)}
+
+Generated with ZeroCore CLI.
+`);
+    await this.write("src/index.ts", `export const packageName = "${packageName}";
+`);
+  }
+  async write(relativePath, content) {
+    await this.fs.writeText(path5.join(this.root, relativePath), content, { force: this.force });
+  }
+};
+function tsconfig() {
+  return `${JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "Bundler",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      noEmit: true
+    },
+    include: ["src", "test"]
+  }, null, 2)}
+`;
+}
+function apiIndexTemplate() {
+  return `import express from "express";
+import { ControllerDiscovery, ServiceContainer, errorHandler, notFoundHandler } from "@zero.core/api-framework";
+import { HealthService } from "./services/HealthService";
+
+const app = express();
+app.use(express.json());
+
+const services = new ServiceContainer()
+  .addSingleton(HealthService);
+
+await new ControllerDiscovery({
+  controllersDir: new URL("./controllers", import.meta.url),
+  recursive: true
+}).register(app, {
+  services,
+  openApi: {
+    info: { title: "Generated API", version: "0.1.0" }
+  }
+});
+
+app.use(notFoundHandler, errorHandler);
+
+const port = Number(process.env.PORT ?? 3000);
+app.listen(port, () => console.log(\`API running at http://127.0.0.1:\${port}\`));
+`;
+}
+function healthDtoTemplate() {
+  return `import { ApiModel, ApiProperty } from "@zero.core/api-framework";
+
+@ApiModel()
+export class HealthDto {
+  @ApiProperty({ type: String })
+  status = "ok";
+}
+`;
+}
+function healthServiceTemplate() {
+  return `import { Injectable } from "@zero.core/api-framework";
+import { HealthDto } from "../models/HealthDto";
+
+@Injectable()
+export class HealthService {
+  read(): HealthDto {
+    return new HealthDto();
+  }
+}
+`;
+}
+function healthControllerTemplate() {
+  return `import { ApiController, ControllerBase, HttpGet, Inject, ProducesResponseType, Route } from "@zero.core/api-framework";
+import { HealthDto } from "../models/HealthDto";
+import { HealthService } from "../services/HealthService";
+
+@ApiController({ tags: ["Health"] })
+@Route("/health")
+export class HealthController extends ControllerBase {
+  constructor(@Inject(HealthService) private readonly healthService: HealthService) {
+    super();
+  }
+
+  @HttpGet("/")
+  @ProducesResponseType(HealthDto)
+  health(): HealthDto {
+    return this.healthService.read();
+  }
+}
+`;
+}
+
+// src/commands/openApiCommand.ts
+async function runOpenApiCommand(positionals, options, context) {
+  const [action, first, second] = positionals;
+  if (!action) throw new CliError("Usage: zerocore api openapi <validate|print|diff> ...");
+  const reader = new OptionsReader({ positionals, options });
+  const fs = new WorkspaceFileSystem(context.cwd);
+  if (action === "validate") {
+    const file = fs.resolve(reader.string("input", first ?? "openapi.json") ?? "openapi.json");
+    const report = new OpenApiInspector(await fs.readJson(file)).validate();
+    context.stdout.write(reader.boolean("json") ? jsonLine(report) : formatValidation(report));
+    return new CliResult(report.errors.length ? 1 : 0);
+  }
+  if (action === "print") {
+    const file = fs.resolve(reader.string("input", first ?? "openapi.json") ?? "openapi.json");
+    const document = await fs.readJson(file);
+    context.stdout.write(reader.boolean("min") ? `${JSON.stringify(document)}
+` : jsonLine(document));
+    return new CliResult(0);
+  }
+  if (action === "diff") {
+    if (!first || !second) throw new CliError("Usage: zerocore api openapi diff <old.json> <new.json> [--json]");
+    const oldDocument = await fs.readJson(fs.resolve(first));
+    const newDocument = await fs.readJson(fs.resolve(second));
+    const report = new OpenApiInspector(newDocument).diff(oldDocument);
+    context.stdout.write(reader.boolean("json") ? jsonLine(report) : formatDiff(report));
+    return new CliResult(report.breaking.length ? 1 : 0);
+  }
+  throw new CliError(`Unsupported OpenAPI action: ${action}`);
+}
+var OpenApiInspector = class {
+  constructor(document) {
+    this.document = document;
+  }
+  document;
+  validate() {
+    const errors = [];
+    const warnings = [];
+    if (!this.document.openapi) errors.push("Missing openapi version.");
+    if (!this.document.info?.title) errors.push("Missing info.title.");
+    if (!this.document.info?.version) errors.push("Missing info.version.");
+    if (!this.document.paths || !Object.keys(this.document.paths).length) errors.push("No paths found.");
+    for (const [route, methods] of Object.entries(this.document.paths ?? {})) {
+      for (const [method, operation] of Object.entries(methods)) {
+        if (!httpMethods.has(method)) continue;
+        if (!operation.operationId) warnings.push(`${method.toUpperCase()} ${route} is missing operationId.`);
+        if (!operation.responses || !Object.keys(operation.responses).length) errors.push(`${method.toUpperCase()} ${route} has no responses.`);
+      }
+    }
+    return { errors, warnings, stats: this.stats() };
+  }
+  diff(oldDocument) {
+    const oldOperations = operationKeys(oldDocument);
+    const newOperations = operationKeys(this.document);
+    const breaking = [];
+    const warnings = [];
+    const added = [];
+    const removed = [];
+    for (const key of oldOperations) {
+      if (!newOperations.has(key)) {
+        breaking.push(`Removed operation ${key}.`);
+        removed.push(key);
+      }
+    }
+    for (const key of newOperations) {
+      if (!oldOperations.has(key)) added.push(key);
+    }
+    const oldSchemas = Object.keys(oldDocument.components?.schemas ?? {});
+    const newSchemas = new Set(Object.keys(this.document.components?.schemas ?? {}));
+    for (const schema of oldSchemas) {
+      if (!newSchemas.has(schema)) breaking.push(`Removed schema ${schema}.`);
+    }
+    for (const schema of newSchemas) {
+      if (!oldSchemas.includes(schema)) warnings.push(`Added schema ${schema}.`);
+    }
+    return { breaking, warnings, added, removed };
+  }
+  stats() {
+    const paths = Object.keys(this.document.paths ?? {}).length;
+    let operations = 0;
+    for (const methods of Object.values(this.document.paths ?? {})) {
+      operations += Object.keys(methods).filter((method) => httpMethods.has(method)).length;
+    }
+    return { paths, operations, schemas: Object.keys(this.document.components?.schemas ?? {}).length };
+  }
+};
+var httpMethods = /* @__PURE__ */ new Set(["get", "put", "post", "delete", "patch", "head", "options", "trace"]);
+function operationKeys(document) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const [route, methods] of Object.entries(document.paths ?? {})) {
+    for (const method of Object.keys(methods)) {
+      if (httpMethods.has(method)) keys.add(`${method.toUpperCase()} ${route}`);
+    }
+  }
+  return keys;
+}
+function formatValidation(report) {
+  return [
+    `OpenAPI: ${report.stats.paths} paths, ${report.stats.operations} operations, ${report.stats.schemas} schemas`,
+    ...report.errors.map((error) => `error: ${error}`),
+    ...report.warnings.map((warning) => `warning: ${warning}`),
+    report.errors.length ? "Validation failed." : "Validation passed."
+  ].join("\n") + "\n";
+}
+function formatDiff(report) {
+  return [
+    ...report.breaking.map((entry) => `breaking: ${entry}`),
+    ...report.warnings.map((entry) => `warning: ${entry}`),
+    ...report.added.map((entry) => `added: ${entry}`),
+    ...report.removed.map((entry) => `removed: ${entry}`),
+    report.breaking.length ? "Diff has breaking changes." : "Diff has no breaking changes."
+  ].join("\n") + "\n";
+}
+
+// src/commands/pubSubCommand.ts
+import path6 from "node:path";
+async function runApiPubSubCommand(positionals, options, context) {
+  const [action] = positionals;
+  if (!["providers", "scan", "validate"].includes(action ?? "")) {
+    throw new CliError("Usage: zerocore api pubsub <providers|scan|validate> [--dir src] [--json]");
+  }
+  const reader = new OptionsReader({ positionals, options });
+  const fs = new WorkspaceFileSystem(context.cwd);
+  if (action === "providers") {
+    if (reader.boolean("json")) context.stdout.write(jsonLine({ providers: PUBSUB_PROVIDERS }));
+    else new TablePrinter().print(context.stdout, [
+      ["Name", "Package", "Provider", "Broker"],
+      ...PUBSUB_PROVIDERS.map((provider) => [provider.name, provider.packageName, provider.providerName, provider.broker])
+    ]);
+    return new CliResult(0);
+  }
+  const report = await new PubSubScanner(fs, fs.resolve(reader.string("dir", "src") ?? "src")).scan();
+  if (action === "scan") {
+    if (reader.boolean("json")) context.stdout.write(jsonLine(report));
+    else printSubscribers(context, report);
+    return new CliResult(0);
+  }
+  const validation = validatePubSubReport(report);
+  context.stdout.write(reader.boolean("json") ? jsonLine(validation) : formatValidation2(validation));
+  return new CliResult(validation.errors.length ? 1 : 0);
+}
+var PUBSUB_PROVIDERS = [
+  {
+    name: "memory",
+    packageName: "@zero.core/api-framework",
+    providerName: "MemoryPubSubProvider",
+    broker: "in-memory",
+    install: "yarn add @zero.core/api-framework"
+  },
+  {
+    name: "redis-pubsub",
+    packageName: "@zero.core/pubsub-redis-pubsub-plugin",
+    providerName: "RedisPubSubPlugin",
+    broker: "Redis Pub/Sub",
+    install: "yarn add @zero.core/pubsub-redis-pubsub-plugin"
+  },
+  {
+    name: "redis-streams",
+    packageName: "@zero.core/pubsub-redis-streams-plugin",
+    providerName: "RedisStreamsPubSubPlugin",
+    broker: "Redis Streams",
+    install: "yarn add @zero.core/pubsub-redis-streams-plugin"
+  },
+  {
+    name: "nats",
+    packageName: "@zero.core/pubsub-nats-plugin",
+    providerName: "NatsPubSubPlugin",
+    broker: "NATS",
+    install: "yarn add @zero.core/pubsub-nats-plugin"
+  },
+  {
+    name: "confluent-kafka",
+    packageName: "@zero.core/pubsub-confluent-kafka-plugin",
+    providerName: "ConfluentKafkaPubSubPlugin",
+    broker: "Confluent Kafka",
+    install: "yarn add @zero.core/pubsub-confluent-kafka-plugin"
+  }
+];
+var PubSubScanner = class {
+  constructor(fs, root) {
+    this.fs = fs;
+    this.root = root;
+  }
+  fs;
+  root;
+  async scan() {
+    const files = await this.fs.listFiles(this.root, { pattern: /\.tsx?$/ });
+    const subscribers = [];
+    const diagnostics = [];
+    for (const file of files) {
+      const source = await this.fs.readText(file);
+      subscribers.push(...subscribersFromSource(source, file, this.fs.cwd));
+      for (const invalid of invalidSubscribeDecorators(source)) {
+        diagnostics.push({ severity: "error", file: path6.relative(this.fs.cwd, file), message: invalid });
+      }
+    }
+    return {
+      subscribers: subscribers.sort((left, right) => left.topic.localeCompare(right.topic) || left.className.localeCompare(right.className)),
+      diagnostics
+    };
+  }
+};
+function subscribersFromSource(source, file, cwd) {
+  const subscribers = [];
+  const decoratorPattern = /@Subscribe\s*\(\s*["'`]([^"'`]+)["'`]\s*(?:,\s*\{([\s\S]*?)\})?\s*\)\s*(?:\r?\n\s*)+(?:async\s+)?([A-Za-z0-9_]+)\s*\(/g;
+  for (const match of source.matchAll(decoratorPattern)) {
+    const options = match[2] ?? "";
+    subscribers.push({
+      className: classNameBefore(source, match.index ?? 0),
+      methodName: match[3],
+      topic: match[1],
+      provider: stringOption(options, "provider") ?? "default",
+      subscriptionName: stringOption(options, "name"),
+      enabled: !/\benabled\s*:\s*false\b/.test(options),
+      file: path6.relative(cwd, file)
+    });
+  }
+  return subscribers;
+}
+function invalidSubscribeDecorators(source) {
+  const diagnostics = [];
+  for (const match of source.matchAll(/@Subscribe\s*\(([^)]*)\)/g)) {
+    if (!/^\s*["'`][^"'`]+["'`]/.test(match[1])) {
+      diagnostics.push("@Subscribe must declare a literal topic string as its first argument.");
+    }
+  }
+  return diagnostics;
+}
+function classNameBefore(source, index) {
+  const matches = [...source.slice(0, index).matchAll(/\bclass\s+([A-Za-z0-9_]+)/g)];
+  return matches.at(-1)?.[1] ?? "UnknownSubscriber";
+}
+function stringOption(source, name) {
+  const pattern = new RegExp(`\\b${name}\\s*:\\s*["'\`]([^"'\`]+)["'\`]`);
+  return source.match(pattern)?.[1];
+}
+function validatePubSubReport(report) {
+  const errors = report.diagnostics.filter((diagnostic) => diagnostic.severity === "error").map((diagnostic) => diagnostic.message);
+  const knownProviders = new Set(PUBSUB_PROVIDERS.map((provider) => provider.name));
+  const warnings = [
+    ...report.diagnostics.filter((diagnostic) => diagnostic.severity === "warning").map((diagnostic) => diagnostic.message),
+    ...report.subscribers.filter((subscriber) => subscriber.provider !== "default" && !knownProviders.has(subscriber.provider)).map((subscriber) => `${subscriber.className}.${subscriber.methodName} uses custom provider '${subscriber.provider}'.`),
+    ...report.subscribers.length ? [] : ["No @Subscribe handlers found."]
+  ];
+  return { errors, warnings, subscribers: report.subscribers.length };
+}
+function printSubscribers(context, report) {
+  if (!report.subscribers.length) {
+    context.stdout.write("No @Subscribe handlers found.\n");
+    return;
+  }
+  new TablePrinter().print(context.stdout, [
+    ["Handler", "Topic", "Provider", "Enabled", "File"],
+    ...report.subscribers.map((subscriber) => [
+      `${subscriber.className}.${subscriber.methodName}`,
+      subscriber.topic,
+      subscriber.provider,
+      String(subscriber.enabled),
+      subscriber.file
+    ])
+  ]);
+}
+function formatValidation2(report) {
+  const lines = [
+    ...report.errors.map((error) => `error: ${error}`),
+    ...report.warnings.map((warning) => `warning: ${warning}`),
+    report.errors.length ? "Pub/sub validation failed." : `Pub/sub validation passed: ${report.subscribers} subscribers.`
+  ];
+  return `${lines.join("\n")}
+`;
+}
+
+// src/commands/tasksCommand.ts
+import { createRequire } from "node:module";
+import path7 from "node:path";
+async function runApiTasksCommand(positionals, options, context) {
+  const [action, taskName] = positionals;
+  if (!["list", "run"].includes(action ?? "")) throw new CliError("Usage: zerocore api tasks <list|run> [taskName] [--dir src/tasks] [--json]");
+  const reader = new OptionsReader({ positionals, options });
+  const fs = new WorkspaceFileSystem(context.cwd);
+  if (action === "list") {
+    const scheduler2 = await schedulerFromOptions(fs, reader);
+    const tasks = scheduler2.tasks();
+    if (reader.boolean("json")) context.stdout.write(jsonLine(tasks));
+    else new TablePrinter().print(context.stdout, [["Name", "Schedule", "Enabled"], ...tasks.map((task) => [
+      task.name,
+      task.schedule.kind === "cron" ? task.schedule.expression ?? "" : `${task.schedule.everyMs}ms`,
+      String(task.enabled)
+    ])]);
+    return new CliResult(0);
+  }
+  if (!taskName) throw new CliError("Usage: zerocore api tasks run <taskName> [--dir src/tasks]");
+  const scheduler = await schedulerFromOptions(fs, reader);
+  const result = await scheduler.runOnce(taskName);
+  context.stdout.write(reader.boolean("json") ? jsonLine(result) : `Task ${result.taskName}: ${result.status}
+`);
+  return new CliResult(result.status === "failed" ? 1 : 0);
+}
+async function schedulerFromOptions(fs, reader) {
+  const modulePath = reader.string("module");
+  if (modulePath) return schedulerFromModule(fs, modulePath);
+  const tasksDir = fs.resolve(reader.string("dir", "src/tasks") ?? "src/tasks");
+  const framework = await loadApiFrameworkFromProject(fs.cwd);
+  if (typeof framework.TaskDiscovery !== "function") {
+    throw new CliError("The target project's @zero.core/api-framework package does not export TaskDiscovery.");
+  }
+  return new framework.TaskDiscovery({ tasksDir, recursive: true }).scheduler();
+}
+async function schedulerFromModule(fs, modulePath) {
+  const loaded = await import(fs.toFileUrl(fs.resolve(modulePath)));
+  const candidate = loaded.createScheduler ?? loaded.createTaskScheduler ?? loaded.scheduler ?? loaded.default;
+  const scheduler = typeof candidate === "function" ? await candidate() : candidate;
+  if (!scheduler || typeof scheduler.runOnce !== "function" || typeof scheduler.tasks !== "function") {
+    throw new CliError("--module must export a TaskScheduler instance or a function that returns one.");
+  }
+  return scheduler;
+}
+async function loadApiFrameworkFromProject(cwd) {
+  const projectRequire = createRequire(path7.join(cwd, "package.json"));
+  let resolved;
+  try {
+    resolved = projectRequire.resolve("@zero.core/api-framework");
+  } catch {
+    throw new CliError("zerocore api tasks --dir requires @zero.core/api-framework to be installed in the target API project. Install it there or use --module to export a scheduler.");
+  }
+  return import(new WorkspaceFileSystem(cwd).toFileUrl(resolved));
+}
+
+// src/utils/versionCheck.ts
+import https from "node:https";
+var CLI_PACKAGE_NAME = "@zero.core/cli";
+var CLI_VERSION = "1.0.0";
+var NpmRegistryVersionChecker = class {
+  async latestVersion(packageName, options) {
+    return await new Promise((resolve) => {
+      let settled = false;
+      const done = (value) => {
+        if (settled) return;
+        settled = true;
+        resolve(value);
+      };
+      const registry = options.registryUrl.replace(/\/+$/, "");
+      const url = new URL(`${encodeURIComponent(packageName)}/latest`, `${registry}/`);
+      const request = https.get(url, {
+        headers: {
+          accept: "application/json",
+          "user-agent": `${CLI_PACKAGE_NAME}/${CLI_VERSION}`
+        }
+      }, (response) => {
+        if (response.statusCode !== 200) {
+          response.resume();
+          done(void 0);
+          return;
+        }
+        let body = "";
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          body += chunk;
+          if (body.length > 64e3) {
+            request.destroy();
+            done(void 0);
+          }
+        });
+        response.on("end", () => {
+          try {
+            const parsed = JSON.parse(body);
+            done(typeof parsed.version === "string" ? parsed.version : void 0);
+          } catch {
+            done(void 0);
+          }
+        });
+      });
+      request.setTimeout(options.timeoutMs, () => {
+        request.destroy();
+        done(void 0);
+      });
+      request.on("error", () => done(void 0));
+    });
+  }
+};
+async function maybeNotifyCliUpdate(options, context) {
+  if (!shouldCheckForUpdates(options, context.env)) return;
+  const checker = context.versionChecker ?? new NpmRegistryVersionChecker();
+  const latest = await checker.latestVersion(CLI_PACKAGE_NAME, {
+    registryUrl: registryUrlFromEnv(context.env),
+    timeoutMs: timeoutFromEnv(context.env)
+  });
+  if (!latest || compareVersions(latest, CLI_VERSION) <= 0) return;
+  context.stderr.write(
+    `Update available: ${CLI_PACKAGE_NAME} ${CLI_VERSION} -> ${latest}. Run: yarn add --dev ${CLI_PACKAGE_NAME}@latest
+`
+  );
+}
+function shouldCheckForUpdates(options, env) {
+  if (options.get("no-version-check") === true) return false;
+  const setting = env.ZEROCORE_CLI_VERSION_CHECK;
+  if (setting && ["0", "false", "off", "no"].includes(setting.toLowerCase())) return false;
+  if (env.CI && !env.ZEROCORE_CLI_VERSION_CHECK_FORCE) return false;
+  return true;
+}
+function compareVersions(left, right) {
+  const leftParts = parseVersion(left);
+  const rightParts = parseVersion(right);
+  for (let index = 0; index < 3; index += 1) {
+    const diff = leftParts[index] - rightParts[index];
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function registryUrlFromEnv(env) {
+  return env.ZEROCORE_CLI_REGISTRY_URL ?? env.npm_config_registry ?? env.NPM_CONFIG_REGISTRY ?? "https://registry.npmjs.org";
+}
+function timeoutFromEnv(env) {
+  const raw = env.ZEROCORE_CLI_VERSION_CHECK_TIMEOUT_MS;
+  if (!raw) return 500;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) throw new CliError("ZEROCORE_CLI_VERSION_CHECK_TIMEOUT_MS must be a positive integer.");
+  return parsed;
+}
+function parseVersion(value) {
+  const match = value.trim().replace(/^v/, "").match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return [0, 0, 0];
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+
+// src/cli.ts
+async function runCli(argv, context) {
+  const parser = new ArgParser();
+  const parsed = parser.parse(argv);
+  try {
+    if (hasHelp(argv)) {
+      context.stdout.write(rootHelp());
+      return new CliResult(0);
+    }
+    const [command, area, action, ...rest] = parsed.positionals;
+    if (command === "version" || command === "--version" || command === "-v") {
+      context.stdout.write(`${CLI_PACKAGE_NAME} ${CLI_VERSION}
+`);
+      return new CliResult(0);
+    }
+    await maybeNotifyCliUpdate(parsed.options, context);
+    if (command === "new") return await runNewCommand(clean([area, action, ...rest]), parsed.options, context);
+    if (command === "doctor") return await runDoctorCommand(clean([area, action, ...rest]), parsed.options, context);
+    if (command === "api" && area === "generate") return await runApiGenerateCommand(clean([action, ...rest]), parsed.options, context);
+    if (command === "api" && area === "openapi") return await runOpenApiCommand(clean([action, ...rest]), parsed.options, context);
+    if (command === "api" && area === "client") return await runApiClientCommand(clean([action, ...rest]), parsed.options, context);
+    if (command === "api" && area === "di") return await runApiDiCommand(clean([action, ...rest]), parsed.options, context);
+    if (command === "api" && area === "tasks") return await runApiTasksCommand(clean([action, ...rest]), parsed.options, context);
+    if (command === "api" && area === "pubsub") return await runApiPubSubCommand(clean([action, ...rest]), parsed.options, context);
+    throw new CliError(`Unknown command: ${argv.join(" ")}`);
+  } catch (error) {
+    if (error instanceof CliError) {
+      context.stderr.write(`${error.message}
+`);
+      return new CliResult(error.exitCode);
+    }
+    throw error;
+  }
+}
+function clean(values) {
+  return values.filter((value) => Boolean(value));
+}
+function rootHelp() {
+  return `ZeroCore CLI
+
+Usage:
+  zerocore new api <name> [--dir <path>] [--force]
+  zerocore new app <name> [--dir <path>] [--force]
+  zerocore new package <name> [--dir <path>] [--force]
+  zerocore api generate resource <Name> [--dir src] [--force]
+  zerocore api generate controller <Name> [--dir src] [--force]
+  zerocore api generate service <Name> [--dir src] [--force]
+  zerocore api generate dto <Name> [--dir src] [--force]
+  zerocore api generate test <Name> [--dir .] [--force]
+  zerocore api generate subscriber <Name> [--topic topic.name] [--provider provider-name] [--dir src] [--force]
+  zerocore doctor [api] [--dir .] [--json]
+  zerocore api openapi validate [file] [--json]
+  zerocore api openapi print [file] [--min]
+  zerocore api openapi diff <old.json> <new.json> [--json]
+  zerocore api client generate --input openapi.json --output src/client.ts [--name ZeroCoreClient]
+  zerocore api di graph [--dir src] [--json]
+  zerocore api di validate [--dir src] [--json]
+  zerocore api tasks list [--dir src/tasks] [--json]
+  zerocore api tasks run <taskName> [--dir src/tasks]
+  zerocore api pubsub providers [--json]
+  zerocore api pubsub scan [--dir src] [--json]
+  zerocore api pubsub validate [--dir src] [--json]
+
+`;
+}
+
+// src/index.ts
+registerTypeScriptLoader();
+var entryPath = fileURLToPath(import.meta.url);
+var invokedPath = process.argv[1] ? path8.resolve(process.argv[1]) : "";
+if (entryPath === invokedPath) {
+  void runCli(process.argv.slice(2), {
+    cwd: process.cwd(),
+    stdout: process.stdout,
+    stderr: process.stderr,
+    env: process.env
+  }).then((result) => {
+    process.exitCode = result.exitCode;
+  });
+}
+export {
+  BufferedWritable,
+  CLI_PACKAGE_NAME,
+  CLI_VERSION,
+  CliError,
+  CliResult,
+  compareVersions,
+  runCli
+};
+//# sourceMappingURL=index.js.map