new logger with suppression functionality

.github/workflows/ci.yml

@@ -10,19 +10,14 @@ permissions:
 jobs:
   test:
     runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        bun-version: [latest]
-
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
 
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: ${{ matrix.bun-version }}
+          bun-version: latest
 
       - name: Install dependencies
         run: bun install --frozen-lockfile

examples/python/generate.ts

@@ -1,8 +1,14 @@
 import { APIBuilder, prettyReport } from "../../src";
+import { type LogManager, mkLogger } from "../../src/utils/log";
 
 console.log("📦 Generating FHIR R4 Core Types...");
 
-const builder = new APIBuilder()
+const logger: LogManager = mkLogger({
+    prefix: "API",
+    suppressTags: ["FIELD_TYPE_NOT_FOUND", "LARGE_VALUESET"],
+});
+
+const builder = new APIBuilder({ logger })
     .throwException()
     .fromPackage("hl7.fhir.r4.core", "4.0.1")
     .python({

src/api/builder.ts

@@ -23,13 +23,7 @@ import type { IrConf, LogicalPromotionConf, TreeShakeConf } from "@root/typesche
 import { type Register, registerFromManager } from "@root/typeschema/register";
 import { type PackageMeta, packageMetaToNpm } from "@root/typeschema/types";
 import { mkTypeSchemaIndex, type TypeSchemaIndex } from "@root/typeschema/utils";
-import {
-    type CodegenLogger,
-    createLogger,
-    type LogLevel,
-    type LogLevelString,
-    parseLogLevel,
-} from "@root/utils/codegen-logger";
+import { type LogManager, type LogLevel, mkLogger } from "@root/utils/log";
 import { IntrospectionWriter, type IntrospectionWriterOptions } from "./writer-generator/introspection";
 import { IrReportWriterWriter, type IrReportWriterWriterOptions } from "./writer-generator/ir-report";
 import type { FileBasedMustacheGeneratorOptions } from "./writer-generator/mustache";
@@ -100,7 +94,7 @@ export interface LocalStructureDefinitionConfig {
     dependencies?: PackageMeta[];
 }
 
-const cleanup = async (opts: APIBuilderOptions, logger: CodegenLogger): Promise<void> => {
+const cleanup = async (opts: APIBuilderOptions, logger: LogManager): Promise<void> => {
     logger.info(`Cleaning outputs...`);
     try {
         logger.info(`Clean ${opts.outputDir}`);
@@ -125,15 +119,15 @@ export class APIBuilder {
         localSDs: LocalPackageConfig[];
         localTgzPackages: TgzPackageConfig[];
     };
-    private logger: CodegenLogger;
+    private logger: LogManager;
     private generators: { name: string; writer: FileSystemWriter }[] = [];
 
     constructor(
         userOpts: Partial<APIBuilderOptions> & {
             manager?: ReturnType<typeof CanonicalManager>;
             register?: Register;
             preprocessPackage?: (context: PreprocessContext) => PreprocessContext;
-            logger?: CodegenLogger;
+            logger?: LogManager;
         } = {},
     ) {
         const defaultOpts: APIBuilderOptions = {
@@ -143,7 +137,7 @@ export class APIBuilder {
             treeShake: undefined,
             promoteLogical: undefined,
             registry: undefined,
-            logLevel: parseLogLevel("INFO"),
+            logLevel: "INFO",
             dropCanonicalManagerCache: false,
         };
         const opts: APIBuilderOptions = {
@@ -179,7 +173,7 @@ export class APIBuilder {
                 dropCache: userOpts.dropCanonicalManagerCache,
                 preprocessPackage: userOpts.preprocessPackage,
             });
-        this.logger = userOpts.logger ?? createLogger({ prefix: "API", level: opts.logLevel });
+        this.logger = userOpts.logger ?? mkLogger({ prefix: "API", level: opts.logLevel });
         this.options = opts;
     }
 
@@ -340,8 +334,8 @@ export class APIBuilder {
         return this;
     }
 
-    setLogLevel(level: LogLevel | LogLevelString): APIBuilder {
-        this.logger?.setLevel(typeof level === "string" ? parseLogLevel(level) : level);
+    setLogLevel(level: LogLevel): APIBuilder {
+        this.logger?.setLevel(level);
         return this;
     }
 
@@ -449,7 +443,7 @@ export class APIBuilder {
 
             this.logger.debug(`Generation completed: ${result.filesGenerated.length} files`);
         } catch (error) {
-            this.logger.error("Code generation failed", error instanceof Error ? error : new Error(String(error)));
+            this.logger.error(`Code generation failed: ${error instanceof Error ? error.message : String(error)}`);
             result.errors.push(error instanceof Error ? error.message : String(error));
             if (this.options.throwException) throw error;
         }

src/api/index.ts

@@ -8,7 +8,7 @@
  */
 
 export type { IrConf, LogicalPromotionConf, TreeShakeConf } from "../typeschema/ir/types";
-export { LogLevel } from "../utils/codegen-logger";
+export type { LogLevel } from "../utils/log";
 export type { APIBuilderOptions, LocalStructureDefinitionConfig } from "./builder";
 export { APIBuilder, prettyReport } from "./builder";
 export type { CSharpGeneratorOptions } from "./writer-generator/csharp/csharp";

src/api/writer-generator/mustache.ts

@@ -22,7 +22,7 @@ import type {
     ViewModel,
 } from "@mustache/types";
 import type { TypeSchemaIndex } from "@root/typeschema/utils";
-import type { CodegenLogger } from "@root/utils/codegen-logger";
+import type { Log } from "@root/utils/log";
 import { default as Mustache } from "mustache";
 import { FileSystemWriter, type FileSystemWriterOptions } from "./writer";
 
@@ -57,7 +57,7 @@ export type MustacheGeneratorOptions = FileSystemWriterOptions &
 
 export function loadMustacheGeneratorConfig(
     templatePath: string,
-    logger?: CodegenLogger,
+    logger?: Log,
 ): Partial<FileBasedMustacheGeneratorOptions> {
     const filePath = Path.resolve(templatePath, "config.json");
     try {

src/api/writer-generator/writer.ts

@@ -2,12 +2,12 @@ import * as fs from "node:fs";
 import * as fsPromises from "node:fs/promises";
 import * as Path from "node:path";
 import type { TypeSchemaIndex } from "@root/typeschema/utils";
-import type { CodegenLogger } from "@root/utils/codegen-logger";
+import type { Log } from "@root/utils/log";
 
 export type FileSystemWriterOptions = {
     outputDir: string;
     inMemoryOnly?: boolean;
-    logger?: CodegenLogger;
+    logger?: Log;
     resolveAssets?: (fn: string) => string;
 };
 
@@ -36,7 +36,7 @@ export abstract class FileSystemWriter<T extends FileSystemWriterOptions = FileS
         this.opts.outputDir = path;
     }
 
-    logger(): CodegenLogger | undefined {
+    logger(): Log | undefined {
         return this.opts.logger;
     }
 

src/cli/commands/index.ts

@@ -6,7 +6,9 @@
  * Modern CLI with subcommands for typeschema and code generation
  */
 
-import { configure, error, header, LogLevel } from "@root/utils/codegen-logger";
+import { header } from "@root/utils/cli-fmt";
+import type { LogLevel } from "@root/utils/log";
+import { mkLogger } from "@root/utils/log";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { typeschemaCommand } from "./typeschema";
@@ -17,45 +19,14 @@ import { typeschemaCommand } from "./typeschema";
 export interface CLIArgv {
     verbose?: boolean;
     debug?: boolean;
-    logLevel?: "debug" | "info" | "warn" | "error" | "silent";
+    logLevel?: LogLevel;
 }
 
-/**
- * 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()];
-}
+const cliLogger = mkLogger({ prefix: "cli" });
 
-/**
- * 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({
-        timestamp: argv.debug,
-        level,
-    });
+    const level: LogLevel = argv.logLevel ?? (argv.debug || argv.verbose ? "DEBUG" : "INFO");
+    cliLogger.setLevel(level);
 }
 
 /**
@@ -84,8 +55,8 @@ export function createCLI() {
         .option("log-level", {
             alias: "l",
             type: "string",
-            choices: ["debug", "info", "warn", "error", "silent"] as const,
-            description: "Set the log level (default: info)",
+            choices: ["DEBUG", "INFO", "WARN", "ERROR", "SILENT"] as const,
+            description: "Set the log level (default: INFO)",
             global: true,
         })
         .demandCommand(0) // Allow 0 commands so we can handle it ourselves
@@ -110,13 +81,8 @@ export function createCLI() {
             "Generate TypeSchemas from FHIR package",
         )
         .fail((msg, err, _yargs) => {
-            if (err) {
-                error(err.message, err);
-            } else {
-                error(msg);
-            }
-
-            error("\nUse --help for usage information");
+            cliLogger.error(err ? err.message : msg);
+            cliLogger.error("Use --help for usage information");
             process.exit(1);
         })
         .wrap(Math.min(120, process.stdout.columns || 80));
@@ -132,8 +98,8 @@ export async function runCLI() {
 
 // Run CLI if this file is executed directly
 if (import.meta.main) {
-    runCLI().catch((error) => {
-        error("Unexpected error:", error);
+    runCLI().catch((err) => {
+        cliLogger.error(String(err));
         process.exit(1);
     });
 }

src/cli/commands/typeschema.ts

@@ -4,13 +4,16 @@
  * Commands for validating and managing TypeSchema files
  */
 
-import { error, info, list } from "@root/utils/codegen-logger";
+import { list } from "@root/utils/cli-fmt";
+import { mkLogger } from "@root/utils/log";
 import type { CommandModule } from "yargs";
 import { generateTypeschemaCommand } from "./typeschema/generate";
 
 /**
  * TypeSchema command group
  */
+const logger = mkLogger({ prefix: "typeschema" });
+
 export const typeschemaCommand: CommandModule = {
     command: "typeschema [subcommand]",
     describe: "TypeSchema operations - generate, validate and merge schemas",
@@ -21,9 +24,8 @@ export const typeschemaCommand: CommandModule = {
             .example("$0 typeschema generate hl7.fhir.r4.core@4.0.1", "Generate TypeSchema from FHIR R4 core package");
     },
     handler: (argv: any) => {
-        // If no subcommand provided, show available subcommands
         if (!argv.subcommand && argv._.length === 1) {
-            info("Available typeschema subcommands:");
+            logger.info("Available typeschema subcommands:");
             list(["generate    Generate TypeSchema files from FHIR packages"]);
             console.log(
                 "\nUse 'atomic-codegen typeschema <subcommand> --help' for more information about a subcommand.",
@@ -37,10 +39,9 @@ export const typeschemaCommand: CommandModule = {
             return;
         }
 
-        // If unknown subcommand provided, show error and available commands
         if (argv.subcommand && !["generate", "validate", "merge"].includes(argv.subcommand)) {
-            error(`Unknown typeschema subcommand: ${argv.subcommand}\n`);
-            info("Available typeschema subcommands:");
+            logger.error(`Unknown typeschema subcommand: ${argv.subcommand}`);
+            logger.info("Available typeschema subcommands:");
             list([
                 "generate    Generate TypeSchema files from FHIR packages",
                 "validate    Validate TypeSchema files for correctness and consistency",

src/cli/commands/typeschema/generate.ts

@@ -6,7 +6,8 @@
 
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { complete, createLogger, list } from "@root/utils/codegen-logger";
+import { complete, list } from "@root/utils/cli-fmt";
+import { mkLogger } from "@root/utils/log";
 import { generateTypeSchemas } from "@typeschema/index";
 import { registerFromPackageMetas } from "@typeschema/register";
 import type { PackageMeta } from "@typeschema/types";
@@ -73,12 +74,12 @@ export const generateTypeschemaCommand: CommandModule<Record<string, unknown>, G
         },
     },
     handler: async (argv) => {
-        const logger = createLogger({
+        const logger = mkLogger({
             prefix: "TypeSchema",
         });
 
         try {
-            logger.step("Generating TypeSchema from FHIR packages");
+            logger.info("Generating TypeSchema from FHIR packages");
             logger.info(`Packages: ${argv.packages.join(", ")}`);
             logger.info(`Output: ${argv.output}`);
 
@@ -113,7 +114,7 @@ export const generateTypeschemaCommand: CommandModule<Record<string, unknown>, G
                 return { name: packageSpec, version: "latest" };
             });
 
-            logger.progress(`Processing packages: ${packageMetas.map((p) => `${p.name}@${p.version}`).join(", ")}`);
+            logger.info(`Processing packages: ${packageMetas.map((p) => `${p.name}@${p.version}`).join(", ")}`);
 
             // Create register from packages
             const register = await registerFromPackageMetas(packageMetas, {
@@ -149,7 +150,7 @@ export const generateTypeschemaCommand: CommandModule<Record<string, unknown>, G
 
             const duration = Date.now() - startTime;
             complete(`Generated ${allSchemas.length} TypeSchema definitions`, duration, { schemas: allSchemas.length });
-            logger.dim(`Output: ${outputPath}`);
+            logger.info(`Output: ${outputPath}`);
 
             if (argv.verbose) {
                 logger.debug("Generated schemas:");
@@ -160,7 +161,7 @@ export const generateTypeschemaCommand: CommandModule<Record<string, unknown>, G
                 list(schemaNames);
             }
         } catch (error) {
-            logger.error("Failed to generate TypeSchema", error instanceof Error ? error : new Error(String(error)));
+            logger.error(`Failed to generate TypeSchema: ${error instanceof Error ? error.message : String(error)}`);
             process.exit(1);
         }
     },