@atomic-ehr/codegen 0.0.1-canary.20251007114955.88a8afc → 0.0.1-canary.20251007144346.822c49c

package/dist/index.js

@@ -1414,7 +1414,7 @@ function isBindingSchema(schema) {
 }
 
 // src/typeschema/register.ts
-var registerFromManager = async (manager, logger) => {
+var registerFromManager = async (manager, logger2) => {
   const packages = await manager.packages();
   const flatRawIndex = {};
   const indexByPackages = [];
@@ -1450,7 +1450,7 @@ var registerFromManager = async (manager, logger) => {
           nameToCanonical[rfs.name] = rfs.url;
           fsSuccess++;
         } catch (error) {
-          logger?.warn(
+          logger2?.warn(
             `Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`
           );
           fsFailed++;
@@ -1463,7 +1463,7 @@ var registerFromManager = async (manager, logger) => {
         vsIndex[resource.url] = resource;
       }
     }
-    logger?.success(
+    logger2?.success(
       `FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' completed: ${fsSuccess} successful, ${fsFailed} failed`
     );
   }
@@ -1596,7 +1596,7 @@ function mkBindingIdentifier(fhirSchema, path, bindingName) {
 }
 
 // src/typeschema/profile/processor.ts
-async function transformProfile(register, fhirSchema, logger) {
+async function transformProfile(register, fhirSchema, logger2) {
   const identifier = mkIdentifier(fhirSchema);
   if (identifier.kind !== "profile") {
     throw new Error(`Expected profile, got ${identifier.kind} for ${fhirSchema.name}`);
@@ -1628,7 +1628,7 @@ async function transformProfile(register, fhirSchema, logger) {
     profileSchema.metadata = metadata;
   }
   if (fhirSchema.elements) {
-    const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
+    const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements, logger2);
     if (fields && Object.keys(fields).length > 0) {
       profileSchema.fields = fields;
     }
@@ -1825,13 +1825,13 @@ function buildFieldType(register, fhirSchema, element) {
   }
   return void 0;
 }
-var mkField = (register, fhirSchema, path, element, logger) => {
+var mkField = (register, fhirSchema, path, element, logger2) => {
   let binding;
   let enumValues;
   if (element.binding) {
     binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
     if (element.binding.strength === "required" && element.type === "code") {
-      enumValues = buildEnum(register, element, logger);
+      enumValues = buildEnum(register, element, logger2);
     }
   }
   return {
@@ -1864,7 +1864,7 @@ function mkNestedField(register, fhirSchema, path, element) {
 }
 
 // src/typeschema/core/binding.ts
-function extractValueSetConceptsByUrl(register, valueSetUrl, logger) {
+function extractValueSetConceptsByUrl(register, valueSetUrl, logger2) {
   const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
   const valueSet = register.resolveVs(cleanUrl);
   if (!valueSet) return void 0;
@@ -1909,7 +1909,7 @@ function extractValueSetConcepts(register, valueSet, _logger) {
   return concepts.length > 0 ? concepts : void 0;
 }
 var MAX_ENUM_LENGTH = 100;
-function buildEnum(register, element, logger) {
+function buildEnum(register, element, logger2) {
   if (!element.binding) return void 0;
   const strength = element.binding.strength;
   const valueSetUrl = element.binding.valueSet;
@@ -1920,14 +1920,14 @@ function buildEnum(register, element, logger) {
   if (!concepts || concepts.length === 0) return void 0;
   const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
   if (codes.length > MAX_ENUM_LENGTH) {
-    logger?.dry_warn(
+    logger2?.dry_warn(
       `Value set ${valueSetUrl} has ${codes.length} which is more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`
     );
     return void 0;
   }
   return codes.length > 0 ? codes : void 0;
 }
-function generateBindingSchema(register, fhirSchema, path, element, logger) {
+function generateBindingSchema(register, fhirSchema, path, element, logger2) {
   if (!element.binding?.valueSet) return void 0;
   const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
   const fieldType = buildFieldType(register, fhirSchema, element);
@@ -1937,7 +1937,7 @@ function generateBindingSchema(register, fhirSchema, path, element, logger) {
     dependencies.push(fieldType);
   }
   dependencies.push(valueSetIdentifier);
-  const enumValues = buildEnum(register, element, logger);
+  const enumValues = buildEnum(register, element, logger2);
   return {
     identifier,
     type: fieldType,
@@ -1947,7 +1947,7 @@ function generateBindingSchema(register, fhirSchema, path, element, logger) {
     dependencies
   };
 }
-function collectBindingSchemas(register, fhirSchema, logger) {
+function collectBindingSchemas(register, fhirSchema, logger2) {
   const processedPaths = /* @__PURE__ */ new Set();
   if (!fhirSchema.elements) return [];
   const bindings = [];
@@ -1958,7 +1958,7 @@ function collectBindingSchemas(register, fhirSchema, logger) {
       if (processedPaths.has(pathKey)) continue;
       processedPaths.add(pathKey);
       if (element.binding) {
-        const binding = generateBindingSchema(register, fhirSchema, path, element, logger);
+        const binding = generateBindingSchema(register, fhirSchema, path, element, logger2);
         if (binding) {
           bindings.push(binding);
         }
@@ -1995,19 +1995,19 @@ function collectNestedElements(fhirSchema, parentPath, elements) {
   }
   return nested;
 }
-function transformNestedElements(fhirSchema, parentPath, elements, register, logger) {
+function transformNestedElements(fhirSchema, parentPath, elements, register, logger2) {
   const fields = {};
   for (const [key, element] of Object.entries(elements)) {
     const path = [...parentPath, key];
     if (isNestedElement(element)) {
       fields[key] = mkNestedField(register, fhirSchema, path, element);
     } else {
-      fields[key] = mkField(register, fhirSchema, path, element, logger);
+      fields[key] = mkField(register, fhirSchema, path, element, logger2);
     }
   }
   return fields;
 }
-function mkNestedTypes(register, fhirSchema, logger) {
+function mkNestedTypes(register, fhirSchema, logger2) {
   if (!fhirSchema.elements) return void 0;
   const nestedElements = collectNestedElements(fhirSchema, [], fhirSchema.elements);
   const actualNested = nestedElements.filter(
@@ -2034,7 +2034,7 @@ function mkNestedTypes(register, fhirSchema, logger) {
         url: `http://hl7.org/fhir/StructureDefinition/${element.type}`
       };
     }
-    const fields = transformNestedElements(fhirSchema, path, element.elements, register, logger);
+    const fields = transformNestedElements(fhirSchema, path, element.elements, register, logger2);
     const nestedType = {
       identifier,
       base,
@@ -2064,7 +2064,7 @@ function extractNestedDependencies(nestedTypes) {
 }
 
 // src/typeschema/core/transformer.ts
-function mkFields(register, fhirSchema, parentPath, elements, logger) {
+function mkFields(register, fhirSchema, parentPath, elements, logger2) {
   if (!elements) return void 0;
   const geneology = register.resolveFsGenealogy(fhirSchema.url);
   const elems = {};
@@ -2089,7 +2089,7 @@ function mkFields(register, fhirSchema, parentPath, elements, logger) {
     if (isNestedElement(elemSnapshot)) {
       fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot);
     } else {
-      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger);
+      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger2);
     }
   }
   return fields;
@@ -2134,7 +2134,7 @@ function isExtensionSchema(fhirSchema, _identifier) {
   }
   return false;
 }
-async function transformValueSet(register, valueSet, logger) {
+async function transformValueSet(register, valueSet, logger2) {
   if (!valueSet.url) throw new Error("ValueSet URL is required");
   const identifier = mkValueSetIdentifierByUrl(register, valueSet.url);
   const concept = extractValueSetConceptsByUrl(register, valueSet.url);
@@ -2145,7 +2145,7 @@ async function transformValueSet(register, valueSet, logger) {
     compose: !concept ? valueSet.compose : void 0
   };
 }
-async function transformExtension(fhirSchema, register, logger) {
+async function transformExtension(fhirSchema, register, logger2) {
   try {
     const identifier = mkIdentifier(fhirSchema);
     let base;
@@ -2182,13 +2182,13 @@ async function transformExtension(fhirSchema, register, logger) {
       extensionSchema.dependencies.push(base);
     }
     if (fhirSchema.elements) {
-      const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
+      const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger2);
       if (fields && Object.keys(fields).length > 0) {
         extensionSchema.fields = fields;
         extensionSchema.dependencies.push(...extractFieldDependencies(fields));
       }
     }
-    const nestedTypes = mkNestedTypes(register, fhirSchema, logger);
+    const nestedTypes = mkNestedTypes(register, fhirSchema, logger2);
     if (nestedTypes && nestedTypes.length > 0) {
       extensionSchema.nested = nestedTypes;
       extensionSchema.dependencies.push(...extractNestedDependencies(nestedTypes));
@@ -2215,7 +2215,7 @@ function extractDependencies(identifier, base, fields, nestedTypes) {
   const result = Object.values(uniqDeps).filter((e) => !(e.kind === "nested" && localNestedTypeUrls.has(e.url))).sort((a, b) => a.url.localeCompare(b.url));
   return result.length > 0 ? result : void 0;
 }
-function transformFhirSchemaResource(register, fhirSchema, logger) {
+function transformFhirSchemaResource(register, fhirSchema, logger2) {
   const identifier = mkIdentifier(fhirSchema);
   let base;
   if (fhirSchema.base && fhirSchema.type !== "Element") {
@@ -2225,8 +2225,8 @@ function transformFhirSchemaResource(register, fhirSchema, logger) {
     }
     base = mkIdentifier(baseFs);
   }
-  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
-  const nested = mkNestedTypes(register, fhirSchema, logger);
+  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger2);
+  const nested = mkNestedTypes(register, fhirSchema, logger2);
   const dependencies = extractDependencies(identifier, base, fields, nested);
   const typeSchema = {
     identifier,
@@ -2236,27 +2236,27 @@ function transformFhirSchemaResource(register, fhirSchema, logger) {
     description: fhirSchema.description,
     dependencies
   };
-  const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
+  const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger2);
   return [typeSchema, ...bindingSchemas];
 }
-async function transformFhirSchema(register, fhirSchema, logger) {
+async function transformFhirSchema(register, fhirSchema, logger2) {
   const results = [];
   const identifier = mkIdentifier(fhirSchema);
   if (identifier.kind === "profile") {
-    const profileSchema = await transformProfile(register, fhirSchema, logger);
+    const profileSchema = await transformProfile(register, fhirSchema, logger2);
     results.push(profileSchema);
-    const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
+    const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger2);
     results.push(...bindingSchemas);
     return results;
   }
   if (isExtensionSchema(fhirSchema)) {
-    const extensionSchema = await transformExtension(fhirSchema, register, logger);
+    const extensionSchema = await transformExtension(fhirSchema, register, logger2);
     if (extensionSchema) {
       results.push(extensionSchema);
     }
     return results;
   }
-  return transformFhirSchemaResource(register, fhirSchema, logger);
+  return transformFhirSchemaResource(register, fhirSchema, logger2);
 }
 var TypeSchemaCache = class {
   cache = /* @__PURE__ */ new Map();
@@ -2476,6 +2476,224 @@ var TypeSchemaCache = class {
     }
   }
 };
+
+// src/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
+  return LogLevel2;
+})(LogLevel || {});
+var ConsoleOutput = class {
+  constructor(useStderr = false) {
+    this.useStderr = useStderr;
+  }
+  write(entry, formatted) {
+    const output = this.useStderr || entry.level >= 2 /* WARN */ ? console.error : console.log;
+    output(formatted);
+  }
+};
+var Logger = class _Logger {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      level: 1 /* INFO */,
+      format: "pretty",
+      includeTimestamp: true,
+      includeContext: true,
+      colorize: true,
+      outputs: [new ConsoleOutput()],
+      ...config
+    };
+  }
+  /**
+   * Update logger configuration
+   */
+  configure(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Check if a log level should be output
+   */
+  shouldLog(level) {
+    return level >= this.config.level;
+  }
+  /**
+   * Create a log entry
+   */
+  createEntry(level, message, context, error, operation) {
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      levelName: LogLevel[level],
+      message,
+      component: this.config.component
+    };
+    if (context && this.config.includeContext) {
+      entry.context = context;
+    }
+    if (operation) {
+      entry.operation = operation;
+    }
+    if (error) {
+      entry.error = {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+      };
+    }
+    return entry;
+  }
+  /**
+   * Format log entry for output
+   */
+  formatEntry(entry) {
+    switch (this.config.format) {
+      case "json":
+        return JSON.stringify(entry);
+      case "compact":
+        return this.formatCompact(entry);
+      default:
+        return this.formatPretty(entry);
+    }
+  }
+  /**
+   * Format entry in compact format
+   */
+  formatCompact(entry) {
+    const timestamp = this.config.includeTimestamp ? `${entry.timestamp} ` : "";
+    const component = entry.component ? `[${entry.component}] ` : "";
+    const operation = entry.operation ? `(${entry.operation}) ` : "";
+    const level = this.colorizeLevel(entry.levelName, entry.level);
+    return `${timestamp}${level} ${component}${operation}${entry.message}`;
+  }
+  /**
+   * Format entry in pretty format
+   */
+  formatPretty(entry) {
+    let formatted = "";
+    const timestamp = this.config.includeTimestamp ? `${entry.timestamp} ` : "";
+    const component = entry.component ? `[${entry.component}] ` : "";
+    const operation = entry.operation ? `(${entry.operation}) ` : "";
+    const level = this.colorizeLevel(entry.levelName.padEnd(5), entry.level);
+    formatted += `${timestamp}${level} ${component}${operation}${entry.message}`;
+    if (entry.context && Object.keys(entry.context).length > 0) {
+      formatted += `
+  Context: ${JSON.stringify(entry.context, null, 2).split("\n").join("\n  ")}`;
+    }
+    if (entry.error) {
+      formatted += `
+  Error: [${entry.error.code || entry.error.name}] ${entry.error.message}`;
+      if (entry.error.context && Object.keys(entry.error.context).length > 0) {
+        formatted += `
+  Error Context: ${JSON.stringify(entry.error.context, null, 2).split("\n").join("\n  ")}`;
+      }
+      if (entry.error.suggestions && entry.error.suggestions.length > 0) {
+        formatted += `
+  Suggestions:
+${entry.error.suggestions.map((s) => `    \u2022 ${s}`).join("\n")}`;
+      }
+      if (entry.level === 0 /* DEBUG */ && entry.error.stack) {
+        formatted += `
+  Stack: ${entry.error.stack.split("\n").join("\n  ")}`;
+      }
+    }
+    return formatted;
+  }
+  /**
+   * Colorize log level if enabled
+   */
+  colorizeLevel(levelName, level) {
+    if (!this.config.colorize) {
+      return levelName;
+    }
+    const colors = {
+      [0 /* DEBUG */]: "\x1B[36m",
+      // Cyan
+      [1 /* INFO */]: "\x1B[32m",
+      // Green
+      [2 /* WARN */]: "\x1B[33m",
+      // Yellow
+      [3 /* ERROR */]: "\x1B[31m"
+      // Red
+    };
+    const reset = "\x1B[0m";
+    const color = colors[level] || "";
+    return `${color}${levelName}${reset}`;
+  }
+  /**
+   * Write log entry to all outputs
+   */
+  async writeEntry(entry) {
+    if (!this.shouldLog(entry.level)) {
+      return;
+    }
+    const formatted = this.formatEntry(entry);
+    for (const output of this.config.outputs) {
+      try {
+        await output.write(entry, formatted);
+      } catch (error) {
+        console.error("Logger output failed:", error);
+        console.error(formatted);
+      }
+    }
+  }
+  /**
+   * Log debug message
+   */
+  async debug(message, context, operation) {
+    const entry = this.createEntry(0 /* DEBUG */, message, context, void 0, operation);
+    await this.writeEntry(entry);
+  }
+  /**
+   * Log info message
+   */
+  async info(message, context, operation) {
+    const entry = this.createEntry(1 /* INFO */, message, context, void 0, operation);
+    await this.writeEntry(entry);
+  }
+  /**
+   * Log warning message
+   */
+  async warn(message, context, operation) {
+    const entry = this.createEntry(2 /* WARN */, message, context, void 0, operation);
+    await this.writeEntry(entry);
+  }
+  /**
+   * Log error message
+   */
+  async error(message, error, context, operation) {
+    const entry = this.createEntry(3 /* ERROR */, message, context, error, operation);
+    await this.writeEntry(entry);
+  }
+  /**
+   * Create a child logger with additional context
+   */
+  child(component, context) {
+    const childLogger = new _Logger({
+      ...this.config,
+      component: this.config.component ? `${this.config.component}.${component}` : component
+    });
+    if (context) {
+      const originalMethods = {
+        debug: childLogger.debug.bind(childLogger),
+        info: childLogger.info.bind(childLogger),
+        warn: childLogger.warn.bind(childLogger),
+        error: childLogger.error.bind(childLogger)
+      };
+      childLogger.debug = (message, additionalContext, operation) => originalMethods.debug(message, { ...context, ...additionalContext }, operation);
+      childLogger.info = (message, additionalContext, operation) => originalMethods.info(message, { ...context, ...additionalContext }, operation);
+      childLogger.warn = (message, additionalContext, operation) => originalMethods.warn(message, { ...context, ...additionalContext }, operation);
+      childLogger.error = (message, error, additionalContext, operation) => originalMethods.error(message, error, { ...context, ...additionalContext }, operation);
+    }
+    return childLogger;
+  }
+};
+new Logger();
+
+// src/utils/codegen-logger.ts
 var CodegenLogger = class _CodegenLogger {
   options;
   dryWarnSet = /* @__PURE__ */ new Set();
@@ -2486,22 +2704,39 @@ var CodegenLogger = class _CodegenLogger {
       ...options
     };
   }
+  static consoleLevelsMap = {
+    [1 /* INFO */]: console.log,
+    [2 /* WARN */]: console.warn,
+    [3 /* ERROR */]: console.error,
+    [0 /* DEBUG */]: console.log,
+    [4 /* SILENT */]: () => {
+    }
+  };
   formatMessage(level, message, color) {
     const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
     const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
     return `${timestamp}${color(level)} ${prefix}${message}`;
   }
+  isSuppressed(level) {
+    return this.options.suppressLoggingLevel === "all" || this.options.suppressLoggingLevel?.includes(level) || false;
+  }
+  tryWriteToConsole(level, formattedMessage) {
+    if (this.isSuppressed(level)) return;
+    const logFn = _CodegenLogger.consoleLevelsMap[level] || console.log;
+    logFn(formattedMessage);
+  }
   /**
    * Success message with checkmark
    */
   success(message) {
-    console.log(this.formatMessage("\u2705", message, pc.green));
+    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("", message, pc.green));
   }
   /**
    * Error message with X mark
    */
   error(message, error) {
-    console.error(this.formatMessage("\u274C", message, pc.red));
+    if (this.isSuppressed(3 /* ERROR */)) return;
+    console.error(this.formatMessage("", message, pc.red));
     if (error && this.options.verbose) {
       console.error(pc.red(`   ${error.message}`));
       if (error.stack) {
@@ -2513,7 +2748,7 @@ var CodegenLogger = class _CodegenLogger {
    * Warning message with warning sign
    */
   warn(message) {
-    console.warn(this.formatMessage("!", message, pc.yellow));
+    this.tryWriteToConsole(2 /* WARN */, this.formatMessage("!", message, pc.yellow));
   }
   dry_warn(message) {
     if (!this.dryWarnSet.has(message)) {
@@ -2525,27 +2760,27 @@ var CodegenLogger = class _CodegenLogger {
    * Info message with info icon
    */
   info(message) {
-    console.log(this.formatMessage("i", message, pc.blue));
+    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("i", message, pc.blue));
   }
   /**
    * Debug message (only shows in verbose mode)
    */
   debug(message) {
     if (this.options.verbose) {
-      console.log(this.formatMessage("\u{1F41B}", message, pc.magenta));
+      this.tryWriteToConsole(0 /* DEBUG */, this.formatMessage("\u{1F41B}", message, pc.magenta));
     }
   }
   /**
    * Step message with rocket
    */
   step(message) {
-    console.log(this.formatMessage("\u{1F680}", message, pc.cyan));
+    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("\u{1F680}", message, pc.cyan));
   }
   /**
    * Progress message with clock
    */
   progress(message) {
-    console.log(this.formatMessage("\u23F3", message, pc.blue));
+    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("\u23F3", message, pc.blue));
   }
   /**
    * Plain message (no icon, just colored text)
@@ -2553,7 +2788,7 @@ var CodegenLogger = class _CodegenLogger {
   plain(message, color = (s) => s) {
     const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
     const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
-    console.log(`${timestamp}${prefix}${color(message)}`);
+    this.tryWriteToConsole(1 /* INFO */, `${timestamp}${prefix}${color(message)}`);
   }
   /**
    * Dimmed/gray text for less important info
@@ -2634,11 +2869,11 @@ var TypeSchemaGenerator = class {
     );
     return fhirSchemas;
   }
-  async generateValueSetSchemas(valueSets, logger) {
+  async generateValueSetSchemas(valueSets, logger2) {
     if (valueSets.length > 0) {
       this.logger?.debug(`${valueSets.length} ValueSets available for enum extraction`);
     }
-    const register = await registerFromManager(this.manager, logger);
+    const register = await registerFromManager(this.manager, logger2);
     const valueSetSchemas = [];
     if (valueSets.length > 0) {
       this.logger?.progress(`Converting ${valueSets.length} ValueSets to TypeSchema`);
@@ -2646,7 +2881,7 @@ var TypeSchemaGenerator = class {
       let valueSetFailedCount = 0;
       for (const vs of valueSets) {
         try {
-          const valueSetSchema = await transformValueSet(register, vs, logger);
+          const valueSetSchema = await transformValueSet(register, vs, logger2);
           if (valueSetSchema) {
             valueSetSchemas.push(valueSetSchema);
             valueSetConvertedCount++;
@@ -2665,7 +2900,7 @@ var TypeSchemaGenerator = class {
     }
     return valueSetSchemas;
   }
-  async generateFromPackage(packageName, packageVersion, logger) {
+  async generateFromPackage(packageName, packageVersion, logger2) {
     await this.initializeCache();
     if (this.cache && !(this.cacheConfig?.forceRegenerate ?? false)) {
       const cachedSchemas = this.cache.getByPackage(packageName);
@@ -2681,8 +2916,8 @@ var TypeSchemaGenerator = class {
       version: packageVersion || "latest"
     };
     const register = await this.registerFromPackageMetas([packageInfo]);
-    const valueSets = await this.generateValueSetSchemas(register.allVs(), logger);
-    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs2) => await transformFhirSchema(register, fs2, logger)))).flat();
+    const valueSets = await this.generateValueSetSchemas(register.allVs(), logger2);
+    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs2) => await transformFhirSchema(register, fs2, logger2)))).flat();
     const allSchemas = [...fhirSchemas, ...valueSets];
     if (this.cache) {
       for (const schema of allSchemas) {
@@ -3051,10 +3286,10 @@ var TypeSchemaParser = class {
 };
 
 // src/typeschema/index.ts
-var generateTypeSchemas = async (register, logger) => {
+var generateTypeSchemas = async (register, logger2) => {
   const fhirSchemas = [];
   for (const fhirSchema of register.allFs()) {
-    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger));
+    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger2));
   }
   for (const vsSchema of register.allVs()) {
     fhirSchemas.push(await transformValueSet(register, vsSchema));
@@ -3112,45 +3347,45 @@ var ErrorHandler = class {
   handleUnknownError(error, context) {
     this.options.logger.error("Unexpected error occurred:", error);
     if (this.options.verbose) {
-      console.error("\n\u{1F6A8} Unexpected Error Details:");
-      console.error(`   Type: ${error.constructor.name}`);
-      console.error(`   Message: ${error.message}`);
+      this.options.logger.error("\n\u{1F6A8} Unexpected Error Details:");
+      this.options.logger.error(`   Type: ${error.constructor.name}`);
+      this.options.logger.error(`   Message: ${error.message}`);
       if (error.stack) {
-        console.error(`   Stack: ${error.stack}`);
+        this.options.logger.error(`   Stack: ${error.stack}`);
       }
       if (context?.schema) {
-        console.error(`   Schema: ${context.schema.identifier.name}`);
+        this.options.logger.error(`   Schema: ${context.schema.identifier.name}`);
       }
       if (context?.filename) {
-        console.error(`   File: ${context.filename}`);
+        this.options.logger.error(`   File: ${context.filename}`);
       }
     }
-    console.error("\n\u{1F4A1} General troubleshooting suggestions:");
-    console.error("   \u2022 Run with --verbose flag for more details");
-    console.error("   \u2022 Check your input files for corruption");
-    console.error("   \u2022 Update to the latest version of atomic-codegen");
-    console.error("   \u2022 Report this issue at: https://github.com/atomic-ehr/codegen/issues");
+    this.options.logger.error("\n\u{1F4A1} General troubleshooting suggestions:");
+    this.options.logger.error("   \u2022 Run with --verbose flag for more details");
+    this.options.logger.error("   \u2022 Check your input files for corruption");
+    this.options.logger.error("   \u2022 Update to the latest version of atomic-codegen");
+    this.options.logger.error("   \u2022 Report this issue at: https://github.com/atomic-ehr/codegen/issues");
   }
   /**
    * Report error to console with formatting
    */
   reportErrorToConsole(error) {
     if ("getFormattedMessage" in error) {
-      console.error(error.getFormattedMessage());
+      this.options.logger.error(error.getFormattedMessage());
     } else {
-      console.error(`
+      this.options.logger.error(`
 \u274C ${error.constructor.name}: ${error.message}`);
       const suggestions = error.getSuggestions();
       if (suggestions.length > 0) {
-        console.error("\n\u{1F4A1} Suggestions:");
+        this.options.logger.error("\n\u{1F4A1} Suggestions:");
         suggestions.forEach((suggestion) => {
-          console.error(`   \u2022 ${suggestion}`);
+          this.options.logger.error(`   \u2022 ${suggestion}`);
         });
       }
     }
     if (this.options.verbose && error.context) {
-      console.error("\n\u{1F50D} Debug Information:");
-      console.error(JSON.stringify(error.context, null, 2));
+      this.options.logger.error("\n\u{1F50D} Debug Information:");
+      this.options.logger.error(JSON.stringify(error.context, null, 2));
     }
   }
   /**
@@ -3165,7 +3400,7 @@ var ErrorHandler = class {
       suggestions: error.getSuggestions(),
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
-    console.error(JSON.stringify(errorData, null, 2));
+    this.options.logger.error(JSON.stringify(errorData, null, 2));
   }
   /**
    * Report error in structured format
@@ -3181,16 +3416,16 @@ var ErrorHandler = class {
       suggestions: error.getSuggestions(),
       actions: this.getRecoveryActions(error)
     };
-    console.error("---");
-    console.error("Error Report:");
-    console.error(JSON.stringify(structure, null, 2));
-    console.error("---");
+    this.options.logger.error("---");
+    this.options.logger.error("Error Report:");
+    this.options.logger.error(JSON.stringify(structure, null, 2));
+    this.options.logger.error("---");
   }
   /**
    * Report multiple errors efficiently
    */
   reportBatchErrors(errors) {
-    console.error(`
+    this.options.logger.error(`
 \u274C ${errors.length} errors occurred during generation:`);
     const errorGroups = /* @__PURE__ */ new Map();
     errors.forEach((error) => {
@@ -3201,19 +3436,19 @@ var ErrorHandler = class {
       errorGroups.get(type)?.push(error);
     });
     for (const [type, groupErrors] of errorGroups) {
-      console.error(`
+      this.options.logger.error(`
 \u{1F4CB} ${type} (${groupErrors.length} occurrences):`);
       groupErrors.forEach((error, index) => {
-        console.error(`   ${index + 1}. ${error.message}`);
+        this.options.logger.error(`   ${index + 1}. ${error.message}`);
         if (error.context?.schemaName) {
-          console.error(`      Schema: ${error.context.schemaName}`);
+          this.options.logger.error(`      Schema: ${error.context.schemaName}`);
         }
       });
       const commonSuggestions = this.getCommonSuggestions(groupErrors);
       if (commonSuggestions.length > 0) {
-        console.error("\n   \u{1F4A1} Common suggestions:");
+        this.options.logger.error("\n   \u{1F4A1} Common suggestions:");
         commonSuggestions.forEach((suggestion) => {
-          console.error(`      \u2022 ${suggestion}`);
+          this.options.logger.error(`      \u2022 ${suggestion}`);
         });
       }
     }
@@ -3523,7 +3758,7 @@ var BaseGenerator = class {
       logger: this.logger,
       verbose: this.options.verbose || false,
       beginnerMode: this.options.beginnerMode || false,
-      outputFormat: this.options.errorFormat || "console"
+      outputFormat: "this.options.logger"
     });
     this.errorBoundary = new GeneratorErrorBoundary(this.errorHandler);
     this.logger.debug(`${this.getLanguageName()} generator initialized`);
@@ -5195,8 +5430,8 @@ var Writer = class extends FileSystemWriter {
   }
   disclaimer() {
     return [
-      "WARNING: This file is autogenerated by FHIR Schema Codegen.",
-      "https://github.com/fhir-schema/fhir-schema-codegen",
+      "WARNING: This file is autogenerated by @atomic-ehr/codegen.",
+      "GitHub: https://github.com/orgs/atomic-ehr/repositories",
       "Any manual changes made to this file may be overwritten."
     ];
   }