infra-kit 0.1.128 → 0.1.129

package/src/lib/infra-kit-config/infra-kit-config.ts

@@ -1,454 +0,0 @@
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { z } from 'zod'
-
-import { getProjectRoot } from 'src/lib/git-utils'
-
-const INFRA_KIT_CONFIG_FILE = 'infra-kit.json'
-
-/**
- * Directory under the user's home that holds all machine-local infra-kit config:
- * the runtime `infra-kit.json` merge layer, per-project overrides, and the factory
- * registry (`vendor.json`). Single source of truth for `.infra-kit`, reused
- * by the vendor factory-config loader (no import cycle — this module imports no
- * `lib/vendor` code).
- */
-export const USER_CONFIG_DIR_NAME = '.infra-kit'
-const USER_GLOBAL_CONFIG_FILE = 'infra-kit.json'
-const USER_PROJECTS_DIR = 'projects'
-
-// envManagement
-const dopplerEnvManagementSchema = z.object({
-  provider: z.literal('doppler'),
-  config: z.object({
-    name: z.string().min(1),
-  }),
-})
-
-const envManagementSchema = z.discriminatedUnion('provider', [dopplerEnvManagementSchema])
-
-// ide
-// There is one attach style: each worktree is added to the configured editor's
-// workspace and opened (no per-window mode). Cursor needs a `.code-workspace`
-// path to reconcile its `folders` array against.
-const cursorIdeConfigSchema = z.object({
-  workspaceConfigPath: z.string().min(1),
-})
-
-const cursorIdeSchema = z.object({
-  provider: z.literal('cursor'),
-  config: cursorIdeConfigSchema,
-})
-
-// Zed has no portable workspace file (no `.code-workspace`) and no folder-remove
-// CLI: a multi-worktree workspace is realized by a single `zed <root> <wt...>`
-// invocation. So `config` carries no settings — there's no path to point at.
-const zedIdeConfigSchema = z.object({})
-
-const zedIdeSchema = z.object({
-  provider: z.literal('zed'),
-  config: zedIdeConfigSchema,
-})
-
-const ideSchema = z.discriminatedUnion('provider', [cursorIdeSchema, zedIdeSchema])
-
-// `ide` accepts a single provider (back-compat) OR an array to drive multiple
-// editors at once (e.g. Cursor + Zed). Normalized to an array everywhere via
-// `resolveConfiguredIdes`. Uniqueness-by-provider is enforced at parse time by a
-// `.superRefine` on the full config schema (see below) — not here, so the message
-// survives `z.union` error aggregation.
-const idesSchema = z.union([ideSchema, z.array(ideSchema).min(1)])
-
-// taskManager
-const jiraTaskManagerSchema = z.object({
-  provider: z.literal('jira'),
-  config: z.object({
-    baseUrl: z.string().url(),
-    projectId: z.number().int().positive(),
-  }),
-})
-
-const taskManagerSchema = z.discriminatedUnion('provider', [jiraTaskManagerSchema])
-
-// cmux pane layout for opened worktree workspaces. Named presets keep the config
-// typo-proof (an enum, not a free string) and let the opener switch on a single
-// value; extend the enum + the opener's switch to add a layout.
-//   two-columns — left | right, both full-height (default)
-//   three-pane  — left split top/bottom + full-height right (legacy layout)
-const cmuxLayouts = ['two-columns', 'three-pane'] as const
-
-const cmuxConfigSchema = z.object({
-  layout: z.enum(cmuxLayouts).optional(),
-})
-
-// worktrees prompt defaults
-const worktreesConfigSchema = z.object({
-  openInGithubDesktop: z.boolean().optional(),
-  openInCmux: z.boolean().optional(),
-  cmux: cmuxConfigSchema.optional(),
-})
-
-// dev-server per-app overrides. Maps an app folder name (e.g. `client`) to its
-// local dev port and/or URL prefix. Both keys optional. An app absent from the
-// map falls back to env (`{APP}_PORT` / `PORT`) then the built-in defaults, so
-// the map is intentionally NOT validated against the discovered apps here — an
-// unknown app name is simply ignored at resolve time (lib/dev), never a parse
-// error that would brick every command.
-const devAppConfigSchema = z
-  .object({
-    port: z.number().int().positive().optional(),
-    prefixUrl: z.string().min(1).optional(),
-  })
-  .strict()
-
-const devConfigSchema = z.record(z.string().min(1), devAppConfigSchema)
-
-// env auto-load: opt-in convenience that primes Doppler env when you work inside
-// this project / a worktree. Absent => disabled. `trigger` selects the moment
-// (pick one):
-//   shell-startup  — when a new shell opens inside the project
-//   cli-invocation — before each `infra-kit` command (primes SUBSEQUENT commands)
-// `config` names which environment to load. It is intentionally NOT validated
-// against `environments` here: an invalid name must DISABLE the feature at
-// resolve time (lib/env-autoload), never throw inside the merged-config parse and
-// brick every command.
-const envAutoLoadSchema = z
-  .object({
-    trigger: z.enum(['shell-startup', 'cli-invocation']),
-    config: z.string().min(1),
-  })
-  .strict()
-
-// Base object shape, kept separate so `.partial()` (which only works on a plain
-// ZodObject, not the `.superRefine`-wrapped full schema) can derive the override
-// schema from it.
-const infraKitConfigObject = z.object({
-  environments: z.array(z.string().min(1)).min(1),
-  envManagement: envManagementSchema,
-  ide: idesSchema.optional(),
-  taskManager: taskManagerSchema.optional(),
-  worktrees: worktreesConfigSchema.optional(),
-  envAutoLoad: envAutoLoadSchema.optional(),
-  dev: devConfigSchema.optional(),
-})
-
-// Full schema = base object + a parse-time uniqueness check on the `ide` array.
-// This runs inside the *merged* `safeParse` in getInfraKitConfig, so it's the
-// gate for the final config. (The override layers use the `.partial()` form
-// below, which drops this object-level refinement — acceptable, the merged
-// parse is authoritative.)
-export const infraKitConfigSchema = infraKitConfigObject.superRefine((cfg, ctx) => {
-  if (!Array.isArray(cfg.ide)) return
-
-  const seen = new Set<string>()
-
-  for (const entry of cfg.ide) {
-    if (seen.has(entry.provider)) {
-      ctx.addIssue({
-        code: 'custom',
-        message: 'each IDE provider may appear at most once',
-        path: ['ide'],
-      })
-
-      return
-    }
-
-    seen.add(entry.provider)
-  }
-})
-
-export const infraKitOverrideConfigSchema = infraKitConfigObject.partial()
-
-export type InfraKitConfig = z.infer<typeof infraKitConfigSchema>
-
-/** Resolved env auto-load config (`{ trigger, config }`), or `undefined` when off. */
-export type EnvAutoLoadConfig = z.infer<typeof envAutoLoadSchema>
-
-/** Per-app dev-server overrides (`{ port?, prefixUrl? }`). */
-export type DevAppConfig = z.infer<typeof devAppConfigSchema>
-
-/** The full `dev` section: a map of app folder name to its {@link DevAppConfig}. */
-export type DevConfig = z.infer<typeof devConfigSchema>
-
-/** A single resolved IDE entry (`{ provider, config }`). */
-export type ConfiguredIde = z.infer<typeof ideSchema>
-
-/**
- * Normalize the `ide` config (single object, array, or unset) into a flat list.
- * Validation-free: assumes already-parsed input (uniqueness is enforced by the
- * schema). The one source of truth for "which editors are configured."
- *
- * @example
- * resolveConfiguredIdes({ ide: { provider: 'cursor', config: {...} } }) // => [cursor]
- * resolveConfiguredIdes({ ide: [cursor, zed] })                         // => [cursor, zed]
- * resolveConfiguredIdes({})                                             // => []
- */
-export const resolveConfiguredIdes = (config: InfraKitConfig): ConfiguredIde[] => {
-  const ide = config.ide
-
-  if (!ide) return []
-
-  return Array.isArray(ide) ? ide : [ide]
-}
-
-/** A cmux pane layout preset (see {@link cmuxLayouts}). */
-export type CmuxLayout = (typeof cmuxLayouts)[number]
-
-/** The layout applied when `worktrees.cmux.layout` is left unset. */
-export const DEFAULT_CMUX_LAYOUT: CmuxLayout = 'two-columns'
-
-/**
- * Resolve the cmux pane layout for opened worktree workspaces, falling back to
- * {@link DEFAULT_CMUX_LAYOUT} when unconfigured. The one source of truth for
- * "which layout should the cmux opener build."
- *
- * @example
- * resolveCmuxLayout({ worktrees: { cmux: { layout: 'three-pane' } } }) // => 'three-pane'
- * resolveCmuxLayout({})                                                // => 'two-columns'
- */
-export const resolveCmuxLayout = (config: InfraKitConfig): CmuxLayout => {
-  return config.worktrees?.cmux?.layout ?? DEFAULT_CMUX_LAYOUT
-}
-
-export interface InfraKitConfigPaths {
-  /** Committed project config (required). */
-  main: string
-  /** User-scope global overrides applied to every project. */
-  userGlobal: string
-  /** User-scope per-project overrides — `<userProjectsDir>/<projectName>/infra-kit.json`. */
-  userProject: string
-  /** Repo basename (`path.basename(projectRoot)`) used to namespace the user-project file. */
-  projectName: string
-}
-
-interface CacheEntry {
-  mtimes: Record<keyof Omit<InfraKitConfigPaths, 'projectName'>, number | null>
-  value: InfraKitConfig
-}
-
-let cached: CacheEntry | null = null
-
-/**
- * Resolve every file path that participates in the config merge chain. Always
- * returns paths even for files that don't yet exist, so callers can use them
- * for "where would my override go?" prompts.
- *
- * @example
- * const paths = await getInfraKitConfigPaths()
- * // {
- * //   main:        '/Users/arthur/projects/api/infra-kit.json',
- * //   userGlobal:  '/Users/arthur/.infra-kit/infra-kit.json',
- * //   userProject: '/Users/arthur/.infra-kit/projects/api/infra-kit.json',
- * //   projectName: 'api',
- * // }
- */
-export const getInfraKitConfigPaths = async (): Promise<InfraKitConfigPaths> => {
-  const projectRoot = await getProjectRoot()
-  // Repo name is the project-root basename (same as getRepoName), derived here to
-  // avoid a second `git rev-parse` — getRepoName would re-resolve the root.
-  const projectName = path.basename(projectRoot)
-  const userConfigDir = path.join(os.homedir(), USER_CONFIG_DIR_NAME)
-
-  return {
-    main: path.join(projectRoot, INFRA_KIT_CONFIG_FILE),
-    userGlobal: path.join(userConfigDir, USER_GLOBAL_CONFIG_FILE),
-    userProject: path.join(userConfigDir, USER_PROJECTS_DIR, projectName, INFRA_KIT_CONFIG_FILE),
-    projectName,
-  }
-}
-
-/**
- * Read and validate `infra-kit.json`, with optional override layers shallow-merged
- * on top in this order (later wins):
- *   1. project `infra-kit.json`                            — committed source of truth
- *   2. `~/.infra-kit/infra-kit.json`                       — user-global defaults
- *   3. `~/.infra-kit/projects/<repo-name>/infra-kit.json`  — user-scope per-project overrides
- *
- * Top-level keys (entire capability sections like `ide`, `envManagement`)
- * replace wholesale. Results are cached per file mtimes so the long-running
- * MCP server picks up edits without a restart.
- *
- * @example
- * // infra-kit.json:           { "environments": ["dev"], "envManagement": { "provider": "doppler", "config": { "name": "p" } } }
- * // ~/.infra-kit/infra-kit.json: { "ide": { "provider": "cursor", "config": { "workspaceConfigPath": "./ws.code-workspace" } } }
- * const cfg = await getInfraKitConfig()
- * // => { environments: ['dev'], envManagement: {...}, ide: { provider: 'cursor', config: { workspaceConfigPath: './ws.code-workspace' } } }
- */
-export const getInfraKitConfig = async (): Promise<InfraKitConfig> => {
-  const paths = await getInfraKitConfigPaths()
-
-  let mainStat: Awaited<ReturnType<typeof fs.stat>>
-
-  try {
-    mainStat = await fs.stat(paths.main)
-  } catch {
-    cached = null
-
-    // Bridge the YAML→JSON cutover: if a legacy infra-kit.yml is sitting where
-    // the JSON config should be, point the user at the one-shot migration.
-    const legacyYmlPath = paths.main.replace(/\.json$/, '.yml')
-
-    if (await statIfExists(legacyYmlPath)) {
-      throw new Error(
-        `infra-kit.json not found at ${paths.main}. A legacy infra-kit.yml exists — run \`infra-kit init\` to convert it.`,
-      )
-    }
-
-    throw new Error(`infra-kit.json not found at ${paths.main}`)
-  }
-
-  const [userGlobalStat, userProjectStat] = await Promise.all([
-    statIfExists(paths.userGlobal),
-    statIfExists(paths.userProject),
-  ])
-
-  const mtimes = {
-    main: Number(mainStat.mtimeMs),
-    userGlobal: userGlobalStat ? Number(userGlobalStat.mtimeMs) : null,
-    userProject: userProjectStat ? Number(userProjectStat.mtimeMs) : null,
-  }
-
-  if (cached && shallowEqual(cached.mtimes, mtimes)) {
-    return cached.value
-  }
-
-  const layers: ConfigLayer[] = [
-    { label: 'infra-kit.json', path: paths.main, required: true },
-    { label: '~/.infra-kit/infra-kit.json', path: paths.userGlobal, required: false },
-    {
-      label: `~/.infra-kit/projects/${paths.projectName}/infra-kit.json`,
-      path: paths.userProject,
-      required: false,
-    },
-  ]
-
-  let merged: Record<string, unknown> = {}
-
-  for (const layer of layers) {
-    const data = await loadLayer(layer)
-
-    if (data === null) continue
-
-    merged = { ...merged, ...data }
-  }
-
-  const finalResult = infraKitConfigSchema.safeParse(merged)
-
-  if (!finalResult.success) {
-    throw new Error(`Invalid merged infra-kit config: ${z.prettifyError(finalResult.error)}`)
-  }
-
-  cached = { mtimes, value: finalResult.data }
-
-  return finalResult.data
-}
-
-/**
- * For tests — drops the in-memory cache so the next read hits disk.
- *
- * @example
- * resetInfraKitConfigCache()
- * await getInfraKitConfig() // re-reads files even if mtimes look unchanged
- */
-export const resetInfraKitConfigCache = (): void => {
-  cached = null
-}
-
-/**
- * `fs.stat` that returns `null` instead of throwing on ENOENT. Used so the
- * resolver can probe optional files in the merge chain without try/catch noise.
- *
- * @example
- * const stat = await statIfExists('/does/not/exist') // => null
- */
-const statIfExists = async (filePath: string): Promise<Awaited<ReturnType<typeof fs.stat>> | null> => {
-  try {
-    return await fs.stat(filePath)
-  } catch {
-    return null
-  }
-}
-
-/**
- * `fs.readFile` that returns `null` instead of throwing on ENOENT.
- *
- * @example
- * const raw = await readIfExists('/missing.json') // => null
- * const raw = await readIfExists('/exists.json')  // => '{ "environments": ["dev"] }\n'
- */
-const readIfExists = async (filePath: string): Promise<string | null> => {
-  try {
-    return await fs.readFile(filePath, 'utf-8')
-  } catch {
-    return null
-  }
-}
-
-/**
- * Reference-equality comparison of every key in two flat records. Used to
- * cheaply detect whether the cached mtime fingerprint still matches.
- *
- * @example
- * shallowEqual({ a: 1, b: 2 }, { a: 1, b: 2 }) // => true
- * shallowEqual({ a: 1 },       { a: 1, b: 2 }) // => false
- * shallowEqual({ a: 1 },       { a: 2 })       // => false
- */
-const shallowEqual = <T extends Record<string, unknown>>(a: T, b: T): boolean => {
-  const keys = Object.keys(a)
-
-  if (keys.length !== Object.keys(b).length) return false
-
-  return keys.every((k) => {
-    return a[k] === b[k]
-  })
-}
-
-interface ConfigLayer {
-  label: string
-  path: string
-  required: boolean
-}
-
-/**
- * Read a single layer of the merge chain: parse the JSON if the file exists
- * and validate it against the override schema. Returns `null` if an optional
- * layer is missing; throws if the layer is required, malformed, or invalid.
- * An empty/whitespace-only file is treated as `{}` (JSON.parse would throw).
- *
- * @example
- * await loadLayer({ label: '~/.infra-kit/infra-kit.json', path: '/missing.json', required: false })
- * // => null
- *
- * @example
- * // /home/me/.infra-kit/infra-kit.json: '{ "ide": { "provider": "cursor", "config": { "workspaceConfigPath": "./ws.code-workspace" } } }'
- * await loadLayer({ label: '~/.infra-kit/infra-kit.json', path: '/home/me/.infra-kit/infra-kit.json', required: false })
- * // => { ide: { provider: 'cursor', config: { workspaceConfigPath: './ws.code-workspace' } } }
- */
-const loadLayer = async (layer: ConfigLayer): Promise<Record<string, unknown> | null> => {
-  const raw = await readIfExists(layer.path)
-
-  if (raw === null) {
-    if (layer.required) {
-      throw new Error(`${layer.label} not found at ${layer.path}`)
-    }
-
-    return null
-  }
-
-  let parsedRaw: unknown
-
-  try {
-    parsedRaw = raw.trim() === '' ? {} : JSON.parse(raw)
-  } catch (err) {
-    throw new Error(`Invalid JSON in ${layer.label} at ${layer.path}: ${(err as Error).message}`)
-  }
-
-  const result = infraKitOverrideConfigSchema.safeParse(parsedRaw)
-
-  if (!result.success) {
-    throw new Error(`Invalid ${layer.label} at ${layer.path}: ${z.prettifyError(result.error)}`)
-  }
-
-  return result.data as Record<string, unknown>
-}

