@hexaijs/plugin-contracts-generator 0.2.0 → 0.2.2

package/dist/cli.js

@@ -1,2344 +1,90 @@
 #!/usr/bin/env node
-import { fileURLToPath } from 'url';
-import * as path from 'path';
-import path__default, { resolve, dirname, basename, relative, join } from 'path';
-import * as ts8 from 'typescript';
-import ts8__default from 'typescript';
-import { readFile, readdir, writeFile, mkdir, access, stat } from 'fs/promises';
-import { constants } from 'fs';
-import 'reflect-metadata';
-import { glob } from 'glob';
-import { minimatch } from 'minimatch';
-
-// src/errors.ts
-var MessageParserError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "MessageParserError";
-  }
-};
-var ConfigurationError = class extends MessageParserError {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "ConfigurationError";
-  }
-};
-var ConfigLoadError = class extends ConfigurationError {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "ConfigLoadError";
-  }
-};
-var FileSystemError = class extends MessageParserError {
-  path;
-  constructor(message, path5, options) {
-    super(message, options);
-    this.name = "FileSystemError";
-    this.path = path5;
-  }
-};
-var FileReadError = class extends FileSystemError {
-  constructor(path5, options) {
-    super(`Failed to read file: ${path5}`, path5, options);
-    this.name = "FileReadError";
-  }
+import { fileURLToPath } from "node:url";
+import { resolve, dirname, join, relative } from "node:path";
+import { ConfigLoader, resolveContextEntries } from "./config-loader.js";
+import { ContractsPipeline, ConsoleLogger } from "./index.js";
+import { RegistryGenerator } from "./registry-generator.js";
+import { ReexportGenerator } from "./reexport-generator.js";
+import { nodeFileSystem } from "./file-system.js";
+import { mergeDecoratorNames } from "./domain/index.js";
+const DEFAULT_CONFIG_PATH = "application.config.ts";
+const EXIT_CODE_ERROR = 1;
+const VALID_MESSAGE_TYPES = ["event", "command", "query"];
+const CLI_OPTIONS = {
+    config: { short: "-c", long: "--config", requiresValue: true },
+    outputDir: { short: "-o", long: "--output-dir", requiresValue: true },
+    messageTypes: { short: "-m", long: "--message-types", requiresValue: true },
+    generateMessageRegistry: { short: null, long: "--generate-message-registry", requiresValue: false },
+    help: { short: "-h", long: "--help", requiresValue: false },
 };
-var FileWriteError = class extends FileSystemError {
-  constructor(path5, options) {
-    super(`Failed to write file: ${path5}`, path5, options);
-    this.name = "FileWriteError";
-  }
-};
-var NodeFileSystem = class {
-  async readFile(path5) {
-    return readFile(path5, "utf-8");
-  }
-  async readdir(path5) {
-    return readdir(path5);
-  }
-  async writeFile(path5, content) {
-    await writeFile(path5, content);
-  }
-  async mkdir(path5, options) {
-    await mkdir(path5, options);
-  }
-  async exists(path5) {
-    try {
-      await access(path5, constants.F_OK);
-      return true;
-    } catch {
-      return false;
+function parseMessageTypes(value) {
+    const types = value.split(",").map((type) => type.trim().toLowerCase());
+    const invalidTypes = types.filter((type) => !VALID_MESSAGE_TYPES.includes(type));
+    if (invalidTypes.length > 0) {
+        throw new Error(`Invalid message type(s): ${invalidTypes.join(", ")}. ` +
+            `Valid types are: ${VALID_MESSAGE_TYPES.join(", ")}`);
     }
-  }
-  async stat(path5) {
-    return stat(path5);
-  }
-};
-var nodeFileSystem = new NodeFileSystem();
-
-// src/domain/types.ts
-var DEFAULT_DECORATOR_NAMES = {
-  event: "PublicEvent",
-  command: "PublicCommand",
-  query: "PublicQuery"
-};
-function mergeDecoratorNames(partial) {
-  return {
-    ...DEFAULT_DECORATOR_NAMES,
-    ...partial
-  };
+    return types;
 }
-var TYPESCRIPT_EXTENSIONS = [".ts", ".tsx", ".d.ts"];
-var INDEX_FILE = "index.ts";
-var Tsconfig = class _Tsconfig {
-  constructor(paths) {
-    this.paths = paths;
-  }
-  static NONE = new _Tsconfig(/* @__PURE__ */ new Map());
-  static async load(tsconfigPath, fs) {
-    const absolutePath = path__default.resolve(tsconfigPath);
-    const configDir = path__default.dirname(absolutePath);
-    const content = await fs.readFile(absolutePath);
-    const { config, error } = ts8__default.parseConfigFileTextToJson(absolutePath, content);
-    if (error) {
-      throw new Error(
-        `Failed to parse tsconfig: ${ts8__default.flattenDiagnosticMessageText(error.messageText, "\n")}`
-      );
-    }
-    const parsed = ts8__default.parseJsonConfigFileContent(config, ts8__default.sys, configDir);
-    const baseUrl = parsed.options.baseUrl ?? configDir;
-    const paths = /* @__PURE__ */ new Map();
-    if (parsed.options.paths) {
-      for (const [alias, targets] of Object.entries(parsed.options.paths)) {
-        const resolvedTargets = targets.map(
-          (target) => path__default.join(baseUrl, target)
-        );
-        paths.set(alias, resolvedTargets);
-      }
-    }
-    return new _Tsconfig(paths);
-  }
-  /**
-   * Pure string transformation: resolves path alias to potential file paths.
-   * Returns null if no alias matches.
-   */
-  resolvePath(importPath) {
-    for (const [pattern, targets] of this.paths) {
-      const wildcardMatch = this.matchPathPattern(importPath, pattern);
-      if (wildcardMatch === null) {
-        continue;
-      }
-      return targets.map((target) => target.replace("*", wildcardMatch));
-    }
-    return null;
-  }
-  matchPathPattern(moduleSpecifier, pattern) {
-    if (pattern.endsWith("*")) {
-      const prefix = pattern.slice(0, -1);
-      if (moduleSpecifier.startsWith(prefix)) {
-        return moduleSpecifier.slice(prefix.length);
-      }
-    } else if (moduleSpecifier === pattern) {
-      return "";
-    }
-    return null;
-  }
-};
-var ContextConfig = class _ContextConfig {
-  fs;
-  tsconfig;
-  name;
-  sourceDir;
-  responseNamingConventions;
-  constructor(name, sourceDir, tsconfig, fs, responseNamingConventions) {
-    this.name = name;
-    this.sourceDir = sourceDir;
-    this.tsconfig = tsconfig;
-    this.fs = fs;
-    this.responseNamingConventions = responseNamingConventions;
-  }
-  /**
-   * Factory method to create ContextConfig with properly loaded tsconfig.
-   */
-  static async create(input, configDir, fs = nodeFileSystem) {
-    if (!input.name) {
-      throw new Error("ContextConfig requires 'name'");
-    }
-    if (!input.path) {
-      throw new Error(`ContextConfig '${input.name}' requires 'path'`);
-    }
-    const basePath = path__default.resolve(configDir, input.path);
-    const sourceDir = path__default.resolve(basePath, input.sourceDir ?? "src");
-    const tsconfig = await this.loadTsconfig(basePath, input.tsconfigPath, fs);
-    return new _ContextConfig(
-      input.name,
-      sourceDir,
-      tsconfig,
-      fs,
-      input.responseNamingConventions
-    );
-  }
-  static async loadTsconfig(basePath, inputPath, fs) {
-    const tsconfigPath = path__default.resolve(basePath, inputPath ?? "tsconfig.json");
-    if (!await fs.exists(tsconfigPath)) {
-      return Tsconfig.NONE;
-    }
-    return Tsconfig.load(tsconfigPath, fs);
-  }
-  /**
-   * Creates a ContextConfig without async loading (for cases where tsconfig is not needed
-   * or already handled externally).
-   */
-  static createSync(name, sourceDir, fs = nodeFileSystem, responseNamingConventions) {
-    return new _ContextConfig(
-      name,
-      sourceDir,
-      Tsconfig.NONE,
-      fs,
-      responseNamingConventions
-    );
-  }
-  /**
-   * Resolves a module specifier (path alias) to actual file path.
-   * Only handles non-relative imports (path aliases).
-   *
-   * @param moduleSpecifier - The import path to resolve (e.g., "@/utils/helper")
-   * @returns Object with resolvedPath (null if external) and isExternal flag
-   */
-  async resolvePath(moduleSpecifier) {
-    const resolvedPaths = this.tsconfig.resolvePath(moduleSpecifier);
-    if (!resolvedPaths) {
-      return { resolvedPath: null, isExternal: true };
-    }
-    for (const resolvedPath of resolvedPaths) {
-      const filePath = await this.tryResolveWithExtensions(resolvedPath);
-      if (filePath && filePath.startsWith(this.sourceDir)) {
-        return { resolvedPath: filePath, isExternal: false };
-      }
-    }
-    return { resolvedPath: null, isExternal: true };
-  }
-  async tryResolveWithExtensions(basePath) {
-    const extensionCandidates = TYPESCRIPT_EXTENSIONS.map((ext) => basePath + ext);
-    const indexCandidate = path__default.join(basePath, INDEX_FILE);
-    const candidates = [...extensionCandidates, indexCandidate];
-    for (const candidate of candidates) {
-      if (await this.fs.exists(candidate)) {
-        return candidate;
-      }
-    }
-    return null;
-  }
-};
-
-// src/config-loader.ts
-var SUPPORTED_GLOB_PARTS_COUNT = 2;
-var ConfigLoader = class {
-  fs;
-  constructor(options = {}) {
-    this.fs = options.fileSystem ?? nodeFileSystem;
-  }
-  async load(configPath) {
-    const absolutePath = resolve(configPath);
-    const config = await this.loadTypeScriptConfig(absolutePath);
-    return this.extractContractsConfig(config, dirname(absolutePath));
-  }
-  async loadTypeScriptConfig(absolutePath) {
-    const source = await this.fs.readFile(absolutePath);
-    const result = ts8__default.transpileModule(source, {
-      compilerOptions: {
-        module: ts8__default.ModuleKind.CommonJS,
-        target: ts8__default.ScriptTarget.ES2020,
-        esModuleInterop: true
-      }
-    });
-    const exports$1 = {};
-    const moduleWrapper = new Function("exports", result.outputText);
-    moduleWrapper(exports$1);
-    return exports$1.default ?? exports$1;
-  }
-  async extractContractsConfig(config, configDir) {
-    const contracts = config.contracts;
-    if (!contracts) {
-      throw new ConfigLoadError("Missing 'contracts' section in config");
-    }
-    if (!contracts.contexts || !Array.isArray(contracts.contexts)) {
-      throw new ConfigLoadError("Missing 'contracts.contexts' in config");
+function extractOptionValue(args, currentIndex, optionName) {
+    const currentArg = args[currentIndex];
+    const equalsIndex = currentArg.indexOf("=");
+    if (equalsIndex !== -1) {
+        return {
+            value: currentArg.slice(equalsIndex + 1),
+            nextIndex: currentIndex,
+        };
     }
-    const contexts = await this.resolveContexts(contracts.contexts, configDir);
-    if (contexts.length === 0) {
-      throw new ConfigLoadError("No contexts found from 'contexts'");
+    const nextValue = args[currentIndex + 1];
+    if (!nextValue) {
+        throw new Error(`Missing value for ${optionName} option`);
     }
-    const decoratorNames = mergeDecoratorNames(contracts.decoratorNames);
     return {
-      contexts,
-      pathAliasRewrites: contracts.pathAliasRewrites,
-      externalDependencies: contracts.externalDependencies,
-      decoratorNames,
-      responseNamingConventions: contracts.responseNamingConventions,
-      removeDecorators: contracts.removeDecorators ?? true
+        value: nextValue,
+        nextIndex: currentIndex + 1,
     };
-  }
-  async resolveContexts(contextsConfig, configDir) {
-    const contexts = [];
-    for (let i = 0; i < contextsConfig.length; i++) {
-      const item = contextsConfig[i];
-      if (typeof item === "string") {
-        const resolvedContexts = await this.resolveStringContext(item, configDir);
-        contexts.push(...resolvedContexts);
-      } else {
-        const contextConfig = await this.createObjectContext(item, i, configDir);
-        contexts.push(contextConfig);
-      }
-    }
-    return contexts;
-  }
-  async resolveStringContext(contextPath, configDir) {
-    if (contextPath.includes("*")) {
-      return this.expandGlobPattern(contextPath, configDir);
-    }
-    const basePath = resolve(configDir, contextPath);
-    const name = basename(basePath);
-    return [await ContextConfig.create(
-      { name, path: contextPath },
-      configDir,
-      this.fs
-    )];
-  }
-  async expandGlobPattern(pattern, configDir) {
-    const packageDirs = await this.matchGlobPattern(pattern, configDir);
-    return Promise.all(
-      packageDirs.map((dir) => {
-        const name = basename(dir);
-        const relativePath = relative(configDir, dir);
-        return ContextConfig.create(
-          { name, path: relativePath },
-          configDir,
-          this.fs
-        );
-      })
-    );
-  }
-  async createObjectContext(ctx, index, configDir) {
-    if (!ctx.name || typeof ctx.name !== "string") {
-      throw new ConfigLoadError(
-        `Invalid context at index ${index}: missing 'name'`
-      );
-    }
-    if (!ctx.path || typeof ctx.path !== "string") {
-      throw new ConfigLoadError(
-        `Invalid context at index ${index}: missing 'path'`
-      );
-    }
-    return ContextConfig.create(ctx, configDir, this.fs);
-  }
-  async matchGlobPattern(pattern, configDir) {
-    const globParts = pattern.split("*");
-    if (globParts.length !== SUPPORTED_GLOB_PARTS_COUNT) {
-      throw new ConfigLoadError(
-        `Invalid glob pattern: "${pattern}". Only single wildcard patterns like "packages/*" are supported.`
-      );
-    }
-    const [prefix, suffix] = globParts;
-    const baseDir = resolve(configDir, prefix);
-    if (!await this.fs.exists(baseDir)) {
-      return [];
-    }
-    const entries = await this.fs.readdir(baseDir);
-    const matchedDirs = [];
-    for (const entry of entries) {
-      const fullPath = resolve(baseDir, entry);
-      const stats = await this.fs.stat(fullPath);
-      if (!stats.isDirectory()) {
-        continue;
-      }
-      if (suffix) {
-        const suffixPath = resolve(fullPath, suffix.replace(/^\//, ""));
-        if (await this.fs.exists(suffixPath)) {
-          matchedDirs.push(fullPath);
-        }
-      } else {
-        matchedDirs.push(fullPath);
-      }
-    }
-    return matchedDirs.sort();
-  }
-};
-var DEFAULT_EXCLUDE_PATTERNS = [
-  "**/node_modules/**",
-  "**/dist/**",
-  "**/*.d.ts",
-  "**/*.test.ts",
-  "**/*.spec.ts"
-];
-var Scanner = class {
-  exclude;
-  fs;
-  decoratorPatterns;
-  constructor(options = {}) {
-    this.exclude = options.exclude ?? DEFAULT_EXCLUDE_PATTERNS;
-    this.fs = options.fileSystem ?? nodeFileSystem;
-    const names = mergeDecoratorNames(options.decoratorNames);
-    const messageTypes = options.messageTypes ?? ["event", "command", "query"];
-    this.decoratorPatterns = messageTypes.map((type) => {
-      const decoratorName = names[type];
-      return `@${decoratorName}(`;
-    });
-  }
-  async scan(sourceDir) {
-    const files = await glob(`${sourceDir}/**/*.ts`, {
-      ignore: this.exclude
-    });
-    const result = [];
-    for (const file of files) {
-      let content;
-      try {
-        content = await this.fs.readFile(file);
-      } catch (error) {
-        throw new FileReadError(file, { cause: error });
-      }
-      if (this.containsPublicDecorator(content)) {
-        result.push(file);
-      }
-    }
-    return result;
-  }
-  containsPublicDecorator(content) {
-    return this.decoratorPatterns.some((pattern) => content.includes(pattern));
-  }
-};
-function parseTypeNode(typeNode) {
-  if (typeNode.kind === ts8.SyntaxKind.StringKeyword) {
-    return { kind: "primitive", name: "string" };
-  }
-  if (typeNode.kind === ts8.SyntaxKind.NumberKeyword) {
-    return { kind: "primitive", name: "number" };
-  }
-  if (typeNode.kind === ts8.SyntaxKind.BooleanKeyword) {
-    return { kind: "primitive", name: "boolean" };
-  }
-  if (ts8.isArrayTypeNode(typeNode)) {
-    const elementType = parseTypeNode(typeNode.elementType);
-    return { kind: "array", elementType };
-  }
-  if (ts8.isTypeReferenceNode(typeNode)) {
-    const name = typeNode.typeName.getText();
-    const typeArguments = typeNode.typeArguments ? typeNode.typeArguments.map((t) => parseTypeNode(t)) : void 0;
-    return { kind: "reference", name, typeArguments };
-  }
-  if (ts8.isIntersectionTypeNode(typeNode)) {
-    const types = typeNode.types.map((t) => parseTypeNode(t));
-    return { kind: "intersection", types };
-  }
-  if (ts8.isUnionTypeNode(typeNode)) {
-    const types = typeNode.types.map((t) => parseTypeNode(t));
-    return { kind: "union", types };
-  }
-  if (ts8.isTypeLiteralNode(typeNode)) {
-    const fields = extractFieldsFromMembers(typeNode.members);
-    return { kind: "object", fields };
-  }
-  return { kind: "reference", name: typeNode.getText() };
-}
-function extractFieldsFromMembers(members) {
-  const fields = [];
-  for (const member of members) {
-    if (ts8.isPropertySignature(member) && member.name) {
-      const fieldName = member.name.getText();
-      const fieldType = member.type ? parseTypeNode(member.type) : { kind: "primitive", name: "any" };
-      const optional = !!member.questionToken;
-      const readonly = member.modifiers?.some(
-        (m) => m.kind === ts8.SyntaxKind.ReadonlyKeyword
-      ) ?? false;
-      fields.push({
-        name: fieldName,
-        type: fieldType,
-        optional,
-        readonly
-      });
-    }
-  }
-  return fields;
-}
-function hasDecorator(node, decoratorName) {
-  const decorators = ts8.getDecorators(node);
-  if (!decorators) return false;
-  return decorators.some((decorator) => {
-    if (ts8.isCallExpression(decorator.expression)) {
-      const expr = decorator.expression.expression;
-      if (ts8.isIdentifier(expr)) {
-        return expr.text === decoratorName;
-      }
-    }
-    return false;
-  });
-}
-function getDecoratorOptions(node, decoratorName) {
-  const decorators = ts8.getDecorators(node);
-  if (!decorators) return void 0;
-  for (const decorator of decorators) {
-    if (!ts8.isCallExpression(decorator.expression)) continue;
-    const expr = decorator.expression.expression;
-    if (!ts8.isIdentifier(expr) || expr.text !== decoratorName) continue;
-    const args = decorator.expression.arguments;
-    if (args.length === 0) return {};
-    const firstArg = args[0];
-    if (!ts8.isObjectLiteralExpression(firstArg)) return {};
-    const options = {};
-    for (const prop of firstArg.properties) {
-      if (!ts8.isPropertyAssignment(prop)) continue;
-      if (!ts8.isIdentifier(prop.name)) continue;
-      const propName = prop.name.text;
-      if (propName === "response" && ts8.isStringLiteral(prop.initializer)) {
-        options.response = prop.initializer.text;
-      } else if (propName === "context" && ts8.isStringLiteral(prop.initializer)) {
-        options.context = prop.initializer.text;
-      }
-    }
-    return options;
-  }
-  return void 0;
-}
-function hasExportModifier(node) {
-  const modifiers = ts8.canHaveModifiers(node) ? ts8.getModifiers(node) : void 0;
-  return modifiers?.some((m) => m.kind === ts8.SyntaxKind.ExportKeyword) ?? false;
 }
-function extractClassSourceText(node, sourceCode) {
-  const fullStart = node.getFullStart();
-  const end = node.getEnd();
-  let sourceText = sourceCode.slice(fullStart, end);
-  sourceText = sourceText.replace(/^\s*\n/, "");
-  return sourceText;
-}
-function getBaseClassName(node) {
-  if (!node.heritageClauses) return void 0;
-  for (const clause of node.heritageClauses) {
-    if (clause.token === ts8.SyntaxKind.ExtendsKeyword) {
-      const firstType = clause.types[0];
-      if (firstType && ts8.isExpressionWithTypeArguments(firstType)) {
-        const expr = firstType.expression;
-        if (ts8.isIdentifier(expr)) {
-          return expr.text;
-        }
-      }
-    }
-  }
-  return void 0;
-}
-function isExternalModule(moduleSpecifier) {
-  return !moduleSpecifier.startsWith(".");
-}
-function extractImports(sourceFile) {
-  const imports = [];
-  ts8.forEachChild(sourceFile, (node) => {
-    if (ts8.isImportDeclaration(node) && node.importClause) {
-      const moduleSpecifier = node.moduleSpecifier.text;
-      const isExternal = isExternalModule(moduleSpecifier);
-      const isTypeOnly = node.importClause.isTypeOnly ?? false;
-      const importedNames = extractImportedNames(node.importClause);
-      if (importedNames.length > 0) {
-        imports.push({
-          names: importedNames,
-          source: moduleSpecifier,
-          isTypeOnly,
-          isExternal
-        });
-      }
-    }
-  });
-  return imports;
-}
-function extractImportedNames(importClause) {
-  const names = [];
-  if (importClause.name) {
-    names.push(importClause.name.text);
-  }
-  if (importClause.namedBindings) {
-    if (ts8.isNamedImports(importClause.namedBindings)) {
-      for (const element of importClause.namedBindings.elements) {
-        names.push(element.name.text);
-      }
-    }
-  }
-  return names;
-}
-
-// src/parser.ts
-var PAYLOAD_TYPE_ARGUMENT_INDEX = 0;
-function buildDecoratorMappings(decoratorNames) {
-  return [
-    { decorator: decoratorNames.event, messageType: "event" },
-    { decorator: decoratorNames.command, messageType: "command" },
-    { decorator: decoratorNames.query, messageType: "query" }
-  ];
-}
-function extractTypeParameterNames(typeParameters) {
-  if (!typeParameters) return void 0;
-  return typeParameters.map((tp) => tp.name.text);
+function matchesOption(arg, option) {
+    const matchesShortOrLong = arg === option.short || arg === option.long;
+    const matchesLongWithValue = option.long !== null && arg.startsWith(`${option.long}=`);
+    return matchesShortOrLong || matchesLongWithValue;
 }
-var Parser = class {
-  decoratorMappings;
-  responseNamingConventions;
-  messageTypes;
-  constructor(options = {}) {
-    const names = mergeDecoratorNames(options.decoratorNames);
-    this.decoratorMappings = buildDecoratorMappings(names);
-    this.responseNamingConventions = options.responseNamingConventions ?? [];
-    this.messageTypes = options.messageTypes;
-  }
-  parse(sourceCode, sourceFileInfo) {
-    const tsSourceFile = ts8__default.createSourceFile(
-      sourceFileInfo.absolutePath,
-      sourceCode,
-      ts8__default.ScriptTarget.Latest,
-      true
-    );
-    const events = [];
-    const commands = [];
-    const queries = [];
-    const typeDefinitions = [];
-    const messageCollectors = {
-      event: (m) => events.push(m),
-      command: (m) => commands.push(m),
-      query: (m) => queries.push(m)
-    };
-    const visit = (node) => {
-      if (ts8__default.isClassDeclaration(node) && node.name) {
-        this.collectMessagesFromClass(node, sourceCode, tsSourceFile, sourceFileInfo, messageCollectors);
-      }
-      if (ts8__default.isTypeAliasDeclaration(node) && node.name) {
-        typeDefinitions.push(this.extractTypeDefinition(node, sourceFileInfo));
-      }
-      if (ts8__default.isInterfaceDeclaration(node) && node.name) {
-        typeDefinitions.push(this.extractInterfaceDefinition(node, sourceFileInfo));
-      }
-      ts8__default.forEachChild(node, visit);
-    };
-    visit(tsSourceFile);
-    this.applyNamingConventionMatching(commands, typeDefinitions);
-    this.applyNamingConventionMatching(queries, typeDefinitions);
-    return { events, commands, queries, typeDefinitions };
-  }
-  collectMessagesFromClass(node, sourceCode, tsSourceFile, sourceFileInfo, collectors) {
-    for (const { decorator, messageType } of this.decoratorMappings) {
-      if (!hasDecorator(node, decorator)) continue;
-      if (this.messageTypes && !this.messageTypes.includes(messageType)) continue;
-      const message = this.buildMessage(node, sourceCode, tsSourceFile, sourceFileInfo, messageType, decorator);
-      collectors[messageType](message);
-    }
-  }
-  applyNamingConventionMatching(messages, typeDefinitions) {
-    for (const message of messages) {
-      const hasExplicitResultType = Boolean(message.resultType);
-      if (hasExplicitResultType) continue;
-      const matchedTypeName = this.findMatchingResponseType(message.name, typeDefinitions);
-      if (matchedTypeName) {
-        message.resultType = {
-          kind: "reference",
-          name: matchedTypeName
-        };
-      }
-    }
-  }
-  findMatchingResponseType(messageName, typeDefinitions) {
-    for (const convention of this.responseNamingConventions) {
-      const hasSuffix = messageName.endsWith(convention.messageSuffix);
-      if (!hasSuffix) continue;
-      const messagePrefix = messageName.slice(0, -convention.messageSuffix.length);
-      const expectedResponseName = messagePrefix + convention.responseSuffix;
-      const matchingType = typeDefinitions.find((t) => t.name === expectedResponseName);
-      if (matchingType) return matchingType.name;
-    }
-    return void 0;
-  }
-  buildMessage(node, sourceCode, tsSourceFile, sourceFileInfo, messageType, decoratorName) {
-    const extracted = this.extractMessageDetails(node, sourceCode, tsSourceFile);
-    const decoratorOptions = getDecoratorOptions(node, decoratorName);
-    const baseMessage = {
-      name: node.name.text,
-      messageType,
-      sourceFile: sourceFileInfo,
-      fields: extracted.fields,
-      payloadType: extracted.payloadType,
-      sourceText: extracted.sourceText,
-      imports: extracted.imports,
-      baseClass: extracted.baseClass
-    };
-    const explicitResponseName = decoratorOptions?.response;
-    const supportsResultType = messageType === "command" || messageType === "query";
-    if (!supportsResultType || !explicitResponseName) {
-      return baseMessage;
-    }
-    return {
-      ...baseMessage,
-      resultType: {
-        kind: "reference",
-        name: explicitResponseName
-      }
-    };
-  }
-  extractMessageDetails(node, sourceCode, tsSourceFile) {
-    const { fields, payloadType } = this.extractPayload(node);
-    const sourceText = extractClassSourceText(node, sourceCode);
-    const imports = extractImports(tsSourceFile);
-    const baseClass = getBaseClassName(node);
-    return {
-      fields,
-      payloadType,
-      sourceText,
-      imports,
-      baseClass
-    };
-  }
-  extractPayload(node) {
-    const emptyPayload = { fields: [] };
-    if (!node.heritageClauses) return emptyPayload;
-    const extendsClause = node.heritageClauses.find(
-      (clause) => clause.token === ts8__default.SyntaxKind.ExtendsKeyword
-    );
-    if (!extendsClause) return emptyPayload;
-    for (const type of extendsClause.types) {
-      const typeArgs = type.typeArguments;
-      if (!typeArgs || typeArgs.length === 0) continue;
-      const payloadTypeArg = typeArgs[PAYLOAD_TYPE_ARGUMENT_INDEX];
-      const extractedPayload = this.parsePayloadTypeArgument(payloadTypeArg);
-      if (extractedPayload) return extractedPayload;
-    }
-    return emptyPayload;
-  }
-  parsePayloadTypeArgument(typeArg) {
-    if (ts8__default.isTypeReferenceNode(typeArg) && ts8__default.isIdentifier(typeArg.typeName)) {
-      return {
-        fields: [],
-        payloadType: parseTypeNode(typeArg)
-      };
-    }
-    if (ts8__default.isTypeLiteralNode(typeArg)) {
-      return {
-        fields: extractFieldsFromMembers(typeArg.members)
-      };
-    }
-    if (ts8__default.isIntersectionTypeNode(typeArg)) {
-      const parsedType = parseTypeNode(typeArg);
-      return {
-        fields: this.flattenIntersectionToFields(parsedType),
-        payloadType: parsedType
-      };
-    }
-    return void 0;
-  }
-  flattenIntersectionToFields(intersection) {
-    const fields = [];
-    for (const type of intersection.types) {
-      if (type.kind === "object") {
-        fields.push(...type.fields);
-      }
-    }
-    return fields;
-  }
-  extractTypeDefinition(node, sourceFileInfo) {
-    return this.buildTypeDefinition(
-      node.name.text,
-      "type",
-      sourceFileInfo,
-      parseTypeNode(node.type),
-      node.typeParameters,
-      node
-    );
-  }
-  extractInterfaceDefinition(node, sourceFileInfo) {
-    const body = {
-      kind: "object",
-      fields: extractFieldsFromMembers(node.members)
-    };
-    return this.buildTypeDefinition(
-      node.name.text,
-      "interface",
-      sourceFileInfo,
-      body,
-      node.typeParameters,
-      node
-    );
-  }
-  buildTypeDefinition(name, kind, sourceFile, body, typeParameters, node) {
-    return {
-      name,
-      kind,
-      sourceFile,
-      body,
-      typeParameters: extractTypeParameterNames(typeParameters),
-      exported: hasExportModifier(node)
-    };
-  }
-};
-var TYPESCRIPT_EXTENSIONS2 = [".ts", ".tsx"];
-var INDEX_FILE2 = "index.ts";
-var FileGraphResolver = class _FileGraphResolver {
-  contextConfig;
-  fs;
-  excludeDependencies;
-  constructor(contextConfig, fileSystem, excludeDependencies) {
-    this.contextConfig = contextConfig;
-    this.fs = fileSystem;
-    this.excludeDependencies = excludeDependencies;
-  }
-  static create(options) {
-    const fs = options.fileSystem ?? nodeFileSystem;
-    const excludeDependencies = options.excludeDependencies ?? [];
-    return new _FileGraphResolver(options.contextConfig, fs, excludeDependencies);
-  }
-  async buildGraph(entryPoints, sourceRoot) {
-    const nodes = /* @__PURE__ */ new Map();
-    const entryPointSet = new Set(entryPoints);
-    const excludedPaths = /* @__PURE__ */ new Set();
-    const visited = /* @__PURE__ */ new Set();
-    const queue = [...entryPoints];
-    while (queue.length > 0) {
-      const filePath = queue.shift();
-      if (visited.has(filePath)) {
-        continue;
-      }
-      visited.add(filePath);
-      const imports = await this.extractImports(filePath);
-      const node = {
-        absolutePath: filePath,
-        relativePath: path__default.relative(sourceRoot, filePath),
-        imports,
-        isEntryPoint: entryPointSet.has(filePath)
-      };
-      nodes.set(filePath, node);
-      this.queueUnvisitedLocalDependencies(imports, visited, queue, excludedPaths);
-    }
-    return {
-      nodes,
-      entryPoints: entryPointSet,
-      excludedPaths
-    };
-  }
-  async extractImports(filePath) {
-    const sourceCode = await this.readSourceFile(filePath);
-    const sourceFile = ts8__default.createSourceFile(
-      filePath,
-      sourceCode,
-      ts8__default.ScriptTarget.Latest,
-      true
-    );
-    const imports = [];
-    for (const node of sourceFile.statements) {
-      const moduleSpecifier = this.extractModuleSpecifier(node);
-      if (!moduleSpecifier) {
-        continue;
-      }
-      const resolution = await this.resolveModule(moduleSpecifier, filePath);
-      const importedNames = this.extractImportedNamesFromNode(node);
-      imports.push({
-        moduleSpecifier,
-        resolvedPath: resolution.resolvedPath,
-        isExternal: resolution.isExternal,
-        importedNames
-      });
-    }
-    return imports;
-  }
-  async readSourceFile(filePath) {
-    try {
-      return await this.fs.readFile(filePath);
-    } catch (error) {
-      throw new FileReadError(filePath, { cause: error });
-    }
-  }
-  extractModuleSpecifier(node) {
-    if (ts8__default.isImportDeclaration(node)) {
-      return node.moduleSpecifier.text;
-    }
-    if (ts8__default.isExportDeclaration(node) && node.moduleSpecifier) {
-      return node.moduleSpecifier.text;
-    }
-    return null;
-  }
-  extractImportedNamesFromNode(node) {
-    if (ts8__default.isImportDeclaration(node) && node.importClause) {
-      return extractImportedNames(node.importClause);
-    }
-    return [];
-  }
-  async resolveModule(moduleSpecifier, fromFile) {
-    if (moduleSpecifier.startsWith(".")) {
-      const resolvedPath = await this.resolveRelativeModule(
-        moduleSpecifier,
-        fromFile
-      );
-      return { resolvedPath, isExternal: false };
-    }
-    return this.contextConfig.resolvePath(moduleSpecifier);
-  }
-  queueUnvisitedLocalDependencies(imports, visited, queue, excludedPaths) {
-    const localImports = imports.filter(
-      (importInfo) => !importInfo.isExternal && importInfo.resolvedPath !== null
-    );
-    for (const importInfo of localImports) {
-      const resolvedPath = importInfo.resolvedPath;
-      if (this.shouldExclude(resolvedPath)) {
-        excludedPaths.add(resolvedPath);
-        continue;
-      }
-      if (!visited.has(resolvedPath)) {
-        queue.push(resolvedPath);
-      }
-    }
-  }
-  shouldExclude(filePath) {
-    if (this.excludeDependencies.length === 0) {
-      return false;
-    }
-    return this.excludeDependencies.some(
-      (pattern) => minimatch(filePath, pattern, { matchBase: true })
-    );
-  }
-  async resolveRelativeModule(moduleSpecifier, fromFile) {
-    const dir = path__default.dirname(fromFile);
-    const basePath = path__default.resolve(dir, moduleSpecifier);
-    return this.tryResolveWithExtensions(basePath);
-  }
-  async tryResolveWithExtensions(basePath) {
-    const extensionCandidates = TYPESCRIPT_EXTENSIONS2.map((ext) => basePath + ext);
-    const indexCandidate = path__default.join(basePath, INDEX_FILE2);
-    const candidates = [...extensionCandidates, indexCandidate];
-    for (const candidate of candidates) {
-      if (await this.fs.exists(candidate)) {
-        return candidate;
-      }
-    }
-    return null;
-  }
-};
-var CONTRACTS_GENERATOR_MODULE = "@hexaijs/plugin-contracts-generator";
-var CONTRACT_DECORATORS = /* @__PURE__ */ new Set([
-  "PublicCommand",
-  "PublicEvent",
-  "PublicQuery"
-]);
-var TS_EXTENSION_PATTERN = /\.ts$/;
-var REQUEST_SUFFIX = "Request";
-var QUERY_SUFFIX = "Query";
-var FileCopier = class {
-  fs;
-  constructor(options = {}) {
-    this.fs = options.fileSystem ?? nodeFileSystem;
-  }
-  async copyFiles(options) {
-    const {
-      sourceRoot,
-      outputDir,
-      fileGraph,
-      pathAliasRewrites,
-      removeDecorators,
-      responseTypesToExport,
-      messageTypes,
-      decoratorNames
-    } = options;
-    const copiedFiles = [];
-    const rewrittenImports = /* @__PURE__ */ new Map();
-    const { entryContents, usedLocalImports } = await this.preprocessEntryFiles(
-      fileGraph,
-      messageTypes,
-      decoratorNames,
-      sourceRoot
-    );
-    this.expandTransitiveDependencies(usedLocalImports, fileGraph);
-    for (const node of fileGraph.nodes.values()) {
-      const content = await this.resolveNodeContent(
-        node,
-        entryContents,
-        usedLocalImports,
-        messageTypes
-      );
-      if (content === null) {
-        continue;
-      }
-      const transformedContent = this.applyTransformations(
-        content,
-        node,
-        fileGraph,
-        sourceRoot,
-        removeDecorators,
-        responseTypesToExport,
-        pathAliasRewrites
-      );
-      const outputPath = await this.writeOutputFile(
-        outputDir,
-        node.relativePath,
-        transformedContent.content
-      );
-      copiedFiles.push(outputPath);
-      if (transformedContent.rewrites.length > 0) {
-        rewrittenImports.set(outputPath, transformedContent.rewrites);
-      }
-    }
-    return { copiedFiles, rewrittenImports };
-  }
-  async preprocessEntryFiles(fileGraph, messageTypes, decoratorNames, sourceRoot) {
-    const entryContents = /* @__PURE__ */ new Map();
-    const usedLocalImports = /* @__PURE__ */ new Set();
-    if (!messageTypes?.length) {
-      return { entryContents, usedLocalImports };
-    }
-    for (const node of fileGraph.nodes.values()) {
-      if (!node.isEntryPoint) {
-        continue;
-      }
-      const rawContent = await this.readFileContent(node.absolutePath);
-      const { content: extractedContent, usedModuleSpecifiers } = this.extractSymbolsFromEntry(
-        rawContent,
-        node.absolutePath,
-        messageTypes,
-        decoratorNames
-      );
-      entryContents.set(node.absolutePath, extractedContent);
-      for (const specifier of usedModuleSpecifiers) {
-        const importInfo = node.imports.find(
-          (i) => i.moduleSpecifier === specifier
-        );
-        if (importInfo?.resolvedPath && !importInfo.isExternal) {
-          usedLocalImports.add(importInfo.resolvedPath);
-        }
-      }
-    }
-    return { entryContents, usedLocalImports };
-  }
-  expandTransitiveDependencies(usedLocalImports, fileGraph) {
-    let changed = true;
-    while (changed) {
-      changed = false;
-      for (const importPath of usedLocalImports) {
-        const node = fileGraph.nodes.get(importPath);
-        if (!node) continue;
-        for (const imp of node.imports) {
-          const isUnusedLocalImport = imp.resolvedPath && !imp.isExternal && !usedLocalImports.has(imp.resolvedPath);
-          if (isUnusedLocalImport) {
-            usedLocalImports.add(imp.resolvedPath);
-            changed = true;
-          }
-        }
-      }
-    }
-  }
-  async resolveNodeContent(node, entryContents, usedLocalImports, messageTypes) {
-    if (node.isEntryPoint && messageTypes?.length) {
-      return entryContents.get(node.absolutePath) ?? await this.readFileContent(node.absolutePath);
-    }
-    const isUnusedDependency = messageTypes?.length && !usedLocalImports.has(node.absolutePath);
-    if (isUnusedDependency) {
-      return null;
-    }
-    return await this.readFileContent(node.absolutePath);
-  }
-  applyTransformations(content, node, fileGraph, sourceRoot, removeDecorators, responseTypesToExport, pathAliasRewrites) {
-    const rewrites = [];
-    let transformedContent = content;
-    transformedContent = this.processExcludedImports(
-      transformedContent,
-      node,
-      fileGraph.excludedPaths,
-      rewrites
-    );
-    transformedContent = this.processDecoratorRemoval(
-      transformedContent,
-      node.absolutePath,
-      removeDecorators,
-      rewrites
-    );
-    transformedContent = this.processTypeExports(
-      transformedContent,
-      node.absolutePath,
-      responseTypesToExport?.get(node.absolutePath),
-      rewrites
-    );
-    transformedContent = this.processInternalPathAliases(
-      transformedContent,
-      node,
-      fileGraph,
-      sourceRoot,
-      rewrites
-    );
-    transformedContent = this.processExternalPathAliases(
-      transformedContent,
-      pathAliasRewrites,
-      rewrites
-    );
-    return { content: transformedContent, rewrites };
-  }
-  generateBarrelExport(copiedFiles, outputDir) {
-    const lines = [];
-    for (const filePath of copiedFiles) {
-      const relativePath = path.relative(outputDir, filePath);
-      lines.push(this.createExportStatement(relativePath));
-    }
-    return lines.join("\n");
-  }
-  async readFileContent(absolutePath) {
-    try {
-      return await this.fs.readFile(absolutePath);
-    } catch (error) {
-      throw new FileReadError(absolutePath, { cause: error });
-    }
-  }
-  async writeOutputFile(outputDir, relativePath, content) {
-    const outputPath = path.join(outputDir, relativePath);
-    const outputDirPath = path.dirname(outputPath);
-    await this.fs.mkdir(outputDirPath, { recursive: true });
-    try {
-      await this.fs.writeFile(outputPath, content);
-    } catch (error) {
-      throw new FileWriteError(outputPath, { cause: error });
-    }
-    return outputPath;
-  }
-  processExcludedImports(content, node, excludedPaths, rewrites) {
-    if (excludedPaths.size === 0) {
-      return content;
-    }
-    const excludedResult = this.removeExcludedImports(
-      content,
-      node,
-      excludedPaths
-    );
-    rewrites.push(...excludedResult.changes);
-    return excludedResult.content;
-  }
-  processDecoratorRemoval(content, filePath, removeDecorators, rewrites) {
-    if (!removeDecorators) {
-      return content;
-    }
-    const decoratorResult = this.removeContractDecorators(
-      content,
-      filePath
-    );
-    rewrites.push(...decoratorResult.changes);
-    return decoratorResult.content;
-  }
-  processTypeExports(content, filePath, typesToExport, rewrites) {
-    if (!typesToExport || typesToExport.length === 0) {
-      return content;
-    }
-    const exportResult = this.addExportToTypes(
-      content,
-      filePath,
-      typesToExport
-    );
-    rewrites.push(...exportResult.changes);
-    return exportResult.content;
-  }
-  processInternalPathAliases(content, node, fileGraph, sourceRoot, rewrites) {
-    const internalResult = this.rewriteInternalPathAliases(
-      content,
-      node,
-      fileGraph,
-      sourceRoot
-    );
-    rewrites.push(...internalResult.rewrites);
-    return internalResult.content;
-  }
-  processExternalPathAliases(content, pathAliasRewrites, rewrites) {
-    if (!pathAliasRewrites) {
-      return content;
-    }
-    const aliasResult = this.applyPathAliasRewrites(
-      content,
-      pathAliasRewrites
-    );
-    rewrites.push(...aliasResult.rewrites);
-    return aliasResult.content;
-  }
-  createExportStatement(relativePath) {
-    const exportPath = "./" + relativePath.replace(TS_EXTENSION_PATTERN, "");
-    return `export * from '${exportPath}'`;
-  }
-  rewriteInternalPathAliases(content, node, fileGraph, sourceRoot) {
-    let transformedContent = content;
-    const appliedRewrites = [];
-    for (const importInfo of node.imports) {
-      if (this.isExternalOrRelativeImport(importInfo)) {
-        continue;
-      }
-      const targetNode = this.resolveInternalImport(
-        importInfo,
-        fileGraph
-      );
-      if (!targetNode) {
-        continue;
-      }
-      const relativePath = this.computeRelativePath(
-        node.relativePath,
-        targetNode.relativePath
-      );
-      const rewriteResult = this.rewriteModuleSpecifier(
-        transformedContent,
-        importInfo.moduleSpecifier,
-        relativePath
-      );
-      if (rewriteResult.wasRewritten) {
-        transformedContent = rewriteResult.content;
-        appliedRewrites.push(
-          `${importInfo.moduleSpecifier} \u2192 ${relativePath}`
-        );
-      }
-    }
-    return { content: transformedContent, rewrites: appliedRewrites };
-  }
-  isExternalOrRelativeImport(importInfo) {
-    return importInfo.isExternal || importInfo.moduleSpecifier.startsWith(".");
-  }
-  resolveInternalImport(importInfo, fileGraph) {
-    if (!importInfo.resolvedPath || !fileGraph.nodes.has(importInfo.resolvedPath)) {
-      return void 0;
-    }
-    return fileGraph.nodes.get(importInfo.resolvedPath);
-  }
-  rewriteModuleSpecifier(content, originalSpecifier, newSpecifier) {
-    const importPattern = new RegExp(
-      `(from\\s+['"])${this.escapeRegex(originalSpecifier)}(['"])`,
-      "g"
-    );
-    if (!importPattern.test(content)) {
-      return { content, wasRewritten: false };
-    }
-    const rewrittenContent = content.replace(
-      importPattern,
-      `$1${newSpecifier}$2`
-    );
-    return { content: rewrittenContent, wasRewritten: true };
-  }
-  computeRelativePath(fromRelative, toRelative) {
-    const fromDir = path.dirname(fromRelative);
-    let relativePath = path.relative(fromDir, toRelative);
-    relativePath = relativePath.replace(TS_EXTENSION_PATTERN, "");
-    if (!relativePath.startsWith(".")) {
-      relativePath = "./" + relativePath;
-    }
-    return relativePath;
-  }
-  applyPathAliasRewrites(content, rewrites) {
-    let transformedContent = content;
-    const appliedRewrites = [];
-    for (const [from, to] of rewrites) {
-      if (transformedContent.includes(from)) {
-        transformedContent = transformedContent.replace(
-          new RegExp(this.escapeRegex(from), "g"),
-          to
-        );
-        appliedRewrites.push(`${from} \u2192 ${to}`);
-      }
-    }
-    return { content: transformedContent, rewrites: appliedRewrites };
-  }
-  escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
-  removeExcludedImports(content, node, excludedPaths) {
-    const excludedModuleSpecifiers = this.findExcludedModuleSpecifiers(
-      node,
-      excludedPaths
-    );
-    if (excludedModuleSpecifiers.size === 0) {
-      return { content, changes: [] };
-    }
-    const changes = Array.from(excludedModuleSpecifiers).map(
-      (specifier) => `removed import: ${specifier}`
-    );
-    const visitorFactory = this.createExcludedImportsVisitor(
-      excludedModuleSpecifiers
-    );
-    const transformedContent = this.transformSourceFile(
-      content,
-      node.absolutePath,
-      visitorFactory
-    );
-    return { content: transformedContent, changes };
-  }
-  findExcludedModuleSpecifiers(node, excludedPaths) {
-    const excludedModuleSpecifiers = /* @__PURE__ */ new Set();
-    for (const importInfo of node.imports) {
-      if (importInfo.resolvedPath && excludedPaths.has(importInfo.resolvedPath)) {
-        excludedModuleSpecifiers.add(importInfo.moduleSpecifier);
-      }
-    }
-    return excludedModuleSpecifiers;
-  }
-  createExcludedImportsVisitor(excludedModuleSpecifiers) {
-    return (context) => {
-      const visit = (node) => {
-        if (this.isImportFromExcludedModule(
-          node,
-          excludedModuleSpecifiers
-        )) {
-          return void 0;
-        }
-        if (this.isExportFromExcludedModule(
-          node,
-          excludedModuleSpecifiers
-        )) {
-          return void 0;
-        }
-        return ts8.visitEachChild(node, visit, context);
-      };
-      return visit;
-    };
-  }
-  isImportFromExcludedModule(node, excludedModules) {
-    if (!ts8.isImportDeclaration(node)) {
-      return false;
-    }
-    const moduleSpecifier = node.moduleSpecifier.text;
-    return excludedModules.has(moduleSpecifier);
-  }
-  isExportFromExcludedModule(node, excludedModules) {
-    if (!ts8.isExportDeclaration(node) || !node.moduleSpecifier) {
-      return false;
-    }
-    const moduleSpecifier = node.moduleSpecifier.text;
-    return excludedModules.has(moduleSpecifier);
-  }
-  removeContractDecorators(content, filePath) {
-    const changes = [];
-    const visitorFactory = this.createDecoratorRemovalVisitor(changes);
-    const transformedContent = this.transformSourceFile(
-      content,
-      filePath,
-      visitorFactory
-    );
-    return { content: transformedContent, changes };
-  }
-  createDecoratorRemovalVisitor(changes) {
-    return (context) => {
-      const visit = (node) => {
-        if (ts8.isImportDeclaration(node)) {
-          return this.processContractGeneratorImport(node, changes);
-        }
-        if (ts8.isClassDeclaration(node) && node.modifiers) {
-          return this.removeContractDecoratorsFromClass(
-            node,
-            changes
-          );
-        }
-        return ts8.visitEachChild(node, visit, context);
-      };
-      return visit;
-    };
-  }
-  processContractGeneratorImport(node, changes) {
-    const moduleSpecifier = node.moduleSpecifier.text;
-    const isContractGeneratorModule = moduleSpecifier === CONTRACTS_GENERATOR_MODULE || moduleSpecifier.startsWith(CONTRACTS_GENERATOR_MODULE + "/");
-    if (!isContractGeneratorModule) {
-      return node;
-    }
-    const namedBindings = node.importClause?.namedBindings;
-    if (!namedBindings || !ts8.isNamedImports(namedBindings)) {
-      return node;
-    }
-    const remainingElements = namedBindings.elements.filter(
-      (el) => !CONTRACT_DECORATORS.has(el.name.text)
-    );
-    if (remainingElements.length === 0) {
-      changes.push(`removed import: ${moduleSpecifier}`);
-      return void 0;
-    }
-    if (remainingElements.length < namedBindings.elements.length) {
-      changes.push(`removed decorators from import: ${moduleSpecifier}`);
-      return this.createImportWithFilteredBindings(
-        node,
-        remainingElements
-      );
-    }
-    return node;
-  }
-  createImportWithFilteredBindings(originalImport, remainingElements) {
-    const newNamedImports = ts8.factory.createNamedImports(remainingElements);
-    const newImportClause = ts8.factory.createImportClause(
-      originalImport.importClause.isTypeOnly,
-      originalImport.importClause.name,
-      newNamedImports
-    );
-    return ts8.factory.createImportDeclaration(
-      originalImport.modifiers,
-      newImportClause,
-      originalImport.moduleSpecifier,
-      originalImport.attributes
-    );
-  }
-  removeContractDecoratorsFromClass(node, changes) {
-    const filteredModifiers = node.modifiers.filter((modifier) => {
-      if (!ts8.isDecorator(modifier)) {
-        return true;
-      }
-      const decoratorName = this.extractDecoratorName(modifier);
-      if (decoratorName && CONTRACT_DECORATORS.has(decoratorName)) {
-        const decoratorSuffix = this.isDecoratorCallExpression(modifier) ? "()" : "";
-        changes.push(
-          `removed decorator: @${decoratorName}${decoratorSuffix}`
-        );
-        return false;
-      }
-      return true;
-    });
-    if (filteredModifiers.length === node.modifiers.length) {
-      return node;
-    }
-    return ts8.factory.createClassDeclaration(
-      filteredModifiers,
-      node.name,
-      node.typeParameters,
-      node.heritageClauses,
-      node.members
-    );
-  }
-  extractDecoratorName(decorator) {
-    const expression = decorator.expression;
-    if (ts8.isCallExpression(expression) && ts8.isIdentifier(expression.expression)) {
-      return expression.expression.text;
-    }
-    if (ts8.isIdentifier(expression)) {
-      return expression.text;
-    }
-    return void 0;
-  }
-  isDecoratorCallExpression(decorator) {
-    return ts8.isCallExpression(decorator.expression);
-  }
-  hasExportModifier(node) {
-    return node.modifiers?.some(
-      (m) => m.kind === ts8.SyntaxKind.ExportKeyword
-    ) ?? false;
-  }
-  prependExportModifier(modifiers) {
-    const exportModifier = ts8.factory.createModifier(
-      ts8.SyntaxKind.ExportKeyword
-    );
-    return modifiers ? [exportModifier, ...modifiers] : [exportModifier];
-  }
-  addExportToTypes(content, filePath, typeNames) {
-    const changes = [];
-    const typeNamesSet = new Set(typeNames);
-    const visitorFactory = this.createExportAdditionVisitor(
-      typeNamesSet,
-      changes
-    );
-    const transformedContent = this.transformSourceFile(
-      content,
-      filePath,
-      visitorFactory
-    );
-    return { content: transformedContent, changes };
-  }
-  createExportAdditionVisitor(typeNamesSet, changes) {
-    return (context) => {
-      const visit = (node) => {
-        if (ts8.isTypeAliasDeclaration(node)) {
-          return this.addExportToTypeAlias(
-            node,
-            typeNamesSet,
-            changes
-          );
-        }
-        if (ts8.isInterfaceDeclaration(node)) {
-          return this.addExportToInterface(
-            node,
-            typeNamesSet,
-            changes
-          );
-        }
-        return ts8.visitEachChild(node, visit, context);
-      };
-      return visit;
-    };
-  }
-  addExportToTypeAlias(node, typeNamesSet, changes) {
-    const typeName = node.name.text;
-    if (!typeNamesSet.has(typeName) || this.hasExportModifier(node)) {
-      return node;
-    }
-    changes.push(`added export: type ${typeName}`);
-    return ts8.factory.createTypeAliasDeclaration(
-      this.prependExportModifier(node.modifiers),
-      node.name,
-      node.typeParameters,
-      node.type
-    );
-  }
-  addExportToInterface(node, typeNamesSet, changes) {
-    const typeName = node.name.text;
-    if (!typeNamesSet.has(typeName) || this.hasExportModifier(node)) {
-      return node;
-    }
-    changes.push(`added export: interface ${typeName}`);
-    return ts8.factory.createInterfaceDeclaration(
-      this.prependExportModifier(node.modifiers),
-      node.name,
-      node.typeParameters,
-      node.heritageClauses,
-      node.members
-    );
-  }
-  transformSourceFile(content, filePath, visitorFactory) {
-    const sourceFile = ts8.createSourceFile(
-      filePath,
-      content,
-      ts8.ScriptTarget.Latest,
-      true,
-      ts8.ScriptKind.TS
-    );
-    const transformer = (context) => {
-      return (sf) => {
-        const visitor = visitorFactory(context);
-        return ts8.visitNode(sf, visitor);
-      };
-    };
-    const result = ts8.transform(sourceFile, [transformer]);
-    const transformedSourceFile = result.transformed[0];
-    const printer = ts8.createPrinter({ newLine: ts8.NewLineKind.LineFeed });
-    const transformedContent = printer.printFile(transformedSourceFile);
-    result.dispose();
-    return transformedContent;
-  }
-  extractSymbolsFromEntry(content, filePath, messageTypes, decoratorNames) {
-    const sourceFile = ts8.createSourceFile(
-      filePath,
-      content,
-      ts8.ScriptTarget.Latest,
-      true,
-      ts8.ScriptKind.TS
-    );
-    const decoratorToMessageType = this.buildDecoratorToMessageTypeMap(decoratorNames);
-    const context = {
-      sourceFile,
-      content,
-      messageTypes,
-      decoratorToMessageType
-    };
-    const { targetClassNames, targetClasses } = this.findTargetClasses(context);
-    if (targetClasses.length === 0) {
-      return { content, usedModuleSpecifiers: /* @__PURE__ */ new Set() };
-    }
-    const relatedTypeNames = this.computeRelatedTypeNames(targetClassNames);
-    const usedIdentifiers = this.collectUsedIdentifiers(targetClasses);
-    const localTypeDeclarations = this.collectLocalTypeDeclarations(sourceFile);
-    const includedLocalTypes = this.resolveIncludedLocalTypes(
-      usedIdentifiers,
-      relatedTypeNames,
-      localTypeDeclarations
-    );
-    const extractedSymbols = {
-      targetClassNames,
-      targetClasses,
-      usedIdentifiers,
-      includedLocalTypes,
-      localTypeDeclarations
-    };
-    return this.generateExtractedOutput(context, extractedSymbols);
-  }
-  buildDecoratorToMessageTypeMap(decoratorNames) {
-    const names = { ...DEFAULT_DECORATOR_NAMES, ...decoratorNames };
-    return {
-      [names.event]: "event",
-      [names.command]: "command",
-      [names.query]: "query"
-    };
-  }
-  findTargetClasses(context) {
-    const targetClassNames = /* @__PURE__ */ new Set();
-    const targetClasses = [];
-    const findClasses = (node) => {
-      if (ts8.isClassDeclaration(node) && node.name) {
-        for (const [decoratorName, messageType] of Object.entries(
-          context.decoratorToMessageType
-        )) {
-          if (hasDecorator(node, decoratorName) && context.messageTypes.includes(messageType)) {
-            targetClassNames.add(node.name.text);
-            targetClasses.push(node);
-            break;
-          }
-        }
-      }
-      ts8.forEachChild(node, findClasses);
-    };
-    findClasses(context.sourceFile);
-    return { targetClassNames, targetClasses };
-  }
-  computeRelatedTypeNames(targetClassNames) {
-    const relatedTypeNames = /* @__PURE__ */ new Set();
-    for (const className of targetClassNames) {
-      if (className.endsWith(REQUEST_SUFFIX)) {
-        const baseName = className.slice(0, -REQUEST_SUFFIX.length);
-        relatedTypeNames.add(baseName + "Response");
-        relatedTypeNames.add(baseName + "Payload");
-      } else if (className.endsWith(QUERY_SUFFIX)) {
-        const baseName = className.slice(0, -QUERY_SUFFIX.length);
-        relatedTypeNames.add(baseName + "QueryResult");
-        relatedTypeNames.add(baseName + "Payload");
-      }
-      relatedTypeNames.add(className + "Response");
-      relatedTypeNames.add(className + "Payload");
-    }
-    return relatedTypeNames;
-  }
-  collectUsedIdentifiers(targetClasses) {
-    const usedIdentifiers = /* @__PURE__ */ new Set();
-    const collectIdentifiers = (node) => {
-      if (ts8.isTypeReferenceNode(node) && ts8.isIdentifier(node.typeName)) {
-        usedIdentifiers.add(node.typeName.text);
-      }
-      if (ts8.isExpressionWithTypeArguments(node) && ts8.isIdentifier(node.expression)) {
-        usedIdentifiers.add(node.expression.text);
-      }
-      if (ts8.isIdentifier(node) && node.parent) {
-        const isHeritageOrTypeRef = ts8.isHeritageClause(node.parent.parent) || ts8.isTypeReferenceNode(node.parent);
-        if (isHeritageOrTypeRef) {
-          usedIdentifiers.add(node.text);
-        }
-      }
-      if (ts8.isDecorator(node)) {
-        this.collectDecoratorIdentifier(node, usedIdentifiers);
-      }
-      if (ts8.isCallExpression(node) && ts8.isIdentifier(node.expression)) {
-        usedIdentifiers.add(node.expression.text);
-      }
-      ts8.forEachChild(node, collectIdentifiers);
-    };
-    for (const cls of targetClasses) {
-      collectIdentifiers(cls);
-    }
-    return usedIdentifiers;
-  }
-  collectDecoratorIdentifier(decorator, usedIdentifiers) {
-    const expr = decorator.expression;
-    if (ts8.isIdentifier(expr)) {
-      usedIdentifiers.add(expr.text);
-    } else if (ts8.isCallExpression(expr) && ts8.isIdentifier(expr.expression)) {
-      usedIdentifiers.add(expr.expression.text);
-    }
-  }
-  collectLocalTypeDeclarations(sourceFile) {
-    const localTypeDeclarations = /* @__PURE__ */ new Map();
-    const collectLocalTypes = (node) => {
-      if (ts8.isInterfaceDeclaration(node) && node.name) {
-        this.addToDeclarationMap(
-          localTypeDeclarations,
-          node.name.text,
-          node
-        );
-      }
-      if (ts8.isTypeAliasDeclaration(node) && node.name) {
-        this.addToDeclarationMap(
-          localTypeDeclarations,
-          node.name.text,
-          node
-        );
-      }
-      if (ts8.isVariableStatement(node)) {
-        for (const decl of node.declarationList.declarations) {
-          if (ts8.isIdentifier(decl.name)) {
-            this.addToDeclarationMap(
-              localTypeDeclarations,
-              decl.name.text,
-              node
-            );
-          }
-        }
-      }
-      ts8.forEachChild(node, collectLocalTypes);
-    };
-    collectLocalTypes(sourceFile);
-    return localTypeDeclarations;
-  }
-  addToDeclarationMap(map, name, node) {
-    const existing = map.get(name) ?? [];
-    existing.push(node);
-    map.set(name, existing);
-  }
-  resolveIncludedLocalTypes(usedIdentifiers, relatedTypeNames, localTypeDeclarations) {
-    const includedLocalTypes = /* @__PURE__ */ new Set();
-    const queue = [...usedIdentifiers, ...relatedTypeNames];
-    while (queue.length > 0) {
-      const identifier = queue.shift();
-      if (includedLocalTypes.has(identifier)) continue;
-      const typeNodes = localTypeDeclarations.get(identifier);
-      if (!typeNodes || typeNodes.length === 0) continue;
-      includedLocalTypes.add(identifier);
-      const typeIdentifiers = this.collectTypeIdentifiersFromNodes(typeNodes);
-      for (const id of typeIdentifiers) {
-        if (!includedLocalTypes.has(id)) {
-          queue.push(id);
-          usedIdentifiers.add(id);
-        }
-      }
-    }
-    return includedLocalTypes;
-  }
-  collectTypeIdentifiersFromNodes(nodes) {
-    const typeIdentifiers = /* @__PURE__ */ new Set();
-    const collectFromType = (node) => {
-      if (ts8.isTypeReferenceNode(node) && ts8.isIdentifier(node.typeName)) {
-        typeIdentifiers.add(node.typeName.text);
-      }
-      if (ts8.isExpressionWithTypeArguments(node) && ts8.isIdentifier(node.expression)) {
-        typeIdentifiers.add(node.expression.text);
-      }
-      if (ts8.isComputedPropertyName(node)) {
-        this.collectComputedPropertyIdentifier(node, typeIdentifiers);
-      }
-      ts8.forEachChild(node, collectFromType);
-    };
-    for (const typeNode of nodes) {
-      collectFromType(typeNode);
-    }
-    return typeIdentifiers;
-  }
-  collectComputedPropertyIdentifier(node, typeIdentifiers) {
-    const expr = node.expression;
-    if (ts8.isPropertyAccessExpression(expr) && ts8.isIdentifier(expr.expression)) {
-      typeIdentifiers.add(expr.expression.text);
-    }
-    if (ts8.isIdentifier(expr)) {
-      typeIdentifiers.add(expr.text);
-    }
-  }
-  generateExtractedOutput(context, symbols) {
-    const output = [];
-    const importMap = this.buildImportMap(context.sourceFile);
-    const filteredImports = this.filterImports(
-      symbols.usedIdentifiers,
-      importMap,
-      symbols.includedLocalTypes
-    );
-    this.appendImportStatements(output, filteredImports);
-    this.appendLocalTypeDeclarations(output, context, symbols);
-    this.appendTargetClasses(output, context, symbols.targetClasses);
-    const usedModuleSpecifiers = new Set(filteredImports.keys());
-    return {
-      content: output.join("\n"),
-      usedModuleSpecifiers
+function parseArgs(args) {
+    const options = {
+        config: DEFAULT_CONFIG_PATH,
     };
-  }
-  buildImportMap(sourceFile) {
-    const importMap = /* @__PURE__ */ new Map();
-    const collectImports = (node) => {
-      if (ts8.isImportDeclaration(node)) {
-        const moduleSpecifier = node.moduleSpecifier.text;
-        const namedBindings = node.importClause?.namedBindings;
-        const isTypeOnly = node.importClause?.isTypeOnly ?? false;
-        if (namedBindings && ts8.isNamedImports(namedBindings)) {
-          for (const element of namedBindings.elements) {
-            importMap.set(element.name.text, {
-              moduleSpecifier,
-              isTypeOnly
-            });
-          }
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (matchesOption(arg, CLI_OPTIONS.config)) {
+            const { value, nextIndex } = extractOptionValue(args, i, "--config");
+            options.config = value;
+            i = nextIndex;
         }
-      }
-      ts8.forEachChild(node, collectImports);
-    };
-    collectImports(sourceFile);
-    return importMap;
-  }
-  filterImports(usedIdentifiers, importMap, includedLocalTypes) {
-    const filteredImports = /* @__PURE__ */ new Map();
-    for (const identifier of usedIdentifiers) {
-      const importInfo = importMap.get(identifier);
-      if (!importInfo || includedLocalTypes.has(identifier)) {
-        continue;
-      }
-      const existing = filteredImports.get(importInfo.moduleSpecifier);
-      if (existing) {
-        existing.identifiers.add(identifier);
-      } else {
-        filteredImports.set(importInfo.moduleSpecifier, {
-          identifiers: /* @__PURE__ */ new Set([identifier]),
-          isTypeOnly: importInfo.isTypeOnly
-        });
-      }
-    }
-    return filteredImports;
-  }
-  appendImportStatements(output, filteredImports) {
-    for (const [moduleSpecifier, info] of filteredImports) {
-      const identifiers = [...info.identifiers].sort().join(", ");
-      const typeOnlyPrefix = info.isTypeOnly ? "type " : "";
-      output.push(
-        `import ${typeOnlyPrefix}{ ${identifiers} } from "${moduleSpecifier}";`
-      );
-    }
-    if (output.length > 0) {
-      output.push("");
-    }
-  }
-  appendLocalTypeDeclarations(output, context, symbols) {
-    const outputNodes = /* @__PURE__ */ new Set();
-    for (const typeName of symbols.includedLocalTypes) {
-      const typeNodes = symbols.localTypeDeclarations.get(typeName);
-      if (!typeNodes) continue;
-      for (const typeNode of typeNodes) {
-        if (outputNodes.has(typeNode)) continue;
-        outputNodes.add(typeNode);
-        this.appendNodeWithExport(output, context, typeNode);
-      }
-    }
-  }
-  appendTargetClasses(output, context, targetClasses) {
-    for (const cls of targetClasses) {
-      this.appendNodeWithExport(output, context, cls);
-    }
-  }
-  appendNodeWithExport(output, context, node) {
-    const nodeText = context.content.substring(node.getStart(context.sourceFile), node.end).trim();
-    const hasExport = this.nodeHasExportKeyword(node);
-    if (hasExport) {
-      output.push(nodeText);
-    } else {
-      output.push("export " + nodeText);
-    }
-    output.push("");
-  }
-  nodeHasExportKeyword(node) {
-    const isExportableDeclaration = ts8.isInterfaceDeclaration(node) || ts8.isTypeAliasDeclaration(node) || ts8.isVariableStatement(node) || ts8.isClassDeclaration(node);
-    if (!isExportableDeclaration) {
-      return false;
-    }
-    const declarationNode = node;
-    return declarationNode.modifiers?.some(
-      (m) => m.kind === ts8.SyntaxKind.ExportKeyword
-    ) ?? false;
-  }
-};
-
-// src/registry-generator.ts
-var DEFAULT_OPTIONS = {
-  messageRegistryImport: "@hexaijs/plugin-contracts-generator/runtime"
-};
-function hasMessages(ctx) {
-  return ctx.events.length > 0 || ctx.commands.length > 0 || (ctx.queries?.length ?? 0) > 0;
-}
-function getAllMessages(ctx) {
-  return [...ctx.events, ...ctx.commands, ...ctx.queries ?? []];
-}
-var RegistryGenerator = class {
-  options;
-  constructor(options = {}) {
-    this.options = { ...DEFAULT_OPTIONS, ...options };
-  }
-  generate(contexts) {
-    const allMessages = contexts.flatMap(
-      (ctx) => getAllMessages(ctx).map((message) => ({
-        message,
-        contextName: ctx.contextName
-      }))
-    );
-    if (allMessages.length === 0) {
-      return this.generateEmptyRegistry();
-    }
-    if (this.options.useNamespace) {
-      return this.generateWithNamespace(contexts, allMessages);
-    }
-    const imports = this.generateImports(contexts);
-    const registrations = this.generateRegistrations(allMessages);
-    return [
-      imports,
-      "",
-      "export const messageRegistry = new MessageRegistry()",
-      registrations
-    ].join("\n");
-  }
-  generateEmptyRegistry() {
-    return [
-      `import { MessageRegistry } from "${this.options.messageRegistryImport}";`,
-      "",
-      "export const messageRegistry = new MessageRegistry();",
-      ""
-    ].join("\n");
-  }
-  generateWithNamespace(contexts, allMessages) {
-    const imports = this.generateNamespaceImports(contexts);
-    const exports$1 = this.generateNamespaceExports(contexts);
-    const registrations = this.generateNamespaceRegistrations(allMessages);
-    return [
-      imports,
-      "",
-      exports$1,
-      "",
-      "export const messageRegistry = new MessageRegistry()",
-      registrations
-    ].join("\n");
-  }
-  getNamespaceInfos(contexts) {
-    return contexts.filter(hasMessages).map((ctx) => ({
-      importPath: ctx.importPath ?? `./${ctx.contextName}`,
-      namespace: this.toNamespace(ctx.contextName)
-    }));
-  }
-  generateNamespaceImports(contexts) {
-    return [
-      `import { MessageRegistry } from "${this.options.messageRegistryImport}";`,
-      ...this.getNamespaceInfos(contexts).map(
-        ({ importPath, namespace }) => `import * as ${namespace} from "${importPath}";`
-      )
-    ].join("\n");
-  }
-  generateNamespaceExports(contexts) {
-    return this.getNamespaceInfos(contexts).map(
-      ({ importPath, namespace }) => `export * as ${namespace} from "${importPath}";`
-    ).join("\n");
-  }
-  generateNamespaceRegistrations(messages) {
-    const lines = messages.map(({ message, contextName }) => {
-      const namespace = this.toNamespace(contextName);
-      return `    .register(${namespace}.${message.name})`;
-    });
-    return lines.join("\n") + ";\n";
-  }
-  toNamespace(contextName) {
-    return contextName.replace(
-      /-([a-z])/g,
-      (_, letter) => letter.toUpperCase()
-    );
-  }
-  generateImports(contexts) {
-    const lines = [
-      `import { MessageRegistry } from "${this.options.messageRegistryImport}";`
-    ];
-    for (const ctx of contexts) {
-      const messageNames = getAllMessages(ctx).map((m) => m.name);
-      if (messageNames.length > 0) {
-        const importPath = ctx.importPath ?? `./${ctx.contextName}`;
-        lines.push(
-          `import { ${messageNames.join(", ")} } from "${importPath}";`
-        );
-      }
-    }
-    return lines.join("\n");
-  }
-  generateRegistrations(messages) {
-    const lines = messages.map(
-      ({ message }) => `    .register(${message.name})`
-    );
-    return lines.join("\n") + ";\n";
-  }
-};
-var ReexportGenerator = class {
-  fs;
-  constructor(options = {}) {
-    this.fs = options.fileSystem ?? nodeFileSystem;
-  }
-  /**
-   * Analyzes files to find imports that match pathAliasRewrites
-   * and groups them by rewritten path
-   */
-  async analyze(options) {
-    const { files, pathAliasRewrites } = options;
-    const rewrittenToOriginal = /* @__PURE__ */ new Map();
-    for (const [original, rewritten] of pathAliasRewrites) {
-      rewrittenToOriginal.set(rewritten, original);
-    }
-    const allImports = [];
-    for (const file of files) {
-      const content = await this.fs.readFile(file);
-      const imports = this.extractRewrittenImports(content, rewrittenToOriginal);
-      allImports.push(...imports);
-    }
-    return this.groupImportsByPath(allImports);
-  }
-  /**
-   * Generates re-export files
-   */
-  async generate(options) {
-    const { outputDir, reexportFiles } = options;
-    const generatedFiles = [];
-    for (const reexport of reexportFiles) {
-      const filePath = path.join(outputDir, reexport.relativePath);
-      const content = this.generateReexportContent(reexport);
-      await this.fs.mkdir(path.dirname(filePath), { recursive: true });
-      await this.fs.writeFile(filePath, content);
-      generatedFiles.push(filePath);
-    }
-    return generatedFiles;
-  }
-  /**
-   * Extracts imports from source content that match rewritten prefixes
-   */
-  extractRewrittenImports(content, rewrittenToOriginal) {
-    const sourceFile = ts8.createSourceFile(
-      "temp.ts",
-      content,
-      ts8.ScriptTarget.Latest,
-      true
-    );
-    const imports = [];
-    ts8.forEachChild(sourceFile, (node) => {
-      if (!ts8.isImportDeclaration(node) || !node.importClause) {
-        return;
-      }
-      const moduleSpecifier = node.moduleSpecifier.text;
-      for (const [rewrittenPrefix, originalPrefix] of rewrittenToOriginal) {
-        if (moduleSpecifier.startsWith(rewrittenPrefix)) {
-          const symbols = this.extractSymbolNames(node.importClause);
-          if (symbols.length > 0) {
-            const suffix = moduleSpecifier.slice(rewrittenPrefix.length);
-            const originalPath = originalPrefix + suffix;
-            imports.push({
-              rewrittenPath: moduleSpecifier,
-              originalPath,
-              symbols,
-              isTypeOnly: node.importClause.isTypeOnly ?? false
-            });
-          }
-          break;
+        else if (matchesOption(arg, CLI_OPTIONS.outputDir)) {
+            const { value, nextIndex } = extractOptionValue(args, i, "--output-dir");
+            options.outputDir = value;
+            i = nextIndex;
         }
-      }
-    });
-    return imports;
-  }
-  /**
-   * Extracts symbol names from import clause
-   */
-  extractSymbolNames(importClause) {
-    const names = [];
-    if (importClause.name) {
-      names.push(importClause.name.text);
-    }
-    if (importClause.namedBindings && ts8.isNamedImports(importClause.namedBindings)) {
-      for (const element of importClause.namedBindings.elements) {
-        const originalName = element.propertyName?.text ?? element.name.text;
-        names.push(originalName);
-      }
-    }
-    return names;
-  }
-  /**
-   * Groups imports by rewritten path and merges symbols
-   */
-  groupImportsByPath(imports) {
-    const grouped = /* @__PURE__ */ new Map();
-    for (const imp of imports) {
-      const existing = grouped.get(imp.rewrittenPath);
-      if (existing) {
-        for (const symbol of imp.symbols) {
-          existing.symbols.add(symbol);
+        else if (matchesOption(arg, CLI_OPTIONS.messageTypes)) {
+            const { value, nextIndex } = extractOptionValue(args, i, "--message-types");
+            options.messageTypes = parseMessageTypes(value);
+            i = nextIndex;
         }
-        if (!imp.isTypeOnly) {
-          existing.hasValueImport = true;
+        else if (matchesOption(arg, CLI_OPTIONS.generateMessageRegistry)) {
+            options.generateMessageRegistry = true;
         }
-      } else {
-        grouped.set(imp.rewrittenPath, {
-          originalPath: imp.originalPath,
-          symbols: new Set(imp.symbols),
-          hasValueImport: !imp.isTypeOnly
-        });
-      }
-    }
-    const result = [];
-    for (const [rewrittenPath, data] of grouped) {
-      const relativePath = this.rewrittenPathToRelativePath(rewrittenPath);
-      result.push({
-        relativePath,
-        originalModule: data.originalPath,
-        symbols: Array.from(data.symbols).sort(),
-        isTypeOnly: !data.hasValueImport
-      });
-    }
-    return result.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-  }
-  /**
-   * Converts a rewritten package path to a relative file path
-   * e.g., "@libera/contracts/common/request" with prefix "@libera/contracts"
-   *       -> "common/request.ts"
-   */
-  rewrittenPathToRelativePath(rewrittenPath) {
-    const parts = rewrittenPath.split("/");
-    let subpathStart;
-    if (parts[0].startsWith("@")) {
-      subpathStart = 2;
-    } else {
-      subpathStart = 1;
-    }
-    const subpath = parts.slice(subpathStart).join("/");
-    if (!subpath) {
-      return "index.ts";
-    }
-    return subpath + ".ts";
-  }
-  /**
-   * Generates the content for a re-export file
-   */
-  generateReexportContent(reexport) {
-    const exportKeyword = reexport.isTypeOnly ? "export type" : "export";
-    const symbols = reexport.symbols.join(", ");
-    return `${exportKeyword} { ${symbols} } from "${reexport.originalModule}";
-`;
-  }
-};
-
-// src/logger.ts
-var LOG_LEVEL_PRIORITY = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-var ConsoleLogger = class {
-  level;
-  constructor(options = {}) {
-    this.level = options.level ?? "info";
-  }
-  debug(message) {
-    if (this.shouldLog("debug")) {
-      console.debug(message);
-    }
-  }
-  info(message) {
-    if (this.shouldLog("info")) {
-      console.info(message);
-    }
-  }
-  warn(message) {
-    if (this.shouldLog("warn")) {
-      console.warn(message);
-    }
-  }
-  error(message) {
-    if (this.shouldLog("error")) {
-      console.error(message);
-    }
-  }
-  shouldLog(level) {
-    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
-  }
-};
-var NoopLogger = class {
-  debug() {
-  }
-  info() {
-  }
-  warn() {
-  }
-  error() {
-  }
-};
-var noopLogger = new NoopLogger();
-var DEFAULT_EXCLUDE_DEPENDENCIES = [
-  "**/*.test.ts",
-  "**/*.spec.ts",
-  "**/*.eh.ts",
-  "**/db.ts",
-  "**/infra/**"
-];
-var ContractsPipeline = class _ContractsPipeline {
-  constructor(deps, messageTypes) {
-    this.deps = deps;
-    this.messageTypes = messageTypes;
-  }
-  messageTypes;
-  static create(options) {
-    const fileSystem = options.fileSystem ?? nodeFileSystem;
-    const logger = options.logger ?? noopLogger;
-    const excludeDependencies = options.excludeDependencies ?? DEFAULT_EXCLUDE_DEPENDENCIES;
-    const scanner = new Scanner({ fileSystem, messageTypes: options.messageTypes });
-    const parser = new Parser({
-      responseNamingConventions: options.responseNamingConventions ?? options.contextConfig.responseNamingConventions,
-      messageTypes: options.messageTypes
-    });
-    const fileGraphResolver = FileGraphResolver.create({
-      contextConfig: options.contextConfig,
-      fileSystem,
-      excludeDependencies
-    });
-    const fileCopier = new FileCopier({ fileSystem });
-    return new _ContractsPipeline(
-      {
-        scanner,
-        parser,
-        fileGraphResolver,
-        fileCopier,
-        fileSystem,
-        logger
-      },
-      options.messageTypes
-    );
-  }
-  static fromDependencies(deps) {
-    return new _ContractsPipeline(deps);
-  }
-  async execute(options) {
-    const { contextName, sourceDir, outputDir, pathAliasRewrites, removeDecorators } = options;
-    const contextOutputDir = join(outputDir, contextName);
-    this.deps.logger.info(`Processing context: ${contextName}`);
-    this.deps.logger.debug(`  Source: ${sourceDir}`);
-    this.deps.logger.debug(`  Output: ${contextOutputDir}`);
-    const decoratedFiles = await this.scan(sourceDir);
-    const messages = await this.parse(decoratedFiles, sourceDir);
-    const fileGraph = await this.resolve(decoratedFiles, sourceDir);
-    const responseTypesToExport = this.collectResponseTypesToExport(messages);
-    const copiedFiles = await this.copy(fileGraph, sourceDir, contextOutputDir, pathAliasRewrites, responseTypesToExport, removeDecorators, this.messageTypes);
-    await this.exportBarrel(copiedFiles, contextOutputDir);
-    this.deps.logger.info(`Completed context: ${contextName} (${messages.events.length} events, ${messages.commands.length} commands, ${messages.queries.length} queries, ${copiedFiles.length} files)`);
-    return {
-      events: messages.events,
-      commands: messages.commands,
-      queries: messages.queries,
-      copiedFiles
-    };
-  }
-  collectResponseTypesToExport(messages) {
-    const result = /* @__PURE__ */ new Map();
-    const allMessages = [...messages.commands, ...messages.queries];
-    for (const message of allMessages) {
-      if (message.resultType?.kind !== "reference") continue;
-      const typeName = message.resultType.name;
-      const sourceFile = message.sourceFile.absolutePath;
-      const typeDef = messages.typeDefinitions.find(
-        (t) => t.name === typeName && t.sourceFile.absolutePath === sourceFile && !t.exported
-      );
-      if (typeDef) {
-        const existing = result.get(sourceFile) ?? [];
-        if (!existing.includes(typeName)) {
-          existing.push(typeName);
-          result.set(sourceFile, existing);
+        else if (matchesOption(arg, CLI_OPTIONS.help)) {
+            printHelp();
+            process.exit(0);
         }
-      }
-    }
-    if (result.size > 0) {
-      this.deps.logger.debug(`Found ${result.size} file(s) with unexported response types`);
     }
-    return result;
-  }
-  async scan(sourceDir) {
-    this.deps.logger.debug(`Scanning for decorated files in ${sourceDir}`);
-    const files = await this.deps.scanner.scan(sourceDir);
-    this.deps.logger.debug(`Found ${files.length} decorated file(s)`);
-    return files;
-  }
-  async parse(files, sourceRoot) {
-    this.deps.logger.debug(`Parsing ${files.length} file(s)`);
-    const events = [];
-    const commands = [];
-    const queries = [];
-    const typeDefinitions = [];
-    for (const file of files) {
-      const content = await this.deps.fileSystem.readFile(file);
-      const sourceFileInfo = {
-        absolutePath: file,
-        relativePath: relative(sourceRoot, file)
-      };
-      const result = this.deps.parser.parse(content, sourceFileInfo);
-      events.push(...result.events);
-      commands.push(...result.commands);
-      queries.push(...result.queries);
-      typeDefinitions.push(...result.typeDefinitions);
+    if (!options.outputDir) {
+        throw new Error("Missing required option: --output-dir");
     }
-    this.deps.logger.debug(`Parsed ${events.length} event(s), ${commands.length} command(s), ${queries.length} query(s), ${typeDefinitions.length} type(s)`);
-    return { events, commands, queries, typeDefinitions };
-  }
-  async resolve(entryPoints, sourceRoot) {
-    this.deps.logger.debug(`Resolving dependencies for ${entryPoints.length} entry point(s)`);
-    const graph = await this.deps.fileGraphResolver.buildGraph(entryPoints, sourceRoot);
-    this.deps.logger.debug(`Resolved ${graph.nodes.size} file(s) in dependency graph`);
-    return graph;
-  }
-  async copy(fileGraph, sourceRoot, outputDir, pathAliasRewrites, responseTypesToExport, removeDecorators, messageTypes) {
-    this.deps.logger.debug(`Copying files to ${outputDir}`);
-    await this.deps.fileSystem.mkdir(outputDir, { recursive: true });
-    const result = await this.deps.fileCopier.copyFiles({
-      sourceRoot,
-      outputDir,
-      fileGraph,
-      pathAliasRewrites,
-      responseTypesToExport,
-      removeDecorators,
-      messageTypes
-    });
-    this.deps.logger.debug(`Copied ${result.copiedFiles.length} file(s)`);
-    return result.copiedFiles;
-  }
-  async exportBarrel(copiedFiles, outputDir) {
-    this.deps.logger.debug(`Generating barrel export at ${outputDir}/index.ts`);
-    const indexContent = this.deps.fileCopier.generateBarrelExport(copiedFiles, outputDir);
-    await this.deps.fileSystem.writeFile(join(outputDir, "index.ts"), indexContent);
-  }
-};
-
-// src/cli.ts
-var DEFAULT_CONFIG_PATH = "application.config.ts";
-var EXIT_CODE_ERROR = 1;
-var VALID_MESSAGE_TYPES = ["event", "command", "query"];
-var CLI_OPTIONS = {
-  config: { short: "-c", long: "--config"},
-  outputDir: { short: "-o", long: "--output-dir"},
-  messageTypes: { short: "-m", long: "--message-types"},
-  generateMessageRegistry: { short: null, long: "--generate-message-registry"},
-  help: { short: "-h", long: "--help"}
-};
-function parseMessageTypes(value) {
-  const types = value.split(",").map((type) => type.trim().toLowerCase());
-  const invalidTypes = types.filter((type) => !VALID_MESSAGE_TYPES.includes(type));
-  if (invalidTypes.length > 0) {
-    throw new Error(
-      `Invalid message type(s): ${invalidTypes.join(", ")}. Valid types are: ${VALID_MESSAGE_TYPES.join(", ")}`
-    );
-  }
-  return types;
-}
-function extractOptionValue(args, currentIndex, optionName) {
-  const currentArg = args[currentIndex];
-  const equalsIndex = currentArg.indexOf("=");
-  if (equalsIndex !== -1) {
-    return {
-      value: currentArg.slice(equalsIndex + 1),
-      nextIndex: currentIndex
-    };
-  }
-  const nextValue = args[currentIndex + 1];
-  if (!nextValue) {
-    throw new Error(`Missing value for ${optionName} option`);
-  }
-  return {
-    value: nextValue,
-    nextIndex: currentIndex + 1
-  };
-}
-function matchesOption(arg, option) {
-  const matchesShortOrLong = arg === option.short || arg === option.long;
-  const matchesLongWithValue = option.long !== null && arg.startsWith(`${option.long}=`);
-  return matchesShortOrLong || matchesLongWithValue;
-}
-function parseArgs(args) {
-  const options = {
-    config: DEFAULT_CONFIG_PATH
-  };
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (matchesOption(arg, CLI_OPTIONS.config)) {
-      const { value, nextIndex } = extractOptionValue(args, i, "--config");
-      options.config = value;
-      i = nextIndex;
-    } else if (matchesOption(arg, CLI_OPTIONS.outputDir)) {
-      const { value, nextIndex } = extractOptionValue(args, i, "--output-dir");
-      options.outputDir = value;
-      i = nextIndex;
-    } else if (matchesOption(arg, CLI_OPTIONS.messageTypes)) {
-      const { value, nextIndex } = extractOptionValue(args, i, "--message-types");
-      options.messageTypes = parseMessageTypes(value);
-      i = nextIndex;
-    } else if (matchesOption(arg, CLI_OPTIONS.generateMessageRegistry)) {
-      options.generateMessageRegistry = true;
-    } else if (matchesOption(arg, CLI_OPTIONS.help)) {
-      printHelp();
-      process.exit(0);
-    }
-  }
-  if (!options.outputDir) {
-    throw new Error("Missing required option: --output-dir");
-  }
-  return options;
+    return options;
 }
 function printHelp() {
-  console.log(`
+    console.log(`
 contracts-generator - Extract domain events and commands from TypeScript source
 
 Usage:
@@ -2360,9 +106,12 @@ Config file format:
   export default {
     contracts: {
       contexts: [
+        "packages/*",                    // glob: auto-discover all contexts
+        "packages/auth",                 // string: name inferred from directory
         {
           name: "lecture",
-          sourceDir: "packages/lecture/src",
+          path: "packages/lecture",       // required: base directory
+          sourceDir: "src",              // optional, default: "src"
         },
       ],
       pathAliasRewrites: {
@@ -2389,180 +138,177 @@ Examples:
 `);
 }
 function calculateSummaryTotals(results) {
-  return results.reduce(
-    (totals, contextResult) => ({
-      events: totals.events + contextResult.result.events.length,
-      commands: totals.commands + contextResult.result.commands.length,
-      files: totals.files + contextResult.result.copiedFiles.length
-    }),
-    { events: 0, commands: 0, files: 0 }
-  );
+    return results.reduce((totals, contextResult) => ({
+        events: totals.events + contextResult.result.events.length,
+        commands: totals.commands + contextResult.result.commands.length,
+        files: totals.files + contextResult.result.copiedFiles.length,
+    }), { events: 0, commands: 0, files: 0 });
 }
 function countTotalMessages(totals) {
-  return totals.events + totals.commands;
+    return totals.events + totals.commands;
 }
 function logSummary(logger, totals) {
-  logger.info("\n--- Summary ---");
-  logger.info(`Total events: ${totals.events}`);
-  logger.info(`Total commands: ${totals.commands}`);
-  logger.info(`Total files copied: ${totals.files}`);
+    logger.info("\n--- Summary ---");
+    logger.info(`Total events: ${totals.events}`);
+    logger.info(`Total commands: ${totals.commands}`);
+    logger.info(`Total files copied: ${totals.files}`);
 }
-async function run(args) {
-  const options = parseArgs(args);
-  const configPath = resolve(options.config);
-  const configDir = dirname(configPath);
-  const outputDir = resolve(configDir, options.outputDir);
-  const logger = new ConsoleLogger({ level: "info" });
-  logger.info(`Loading config from: ${configPath}`);
-  const configLoader = new ConfigLoader();
-  const config = await configLoader.load(configPath);
-  logger.info(`Found ${config.contexts.length} context(s) to process`);
-  logger.info(`Output directory: ${outputDir}`);
-  if (options.messageTypes) {
-    logger.info(`Message types filter: ${options.messageTypes.join(", ")}`);
-  }
-  const pathAliasRewrites = config.pathAliasRewrites ? new Map(Object.entries(config.pathAliasRewrites)) : void 0;
-  const results = [];
-  for (const contextConfig of config.contexts) {
-    const pipeline = ContractsPipeline.create({
-      contextConfig,
-      messageTypes: options.messageTypes,
-      logger
-    });
-    const result = await pipeline.execute({
-      contextName: contextConfig.name,
-      sourceDir: contextConfig.sourceDir,
-      outputDir,
-      pathAliasRewrites,
-      removeDecorators: config.removeDecorators
-    });
-    results.push({ name: contextConfig.name, result, outputDir });
-  }
-  const totals = calculateSummaryTotals(results);
-  logSummary(logger, totals);
-  if (options.generateMessageRegistry) {
-    await generateRegistry(outputDir, results, totals, logger);
-  }
-  if (config.pathAliasRewrites) {
-    await generateReexports(config, outputDir, results, logger);
-  }
+export async function run(args) {
+    const options = parseArgs(args);
+    const configPath = resolve(options.config);
+    const configDir = dirname(configPath);
+    const outputDir = resolve(configDir, options.outputDir);
+    const logger = new ConsoleLogger({ level: "info" });
+    logger.info(`Loading config from: ${configPath}`);
+    const configLoader = new ConfigLoader();
+    const config = await configLoader.load(configPath);
+    logger.info(`Found ${config.contexts.length} context(s) to process`);
+    logger.info(`Output directory: ${outputDir}`);
+    if (options.messageTypes) {
+        logger.info(`Message types filter: ${options.messageTypes.join(", ")}`);
+    }
+    const pathAliasRewrites = config.pathAliasRewrites
+        ? new Map(Object.entries(config.pathAliasRewrites))
+        : undefined;
+    const results = [];
+    for (const contextConfig of config.contexts) {
+        const pipeline = ContractsPipeline.create({
+            contextConfig,
+            messageTypes: options.messageTypes,
+            logger,
+        });
+        const result = await pipeline.execute({
+            contextName: contextConfig.name,
+            sourceDir: contextConfig.sourceDir,
+            outputDir,
+            pathAliasRewrites,
+            removeDecorators: config.removeDecorators,
+        });
+        results.push({ name: contextConfig.name, result, outputDir });
+    }
+    const totals = calculateSummaryTotals(results);
+    logSummary(logger, totals);
+    if (options.generateMessageRegistry) {
+        await generateRegistry(outputDir, results, totals, logger);
+    }
+    if (config.pathAliasRewrites) {
+        await generateReexports(config, outputDir, results, logger);
+    }
 }
+/**
+ * Converts plugin config to internal ContractsConfig format.
+ */
 async function toContractsConfig(pluginConfig) {
-  const contexts = await Promise.all(
-    pluginConfig.contexts.map(
-      (ctx) => ContextConfig.create(
-        {
-          name: ctx.name,
-          path: ctx.path,
-          sourceDir: ctx.sourceDir,
-          tsconfigPath: ctx.tsconfigPath
-        },
-        process.cwd(),
-        nodeFileSystem
-      )
-    )
-  );
-  return {
-    contexts,
-    pathAliasRewrites: pluginConfig.pathAliasRewrites,
-    externalDependencies: pluginConfig.externalDependencies,
-    decoratorNames: mergeDecoratorNames(pluginConfig.decoratorNames),
-    responseNamingConventions: pluginConfig.responseNamingConventions,
-    removeDecorators: pluginConfig.removeDecorators ?? true
-  };
+    const contexts = await resolveContextEntries(pluginConfig.contexts, process.cwd(), nodeFileSystem);
+    return {
+        contexts,
+        pathAliasRewrites: pluginConfig.pathAliasRewrites,
+        externalDependencies: pluginConfig.externalDependencies,
+        decoratorNames: mergeDecoratorNames(pluginConfig.decoratorNames),
+        responseNamingConventions: pluginConfig.responseNamingConventions,
+        removeDecorators: pluginConfig.removeDecorators ?? true,
+    };
 }
-async function runWithConfig(options, pluginConfig) {
-  const outputDir = resolve(options.outputDir);
-  const logger = new ConsoleLogger({ level: "info" });
-  const config = await toContractsConfig(pluginConfig);
-  logger.info(`Found ${config.contexts.length} context(s) to process`);
-  logger.info(`Output directory: ${outputDir}`);
-  if (options.messageTypes) {
-    logger.info(`Message types filter: ${options.messageTypes.join(", ")}`);
-  }
-  const pathAliasRewrites = config.pathAliasRewrites ? new Map(Object.entries(config.pathAliasRewrites)) : void 0;
-  const results = [];
-  for (const contextConfig of config.contexts) {
-    const pipeline = ContractsPipeline.create({
-      contextConfig,
-      messageTypes: options.messageTypes,
-      logger
-    });
-    const result = await pipeline.execute({
-      contextName: contextConfig.name,
-      sourceDir: contextConfig.sourceDir,
-      outputDir,
-      pathAliasRewrites,
-      removeDecorators: config.removeDecorators
-    });
-    results.push({ name: contextConfig.name, result, outputDir });
-  }
-  const totals = calculateSummaryTotals(results);
-  logSummary(logger, totals);
-  if (options.generateMessageRegistry) {
-    await generateRegistry(outputDir, results, totals, logger);
-  }
-  if (config.pathAliasRewrites) {
-    await generateReexports(config, outputDir, results, logger);
-  }
+/**
+ * Run contracts generator with config provided directly.
+ * This is used by the hexai CLI integration where config comes from hexai.config.ts.
+ *
+ * @param options - CLI options (outputDir, messageTypes, generateMessageRegistry)
+ * @param pluginConfig - Plugin configuration from hexai.config.ts
+ */
+export async function runWithConfig(options, pluginConfig) {
+    const outputDir = resolve(options.outputDir);
+    const logger = new ConsoleLogger({ level: "info" });
+    const config = await toContractsConfig(pluginConfig);
+    logger.info(`Found ${config.contexts.length} context(s) to process`);
+    logger.info(`Output directory: ${outputDir}`);
+    if (options.messageTypes) {
+        logger.info(`Message types filter: ${options.messageTypes.join(", ")}`);
+    }
+    const pathAliasRewrites = config.pathAliasRewrites
+        ? new Map(Object.entries(config.pathAliasRewrites))
+        : undefined;
+    const results = [];
+    for (const contextConfig of config.contexts) {
+        const pipeline = ContractsPipeline.create({
+            contextConfig,
+            messageTypes: options.messageTypes,
+            logger,
+        });
+        const result = await pipeline.execute({
+            contextName: contextConfig.name,
+            sourceDir: contextConfig.sourceDir,
+            outputDir,
+            pathAliasRewrites,
+            removeDecorators: config.removeDecorators,
+        });
+        results.push({ name: contextConfig.name, result, outputDir });
+    }
+    const totals = calculateSummaryTotals(results);
+    logSummary(logger, totals);
+    if (options.generateMessageRegistry) {
+        await generateRegistry(outputDir, results, totals, logger);
+    }
+    if (config.pathAliasRewrites) {
+        await generateReexports(config, outputDir, results, logger);
+    }
 }
 async function generateRegistry(outputDir, results, totals, logger) {
-  const contextMessages = results.map((contextResult) => {
-    const contextOutputDir = join(contextResult.outputDir, contextResult.name);
-    const importPath = "./" + relative(outputDir, contextOutputDir).replace(/\\/g, "/");
-    return {
-      contextName: contextResult.name,
-      events: contextResult.result.events,
-      commands: contextResult.result.commands,
-      queries: contextResult.result.queries,
-      importPath
-    };
-  });
-  const generator = new RegistryGenerator({ useNamespace: true });
-  const registryContent = generator.generate(contextMessages);
-  await nodeFileSystem.mkdir(outputDir, { recursive: true });
-  const indexPath = join(outputDir, "index.ts");
-  await nodeFileSystem.writeFile(indexPath, registryContent);
-  logger.info(`  Generated index.ts with ${countTotalMessages(totals)} message(s)`);
+    const contextMessages = results.map((contextResult) => {
+        const contextOutputDir = join(contextResult.outputDir, contextResult.name);
+        const importPath = "./" + relative(outputDir, contextOutputDir).replace(/\\/g, "/");
+        return {
+            contextName: contextResult.name,
+            events: contextResult.result.events,
+            commands: contextResult.result.commands,
+            queries: contextResult.result.queries,
+            importPath,
+        };
+    });
+    const generator = new RegistryGenerator({ useNamespace: true });
+    const registryContent = generator.generate(contextMessages);
+    await nodeFileSystem.mkdir(outputDir, { recursive: true });
+    const indexPath = join(outputDir, "index.ts");
+    await nodeFileSystem.writeFile(indexPath, registryContent);
+    logger.info(`  Generated index.ts with ${countTotalMessages(totals)} message(s)`);
 }
 async function generateReexports(config, outputDir, results, logger) {
-  logger.info("\n--- Generating re-exports for pathAliasRewrites ---");
-  const pathAliasRewrites = new Map(Object.entries(config.pathAliasRewrites));
-  const allCopiedFiles = results.flatMap((contextResult) => contextResult.result.copiedFiles);
-  const generator = new ReexportGenerator({ fileSystem: nodeFileSystem });
-  const reexportFiles = await generator.analyze({
-    files: allCopiedFiles,
-    pathAliasRewrites
-  });
-  if (reexportFiles.length === 0) {
-    logger.info("  No re-export files needed");
-    return;
-  }
-  const generatedFiles = await generator.generate({
-    outputDir,
-    reexportFiles
-  });
-  logger.info(`  Generated ${generatedFiles.length} re-export file(s):`);
-  for (const file of generatedFiles) {
-    logger.info(`    - ${relative(outputDir, file)}`);
-  }
+    logger.info("\n--- Generating re-exports for pathAliasRewrites ---");
+    const pathAliasRewrites = new Map(Object.entries(config.pathAliasRewrites));
+    const allCopiedFiles = results.flatMap((contextResult) => contextResult.result.copiedFiles);
+    const generator = new ReexportGenerator({ fileSystem: nodeFileSystem });
+    const reexportFiles = await generator.analyze({
+        files: allCopiedFiles,
+        pathAliasRewrites,
+    });
+    if (reexportFiles.length === 0) {
+        logger.info("  No re-export files needed");
+        return;
+    }
+    const generatedFiles = await generator.generate({
+        outputDir,
+        reexportFiles,
+    });
+    logger.info(`  Generated ${generatedFiles.length} re-export file(s):`);
+    for (const file of generatedFiles) {
+        logger.info(`    - ${relative(outputDir, file)}`);
+    }
 }
 async function main() {
-  try {
-    await run(process.argv.slice(2));
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error(`Error: ${error.message}`);
-    } else {
-      console.error("Unknown error occurred");
+    try {
+        await run(process.argv.slice(2));
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(`Error: ${error.message}`);
+        }
+        else {
+            console.error("Unknown error occurred");
+        }
+        process.exit(EXIT_CODE_ERROR);
     }
-    process.exit(EXIT_CODE_ERROR);
-  }
 }
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  main();
+    main();
 }
-
-export { run, runWithConfig };
-//# sourceMappingURL=cli.js.map
 //# sourceMappingURL=cli.js.map