woaru/dist/core/HookSystem.d.ts

Universal Project Setup Autopilot - Analyze and automatically configure development tools for ANY programming language

import { EventEmitter } from 'events';
/**
 * 🎣 WOARU Hook System - Event-basierte Erweiterbarkeit
 *
 * Das Hook-System macht den QualityRunner und andere Komponenten modularer
 * und ermöglicht die einfache Erweiterung der Analyse-Pipeline.
 *
 * Teil der "KI-freundlichen Regelwelt" - definierte Erweiterungspunkte.
 */
export type HookEvent = 'beforeAnalysis' | 'afterAnalysis' | 'beforeFileAnalysis' | 'afterFileAnalysis' | 'beforeToolExecution' | 'afterToolExecution' | 'onError' | 'onConfigLoad' | 'onReportGeneration';
export interface BeforeAnalysisData {
    files: string[];
    projectPath: string;
    config: any;
    timestamp: Date;
}
export interface AfterAnalysisData {
    files: string[];
    results: any[];
    duration: number;
    timestamp: Date;
    success: boolean;
}
export interface BeforeFileAnalysisData {
    filePath: string;
    language: string;
    fileSize: number;
    timestamp: Date;
}
export interface AfterFileAnalysisData {
    filePath: string;
    language: string;
    results: any[];
    duration: number;
    timestamp: Date;
    success: boolean;
}
export interface BeforeToolExecutionData {
    toolName: string;
    filePath: string;
    command: string;
    timestamp: Date;
}
export interface AfterToolExecutionData {
    toolName: string;
    filePath: string;
    command: string;
    output: string;
    exitCode: number;
    duration: number;
    timestamp: Date;
    success: boolean;
}
export interface ErrorHookData {
    error: Error;
    context: string;
    filePath?: string;
    toolName?: string;
    timestamp: Date;
}
export interface ConfigLoadHookData {
    configType: 'ai' | 'tools' | 'user';
    configPath: string;
    configData: any;
    timestamp: Date;
}
export interface ReportGenerationData {
    reportType: string;
    data: any;
    outputPath?: string;
    timestamp: Date;
}
export type HookData = BeforeAnalysisData | AfterAnalysisData | BeforeFileAnalysisData | AfterFileAnalysisData | BeforeToolExecutionData | AfterToolExecutionData | ErrorHookData | ConfigLoadHookData | ReportGenerationData;
export type HookHandler<T extends HookData = HookData> = (data: T) => Promise<void> | void;
/**
 * 🎣 WOARU Hook Manager
 *
 * Zentrale Verwaltung für alle Hook-Registrierungen und -Ausführungen.
 * Basiert auf Node.js EventEmitter für maximale Kompatibilität.
 */
export declare class HookManager extends EventEmitter {
    private static instance;
    private hookStats;
    private debugMode;
    private constructor();
    static getInstance(): HookManager;
    /**
     * 🔗 Hook registrieren
     *
     * @param event Hook-Event Name
     * @param handler Handler-Funktion
     * @param priority Priorität (höhere Zahl = frühere Ausführung)
     */
    registerHook<T extends HookData>(event: HookEvent, handler: HookHandler<T>, priority?: number): void;
    /**
     * 🚀 Hook auslösen
     *
     * Alle registrierten Handler für das Event werden parallel ausgeführt,
     * sortiert nach Priorität (höchste zuerst).
     *
     * @param event Hook-Event Name
     * @param data Event-Daten
     */
    triggerHook<T extends HookData>(event: HookEvent, data: T): Promise<void>;
    /**
     * 🗑️ Hook entfernen
     */
    unregisterHook(event: HookEvent, handler: HookHandler): void;
    /**
     * 🧹 Alle Hooks eines Events entfernen
     */
    clearHooks(event?: HookEvent): void;
    /**
     * 📊 Hook-Statistiken
     */
    getHookStats(): Record<string, number>;
    /**
     * 📋 Registrierte Hooks auflisten
     */
    listRegisteredHooks(): Record<string, number>;
    /**
     * 🐛 Debug-Modus umschalten
     */
    setDebugMode(enabled: boolean): void;
    private incrementHookStats;
}
/**
 * 🎯 Hook Utilities - Hilfs-Funktionen für häufige Hook-Patterns
 */
export declare class HookUtils {
    /**
     * Erstelle einen Hook-Handler mit automatischem Error-Handling
     */
    static createSafeHandler<T extends HookData>(handler: HookHandler<T>, context: string): HookHandler<T>;
    /**
     * Erstelle einen konditionalen Hook-Handler
     */
    static createConditionalHandler<T extends HookData>(condition: (data: T) => boolean, handler: HookHandler<T>): HookHandler<T>;
    /**
     * Erstelle einen Rate-Limited Hook-Handler
     */
    static createRateLimitedHandler<T extends HookData>(handler: HookHandler<T>, intervalMs: number): HookHandler<T>;
}
export declare const hookManager: HookManager;
export declare const registerHook: <T extends HookData>(event: HookEvent, handler: HookHandler<T>, priority?: number) => void;
export declare const triggerHook: <T extends HookData>(event: HookEvent, data: T) => Promise<void>;
export declare const unregisterHook: (event: HookEvent, handler: HookHandler) => void;
export declare const clearHooks: (event?: HookEvent) => void;
//# sourceMappingURL=HookSystem.d.ts.map