Dependency Injection - Logger with Log Level

export const LEVELS = ['debug', 'info', 'warn', 'error'] as const;
export type Level = (typeof LEVELS)[number];

export interface Logger {
  debug(msg: string): void;
  info(msg: string): void;
  warn(msg: string): void;
  error(msg: string): void;
  /** How many messages have been suppressed below the configured level. */
  suppressed(): number;
}

export function makeLogger(level: Level): Logger {
  const threshold = LEVELS.indexOf(level);
  let suppressed = 0;
  const emit = (lvl: Level, msg: string) => {
    if (LEVELS.indexOf(lvl) < threshold) {
      suppressed++;
      return;
    }
    console.log(`[${lvl.toUpperCase()}] ${msg}`);
  };
  return {
    debug: (m) => emit('debug', m),
    info: (m) => emit('info', m),
    warn: (m) => emit('warn', m),
    error: (m) => emit('error', m),
    suppressed: () => suppressed,
  };
}

import { cli } from 'cli-forge';
import { LEVELS, Level, makeLogger } from './logger';
import { runBuild } from './build';

// A CLI that registers a logger as a DI provider. The factory reads
// `args.logLevel` when the provider is first injected, so the logger
// automatically obeys whatever level the user passed on the command line —
// no middleware, no prop drilling, no module-level singletons.
export const app = cli('builder')
  .option('logLevel', {
    type: 'string',
    choices: LEVELS,
    default: 'info' as Level,
    description: 'Minimum log level to emit',
  })
  .provide('logger', {
    // Factory receives the finalized args, so logLevel is the one the user
    // actually passed (after defaults, env vars, and config files resolve).
    factory: (args) => makeLogger(args.logLevel as Level),
  })
  .command('build', {
    description: 'Build a target',
    builder: (cmd) =>
      cmd.option('target', {
        type: 'string',
        required: true,
        description: 'Build target (e.g. web, node)',
      }),
    handler: runBuild,
  });

if (require.main === module) {
  app.forge();
}

import { getCommandContext } from 'cli-forge/context';
import { app } from './cli';

// The handler lives in its own file so that `typeof app` is fully resolved
// by the time this module is type-checked. `getCommandContext(app)` uses
// the imported CLI as both a type witness (for inject/args typing) and a
// runtime identity check — at runtime the stored commandIdChain is walked
// to confirm `app` is part of the active execution.
export function runBuild() {
  const ctx = getCommandContext(app);
  const build = ctx.getChildContext('build');

  const log = ctx.inject('logger');

  log.debug('Resolving toolchain');
  log.debug('Loading config');
  log.info(`Building target: ${build.args.target}`);
  log.warn('No cache configured');

  // Surface how many messages the logger filtered out so tests can verify
  // that log level filtering was applied.
  console.log(`DONE (suppressed=${log.suppressed()})`);
}

1// logger.ts
2export const logger = makeLogger(process.env.LOG_LEVEL ?? 'info');