@hexaijs/plugin-application-builder 0.2.3 → 0.2.4

package/dist/application-builder-generator.d.ts

@@ -0,0 +1,15 @@
+import { BuildPluginConfig } from "./config.js";
+/**
+ * Orchestrates the application builder generation process
+ */
+export declare class ApplicationBuilderGenerator {
+    private contextPath;
+    private config;
+    private metadataExtractor;
+    private codeGenerator;
+    constructor(contextPath: string, config: BuildPluginConfig);
+    generate(): Promise<void>;
+    private scanHandlerFiles;
+    private writeToFile;
+}
+//# sourceMappingURL=application-builder-generator.d.ts.map

package/dist/application-builder-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-builder-generator.d.ts","sourceRoot":"","sources":["../src/application-builder-generator.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIhD;;GAEG;AACH,qBAAa,2BAA2B;IAKhC,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,MAAM;IALlB,OAAO,CAAC,iBAAiB,CAA2B;IACpD,OAAO,CAAC,aAAa,CAA2B;IAEhD,YACY,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,iBAAiB,EAOpC;IAEK,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAK9B;YAEa,gBAAgB;IAc9B,OAAO,CAAC,WAAW;CAOtB"}

package/dist/application-builder-generator.js

@@ -0,0 +1,44 @@
+import * as fs from "fs";
+import * as path from "path";
+import { glob } from "glob";
+import { HandlerMetadataExtractor } from "./metadata-extractor.js";
+import { ApplicationCodeGenerator } from "./code-generator.js";
+/**
+ * Orchestrates the application builder generation process
+ */
+export class ApplicationBuilderGenerator {
+    contextPath;
+    config;
+    metadataExtractor;
+    codeGenerator;
+    constructor(contextPath, config) {
+        this.contextPath = contextPath;
+        this.config = config;
+        this.metadataExtractor = new HandlerMetadataExtractor(contextPath, config.outputFile);
+        this.codeGenerator = new ApplicationCodeGenerator(config);
+    }
+    async generate() {
+        const handlerFiles = await this.scanHandlerFiles();
+        const handlers = this.metadataExtractor.extractHandlersMetadata(handlerFiles);
+        const code = this.codeGenerator.generateCode(handlers);
+        this.writeToFile(code);
+    }
+    async scanHandlerFiles() {
+        const allFiles = [];
+        for (const pattern of this.config.handlers) {
+            const files = await glob(pattern, {
+                cwd: this.contextPath,
+                absolute: true,
+            });
+            allFiles.push(...files);
+        }
+        return allFiles.sort();
+    }
+    writeToFile(code) {
+        const outputFile = path.join(this.contextPath, this.config.outputFile);
+        const outputDir = path.dirname(outputFile);
+        fs.mkdirSync(outputDir, { recursive: true });
+        fs.writeFileSync(outputFile, code, "utf-8");
+    }
+}
+//# sourceMappingURL=application-builder-generator.js.map

package/dist/application-builder-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-builder-generator.js","sourceRoot":"","sources":["../src/application-builder-generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AACzB,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAE/D;;GAEG;AACH,MAAM,OAAO,2BAA2B;IAKxB,WAAW;IACX,MAAM;IALV,iBAAiB,CAA2B;IAC5C,aAAa,CAA2B;IAEhD,YACY,WAAmB,EACnB,MAAyB;2BADzB,WAAW;sBACX,MAAM;QAEd,IAAI,CAAC,iBAAiB,GAAG,IAAI,wBAAwB,CACjD,WAAW,EACX,MAAM,CAAC,UAAU,CACpB,CAAC;QACF,IAAI,CAAC,aAAa,GAAG,IAAI,wBAAwB,CAAC,MAAM,CAAC,CAAC;IAC9D,CAAC;IAED,KAAK,CAAC,QAAQ;QACV,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACnD,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,uBAAuB,CAAC,YAAY,CAAC,CAAC;QAC9E,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QACvD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAEO,KAAK,CAAC,gBAAgB;QAC1B,MAAM,QAAQ,GAAa,EAAE,CAAC;QAE9B,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACzC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE;gBAC9B,GAAG,EAAE,IAAI,CAAC,WAAW;gBACrB,QAAQ,EAAE,IAAI;aACjB,CAAC,CAAC;YACH,QAAQ,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC;QAC5B,CAAC;QAED,OAAO,QAAQ,CAAC,IAAI,EAAE,CAAC;IAC3B,CAAC;IAEO,WAAW,CAAC,IAAY;QAC5B,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QACvE,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAE3C,EAAE,CAAC,SAAS,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC7C,EAAE,CAAC,aAAa,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC;CACJ"}

