feat: add configurable log levels in CLI and API

- Introduced `--log-level` option in CLI for granular logging control.
- Enhanced `CodegenLogger` to support log levels (DEBUG, INFO, WARN, ERROR, SILENT).
- Updated APIBuilder to allow log level configuration.

Author: octoshikari

src/api/builder.ts

@@ -15,7 +15,7 @@ import { mkTypeSchemaIndex, type TreeShake, type TypeSchemaIndex, treeShake } fr
 import { generateTypeSchemas } from "@typeschema/index";
 import { extractNameFromCanonical, packageMetaToFhir, packageMetaToNpm, type TypeSchema } from "@typeschema/types";
 import type { TypeSchemaConfig } from "../config";
-import { CodegenLogger, createLogger } from "../utils/codegen-logger";
+import { CodegenLogger, createLogger, LogLevel } from "../utils/codegen-logger";
 import { TypeScript, type TypeScriptOptions } from "./writer-generator/typescript";
 import type { FileBuffer, FileSystemWriter, WriterOptions } from "./writer-generator/writer";
 
@@ -35,6 +35,8 @@ export interface APIBuilderOptions {
     throwException?: boolean;
     exportTypeTree?: string;
     treeShake?: TreeShake;
+    /** Log level for the logger. Default: INFO */
+    logLevel?: LogLevel;
 }
 
 /**
@@ -70,7 +72,7 @@ export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 
 type APIBuilderConfig = PartialBy<
     Required<APIBuilderOptions>,
-    "logger" | "typeSchemaConfig" | "typeSchemaOutputDir" | "exportTypeTree" | "treeShake"
+    "logger" | "typeSchemaConfig" | "typeSchemaOutputDir" | "exportTypeTree" | "treeShake" | "logLevel"
 > & {
     cleanOutput: boolean;
 };
@@ -208,6 +210,7 @@ export class APIBuilder {
             createLogger({
                 verbose: this.options.verbose,
                 prefix: "API",
+                level: options.logLevel,
             });
     }
 
@@ -297,6 +300,15 @@ export class APIBuilder {
         return this;
     }
 
+    /**
+     * Set the log level for the logger
+     * @param level - The log level to set (DEBUG, INFO, WARN, ERROR, SILENT)
+     */
+    setLogLevel(level: LogLevel): APIBuilder {
+        this.logger?.setLevel(level);
+        return this;
+    }
+
     throwException(enabled = true): APIBuilder {
         this.options.throwException = enabled;
         return this;

src/api/index.ts

@@ -11,3 +11,4 @@ export type { APIBuilderOptions } from "./builder";
 export { APIBuilder } from "./builder";
 export type { CSharpGeneratorOptions } from "./writer-generator/csharp/csharp";
 export type { TypeScriptOptions } from "./writer-generator/typescript";
+export { LogLevel } from "../utils/codegen-logger";

src/cli/commands/index.ts

@@ -6,7 +6,7 @@
  * Modern CLI with subcommands for typeschema and code generation
  */
 
-import { configure, error, header } from "@root/utils/codegen-logger";
+import { configure, error, header, LogLevel } from "@root/utils/codegen-logger";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { generateCommand } from "./generate";
@@ -19,16 +19,45 @@ export interface CLIArgv {
     config?: string;
     verbose?: boolean;
     debug?: boolean;
+    logLevel?: "debug" | "info" | "warn" | "error" | "silent";
+}
+
+/**
+ * Map string log level to LogLevel enum
+ */
+function parseLogLevel(level: string | undefined): LogLevel | undefined {
+    if (!level) return undefined;
+    const levelMap: Record<string, LogLevel> = {
+        debug: LogLevel.DEBUG,
+        info: LogLevel.INFO,
+        warn: LogLevel.WARN,
+        error: LogLevel.ERROR,
+        silent: LogLevel.SILENT,
+    };
+    return levelMap[level.toLowerCase()];
 }
 
 /**
  * Middleware to setup logging
  */
 async function setupLoggingMiddleware(argv: any) {
+    // Determine log level: explicit --log-level takes precedence over --verbose/--debug
+    let level = parseLogLevel(argv.logLevel);
+
+    // If no explicit log level, use --verbose or --debug as shortcuts
+    if (level === undefined) {
+        if (argv.debug || argv.verbose) {
+            level = LogLevel.DEBUG;
+        } else {
+            level = LogLevel.INFO;
+        }
+    }
+
     // Configure the CliLogger with user preferences
     configure({
         verbose: argv.verbose || argv.debug,
         timestamp: argv.debug,
+        level,
     });
 }
 
@@ -56,6 +85,13 @@ export function createCLI() {
             default: false,
             global: true,
         })
