/**
 * Agentic QE v3 - QE ReasoningBank
 * ADR-021: QE ReasoningBank for Pattern Learning
 *
 * QE-specific pattern learning system that extends the concept from
 * claude-flow's ReasoningBank with quality engineering domains.
 *
 * Features:
 * - 8 QE domains for pattern classification
 * - HNSW vector indexing (150x faster search)
 * - Pattern quality scoring with outcome tracking
 * - Short-term to long-term promotion (3+ successful uses)
 * - Domain-specific guidance generation
 * - Agent routing via pattern similarity
 */
import type { MemoryBackend, EventBus } from '../kernel/interfaces.js';
import type { Result } from '../shared/types/index.js';
import { QEPattern, QEPatternContext, QEDomain, ProgrammingLanguage, TestFramework, CreateQEPatternOptions } from './qe-patterns.js';
import { QEGuidance, checkAntiPatterns } from './qe-guidance.js';
import { PatternSearchOptions, PatternSearchResult } from './pattern-store.js';
/**
 * QEReasoningBank configuration
 */
export interface QEReasoningBankConfig {
    /** Enable pattern learning */
    enableLearning: boolean;
    /** Enable guidance generation */
    enableGuidance: boolean;
    /** Enable task routing */
    enableRouting: boolean;
    /** Embedding dimension (must match HNSW config) */
    embeddingDimension: number;
    /** Use ONNX embeddings (when available) */
    useONNXEmbeddings: boolean;
    /** Maximum patterns to consider for routing */
    maxRoutingCandidates: number;
    /** Weights for routing score calculation */
    routingWeights: {
        similarity: number;
        performance: number;
        capabilities: number;
    };
    /** Pattern store configuration */
    patternStore?: Partial<import('./pattern-store.js').PatternStoreConfig>;
}
/**
 * Default configuration
 */
export declare const DEFAULT_QE_REASONING_BANK_CONFIG: QEReasoningBankConfig;
/**
 * Task routing request
 */
export interface QERoutingRequest {
    /** Task description */
    task: string;
    /** Task type hint */
    taskType?: 'test-generation' | 'analysis' | 'debugging' | 'optimization';
    /** Target domain hint */
    domain?: QEDomain;
    /** Required capabilities */
    capabilities?: string[];
    /** Context for matching */
    context?: Partial<QEPatternContext>;
}
/**
 * Task routing result
 */
export interface QERoutingResult {
    /** Recommended agent type */
    recommendedAgent: string;
    /** Confidence in recommendation (0-1) */
    confidence: number;
    /** Alternative agent recommendations */
    alternatives: Array<{
        agent: string;
        score: number;
    }>;
    /** Detected QE domains */
    domains: QEDomain[];
    /** Relevant patterns found */
    patterns: QEPattern[];
    /** Generated guidance */
    guidance: string[];
    /** Reasoning for the recommendation */
    reasoning: string;
}
/**
 * Pattern learning outcome
 */
export interface LearningOutcome {
    /** Pattern ID that was used */
    patternId: string;
    /** Whether the application was successful */
    success: boolean;
    /** Quality metrics from the outcome */
    metrics?: {
        testsPassed?: number;
        testsFailed?: number;
        coverageImprovement?: number;
        executionTimeMs?: number;
    };
    /** Feedback from the agent or user */
    feedback?: string;
}
/**
 * QEReasoningBank interface
 */
export interface IQEReasoningBank {
    /** Initialize the reasoning bank */
    initialize(): Promise<void>;
    /** Store a new pattern */
    storePattern(options: CreateQEPatternOptions): Promise<Result<QEPattern>>;
    /** Search for patterns */
    searchPatterns(query: string | number[], options?: PatternSearchOptions): Promise<Result<PatternSearchResult[]>>;
    /** Get pattern by ID */
    getPattern(id: string): Promise<QEPattern | null>;
    /** Record pattern usage outcome */
    recordOutcome(outcome: LearningOutcome): Promise<Result<void>>;
    /** Route a task to optimal agent */
    routeTask(request: QERoutingRequest): Promise<Result<QERoutingResult>>;
    /** Get guidance for a domain */
    getGuidance(domain: QEDomain, context?: Partial<QEPatternContext>): QEGuidance;
    /** Generate guidance context for Claude */
    generateContext(domain: QEDomain, context?: {
        framework?: TestFramework;
        language?: ProgrammingLanguage;
    }): string;
    /** Check for anti-patterns in content */
    checkAntiPatterns(domain: QEDomain, content: string): ReturnType<typeof checkAntiPatterns>;
    /** Get embedding for text */
    embed(text: string): Promise<number[]>;
    /** Get statistics */
    getStats(): Promise<QEReasoningBankStats>;
    /** Dispose the reasoning bank */
    dispose(): Promise<void>;
}
/**
 * QEReasoningBank statistics
 */