package/src/lib/json-output/__tests__/json-output.test.ts

@@ -1,139 +0,0 @@
-import { Command } from 'commander'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import { addJsonOption, emit, jsonOutput } from '../json-output'
-
-describe('json-output', () => {
-  afterEach(() => {
-    jsonOutput.enabled = false
-  })
-
-  describe('emit', () => {
-    it('writes structuredContent as pretty JSON when enabled', () => {
-      jsonOutput.enabled = true
-      const writes: string[] = []
-
-      const result = emit({ structuredContent: { version: '1.2.3' } }, (text) => {
-        writes.push(text)
-      })
-
-      expect(writes).toHaveLength(1)
-      const [payload = ''] = writes
-
-      expect(JSON.parse(payload)).toEqual({ version: '1.2.3' })
-      // returns the result unchanged for pass-through use (emit(await handler()))
-      expect(result).toEqual({ structuredContent: { version: '1.2.3' } })
-    })
-
-    it('is a no-op when json mode is disabled', () => {
-      jsonOutput.enabled = false
-      const writes: string[] = []
-
-      emit({ structuredContent: { a: 1 } }, (text) => {
-        writes.push(text)
-      })
-
-      expect(writes).toHaveLength(0)
-    })
-
-    it('writes nothing when structuredContent is undefined or null, even if enabled', () => {
-      jsonOutput.enabled = true
-      const writes: string[] = []
-
-      emit(undefined, (text) => {
-        writes.push(text)
-      })
-      emit({}, (text) => {
-        writes.push(text)
-      })
-      emit({ structuredContent: null }, (text) => {
-        writes.push(text)
-      })
-
-      expect(writes).toHaveLength(0)
-    })
-  })
-
-  // Regression: `--json` must activate on grouped/nested subcommands, not just
-  // flat top-level commands. Commander binds a post-subcommand `--json` to the
-  // parent group, so the preAction hook must read `optsWithGlobals()`, not
-  // `opts()`. This drives the real Commander parse path end-to-end.
-  describe('grouped subcommand --json (regression)', () => {
-    const buildProgram = (writes: string[]): Command => {
-      const program = new Command()
-      const group = program.command('group')
-
-      group.command('leaf').action(() => {
-        emit({ structuredContent: { ok: true } }, (text) => {
-          writes.push(text)
-        })
-      })
-
-      program.commands.forEach(addJsonOption)
-      program.hook('preAction', (_thisCommand, actionCommand) => {
-        jsonOutput.enabled = Boolean(actionCommand.optsWithGlobals().json)
-      })
-
-      return program
-    }
-
-    it('emits JSON for `group leaf --json` (post-subcommand flag on a nested command)', async () => {
-      const writes: string[] = []
-
-      await buildProgram(writes).parseAsync(['node', 'cli', 'group', 'leaf', '--json'])
-
-      expect(writes).toHaveLength(1)
-      const [payload = ''] = writes
-
-      expect(JSON.parse(payload)).toEqual({ ok: true })
-    })
-
-    it('emits nothing for `group leaf` without --json', async () => {
-      const writes: string[] = []
-
-      await buildProgram(writes).parseAsync(['node', 'cli', 'group', 'leaf'])
-
-      expect(writes).toHaveLength(0)
-    })
-  })
-
-  describe('addJsonOption', () => {
-    it('registers --json on a command', () => {
-      const cmd = new Command('demo')
-
-      addJsonOption(cmd)
-
-      expect(
-        cmd.options.some((option) => {
-          return option.long === '--json'
-        }),
-      ).toBe(true)
-    })
-
-    it('is idempotent (does not double-register)', () => {
-      const cmd = new Command('demo')
-
-      addJsonOption(cmd)
-      addJsonOption(cmd)
-
-      const jsonOptions = cmd.options.filter((option) => {
-        return option.long === '--json'
-      })
-
-      expect(jsonOptions).toHaveLength(1)
-    })
-
-    it('registers --json on nested subcommands too', () => {
-      const parent = new Command('parent')
-      const child = parent.command('child')
-
-      addJsonOption(parent)
-
-      expect(
-        child.options.some((option) => {
-          return option.long === '--json'
-        }),
-      ).toBe(true)
-    })
-  })
-})

