@lumenflow/core 1.4.0 → 1.6.0

package/dist/adapters/recovery-adapters.js

@@ -0,0 +1,43 @@
+/**
+ * Recovery Adapters
+ *
+ * WU-1094: INIT-002 Phase 2 - Implement adapters and dependency injection
+ *
+ * Concrete adapter implementations for recovery-related port interfaces.
+ * These adapters wrap the existing implementation functions to conform
+ * to the port interfaces, enabling dependency injection.
+ *
+ * Adapters:
+ * - RecoveryAnalyzerAdapter - Implements IRecoveryAnalyzer
+ *
+ * @module adapters/recovery-adapters
+ */
+// Import existing implementation
+import { analyzeRecovery } from '../recovery/recovery-analyzer.js';
+/**
+ * RecoveryAnalyzerAdapter
+ *
+ * Implements IRecoveryAnalyzer by delegating to the analyzeRecovery function.
+ * Analyzes WU context to detect state inconsistencies and suggests
+ * recovery actions.
+ *
+ * @example
+ * // Use default adapter
+ * const adapter = new RecoveryAnalyzerAdapter();
+ * const analysis = await adapter.analyzeRecovery(context);
+ *
+ * @example
+ * // Use as port interface
+ * const analyzer: IRecoveryAnalyzer = new RecoveryAnalyzerAdapter();
+ */
+export class RecoveryAnalyzerAdapter {
+    /**
+     * Analyze context for recovery issues.
+     *
+     * @param context - Current WU context
+     * @returns Promise<RecoveryAnalysis> - Recovery analysis with issues and suggested actions
+     */
+    async analyzeRecovery(context) {
+        return analyzeRecovery(context);
+    }
+}

package/dist/adapters/validation-adapters.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Validation Adapters
+ *
+ * WU-1094: INIT-002 Phase 2 - Implement adapters and dependency injection
+ *
+ * Concrete adapter implementations for validation-related port interfaces.
+ * These adapters wrap the existing implementation functions to conform
+ * to the port interfaces, enabling dependency injection.
+ *
+ * Adapters:
+ * - CommandRegistryAdapter - Implements ICommandRegistry
+ *
+ * @module adapters/validation-adapters
+ */
+import type { ICommandRegistry, CommandDefinition, WuContext } from '../ports/validation.ports.js';
+/**
+ * CommandRegistryAdapter
+ *
+ * Implements ICommandRegistry by delegating to the command registry functions.
+ * Provides access to command definitions and context-based validation.
+ *
+ * @example
+ * // Use default adapter
+ * const adapter = new CommandRegistryAdapter();
+ * const def = adapter.getCommandDefinition('wu:done');
+ *
+ * @example
+ * // Use as port interface
+ * const registry: ICommandRegistry = new CommandRegistryAdapter();
+ */
+export declare class CommandRegistryAdapter implements ICommandRegistry {
+    /**
+     * Get command definition by name.
+     *
+     * @param command - Command name (e.g., 'wu:create', 'wu:done')
+     * @returns CommandDefinition or null if not found
+     */
+    getCommandDefinition(command: string): CommandDefinition | null;
+    /**
+     * Get all commands valid for the current context.
+     *
+     * @param context - Current WU context
+     * @returns Array of valid CommandDefinitions
+     */
+    getValidCommandsForContext(context: WuContext): CommandDefinition[];
+    /**
+     * Get all registered command definitions.
+     *
+     * @returns Array of all CommandDefinitions
+     */
+    getAllCommands(): CommandDefinition[];
+}

package/dist/adapters/validation-adapters.js