+        .option("log-level", {
+            alias: "l",
+            type: "string",
+            choices: ["debug", "info", "warn", "error", "silent"] as const,
+            description: "Set the log level (default: info)",
+            global: true,
+        })
         .option("config", {
             alias: "c",
             type: "string",

src/utils/codegen-logger.ts

@@ -19,6 +19,8 @@ export interface LogOptions {
     timestamp?: boolean;
     verbose?: boolean;
     suppressLoggingLevel?: LogLevel[] | "all";
+    /** Minimum log level to display. Messages below this level are suppressed. Default: INFO */
+    level?: LogLevel;
 }
 
 /**
@@ -32,8 +34,20 @@ export class CodegenLogger {
         this.options = {
             timestamp: false,
             verbose: false,
+            level: LogLevel.INFO,
             ...options,
         };
+        if (options.verbose === true && options.level === undefined) {
+            this.options.level = LogLevel.DEBUG;
+        }
+    }
+
+    /**
+     * Check if a message at the given level should be logged
+     */
+    private shouldLog(messageLevel: LogLevel): boolean {
+        const currentLevel = this.options.level ?? LogLevel.INFO;
+        return messageLevel >= currentLevel;
     }
 
     private static consoleLevelsMap: Record<LogLevel, (...data: any[]) => void> = {
@@ -58,6 +72,7 @@ export class CodegenLogger {
 
     private tryWriteToConsole(level: LogLevel, formattedMessage: string): void {
         if (this.isSuppressed(level)) return;
+        if (!this.shouldLog(level)) return;
         const logFn = CodegenLogger.consoleLevelsMap[level] || console.log;
         logFn(formattedMessage);
     }
@@ -74,8 +89,11 @@ export class CodegenLogger {
      */
     error(message: string, error?: Error): void {
         if (this.isSuppressed(LogLevel.ERROR)) return;
+        if (!this.shouldLog(LogLevel.ERROR)) return;
         console.error(this.formatMessage("X", message, pc.red));
-        if (error && this.options.verbose) {
+        // Show error details if verbose or log level is DEBUG
+        const showDetails = this.options.verbose || this.options.level === LogLevel.DEBUG;
+        if (error && showDetails) {
             console.error(pc.red(`   ${error.message}`));
             if (error.stack) {
                 console.error(pc.gray(error.stack));
@@ -105,10 +123,11 @@ export class CodegenLogger {
     }
 
     /**
-     * Debug message (only shows in verbose mode)
+     * Debug message (only shows when log level is DEBUG or verbose is true)
      */
     debug(message: string): void {
-        if (this.options.verbose) {
+        // Debug shows if verbose is true OR log level allows DEBUG
+        if (this.options.verbose || this.shouldLog(LogLevel.DEBUG)) {
             this.tryWriteToConsole(LogLevel.DEBUG, this.formatMessage("🐛", message, pc.magenta));
         }
     }
@@ -158,6 +177,24 @@ export class CodegenLogger {
      */
     configure(options: Partial<LogOptions>): void {
         this.options = { ...this.options, ...options };
+        // If verbose is set to true and level wasn't explicitly provided, set level to DEBUG
+        if (options.verbose === true && options.level === undefined) {
+            this.options.level = LogLevel.DEBUG;
+        }
+    }
+
+    /**
+     * Get the current log level
+     */
+    getLevel(): LogLevel {
+        return this.options.level ?? LogLevel.INFO;
+    }
+
+    /**
+     * Set the log level
+     */
+    setLevel(level: LogLevel): void {
+        this.options.level = level;
     }
 }