package/src/lib/json-output/index.ts

@@ -1 +0,0 @@
-export { addJsonOption, emit, jsonOutput } from './json-output'

package/src/lib/json-output/json-output.ts

@@ -1,47 +0,0 @@
-import type { Command } from 'commander'
-import process from 'node:process'
-
-/**
- * `--json` output mode for the CLI. This is a presentation concern only: every
- * command handler already returns a `structuredContent` payload (the same one
- * the MCP surface consumes). Human/log output goes to stderr (see lib/logger),
- * so writing the structured payload to stdout never collides with it.
- */
-
-export interface CommandResult {
-  structuredContent?: unknown
-}
-
-/** Mutable holder (object so `prefer-const` holds while the flag toggles per run). */
-export const jsonOutput = { enabled: false }
-
-/**
- * In `--json` mode, write a command result's `structuredContent` to stdout as
- * pretty JSON and return the result unchanged. Outside `--json` mode it is a
- * no-op pass-through. The writer is injectable for testing.
- */
-export const emit = <T extends CommandResult | void>(
-  result: T,
-  write: (text: string) => void = (text) => {
-    process.stdout.write(text)
-  },
-): T => {
-  if (jsonOutput.enabled && result && result.structuredContent != null) {
-    write(`${JSON.stringify(result.structuredContent, null, 2)}\n`)
-  }
-
-  return result
-}
-
-/** Register `--json` on a command and every nested subcommand (idempotent). */
-export const addJsonOption = (cmd: Command): void => {
-  const alreadyHasJson = cmd.options.some((option) => {
-    return option.long === '--json'
-  })
-
-  if (!alreadyHasJson) {
-    cmd.option('--json', 'Output the structured result as JSON on stdout (human logs stay on stderr)')
-  }
-
-  cmd.commands.forEach(addJsonOption)
-}