@@ -0,0 +1,59 @@
+/**
+ * Validation Adapters
+ *
+ * WU-1094: INIT-002 Phase 2 - Implement adapters and dependency injection
+ *
+ * Concrete adapter implementations for validation-related port interfaces.
+ * These adapters wrap the existing implementation functions to conform
+ * to the port interfaces, enabling dependency injection.
+ *
+ * Adapters:
+ * - CommandRegistryAdapter - Implements ICommandRegistry
+ *
+ * @module adapters/validation-adapters
+ */
+// Import existing implementations
+import { COMMAND_REGISTRY, getCommandDefinition, getValidCommandsForContext, } from '../validation/command-registry.js';
+/**
+ * CommandRegistryAdapter
+ *
+ * Implements ICommandRegistry by delegating to the command registry functions.
+ * Provides access to command definitions and context-based validation.
+ *
+ * @example
+ * // Use default adapter
+ * const adapter = new CommandRegistryAdapter();
+ * const def = adapter.getCommandDefinition('wu:done');
+ *
+ * @example
+ * // Use as port interface
+ * const registry: ICommandRegistry = new CommandRegistryAdapter();
+ */
+export class CommandRegistryAdapter {
+    /**
+     * Get command definition by name.
+     *
+     * @param command - Command name (e.g., 'wu:create', 'wu:done')
+     * @returns CommandDefinition or null if not found
+     */
+    getCommandDefinition(command) {
+        return getCommandDefinition(command);
+    }
+    /**
+     * Get all commands valid for the current context.
+     *
+     * @param context - Current WU context
+     * @returns Array of valid CommandDefinitions
+     */
+    getValidCommandsForContext(context) {
+        return getValidCommandsForContext(context);
+    }
+    /**
+     * Get all registered command definitions.
+     *
+     * @returns Array of all CommandDefinitions
+     */
+    getAllCommands() {
+        return Array.from(COMMAND_REGISTRY.values());
+    }
+}

package/dist/agent-patterns-registry.d.ts

@@ -5,6 +5,8 @@
  * that bypass worktree requirements. Static JSON served from lumenflow.dev,
  * cached locally for 7 days with fallback to defaults.
  *
+ * WU-1089: Added merge/override/airgapped modes via resolveAgentPatterns()
+ *
  * @module agent-patterns-registry
  */
 /** Default agent branch patterns (narrow: just agent/*) */
@@ -16,12 +18,48 @@ export declare const CACHE_TTL_MS: number;
 /**
  * Options for getAgentPatterns
  */
