@devcraft-ts/diadem 0.1.0

package/dist/cli.js

@@ -0,0 +1,815 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync } from 'fs';
+import { resolve, dirname, join, relative } from 'path';
+import ts from 'typescript';
+
+var DEFAULTS = {
+  scanDirs: ["src"],
+  // Default: every .ts file. The AST pass keeps only DI-decorated classes, so
+  // `include` is purely an optional performance narrowing (e.g. ['Service\\.ts$']).
+  include: ["\\.ts$"],
+  exclude: [
+    "\\.test\\.ts$",
+    "\\.spec\\.ts$",
+    "\\.d\\.ts$",
+    "node_modules",
+    "/dist/",
+    "/build/",
+    "/generated/"
+  ],
+  outFile: "src/generated/service-manifest.ts",
+  environments: ["development", "production", "test"],
+  emit: "manifest",
+  targetEnv: void 0
+};
+function stripUndefined(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([, v]) => v !== void 0)
+  );
+}
+function loadConfig(rootDir, overrides = {}) {
+  let fileConfig = {};
+  const configPath = resolve(rootDir, "diadem.config.json");
+  if (existsSync(configPath)) {
+    fileConfig = JSON.parse(
+      readFileSync(configPath, "utf8")
+    );
+  }
+  const merged = {
+    ...DEFAULTS,
+    ...stripUndefined(fileConfig),
+    ...stripUndefined(overrides)
+  };
+  return {
+    rootDir,
+    scanDirs: merged.scanDirs,
+    include: merged.include.map((p) => new RegExp(p)),
+    exclude: merged.exclude.map((p) => new RegExp(p)),
+    outFile: merged.outFile,
+    environments: merged.environments,
+    emit: merged.emit,
+    targetEnv: merged.targetEnv
+  };
+}
+var PACKAGE_NAME = "@devcraft-ts/diadem";
+var LIFECYCLE_BY_DECORATOR = {
+  singleton: "singleton",
+  factory: "factory",
+  lazy: "lazy",
+  lazySingleton: "lazySingleton",
+  injectable: "dependency"
+};
+var PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "Date",
+  "Array",
+  "Object",
+  "any",
+  "unknown",
+  "void",
+  "null",
+  "undefined",
+  "Promise",
+  "RegExp",
+  "Error",
+  "Map",
+  "Set"
+]);
+function generateManifest(config) {
+  const files = collectFiles(config);
+  const services = [];
+  for (const file of files) {
+    services.push(...analyzeFile(file.fullPath, file.relPath));
+  }
+  const { sorted, cycles, duplicateTokens } = resolveAndSort(services);
+  sorted.forEach((service, index) => {
+    service.registrationOrder = index;
+  });
+  const outFile = resolve(config.rootDir, config.outFile);
+  const content = config.emit === "compiled" ? renderCompiled(sorted, config, outFile) : renderManifest(sorted, config, outFile);
+  mkdirSync(dirname(outFile), { recursive: true });
+  writeFileSync(outFile, content, "utf8");
+  const externalDependencies = sorted.reduce(
+    (sum, s) => sum + s.resolvedDependencies.filter((d) => d.external).length,
+    0
+  );
+  const unresolved = [];
+  for (const service of sorted) {
+    for (const dep of service.resolvedDependencies) {
+      if (dep.external && !dep.isOptional) {
+        unresolved.push({
+          service: service.className,
+          paramName: dep.paramName,
+          typeName: dep.typeName
+        });
+      }
+    }
+  }
+  return {
+    outFile,
+    serviceCount: sorted.length,
+    cycles,
+    externalDependencies,
+    unresolved,
+    duplicateTokens
+  };
+}
+function collectFiles(config) {
+  const files = [];
+  for (const dir of config.scanDirs) {
+    const abs = resolve(config.rootDir, dir);
+    if (!existsSync(abs)) {
+      continue;
+    }
+    walk(abs, dir, config, files);
+  }
+  return files;
+}
+function walk(absDir, relDir, config, out) {
+  for (const entry of readdirSync(absDir, { withFileTypes: true })) {
+    const fullPath = join(absDir, entry.name);
+    const relPath = join(relDir, entry.name);
+    if (entry.isDirectory()) {
+      walk(fullPath, relPath, config, out);
+    } else if (entry.isFile() && shouldScan(relPath, config)) {
+      out.push({ fullPath, relPath });
+    }
+  }
+}
+function shouldScan(relPath, config) {
+  const normalized = relPath.replace(/\\/g, "/");
+  if (config.exclude.some((re) => re.test(normalized))) {
+    return false;
+  }
+  return config.include.some((re) => re.test(normalized));
+}
+function analyzeFile(fullPath, relPath) {
+  const source = ts.createSourceFile(
+    fullPath,
+    readFileSync(fullPath, "utf8"),
+    ts.ScriptTarget.Latest,
+    /* setParentNodes */
+    true
+  );
+  const tokenSources = /* @__PURE__ */ new Map();
+  const fileDir = dirname(fullPath);
+  const exportedClasses = /* @__PURE__ */ new Set();
+  ts.forEachChild(source, function collect(node) {
+    if (ts.isImportDeclaration(node) && node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings) && ts.isStringLiteral(node.moduleSpecifier)) {
+      const specifier = node.moduleSpecifier.text;
+      const module = specifier.startsWith(".") ? { kind: "file", fullPath: resolve(fileDir, specifier) } : { kind: "bare", specifier };
+      for (const element of node.importClause.namedBindings.elements) {
+        tokenSources.set(element.name.text, module);
+      }
+    }
+    if (ts.isClassDeclaration(node) && node.name && isExported(node)) {
+      exportedClasses.add(node.name.text);
+      tokenSources.set(node.name.text, { kind: "file", fullPath });
+    }
+    ts.forEachChild(node, collect);
+  });
+  const services = [];
+  ts.forEachChild(source, function visit(node) {
+    if (ts.isClassDeclaration(node)) {
+      const info = analyzeClass(node, fullPath, relPath, exportedClasses, tokenSources);
+      if (info) {
+        services.push(info);
+      }
+    }
+    ts.forEachChild(node, visit);
+  });
+  return services;
+}
+function analyzeClass(node, fullPath, relPath, exportedClasses, tokenSources) {
+  if (!node.name) {
+    return null;
+  }
+  const decoratorInfo = findDIDecorator(node);
+  if (!decoratorInfo) {
+    return null;
+  }
+  const dependencies = analyzeConstructor(node);
+  const token = decoratorInfo.token;
+  return {
+    className: node.name.text,
+    lifecycle: decoratorInfo.lifecycle,
+    environment: decoratorInfo.environment,
+    token,
+    tokenExported: !!token && exportedClasses.has(token),
+    tokenModule: token ? tokenSources.get(token) : void 0,
+    fullPath,
+    filePath: relPath.replace(/\\/g, "/"),
+    exported: isExported(node),
+    dependencies,
+    resolvedDependencies: [],
+    registrationOrder: 0
+  };
+}
+function findDIDecorator(node) {
+  const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) ?? [] : [];
+  for (const decorator of decorators) {
+    const expr = decorator.expression;
+    let name = "";
+    let args;
+    if (ts.isCallExpression(expr)) {
+      name = expr.expression.getText();
+      args = expr.arguments;
+    } else if (ts.isIdentifier(expr)) {
+      name = expr.getText();
+    }
+    const lifecycle = LIFECYCLE_BY_DECORATOR[name];
+    if (!lifecycle) {
+      continue;
+    }
+    let token;
+    let environment;
+    if (args && args.length > 0 && ts.isIdentifier(args[0])) {
+      token = args[0].getText();
+    }
+    if (args && args.length > 1 && ts.isStringLiteral(args[1])) {
+      environment = args[1].text;
+    }
+    return { lifecycle, token, environment };
+  }
+  return null;
+}
+function analyzeConstructor(node) {
+  const ctor = node.members.find((m) => ts.isConstructorDeclaration(m));
+  if (!ctor) {
+    return [];
+  }
+  const deps = [];
+  ctor.parameters.forEach((param, index) => {
+    if (!param.type) {
+      return;
+    }
+    const typeName = extractTypeName(param.type);
+    if (isPrimitive(typeName)) {
+      return;
+    }
+    const modifiers = ts.canHaveModifiers(param) ? ts.getModifiers(param) ?? [] : [];
+    deps.push({
+      paramName: param.name.getText(),
+      paramIndex: index,
+      typeName,
+      isOptional: !!param.questionToken || !!param.initializer,
+      isReadonly: modifiers.some(
+        (m) => m.kind === ts.SyntaxKind.ReadonlyKeyword
+      ),
+      isPrivate: modifiers.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword)
+    });
+  });
+  return deps;
+}
+function extractTypeName(typeNode) {
+  const raw = ts.isTypeReferenceNode(typeNode) ? typeNode.typeName.getText() : typeNode.getText();
+  return raw.replace(/<[^>]*>/g, "").replace(/\[\]/g, "").trim();
+}
+function isPrimitive(typeName) {
+  return PRIMITIVE_TYPES.has(typeName) || typeName.toLowerCase() === typeName || typeName.includes("<");
+}
+function isExported(node) {
+  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+  return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function resolveAndSort(services) {
+  const serviceByName = /* @__PURE__ */ new Map();
+  const tokenToImpl = /* @__PURE__ */ new Map();
+  const duplicateTokens = /* @__PURE__ */ new Set();
+  for (const service of services) {
+    serviceByName.set(service.className, service);
+    if (service.token) {
+      if (tokenToImpl.has(service.token)) {
+        duplicateTokens.add(service.token);
+      } else {
+        tokenToImpl.set(service.token, service.className);
+      }
+    }
+  }
+  const resolveByHeuristic = (typeName) => {
+    const direct = serviceByName.get(typeName);
+    if (direct) {
+      return direct.className;
+    }
+    if (typeName.startsWith("I")) {
+      const stripped = typeName.slice(1);
+      if (serviceByName.has(stripped)) {
+        return stripped;
+      }
+      const suffixed = services.find(
+        (s) => (s.className.endsWith("Service") || s.className.endsWith("Repository")) && s.className.includes(stripped)
+      );
+      if (suffixed) {
+        return suffixed.className;
+      }
+    }
+    return void 0;
+  };
+  for (const service of services) {
+    service.resolvedDependencies = service.dependencies.map((dep) => {
+      const implementingService = tokenToImpl.get(dep.typeName) ?? resolveByHeuristic(dep.typeName);
+      return implementingService ? { ...dep, implementingService } : { ...dep, external: true };
+    });
+  }
+  const { sorted, cycles } = topologicalSort(services, serviceByName);
+  return { sorted, cycles, duplicateTokens: [...duplicateTokens] };
+}
+function topologicalSort(services, serviceByName) {
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const sorted = [];
+  const cycles = [];
+  const visit = (name) => {
+    if (visited.has(name)) {
+      return;
+    }
+    if (visiting.has(name)) {
+      cycles.push(name);
+      return;
+    }
+    const service = serviceByName.get(name);
+    if (!service) {
+      return;
+    }
+    visiting.add(name);
+    for (const dep of service.resolvedDependencies) {
+      if (dep.implementingService && !dep.external) {
+        visit(dep.implementingService);
+      }
+    }
+    visiting.delete(name);
+    visited.add(name);
+    sorted.push(service);
+  };
+  for (const service of services) {
+    visit(service.className);
+  }
+  return { sorted, cycles };
+}
+function importPathFor(outFile, serviceFullPath) {
+  let rel = relative(dirname(outFile), serviceFullPath).replace(/\\/g, "/").replace(/\.ts$/, "");
+  if (!rel.startsWith(".")) {
+    rel = `./${rel}`;
+  }
+  return rel;
+}
+function groupByEnvironment(services, environments) {
+  const groups = { all: [] };
+  for (const env of environments) {
+    groups[env] = [];
+  }
+  for (const service of services) {
+    groups.all.push(service);
+    if (service.environment) {
+      groups[service.environment]?.push(service);
+    } else {
+      for (const env of environments) {
+        groups[env].push(service);
+      }
+    }
+  }
+  return groups;
+}
+function toEntry(service, outFile) {
+  const entry = {
+    className: service.className,
+    importPath: importPathFor(outFile, service.fullPath),
+    lifecycle: service.lifecycle,
+    exported: service.exported,
+    filePath: service.filePath,
+    registrationOrder: service.registrationOrder,
+    dependencies: service.dependencies,
+    resolvedDependencies: service.resolvedDependencies
+  };
+  if (service.environment) {
+    entry.environment = service.environment;
+  }
+  return entry;
+}
+function renderManifest(services, config, outFile) {
+  const byEnv = groupByEnvironment(services, config.environments);
+  const importsByPath = /* @__PURE__ */ new Map();
+  for (const service of services) {
+    const path = importPathFor(outFile, service.fullPath);
+    const names = importsByPath.get(path) ?? /* @__PURE__ */ new Set();
+    names.add(service.className);
+    if (service.token && service.token !== service.className && service.tokenExported) {
+      names.add(service.token);
+    }
+    importsByPath.set(path, names);
+  }
+  const staticImports = [...importsByPath.keys()].sort().map((path) => {
+    const names = [...importsByPath.get(path) ?? []].sort();
+    return names.length === 1 ? `import { ${names[0]} } from '${path}'` : `import {
+  ${names.join(",\n  ")}
+} from '${path}'`;
+  }).join("\n");
+  const serviceClassMapping = services.map((s) => `  ${s.className}`).join(",\n");
+  const envEntries = ["all", ...config.environments].map(
+    (env) => `  ${env}: ${JSON.stringify(byEnv[env].map((s) => toEntry(s, outFile)), null, 2)} as ServiceManifestEntry[]`
+  ).join(",\n");
+  const lifecycleCounts = ["dependency", "singleton", "factory", "lazy", "lazySingleton"].map((lc) => `    ${lc}: ${services.filter((s) => s.lifecycle === lc).length}`).join(",\n");
+  const totalDependencies = services.reduce(
+    (sum, s) => sum + s.dependencies.length,
+    0
+  );
+  const externalDependencies = services.reduce(
+    (sum, s) => sum + s.resolvedDependencies.filter((d) => d.external).length,
+    0
+  );
+  const maxDepth = services.reduce(
+    (max, s) => Math.max(max, s.dependencies.length),
+    0
+  );
+  return `/**
+ * Auto-generated by \`diadem build\`. DO NOT EDIT MANUALLY.
+ *
+ * Total services: ${services.length}
+ */
+
+/* eslint-disable */
+
+import type {
+  ImportedService,
+  ServiceManifestEntry
+} from '${PACKAGE_NAME}'
+
+${staticImports}
+
+export const SERVICE_MANIFEST: ServiceManifestEntry[] = ${JSON.stringify(
+    services.map((s) => toEntry(s, outFile)),
+    null,
+    2
+  )} as ServiceManifestEntry[]
+
+export const SERVICES_BY_ENVIRONMENT = {
+${envEntries}
+}
+
+export const SERVICE_CLASSES = {
+${serviceClassMapping}
+} as const
+
+export function getServicesForEnvironment(
+  environment?: string
+): ServiceManifestEntry[] {
+  if (!environment || environment === 'all') {
+    return SERVICE_MANIFEST
+  }
+  return (
+    SERVICES_BY_ENVIRONMENT[
+      environment as keyof typeof SERVICES_BY_ENVIRONMENT
+    ] ?? []
+  )
+}
+
+export async function importService(entry: ServiceManifestEntry) {
+  const serviceClass =
+    SERVICE_CLASSES[entry.className as keyof typeof SERVICE_CLASSES]
+  if (!serviceClass) {
+    throw new Error(\`Service \${entry.className} not found in manifest.\`)
+  }
+  return serviceClass
+}
+
+export async function importAllServices(
+  entries: ServiceManifestEntry[]
+): Promise<ImportedService[]> {
+  const ordered = [...entries].sort(
+    (a, b) => a.registrationOrder - b.registrationOrder
+  )
+  const results: ImportedService[] = []
+  for (const entry of ordered) {
+    const serviceClass =
+      SERVICE_CLASSES[entry.className as keyof typeof SERVICE_CLASSES]
+    if (serviceClass) {
+      results.push({ entry, serviceClass })
+    }
+  }
+  return results
+}
+
+export const MANIFEST_STATS = {
+  totalServices: ${services.length},
+  environments: [${config.environments.map((e) => `'${e}'`).join(", ")}],
+  lifecycles: {
+${lifecycleCounts}
+  },
+  dependencyAnalysis: {
+    servicesWithDependencies: ${services.filter((s) => s.dependencies.length > 0).length},
+    totalDependencies: ${totalDependencies},
+    externalDependencies: ${externalDependencies},
+    maxDependencyDepth: ${maxDepth}
+  }
+}
+`;
+}
+var EAGER_LIFECYCLES = /* @__PURE__ */ new Set([
+  "singleton",
+  "dependency",
+  "lazySingleton"
+]);
+function localName(className) {
+  return `_${className}`;
+}
+function externalDefault(typeName) {
+  switch (typeName) {
+    case "string":
+      return "''";
+    case "number":
+      return "0";
+    case "boolean":
+      return "false";
+    default:
+      return "undefined";
+  }
+}
+function renderCompiled(allServices, config, outFile) {
+  const target = config.targetEnv;
+  const services = allServices.filter(
+    (s) => !target || !s.environment || s.environment === target
+  );
+  const selected = new Set(services.map((s) => s.className));
+  const eager = /* @__PURE__ */ new Map();
+  for (const s of services) {
+    eager.set(s.className, EAGER_LIFECYCLES.has(s.lifecycle));
+  }
+  const classNames = new Set(services.map((s) => s.className));
+  const importsByPath = /* @__PURE__ */ new Map();
+  const addImport = (path, name) => {
+    const names = importsByPath.get(path) ?? /* @__PURE__ */ new Set();
+    names.add(name);
+    importsByPath.set(path, names);
+  };
+  for (const service of services) {
+    addImport(importPathFor(outFile, service.fullPath), service.className);
+  }
+  const tokenCount = /* @__PURE__ */ new Map();
+  for (const s of services) {
+    if (s.token) {
+      tokenCount.set(s.token, (tokenCount.get(s.token) ?? 0) + 1);
+    }
+  }
+  const tokenPath = (m) => m.kind === "file" ? importPathFor(outFile, m.fullPath) : m.specifier;
+  const typed = services.filter(
+    (s) => !!s.token && !!s.tokenModule && tokenCount.get(s.token) === 1 && (s.token === s.className || !classNames.has(s.token))
+  );
+  for (const s of typed) {
+    addImport(tokenPath(s.tokenModule), s.token);
+  }
+  const serviceImports = [...importsByPath.keys()].sort().map((path) => {
+    const names = [...importsByPath.get(path) ?? []].sort();
+    return names.length === 1 ? `import { ${names[0]} } from '${path}'` : `import {
+  ${names.join(",\n  ")}
+} from '${path}'`;
+  }).join("\n");
+  const argExpr = (service) => {
+    const arity = service.dependencies.reduce(
+      (max, d) => Math.max(max, d.paramIndex + 1),
+      0
+    );
+    const args = Array.from({ length: arity }, () => "undefined");
+    for (const dep of service.resolvedDependencies) {
+      if (dep.external) {
+        args[dep.paramIndex] = dep.isOptional ? "undefined" : externalDefault(dep.typeName);
+        continue;
+      }
+      const impl = dep.implementingService;
+      if (impl && selected.has(impl)) {
+        args[dep.paramIndex] = eager.get(impl) ? localName(impl) : `c.resolve(token(${impl}))`;
+      } else {
+        args[dep.paramIndex] = "undefined";
+      }
+    }
+    return args.join(", ");
+  };
+  const lines = [];
+  for (const service of services) {
+    const cls = service.className;
+    if (eager.get(cls)) {
+      lines.push(`  const ${localName(cls)} = new ${cls}(${argExpr(service)})`);
+      lines.push(`  c.register(token(${cls}), ${localName(cls)})`);
+    } else {
+      lines.push(
+        `  c.registerFactory(token(${cls}), () => new ${cls}(${argExpr(service)}))`
+      );
+    }
+  }
+  const targetComment = target ? `environment: ${target}` : "environment: all";
+  const accessorBlock = typed.length === 0 ? "" : `
+/**
+ * Type-safe accessor surface. Only registered tokens are present, each typed to
+ * its token \u2014 resolving an unregistered token is a compile error.
+ */
+export interface DiademServices {
+${typed.map((s) => `  ${s.token}: ${s.token}`).join("\n")}
+}
+
+export function createServices(): DiademServices & {
+  readonly container: DiademContainer
+  dispose: () => Promise<void>
+} {
+  const container = createContainer()
+  return {
+    container,
+    dispose: () => container.dispose(),
+${typed.map(
+    (s) => `    get ${s.token}(): ${s.token} {
+      return container.resolve(${s.token})
+    }`
+  ).join(",\n")}
+  }
+}
+`;
+  return `/**
+ * Auto-generated by \`diadem build --emit=compiled\`. DO NOT EDIT MANUALLY.
+ *
+ * Straight-line wiring (${targetComment}). Total services: ${services.length}.
+ */
+
+/* eslint-disable */
+
+import { DiademContainer, getDIMetadata } from '${PACKAGE_NAME}'
+
+${serviceImports}
+
+function token(cls: any): any {
+  const meta = getDIMetadata(cls)
+  if (!meta) {
+    throw new Error('diadem: missing DI metadata for ' + cls.name)
+  }
+  return meta.token
+}
+
+/** Build a fully-wired, ready container. */
+export function createContainer(): DiademContainer {
+  const c = new DiademContainer()
+${lines.join("\n")}
+  c.setReady()
+  return c
+}
+${accessorBlock}`;
+}
+
+// src/cli/index.ts
+function parseArgs(argv) {
+  const parsed = {
+    command: "build",
+    cwd: process.cwd(),
+    failOnCycle: false,
+    strict: false,
+    help: false,
+    overrides: {}
+  };
+  const scanDirs = [];
+  const include = [];
+  const exclude = [];
+  const environments = [];
+  let i = 0;
+  if (argv[i] && !argv[i].startsWith("-")) {
+    parsed.command = argv[i];
+    i++;
+  }
+  for (; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = () => {
+      const value = argv[++i];
+      if (value === void 0) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+      return value;
+    };
+    switch (arg) {
+      case "--scan-dir":
+        scanDirs.push(next());
+        break;
+      case "--out":
+        parsed.overrides.outFile = next();
+        break;
+      case "--include":
+        include.push(next());
+        break;
+      case "--exclude":
+        exclude.push(next());
+        break;
+      case "--env":
+        environments.push(next());
+        break;
+      case "--cwd":
+        parsed.cwd = next();
+        break;
+      case "--emit": {
+        const mode = next();
+        if (mode !== "manifest" && mode !== "compiled") {
+          throw new Error(`Invalid --emit value: ${mode} (expected manifest|compiled)`);
+        }
+        parsed.overrides.emit = mode;
+        break;
+      }
+      case "--target-env":
+        parsed.overrides.targetEnv = next();
+        break;
+      case "--fail-on-cycle":
+        parsed.failOnCycle = true;
+        break;
+      case "--strict":
+        parsed.strict = true;
+        break;
+      case "-h":
+      case "--help":
+        parsed.help = true;
+        break;
+      default:
+        throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  if (scanDirs.length) parsed.overrides.scanDirs = scanDirs;
+  if (include.length) parsed.overrides.include = include;
+  if (exclude.length) parsed.overrides.exclude = exclude;
+  if (environments.length) parsed.overrides.environments = environments;
+  return parsed;
+}
+var HELP = `diadem \u2014 build-time DI manifest generator
+
+Usage:
+  diadem build [options]
+
+Options:
+  --scan-dir <dir>     Directory to scan (repeatable). Default: src
+  --out <file>         Output manifest path. Default: src/generated/service-manifest.ts
+  --include <regex>    Filename include pattern (repeatable). Default: \\.ts$
+  --exclude <regex>    Filename exclude pattern (repeatable).
+  --env <name>         Environment to group by (repeatable). Default: development, production, test
+  --emit <mode>        Output mode: manifest (default) or compiled (straight-line wiring)
+  --target-env <name>  For --emit=compiled, bake in a single environment
+  --cwd <dir>          Project root. Default: current directory
+  --fail-on-cycle      Exit non-zero if a dependency cycle is detected
+  --strict             Exit non-zero on cycles, ambiguous tokens, or required
+                       dependencies with no implementing service
+  -h, --help           Show this help
+
+A diadem.config.json in the project root is merged under CLI flags.
+`;
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    process.stdout.write(HELP);
+    return;
+  }
+  if (args.command !== "build") {
+    process.stderr.write(`Unknown command: ${args.command}
+
+${HELP}`);
+    process.exit(1);
+  }
+  const config = loadConfig(args.cwd, args.overrides);
+  const result = generateManifest(config);
+  process.stdout.write(
+    `diadem: wrote ${result.serviceCount} services to ${result.outFile}
+`
+  );
+  if (result.externalDependencies > 0) {
+    process.stdout.write(
+      `diadem: ${result.externalDependencies} external dependencies (not container-managed)
+`
+    );
+  }
+  for (const token of result.duplicateTokens) {
+    process.stderr.write(
+      `diadem: warning \u2014 token ${token} is declared by more than one service (ambiguous)
+`
+    );
+  }
+  if (result.cycles.length > 0) {
+    process.stderr.write(
+      `diadem: warning \u2014 dependency cycle(s) detected: ${result.cycles.join(", ")}
+`
+    );
+  }
+  const cycleViolation = result.cycles.length > 0 && (args.strict || args.failOnCycle);
+  const strictViolation = args.strict && (result.unresolved.length > 0 || result.duplicateTokens.length > 0);
+  if (args.strict) {
+    for (const dep of result.unresolved) {
+      process.stderr.write(
+        `diadem: error \u2014 ${dep.service} requires ${dep.typeName} (${dep.paramName}), but no service implements it
+`
+      );
+    }
+  }
+  if (cycleViolation || strictViolation) {
+    process.exit(1);
+  }
+}
+try {
+  main();
+} catch (error) {
+  process.stderr.write(
+    `diadem: ${error instanceof Error ? error.message : String(error)}
+`
+  );
+  process.exit(1);
+}
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map