package/dist/cli.d.ts

@@ -1 +1,3 @@
 #!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -1,578 +1,26 @@
 #!/usr/bin/env node
-import * as path from 'path';
-import * as fs from 'fs';
-import { glob } from 'glob';
-import * as ts from 'typescript';
-
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/errors.ts
-var DuplicateCommandHandlerError = class extends Error {
-  constructor(commandClassName, handlers) {
-    super(
-      `Duplicate command handlers for "${commandClassName}": ${handlers.join(", ")}`
-    );
-    this.name = "DuplicateCommandHandlerError";
-  }
-};
-var DuplicateEventHandlerError = class extends Error {
-  constructor(eventName, handlers) {
-    super(
-      `Duplicate event handlers for event "${eventName}": ${handlers.join(", ")}`
-    );
-    this.name = "DuplicateEventHandlerError";
-  }
-};
-var DuplicateQueryHandlerError = class extends Error {
-  constructor(queryClassName, handlers) {
-    super(
-      `Duplicate query handlers for "${queryClassName}": ${handlers.join(", ")}`
-    );
-    this.name = "DuplicateQueryHandlerError";
-  }
-};
-var MessageClassNotFoundError = class extends Error {
-  constructor(messageClassName, filePath) {
-    super(
-      `Cannot find "${messageClassName}" - not imported and not defined in "${filePath}"`
-    );
-    this.name = "MessageClassNotFoundError";
-  }
-};
-
-// src/metadata-extractor.ts
-var HandlerMetadataExtractor = class {
-  constructor(contextPath, outputFile, config = {}) {
-    this.contextPath = contextPath;
-    this.outputFile = outputFile;
-    if (config.commandHandlerDecorator) {
-      this.config.commandHandlerDecorator = config.commandHandlerDecorator;
-    }
-    if (config.eventHandlerDecorator) {
-      this.config.eventHandlerDecorator = config.eventHandlerDecorator;
-    }
-  }
-  config = {
-    commandHandlerDecorator: "CommandHandlerMarker",
-    eventHandlerDecorator: "EventHandlerMarker"
-  };
-  extractHandlersMetadata(files) {
-    const handlers = [];
-    for (const file of files) {
-      const sourceCode = fs.readFileSync(file, "utf-8");
-      const sourceFile = ts.createSourceFile(
-        file,
-        sourceCode,
-        ts.ScriptTarget.Latest,
-        true
-      );
-      ts.forEachChild(sourceFile, (node) => {
-        if (ts.isClassDeclaration(node)) {
-          const metadata = this.extractFromClass(
-            node,
-            file,
-            sourceFile
-          );
-          if (metadata) {
-            handlers.push(metadata);
-          }
-        }
-      });
-    }
-    return handlers;
-  }
-  extractFromClass(classNode, filePath, sourceFile) {
-    const className = classNode.name?.text;
-    if (!className) return null;
-    const decorators = ts.canHaveDecorators(classNode) ? ts.getDecorators(classNode) : void 0;
-    if (!decorators) return null;
-    for (const decorator of decorators) {
-      const expression = decorator.expression;
-      if (!ts.isCallExpression(expression)) continue;
-      const decoratorName = expression.expression.getText();
-      if (decoratorName === "CommandHandlerMarker") {
-        return this.extractCommandHandlerMetadata(
-          className,
-          expression,
-          filePath,
-          sourceFile
-        );
-      }
-      if (decoratorName === "EventHandlerMarker") {
-        return this.extractEventHandlerMetadata(
-          className,
-          expression,
-          filePath
-        );
-      }
-      if (decoratorName === "QueryHandlerMarker") {
-        return this.extractQueryHandlerMetadata(
-          className,
-          expression,
-          filePath,
-          sourceFile
-        );
-      }
-    }
-    return null;
-  }
-  extractMessageHandlerMetadata(className, expression, filePath, sourceFile) {
-    const messageClassArg = expression.arguments[0];
-    const messageClassName = messageClassArg.getText();
-    const messageImport = this.findImportForSymbol(
-      messageClassName,
-      sourceFile
-    );
-    let messagePath = "";
-    let resolvedMessageClassName = messageClassName;
-    if (messageImport) {
-      const handlerDir = path.dirname(filePath);
-      const resolvedImportPath = this.resolvePathAlias(messageImport.path);
-      const messageAbsolutePath = path.resolve(
-        handlerDir,
-        resolvedImportPath + ".ts"
-      );
-      messagePath = this.toRelativeImport(messageAbsolutePath);
-      resolvedMessageClassName = messageImport.symbol;
-    } else if (this.isClassDefinedInFile(messageClassName, sourceFile)) {
-      messagePath = this.toRelativeImport(filePath);
-    } else {
-      throw new MessageClassNotFoundError(messageClassName, filePath);
-    }
-    return {
-      messagePath,
-      messageClassName: resolvedMessageClassName
-    };
-  }
-  isClassDefinedInFile(className, sourceFile) {
-    for (const statement of sourceFile.statements) {
-      if (ts.isClassDeclaration(statement) && statement.name?.text === className) {
-        return true;
-      }
-    }
-    return false;
-  }
-  extractCommandHandlerMetadata(className, expression, filePath, sourceFile) {
-    const { messagePath, messageClassName } = this.extractMessageHandlerMetadata(
-      className,
-      expression,
-      filePath,
-      sourceFile
-    );
-    return {
-      type: "command",
-      handlerPath: this.toRelativeImport(filePath),
-      handlerClassName: className,
-      commandPath: messagePath,
-      commandClassName: messageClassName
-    };
-  }
-  extractEventHandlerMetadata(className, expression, filePath) {
-    let options = {};
-    if (expression.arguments.length > 0) {
-      const optionsArg = expression.arguments[0];
-      options = this.parseObjectLiteral(optionsArg);
-    }
-    return {
-      type: "event",
-      handlerPath: this.toRelativeImport(filePath),
-      handlerClassName: className,
-      eventHandlerOptions: options
-    };
-  }
-  extractQueryHandlerMetadata(className, expression, filePath, sourceFile) {
-    const { messagePath, messageClassName } = this.extractMessageHandlerMetadata(
-      className,
-      expression,
-      filePath,
-      sourceFile
-    );
-    return {
-      type: "query",
-      handlerPath: this.toRelativeImport(filePath),
-      handlerClassName: className,
-      queryPath: messagePath,
-      queryClassName: messageClassName
-    };
-  }
-  findImportForSymbol(symbol, sourceFile) {
-    for (const statement of sourceFile.statements) {
-      if (ts.isImportDeclaration(statement)) {
-        const importClause = statement.importClause;
-        const moduleSpecifier = statement.moduleSpecifier.text;
-        if (importClause?.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
-          for (const element of importClause.namedBindings.elements) {
-            if (element.name.text === symbol) {
-              return {
-                path: moduleSpecifier,
-                symbol: element.name.text
-              };
-            }
-          }
-        }
-      }
-    }
-    return null;
-  }
-  toRelativeImport(absolutePath) {
-    const outputFileAbsolutePath = path.join(
-      this.contextPath,
-      this.outputFile
-    );
-    const outputDir = path.dirname(outputFileAbsolutePath);
-    const relative2 = path.relative(outputDir, absolutePath);
-    const withoutExtension = relative2.replace(/\.ts$/, "");
-    return withoutExtension.startsWith(".") ? withoutExtension : "./" + withoutExtension;
-  }
-  parseObjectLiteral(node) {
-    if (!ts.isObjectLiteralExpression(node)) {
-      return {};
-    }
-    const result = {};
-    for (const property of node.properties) {
-      if (ts.isPropertyAssignment(property)) {
-        const name = property.name.getText();
-        const value = property.initializer;
-        if (ts.isStringLiteral(value)) {
-          result[name] = value.text;
-        } else if (ts.isNumericLiteral(value)) {
-          result[name] = Number(value.text);
-        } else if (value.kind === ts.SyntaxKind.TrueKeyword) {
-          result[name] = true;
-        } else if (value.kind === ts.SyntaxKind.FalseKeyword) {
-          result[name] = false;
-        }
-      }
-    }
-    return result;
-  }
-  resolvePathAlias(importPath) {
-    const tsconfigPath = path.join(this.contextPath, "tsconfig.json");
-    if (!fs.existsSync(tsconfigPath)) return importPath;
-    const tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, "utf-8"));
-    const paths = tsconfig.compilerOptions?.paths;
-    const baseUrl = tsconfig.compilerOptions?.baseUrl || ".";
-    if (!paths) return importPath;
-    for (const [alias, targets] of Object.entries(paths)) {
-      const aliasPrefix = alias.replace("/*", "");
-      if (importPath.startsWith(aliasPrefix)) {
-        const targetBase = targets[0].replace("/*", "");
-        const resolvedBase = path.join(this.contextPath, baseUrl, targetBase);
-        return importPath.replace(aliasPrefix, resolvedBase);
-      }
-    }
-    return importPath;
-  }
-};
-
-// src/code-generator.ts
-var ApplicationCodeGenerator = class {
-  constructor(config) {
-    this.config = config;
-  }
-  generateCode(handlers) {
-    this.validateNoDuplicates(handlers);
-    const imports = this.collectImports(handlers);
-    const registrations = this.generateRegistrations(handlers);
-    return this.assembleGeneratedCode(imports, registrations);
-  }
-  validateNoDuplicates(handlers) {
-    this.validateNoDuplicateCommandHandlers(handlers);
-    this.validateNoDuplicateEventHandlers(handlers);
-    this.validateNoDuplicateQueryHandlers(handlers);
-  }
-  validateNoDuplicateHandlers(handlers, typeFilter, keyExtractor, errorFactory) {
-    const filteredHandlers = handlers.filter(typeFilter);
-    const keyToHandlers = /* @__PURE__ */ new Map();
-    for (const handler of filteredHandlers) {
-      const key = keyExtractor(handler);
-      const existing = keyToHandlers.get(key) ?? [];
-      existing.push(handler.handlerClassName);
-      keyToHandlers.set(key, existing);
-    }
-    for (const [key, handlerList] of keyToHandlers) {
-      if (handlerList.length > 1) {
-        throw errorFactory(key, handlerList);
-      }
-    }
-  }
-  validateNoDuplicateCommandHandlers(handlers) {
-    this.validateNoDuplicateHandlers(
-      handlers,
-      (h) => h.type === "command",
-      (h) => h.commandClassName,
-      (key, handlers2) => new DuplicateCommandHandlerError(key, handlers2)
-    );
-  }
-  validateNoDuplicateEventHandlers(handlers) {
-    const eventHandlers = handlers.filter(
-      (h) => h.type === "event"
-    );
-    const namedEventHandlers = eventHandlers.filter(
-      (h) => h.eventHandlerOptions.name !== void 0
-    );
-    this.validateNoDuplicateHandlers(
-      namedEventHandlers,
-      (h) => true,
-      (h) => h.eventHandlerOptions.name,
-      (key, handlers2) => new DuplicateEventHandlerError(key, handlers2)
-    );
-  }
-  validateNoDuplicateQueryHandlers(handlers) {
-    this.validateNoDuplicateHandlers(
-      handlers,
-      (h) => h.type === "query",
-      (h) => h.queryClassName,
-      (key, handlers2) => new DuplicateQueryHandlerError(key, handlers2)
-    );
-  }
-  createImportStatement(symbolName, importPath) {
-    return `import { ${symbolName} } from '${importPath}';`;
-  }
-  createCommandHandlerRegistration(commandClassName, handlerClassName) {
-    return `    .withCommandHandler(${commandClassName}, () => new ${handlerClassName}())`;
-  }
-  createEventHandlerRegistration(handlerClassName, eventName) {
-    const nameArg = eventName ? `, '${eventName}'` : "";
-    return `    .withEventHandler(() => new ${handlerClassName}()${nameArg})`;
-  }
-  createQueryHandlerRegistration(queryClassName, handlerClassName) {
-    return `    .withQueryHandler(${queryClassName}, () => new ${handlerClassName}())`;
-  }
-  isCommandHandler(handler) {
-    return handler.type === "command";
-  }
-  isEventHandler(handler) {
-    return handler.type === "event";
-  }
-  isQueryHandler(handler) {
-    return handler.type === "query";
-  }
-  collectImports(handlers) {
-    const imports = /* @__PURE__ */ new Set();
-    imports.add(
-      this.createImportStatement(
-        "ApplicationBuilder",
-        this.config.applicationBuilderImportPath
-      )
-    );
-    for (const handler of handlers) {
-      imports.add(
-        this.createImportStatement(
-          handler.handlerClassName,
-          handler.handlerPath
-        )
-      );
-      if (this.isCommandHandler(handler) && handler.commandPath) {
-        imports.add(
-          this.createImportStatement(
-            handler.commandClassName,
-            handler.commandPath
-          )
-        );
-      }
-      if (this.isQueryHandler(handler) && handler.queryPath) {
-        imports.add(
-          this.createImportStatement(
-            handler.queryClassName,
-            handler.queryPath
-          )
-        );
-      }
-    }
-    return imports;
-  }
-  generateRegistrations(handlers) {
-    const commandRegistrations = this.generateCommandRegistrations(handlers);
-    const queryRegistrations = this.generateQueryRegistrations(handlers);
-    const eventRegistrations = this.generateEventRegistrations(handlers);
-    return [...commandRegistrations, ...queryRegistrations, ...eventRegistrations];
-  }
-  generateCommandRegistrations(handlers) {
-    return handlers.filter(
-      (h) => this.isCommandHandler(h)
-    ).map(
-      (h) => this.createCommandHandlerRegistration(
-        h.commandClassName,
-        h.handlerClassName
-      )
-    );
-  }
-  generateQueryRegistrations(handlers) {
-    return handlers.filter(
-      (h) => this.isQueryHandler(h)
-    ).map(
-      (h) => this.createQueryHandlerRegistration(
-        h.queryClassName,
-        h.handlerClassName
-      )
-    );
-  }
-  generateEventRegistrations(handlers) {
-    return handlers.filter((h) => this.isEventHandler(h)).map((handler) => {
-      this.validateEventHandlerOptions(handler);
-      const eventName = handler.eventHandlerOptions.name;
-      return this.createEventHandlerRegistration(
-        handler.handlerClassName,
-        eventName
-      );
-    });
-  }
-  validateEventHandlerOptions(handler) {
-    const options = handler.eventHandlerOptions;
-    const invalidKeys = Object.keys(options).filter(
-      (key) => key !== "name"
-    );
-    if (invalidKeys.length > 0) {
-      throw new Error(
-        `EventHandler for ${handler.handlerClassName} has invalid options: ${invalidKeys.join(", ")}.
-Only 'name' option is supported. Use @EventHandler({ name: 'event-name' })`
-      );
-    }
-  }
-  assembleGeneratedCode(imports, registrations) {
-    const registrationCode = registrations.length > 0 ? "\n" + registrations.join("\n") : "";
-    return `
-${Array.from(imports).join("\n")}
-
-export function createApplicationBuilder(): ApplicationBuilder {
-  return new ApplicationBuilder()${registrationCode};
-}
-`;
-  }
-};
-
-// src/application-builder-generator.ts
-var ApplicationBuilderGenerator = class {
-  constructor(contextPath, config) {
-    this.contextPath = contextPath;
-    this.config = config;
-    this.metadataExtractor = new HandlerMetadataExtractor(
-      contextPath,
-      config.outputFile
-    );
-    this.codeGenerator = new ApplicationCodeGenerator(config);
-  }
-  metadataExtractor;
-  codeGenerator;
-  async generate() {
-    const handlerFiles = await this.scanHandlerFiles();
-    const handlers = this.metadataExtractor.extractHandlersMetadata(handlerFiles);
-    const code = this.codeGenerator.generateCode(handlers);
-    this.writeToFile(code);
-  }
-  async scanHandlerFiles() {
-    const allFiles = [];
-    for (const pattern of this.config.handlers) {
-      const files = await glob(pattern, {
-        cwd: this.contextPath,
-        absolute: true
-      });
-      allFiles.push(...files);
-    }
-    return allFiles.sort();
-  }
-  writeToFile(code) {
-    const outputFile = path.join(this.contextPath, this.config.outputFile);
-    const outputDir = path.dirname(outputFile);
-    fs.mkdirSync(outputDir, { recursive: true });
-    fs.writeFileSync(outputFile, code, "utf-8");
-  }
-};
-
-// src/config.ts
-var BuildPluginConfig = class _BuildPluginConfig {
-  handlers;
-  outputFile;
-  applicationBuilderImportPath;
-  constructor(config) {
-    this.handlers = config.handlers;
-    this.outputFile = config.outputFile;
-    this.applicationBuilderImportPath = config.applicationBuilderImportPath;
-  }
-  static fromRawConfig(raw) {
-    if (!raw.applicationBuilderImportPath) {
-      throw new Error(
-        "applicationBuilderImportPath is required in hexai.config.ts\nExample: { applicationBuilderImportPath: '@/application', ... }"
-      );
-    }
-    if (!raw.handlers || raw.handlers.length === 0) {
-      throw new Error(
-        "handlers array is required and must not be empty in hexai.config.ts"
-      );
-    }
-    return new _BuildPluginConfig({
-      handlers: raw.handlers,
-      outputFile: raw.outputFile ?? "src/.generated/application-builder.ts",
-      applicationBuilderImportPath: raw.applicationBuilderImportPath
-    });
-  }
-};
-
-// src/config-loader.ts
-async function loadConfig(configPath) {
-  const configSource = fs.readFileSync(configPath, "utf-8");
-  const transpiledCode = transpileConfigFile(configSource);
-  const moduleExports = evaluateConfigModule(transpiledCode);
-  const rawConfig = extractConfigFromModule(moduleExports);
-  return BuildPluginConfig.fromRawConfig(rawConfig);
-}
-function transpileConfigFile(source) {
-  const result = ts.transpileModule(source, {
-    compilerOptions: {
-      module: ts.ModuleKind.CommonJS,
-      target: ts.ScriptTarget.ES2020
-    }
-  });
-  return result.outputText;
-}
-function evaluateConfigModule(code) {
-  const tempModule = { exports: {} };
-  const fn = new Function("module", "exports", "require", code);
-  fn(tempModule, tempModule.exports, __require);
-  return tempModule.exports;
-}
-function extractConfigFromModule(moduleExports) {
-  return moduleExports.default || moduleExports;
-}
-
-// src/main.ts
-async function generateApplicationBuilder(contextPath, options = {}) {
-  let configFile = "hexai.config.ts";
-  if (options.configFile) {
-    configFile = options.configFile;
-  }
-  const configPath = path.join(contextPath, configFile);
-  const config = await loadConfig(configPath);
-  const generator = new ApplicationBuilderGenerator(contextPath, config);
-  await generator.generate();
-}
-
-// src/cli.ts
+import * as path from "path";
+import { generateApplicationBuilder } from "./index.js";
 async function main() {
-  const args = process.argv.slice(2);
-  let contextPath = process.cwd();
-  const contextPathIndex = args.indexOf("--context-path");
-  if (contextPathIndex !== -1 && args[contextPathIndex + 1]) {
-    contextPath = path.resolve(args[contextPathIndex + 1]);
-  }
-  try {
-    console.log(`Generating application builder for: ${contextPath}`);
-    await generateApplicationBuilder(contextPath);
-    console.log("\u2713 Application builder generated successfully");
-  } catch (error) {
-    console.error("Error generating application builder:", error);
-    process.exit(1);
-  }
+    const args = process.argv.slice(2);
+    // Support --context-path or default to cwd
+    let contextPath = process.cwd();
+    const contextPathIndex = args.indexOf("--context-path");
+    if (contextPathIndex !== -1 && args[contextPathIndex + 1]) {
+        contextPath = path.resolve(args[contextPathIndex + 1]);
+    }
+    try {
+        console.log(`Generating application builder for: ${contextPath}`);
+        await generateApplicationBuilder(contextPath);
+        console.log("✓ Application builder generated successfully");
+    }
+    catch (error) {
+        console.error("Error generating application builder:", error);
+        process.exit(1);
+    }
 }
 main().catch((error) => {
-  console.error("Unexpected error:", error);
-  process.exit(1);
+    console.error("Unexpected error:", error);
+    process.exit(1);
 });
-//# sourceMappingURL=cli.js.map
 //# sourceMappingURL=cli.js.map