-interface GetAgentPatternsOptions {
+export interface GetAgentPatternsOptions {
     /** Override cache directory (default: ~/.lumenflow/cache) */
     cacheDir?: string;
     /** Fetch timeout in milliseconds (default: 5000) */
     timeoutMs?: number;
 }
+/**
+ * Source of agent patterns for observability
+ */
+export type AgentPatternSource = 'registry' | 'merged' | 'override' | 'config' | 'defaults';
+/**
+ * Result of resolveAgentPatterns with observability fields
+ */
+export interface AgentPatternResult {
+    /** Resolved patterns to use for agent branch matching */
+    patterns: string[];
+    /** Source of the patterns for observability */
+    source: AgentPatternSource;
+    /** Whether the registry was successfully fetched */
+    registryFetched: boolean;
+}
+/**
+ * Type for injectable registry fetcher function
+ */
+export type RegistryFetcher = (options: GetAgentPatternsOptions) => Promise<string[]>;
+/**
+ * Options for resolveAgentPatterns (WU-1089)
+ */
+export interface ResolveAgentPatternsOptions {
+    /** Injectable registry fetcher for testing (uses getAgentPatterns by default) */
+    registryFetcher?: RegistryFetcher;
+    /** Patterns from config.git.agentBranchPatterns (merged with registry by default) */
+    configPatterns?: string[];
+    /** Patterns from config.git.agentBranchPatternsOverride (replaces everything if set) */
+    overridePatterns?: string[];
+    /** config.git.disableAgentPatternRegistry - skips network fetch (airgapped mode) */
+    disableAgentPatternRegistry?: boolean;
+    /** Override cache directory (passed to fetcher) */
+    cacheDir?: string;
+    /** Fetch timeout in milliseconds (passed to fetcher) */
+    timeoutMs?: number;
+}
 /**
  * Get the default cache directory
  *
@@ -44,10 +82,70 @@ export declare function getCacheDir(): string;
  * ```
  */
 export declare function getAgentPatterns(options?: GetAgentPatternsOptions): Promise<string[]>;
+/**
+ * Resolve agent branch patterns based on config with merge/override/airgapped support
+ *
+ * Behavior matrix (WU-1089):
+ *
+ * | disableRegistry | override patterns | config patterns | Result                 | Source        |
+ * |-----------------|-------------------|-----------------|------------------------|---------------|
+ * | false           | undefined         | undefined/[]    | registry               | 'registry'    |
+ * | false           | undefined         | ['custom/*']    | config + registry      | 'merged'      |
+ * | false           | ['only/*']        | any             | override only          | 'override'    |
+ * | true            | undefined         | undefined/[]    | defaults               | 'defaults'    |
+ * | true            | undefined         | ['custom/*']    | config only            | 'config'      |
+ * | true            | ['only/*']        | any             | override only          | 'override'    |
+ *
+ * When registry fetch fails:
+ * - Falls back to config patterns if provided, source = 'config'
+ * - Falls back to defaults if no config, source = 'defaults'
+ *
+ * @param options - Resolution options
+ * @returns Result with patterns, source, and registryFetched flag
+ *
+ * @example Default (fetch from registry)
+ * ```typescript
+ * const result = await resolveAgentPatterns({});
+ * // result.patterns = ['claude/*', 'codex/*', ...] (from registry)
+ * // result.source = 'registry'
+ * // result.registryFetched = true
+ * ```
+ *
+ * @example Merge mode (config + registry)
+ * ```typescript
+ * const result = await resolveAgentPatterns({
+ *   configPatterns: ['my-agent/*'],
+ * });
+ * // result.patterns = ['my-agent/*', 'claude/*', 'codex/*', ...]
+ * // result.source = 'merged'
+ * // result.registryFetched = true
+ * ```
+ *
+ * @example Override mode (explicit replacement)
+ * ```typescript
+ * const result = await resolveAgentPatterns({
+ *   overridePatterns: ['only-this/*'],
+ * });
+ * // result.patterns = ['only-this/*']
+ * // result.source = 'override'
+ * // result.registryFetched = false
+ * ```
+ *
+ * @example Airgapped mode (no network)
+ * ```typescript
+ * const result = await resolveAgentPatterns({
+ *   disableAgentPatternRegistry: true,
+ *   configPatterns: ['my-agent/*'],
+ * });
+ * // result.patterns = ['my-agent/*']
+ * // result.source = 'config'
+ * // result.registryFetched = false
+ * ```
+ */
+export declare function resolveAgentPatterns(options?: ResolveAgentPatternsOptions): Promise<AgentPatternResult>;
 /**
  * Clear the in-memory cache
  *
  * Used primarily for testing.
  */
 export declare function clearCache(): void;
-export {};

package/dist/agent-patterns-registry.js

@@ -5,6 +5,8 @@
  * that bypass worktree requirements. Static JSON served from lumenflow.dev,
  * cached locally for 7 days with fallback to defaults.
  *
+ * WU-1089: Added merge/override/airgapped modes via resolveAgentPatterns()
+ *
  * @module agent-patterns-registry
  */
 import * as fs from 'node:fs';
@@ -179,6 +181,128 @@ export async function getAgentPatterns(options = {}) {
     // No cache, no network - use defaults
     return DEFAULT_AGENT_PATTERNS;
 }
+/**
+ * Resolve agent branch patterns based on config with merge/override/airgapped support
+ *
+ * Behavior matrix (WU-1089):
+ *
+ * | disableRegistry | override patterns | config patterns | Result                 | Source        |
+ * |-----------------|-------------------|-----------------|------------------------|---------------|
+ * | false           | undefined         | undefined/[]    | registry               | 'registry'    |
+ * | false           | undefined         | ['custom/*']    | config + registry      | 'merged'      |
+ * | false           | ['only/*']        | any             | override only          | 'override'    |
+ * | true            | undefined         | undefined/[]    | defaults               | 'defaults'    |
+ * | true            | undefined         | ['custom/*']    | config only            | 'config'      |
+ * | true            | ['only/*']        | any             | override only          | 'override'    |
+ *
+ * When registry fetch fails:
+ * - Falls back to config patterns if provided, source = 'config'
+ * - Falls back to defaults if no config, source = 'defaults'
+ *
+ * @param options - Resolution options
+ * @returns Result with patterns, source, and registryFetched flag
+ *
+ * @example Default (fetch from registry)
+ * ```typescript
+ * const result = await resolveAgentPatterns({});
+ * // result.patterns = ['claude/*', 'codex/*', ...] (from registry)
+ * // result.source = 'registry'
+ * // result.registryFetched = true
+ * ```
+ *
+ * @example Merge mode (config + registry)
+ * ```typescript
+ * const result = await resolveAgentPatterns({
+ *   configPatterns: ['my-agent/*'],
+ * });
+ * // result.patterns = ['my-agent/*', 'claude/*', 'codex/*', ...]
+ * // result.source = 'merged'
+ * // result.registryFetched = true
+ * ```
+ *
+ * @example Override mode (explicit replacement)
+ * ```typescript
+ * const result = await resolveAgentPatterns({
+ *   overridePatterns: ['only-this/*'],
+ * });
+ * // result.patterns = ['only-this/*']
+ * // result.source = 'override'
+ * // result.registryFetched = false
+ * ```
+ *
+ * @example Airgapped mode (no network)
+ * ```typescript
+ * const result = await resolveAgentPatterns({
+ *   disableAgentPatternRegistry: true,
+ *   configPatterns: ['my-agent/*'],
+ * });
+ * // result.patterns = ['my-agent/*']
+ * // result.source = 'config'
+ * // result.registryFetched = false
+ * ```
+ */
+export async function resolveAgentPatterns(options = {}) {
+    const { registryFetcher = getAgentPatterns, configPatterns, overridePatterns, disableAgentPatternRegistry = false, cacheDir, timeoutMs, } = options;
+    // Scenario 3/6: Override mode - overridePatterns replaces everything
+    if (overridePatterns && overridePatterns.length > 0) {
+        return {
+            patterns: overridePatterns,
+            source: 'override',
+            registryFetched: false,
+        };
+    }
+    // Scenario 4/5: Airgapped mode - disableAgentPatternRegistry skips network
+    if (disableAgentPatternRegistry) {
+        const hasConfigPatterns = configPatterns && configPatterns.length > 0;
+        return {
+            patterns: hasConfigPatterns ? configPatterns : DEFAULT_AGENT_PATTERNS,
+            source: hasConfigPatterns ? 'config' : 'defaults',
+            registryFetched: false,
+        };
+    }
+    // Scenario 1/2: Normal mode - fetch from registry, optionally merge with config
+    const hasConfigPatterns = configPatterns && configPatterns.length > 0;
+    // Try to fetch from registry
+    let registryPatterns = null;
+    let fetchedSuccessfully = false;
+    try {
+        registryPatterns = await registryFetcher({ cacheDir, timeoutMs });
+        fetchedSuccessfully = registryPatterns !== null && registryPatterns.length > 0;
+    }
+    catch {
+        // Fetch failed - will use fallback below
+        fetchedSuccessfully = false;
+    }
+    // If registry fetch succeeded
+    if (fetchedSuccessfully && registryPatterns) {
+        if (hasConfigPatterns) {
+            // Scenario 2: Merge mode - config first, then registry (deduplicated)
+            const merged = [...configPatterns];
+            for (const pattern of registryPatterns) {
+                if (!merged.includes(pattern)) {
+                    merged.push(pattern);
+                }
+            }
+            return {
+                patterns: merged,
+                source: 'merged',
+                registryFetched: true,
+            };
+        }
+        // Scenario 1: Registry only
+        return {
+            patterns: registryPatterns,
+            source: 'registry',
+            registryFetched: true,
+        };
+    }
+    // Registry fetch failed - fallback to config or defaults
+    return {
+        patterns: hasConfigPatterns ? configPatterns : DEFAULT_AGENT_PATTERNS,
+        source: hasConfigPatterns ? 'config' : 'defaults',
+        registryFetched: false,
+    };
+}
 /**
  * Clear the in-memory cache
  *

package/dist/arg-parser.js

@@ -247,6 +247,13 @@ export const WU_OPTIONS = {
         flags: '--color',
         description: 'Enable colored output',
     },
+    // WU-1085: NO_COLOR standard support (https://no-color.org/)
+    noColor: {
+        name: 'noColor',
+        flags: '--no-color',
+        description: 'Disable colored output (respects NO_COLOR env var)',
+        isNegated: true,
+    },
     status: {
         name: 'status',
         flags: '--status <status>',

package/dist/branch-check.d.ts

@@ -4,14 +4,19 @@
  * Provides functions to check if a branch is an agent branch that can
  * bypass worktree requirements, and if headless mode is allowed.
  *
+ * WU-1089: Updated to use resolveAgentPatterns with merge/override/airgapped support.
+ *
  * @module branch-check
  */
+import { type AgentPatternResult } from './agent-patterns-registry.js';
 /**
  * Check if branch is an agent branch that can bypass worktree requirements.
  *
- * Uses the central registry for agent patterns (fetched from lumenflow.dev
- * with 7-day cache), falling back to config patterns if specified, then
- * to defaults.
+ * WU-1089: Now uses resolveAgentPatterns with proper merge/override/airgapped support:
+ * - Default: Fetches from registry (lumenflow.dev) with 7-day cache
+ * - Config patterns merge with registry patterns (config first)
+ * - Override patterns (agentBranchPatternsOverride) replace everything
+ * - Airgapped mode (disableAgentPatternRegistry) skips network fetch
  *
  * @param branch - Branch name to check
  * @returns Promise<true> if branch matches agent patterns
@@ -24,12 +29,36 @@
  * ```
  */
 export declare function isAgentBranch(branch: string | null | undefined): Promise<boolean>;
+/**
+ * Check if branch is an agent branch with full result details.
+ *
+ * Same as isAgentBranch but returns the full AgentPatternResult
+ * for observability and debugging.
+ *
+ * @param branch - Branch name to check
+ * @returns Promise with match result and pattern resolution details
+ *
+ * @example
+ * ```typescript
+ * const result = await isAgentBranchWithDetails('claude/session-123');
+ * if (result.isMatch) {
+ *   console.log(`Matched via ${result.patternResult.source}`);
+ *   console.log(`Registry fetched: ${result.patternResult.registryFetched}`);
+ * }
+ * ```
+ */
+export declare function isAgentBranchWithDetails(branch: string | null | undefined): Promise<{
+    isMatch: boolean;
+    patternResult: AgentPatternResult;
+}>;
 /**
  * Synchronous version of isAgentBranch for backwards compatibility.
  *
  * Uses only local config patterns or defaults - does NOT fetch from registry.
  * Prefer async isAgentBranch() when possible.
  *
+ * WU-1089: Updated to respect override and disable flags, but cannot fetch from registry.
+ *
  * @param branch - Branch name to check
  * @returns True if branch matches agent patterns
  *

package/dist/branch-check.js

@@ -4,11 +4,13 @@
  * Provides functions to check if a branch is an agent branch that can
  * bypass worktree requirements, and if headless mode is allowed.
  *
+ * WU-1089: Updated to use resolveAgentPatterns with merge/override/airgapped support.
+ *
  * @module branch-check
  */
 import micromatch from 'micromatch';
 import { getConfig } from './lumenflow-config.js';
-import { getAgentPatterns, DEFAULT_AGENT_PATTERNS } from './agent-patterns-registry.js';
+import { resolveAgentPatterns, DEFAULT_AGENT_PATTERNS, } from './agent-patterns-registry.js';
 /** Legacy protected branch (always protected regardless of mainBranch setting) */
 const LEGACY_PROTECTED = 'master';
 /**
@@ -36,9 +38,11 @@ function getProtectedBranches() {
 /**
  * Check if branch is an agent branch that can bypass worktree requirements.
  *
- * Uses the central registry for agent patterns (fetched from lumenflow.dev
- * with 7-day cache), falling back to config patterns if specified, then
- * to defaults.
+ * WU-1089: Now uses resolveAgentPatterns with proper merge/override/airgapped support:
+ * - Default: Fetches from registry (lumenflow.dev) with 7-day cache
+ * - Config patterns merge with registry patterns (config first)
+ * - Override patterns (agentBranchPatternsOverride) replace everything
+ * - Airgapped mode (disableAgentPatternRegistry) skips network fetch
  *
  * @param branch - Branch name to check
  * @returns Promise<true> if branch matches agent patterns
@@ -66,18 +70,73 @@ export async function isAgentBranch(branch) {
     // LumenFlow lane branches require worktrees (uses config's laneBranchPrefix)
     if (getLaneBranchPattern().test(branch))
         return false;
-    // Get patterns: prefer config override, then registry, then defaults
-    let patterns;
-    if (config?.git?.agentBranchPatterns?.length > 0) {
-        // Config has explicit patterns - use those
-        patterns = config.git.agentBranchPatterns;
+    // WU-1089: Use resolveAgentPatterns with full merge/override/airgapped support
+    const result = await resolveAgentPatterns({
+        configPatterns: config?.git?.agentBranchPatterns,
+        overridePatterns: config?.git?.agentBranchPatternsOverride,
+        disableAgentPatternRegistry: config?.git?.disableAgentPatternRegistry,
+    });
+    // Use micromatch for proper glob matching
+    return micromatch.isMatch(branch, result.patterns);
+}
+/**
+ * Check if branch is an agent branch with full result details.
+ *
+ * Same as isAgentBranch but returns the full AgentPatternResult
+ * for observability and debugging.
+ *
+ * @param branch - Branch name to check
+ * @returns Promise with match result and pattern resolution details
+ *
+ * @example
+ * ```typescript
+ * const result = await isAgentBranchWithDetails('claude/session-123');
+ * if (result.isMatch) {
+ *   console.log(`Matched via ${result.patternResult.source}`);
+ *   console.log(`Registry fetched: ${result.patternResult.registryFetched}`);
+ * }
+ * ```
+ */
+export async function isAgentBranchWithDetails(branch) {
+    // Fail-closed: no branch = protected
+    if (!branch) {
+        return {
+            isMatch: false,
+            patternResult: { patterns: [], source: 'defaults', registryFetched: false },
+        };
     }
-    else {
-        // Fetch from registry (with caching and fallback to defaults)
-        patterns = await getAgentPatterns();
+    // Detached HEAD = protected (fail-closed)
+    if (branch === 'HEAD') {
+        return {
+            isMatch: false,
+            patternResult: { patterns: [], source: 'defaults', registryFetched: false },
+        };
     }
-    // Use micromatch for proper glob matching
-    return micromatch.isMatch(branch, patterns);
+    // Load config
+    const config = getConfig();
+    const protectedBranches = getProtectedBranches();
+    // Protected branches are NEVER bypassed
+    if (protectedBranches.includes(branch)) {
+        return {
+            isMatch: false,
+            patternResult: { patterns: [], source: 'defaults', registryFetched: false },
+        };
+    }
+    // Lane branches require worktrees
+    if (getLaneBranchPattern().test(branch)) {
+        return {
+            isMatch: false,
+            patternResult: { patterns: [], source: 'defaults', registryFetched: false },
+        };
+    }
+    // Resolve patterns with full details
+    const patternResult = await resolveAgentPatterns({
+        configPatterns: config?.git?.agentBranchPatterns,
+        overridePatterns: config?.git?.agentBranchPatternsOverride,
+        disableAgentPatternRegistry: config?.git?.disableAgentPatternRegistry,
+    });
+    const isMatch = micromatch.isMatch(branch, patternResult.patterns);
+    return { isMatch, patternResult };
 }
 /**
  * Synchronous version of isAgentBranch for backwards compatibility.
@@ -85,6 +144,8 @@ export async function isAgentBranch(branch) {
  * Uses only local config patterns or defaults - does NOT fetch from registry.
  * Prefer async isAgentBranch() when possible.
  *
+ * WU-1089: Updated to respect override and disable flags, but cannot fetch from registry.
+ *
  * @param branch - Branch name to check
  * @returns True if branch matches agent patterns
  *
@@ -106,7 +167,12 @@ export function isAgentBranchSync(branch) {
     // LumenFlow lane branches require worktrees (uses config's laneBranchPrefix)
     if (getLaneBranchPattern().test(branch))
         return false;
-    // Use config patterns or defaults (no registry fetch in sync version)
+    // WU-1089: Check override first
+    if (config?.git?.agentBranchPatternsOverride?.length) {
+        return micromatch.isMatch(branch, config.git.agentBranchPatternsOverride);
+    }
+    // Use config patterns if provided, otherwise defaults
+    // Note: sync version cannot fetch from registry
     const patterns = config?.git?.agentBranchPatterns?.length > 0
         ? config.git.agentBranchPatterns
         : DEFAULT_AGENT_PATTERNS;

package/dist/color-support.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @file color-support.ts
+ * Color control for CLI commands (WU-1085)
+ *
+ * Respects standard environment variables and CLI flags:
+ * - NO_COLOR: Disable colors (https://no-color.org/)
+ * - FORCE_COLOR: Override color level 0-3 (chalk standard)
+ * - --no-color: CLI flag to disable colors
+ *
+ * @see https://no-color.org/
+ * @see https://github.com/chalk/chalk#supportscolor
+ */
+/**
+ * Get the current color level.
+ * @returns Color level 0-3 (0 = no colors, 3 = full 16m colors)
+ */
+export declare function getColorLevel(): number;
+/**
+ * Initialize color support respecting NO_COLOR and FORCE_COLOR standards.
+ * Call this before any colored output.
+ *
+ * Priority order:
+ * 1. NO_COLOR env var (always wins, per spec)
+ * 2. --no-color CLI flag
+ * 3. FORCE_COLOR env var
+ * 4. Default chalk detection
+ *
+ * @param argv - Command line arguments (defaults to process.argv)
+ * @see https://no-color.org/
+ * @see https://github.com/chalk/chalk#supportscolor
+ */
+export declare function initColorSupport(argv?: string[]): void;