@invisiblecities/sidequest-cqo/dist/services/unified-orchestrator.d.ts

Configuration-agnostic TypeScript and ESLint orchestrator with real-time watch mode, SQLite persistence, and intelligent terminal detection

/**
 * Unified Code Quality Orchestrator
 *
 * Combines the analysis capabilities of CodeQualityOrchestrator with the
 * service management and persistence capabilities of OrchestratorService.
 * This replaces both legacy systems with a single, unified orchestrator.
 */
import { EventEmitter } from "node:events";
import type { IOrchestratorService, IStorageService, IPollingService, IAnalysisService, IViolationTracker, WatchModeOptions, OrchestratorConfig, HealthCheckResult, SystemStats, RuleCheckResult } from "./interfaces.js";
import { ConfigManager } from "./config-manager.js";
import { BaseAuditEngine } from "../engines/base-engine.js";
import type { OrchestratorResult, EngineConfig, WatchEvent, WatchEventData, CrossoverConfig } from "../utils/violation-types.js";
/**
 * Unified orchestrator configuration combining both systems
 */
export interface UnifiedOrchestratorConfig {
    targetPath: string;
    engines: {
        typescript?: EngineConfig;
        eslint?: EngineConfig;
        unusedExports?: EngineConfig;
        zodDetection?: EngineConfig;
        archaeology?: EngineConfig;
    };
    deduplication?: {
        enabled: boolean;
        strategy: "exact" | "similar" | "location";
    };
    crossover?: CrossoverConfig;
    output?: {
        console: boolean;
        json?: string;
        html?: string;
    };
    database: {
        path: string;
        enableWAL: boolean;
        maxHistoryDays: number;
    };
    polling: {
        defaultFrequencyMs: number;
        maxConcurrentChecks: number;
        adaptivePolling: boolean;
    };
    watch: {
        intervalMs: number;
        debounceMs: number;
        autoCleanup: boolean;
    };
    performance: {
        batchSize: number;
        enableMetrics: boolean;
    };
}
/**
 * Unified interface combining analysis and service capabilities
 */
export interface IUnifiedOrchestrator extends IOrchestratorService {
    analyze(_targetPath?: string): Promise<OrchestratorResult>;
    addEngine(_name: string, _engine: BaseAuditEngine): void;
    removeEngine(_name: string): void;
    getEngine(_name: string): BaseAuditEngine | undefined;
    getEngineMetadata(): Record<string, unknown>;
    updateUnifiedConfig(_config: Partial<UnifiedOrchestratorConfig>): Promise<void>;
    getUnifiedConfig(): UnifiedOrchestratorConfig;
    addWatchEventListener(_event: WatchEvent, _callback: (_data: WatchEventData) => void): void;
    emit(_event: WatchEvent, _data: any): void;
}
/**
 * Unified Code Quality Orchestrator Implementation
 *
 * This class merges the capabilities of both legacy orchestrators:
 * - Direct analysis execution with multi-engine coordination
 * - Service management with SQLite persistence
 * - Watch mode with real-time monitoring
 * - Configuration management and health monitoring
 */
export declare class UnifiedOrchestrator extends EventEmitter implements IUnifiedOrchestrator {
    private configManager;
    private storageService;
    private pollingService;
    private analysisService;
    private violationTracker;
    private engines;
    private unifiedConfig;
    private initialized;
    private watchModeActive;
    private watchModeInterval;
    private silent;
    private eventListeners;
    constructor(config: UnifiedOrchestratorConfig, configManager?: ConfigManager);
    initialize(): Promise<void>;
    shutdown(): Promise<void>;
    /**
     * Execute all enabled engines and return unified results
     * This is the core analysis method from the legacy orchestrator
     */
    analyze(targetPath?: string): Promise<OrchestratorResult>;
    /**
     * Initialize audit engines based on configuration
     */
    private initializeEngines;
    addEngine(name: string, engine: BaseAuditEngine): void;
    removeEngine(name: string): void;
    getEngine(name: string): BaseAuditEngine | undefined;
    getEngineMetadata(): Record<string, unknown>;
    startWatchMode(options?: WatchModeOptions): Promise<void>;
    stopWatchMode(): Promise<void>;
    isWatchModeActive(): boolean;
    getStorageService(): IStorageService;
    getPollingService(): IPollingService;
    getAnalysisService(): IAnalysisService;
    getViolationTracker(): IViolationTracker;
    setSilentMode(silent: boolean): void;
    runSingleCheck(rule: string, engine: "typescript" | "eslint"): Promise<RuleCheckResult>;
    runAllChecks(): Promise<RuleCheckResult[]>;
    updateConfiguration(config: Partial<OrchestratorConfig>): Promise<void>;
    updateUnifiedConfig(config: Partial<UnifiedOrchestratorConfig>): Promise<void>;
    getConfiguration(): OrchestratorConfig;
    getUnifiedConfig(): UnifiedOrchestratorConfig;
    healthCheck(): Promise<HealthCheckResult>;
    getSystemStats(): Promise<SystemStats>;
    addWatchEventListener(_event: WatchEvent, _callback: (_data: WatchEventData) => void): void;
    private emitEvent;
    private ensureInitialized;
    private executeWatchCycle;
    /**
     * Merge violations from multiple engines (from legacy orchestrator)
     */
    private mergeViolations;
    /**
     * Deduplicate violations based on configuration (from legacy orchestrator)
     */
    private deduplicateViolations;
    /**
     * Generate summary statistics (from legacy orchestrator)
     */
    private generateSummary;
    /**
     * Persist analysis results to storage service
     */
    private persistAnalysisResults;
}
/**
 * Get or create unified orchestrator service instance
 */
export declare function getUnifiedOrchestrator(config: UnifiedOrchestratorConfig, configManager?: ConfigManager): UnifiedOrchestrator;
/**
 * Reset unified orchestrator service instance (useful for testing)
 */
export declare function resetUnifiedOrchestrator(): void;
/**
 * Create a fully configured unified orchestrator for a specific environment
 */
export declare function createUnifiedOrchestrator(config: UnifiedOrchestratorConfig, environment?: "development" | "test" | "production"): Promise<UnifiedOrchestrator>;
/**
 * Create default unified orchestrator configuration
 */
export declare function createDefaultUnifiedConfig(targetPath: string): UnifiedOrchestratorConfig;
//# sourceMappingURL=unified-orchestrator.d.ts.map