package/src/lib/logger/index.ts

@@ -1,40 +0,0 @@
-import process from 'node:process'
-import pino from 'pino'
-import pretty from 'pino-pretty'
-
-// eslint-disable-next-line sonarjs/publicly-writable-directories
-export const LOG_FILE_PATH = '/tmp/mcp-infra-kit.log'
-
-export const initLoggerMcp = () => {
-  const logLevel = process.argv.includes('--debug') ? 'debug' : 'info'
-
-  const logger = pino({ level: logLevel }, pino.destination({ dest: LOG_FILE_PATH }))
-
-  logger.info(`Logger initialized with level: ${logLevel}. Logging to: ${LOG_FILE_PATH}`)
-
-  return logger
-}
-
-export const initLoggerCLI = () => {
-  const logLevel = process.argv.includes('--debug') ? 'debug' : 'info'
-
-  const ignoreFields = ['time', 'pid', 'hostname']
-
-  if (logLevel === 'debug') {
-    ignoreFields.push('level')
-  }
-
-  const logger = pino(
-    { level: logLevel },
-    pretty({
-      destination: 2,
-      ignore: ignoreFields.join(','),
-      colorize: true,
-    }),
-  )
-
-  return logger
-}
-
-// Singleton logger instance for CLI usage
-export const logger = initLoggerCLI()