export interface QEReasoningBankStats {
    /** Total patterns */
    totalPatterns: number;
    /** Patterns by domain */
    byDomain: Record<QEDomain, number>;
    /** Routing requests served */
    routingRequests: number;
    /** Average routing confidence */
    avgRoutingConfidence: number;
    /** Learning outcomes recorded */
    learningOutcomes: number;
    /** Pattern success rate */
    patternSuccessRate: number;
    /** Pattern store stats */
    patternStoreStats: import('./pattern-store.js').PatternStoreStats;
}
/**
 * QE ReasoningBank - Pattern learning for quality engineering
 *
 * @example
 * ```typescript
 * const bank = new QEReasoningBank(memory);
 * await bank.initialize();
 *
 * // Store a pattern
 * await bank.storePattern({
 *   patternType: 'test-template',
 *   name: 'AAA Unit Test',
 *   description: 'Arrange-Act-Assert pattern for unit tests',
 *   template: { type: 'code', content: '...', variables: [] },
 * });
 *
 * // Route a task
 * const routing = await bank.routeTask({
 *   task: 'Generate unit tests for UserService',
 *   context: { language: 'typescript', framework: 'vitest' },
 * });
 * ```
 */
export declare class QEReasoningBank implements IQEReasoningBank {
    private readonly memory;
    private readonly eventBus?;
    private readonly config;
    private patternStore;
    private initialized;
    private stats;
    private readonly agentCapabilities;
    constructor(memory: MemoryBackend, eventBus?: EventBus | undefined, config?: Partial<QEReasoningBankConfig>);
    /**
     * Initialize the reasoning bank
     */
    initialize(): Promise<void>;
    /**
     * Load pre-trained patterns for common QE scenarios
     */
    private loadPretrainedPatterns;
    /**
     * Store a new pattern
     */
    storePattern(options: CreateQEPatternOptions): Promise<Result<QEPattern>>;
    /**
     * Search for patterns
     */
    searchPatterns(query: string | number[], options?: PatternSearchOptions): Promise<Result<PatternSearchResult[]>>;
    /**
     * Get pattern by ID
     */
    getPattern(id: string): Promise<QEPattern | null>;
    /**
     * Record pattern usage outcome
     */
    recordOutcome(outcome: LearningOutcome): Promise<Result<void>>;
    /**
     * Route a task to optimal agent
     */
    routeTask(request: QERoutingRequest): Promise<Result<QERoutingResult>>;
    /**
     * Get guidance for a domain
     */
    getGuidance(domain: QEDomain, _context?: Partial<QEPatternContext>): QEGuidance;
    /**
     * Generate guidance context for Claude
     */
    generateContext(domain: QEDomain, context?: {
        framework?: TestFramework;
        language?: ProgrammingLanguage;
    }): string;
    /**
     * Check for anti-patterns
     */
    checkAntiPatterns(domain: QEDomain, content: string): import("./qe-guidance.js").AntiPattern[];
    /**
     * Generate embedding for text
     *
     * Uses ONNX transformer embeddings when available, with hash-based fallback
     * for ARM64 or when transformers module cannot be loaded.
     */
    embed(text: string): Promise<number[]>;
    /**
     * Resize embedding to target dimension using averaging or truncation
     */
    private resizeEmbedding;
    /**
     * Simple hash-based embedding fallback
     */
    private hashEmbedding;
    /**
     * Get statistics
     */
    getStats(): Promise<QEReasoningBankStats>;
    /**
     * Dispose the reasoning bank
     */
    dispose(): Promise<void>;
}
/**
 * Create a new QEReasoningBank instance
 */
export declare function createQEReasoningBank(memory: MemoryBackend, eventBus?: EventBus, config?: Partial<QEReasoningBankConfig>): QEReasoningBank;
export { detectQEDomain, detectQEDomains, mapQEDomainToAQE, applyPatternTemplate, } from './qe-patterns.js';
export type { QEPattern, QEPatternType, QEDomain, QEPatternContext, ProgrammingLanguage, TestFramework, CreateQEPatternOptions, } from './qe-patterns.js';
export { getGuidance, getCombinedGuidance, generateGuidanceContext, } from './qe-guidance.js';
export type { QEGuidance } from './qe-guidance.js';
//# sourceMappingURL=qe-reasoning-bank.d.ts.map