driftdetect-core 0.1.0

package/dist/matcher/confidence-scorer.js

@@ -0,0 +1,302 @@
+/**
+ * Confidence Scorer - Pattern confidence calculation
+ *
+ * Calculates confidence scores based on frequency, consistency,
+ * age, and spread. Classifies patterns into confidence levels.
+ *
+ * The confidence score is a weighted combination of four factors:
+ * - Frequency: How often the pattern appears relative to applicable locations
+ * - Consistency: How consistent the pattern implementation is across occurrences
+ * - Age: How long the pattern has been observed (normalized)
+ * - Spread: How many files contain the pattern relative to total files
+ *
+ * @requirements 5.1 - Pattern confidence scoring with frequency, consistency, age, spread factors
+ * @requirements 5.2 - Confidence score SHALL be a decimal value between 0.0 and 1.0
+ * @requirements 5.3 - High confidence: score >= 0.85
+ * @requirements 5.4 - Medium confidence: score >= 0.70 and < 0.85
+ * @requirements 5.5 - Low confidence: score >= 0.50 and < 0.70
+ * @requirements 5.6 - Uncertain: score < 0.50
+ */
+import { CONFIDENCE_THRESHOLDS, DEFAULT_CONFIDENCE_WEIGHTS, } from './types.js';
+/**
+ * Default age normalization configuration
+ */
+export const DEFAULT_AGE_CONFIG = {
+    maxAgeDays: 30,
+    minAgeFactor: 0.1,
+};
+/**
+ * ConfidenceScorer class for calculating pattern confidence scores.
+ *
+ * Calculates a weighted confidence score from four factors:
+ * - Frequency: occurrences / totalLocations
+ * - Consistency: 1 - variance (inverted so higher is better)
+ * - Age: normalized based on days since first seen
+ * - Spread: fileCount / totalFiles
+ *
+ * The final score is classified into confidence levels:
+ * - High: score >= 0.85
+ * - Medium: score >= 0.70 and < 0.85
+ * - Low: score >= 0.50 and < 0.70
+ * - Uncertain: score < 0.50
+ *
+ * @requirements 5.1, 5.2, 5.3, 5.4, 5.5, 5.6
+ */
+export class ConfidenceScorer {
+    weights;
+    ageConfig;
+    /**
+     * Create a new ConfidenceScorer instance.
+     *
+     * @param weights - Optional custom weights for score calculation
+     * @param ageConfig - Optional custom age normalization configuration
+     */
+    constructor(weights, ageConfig) {
+        this.weights = {
+            ...DEFAULT_CONFIDENCE_WEIGHTS,
+            ...weights,
+        };
+        this.ageConfig = {
+            ...DEFAULT_AGE_CONFIG,
+            ...ageConfig,
+        };
+        // Validate weights sum to 1.0 (with small tolerance for floating point)
+        this.validateWeights();
+    }
+    /**
+     * Calculate the confidence score for a pattern.
+     *
+     * @param input - The input data for confidence calculation
+     * @returns The calculated confidence score with all factors
+     *
+     * @requirements 5.1 - Pattern confidence scoring with frequency, consistency, age, spread factors
+     * @requirements 5.2 - Confidence score SHALL be a decimal value between 0.0 and 1.0
+     */
+    calculateScore(input) {
+        // Calculate individual factors
+        const frequency = this.calculateFrequency(input.occurrences, input.totalLocations);
+        const consistency = this.calculateConsistency(input.variance);
+        const ageFactor = this.calculateAgeFactor(input.daysSinceFirstSeen);
+        const spread = this.calculateSpread(input.fileCount, input.totalFiles);
+        // Calculate weighted score
+        const weightedScore = frequency * this.weights.frequency +
+            consistency * this.weights.consistency +
+            ageFactor * this.weights.age +
+            spread * this.weights.spread;
+        // Clamp score to [0.0, 1.0] range
+        const score = this.clamp(weightedScore, 0.0, 1.0);
+        // Classify into confidence level
+        const level = this.classifyLevel(score);
+        return {
+            frequency,
+            consistency,
+            age: input.daysSinceFirstSeen,
+            spread: input.fileCount,
+            score,
+            level,
+        };
+    }
+    /**
+     * Calculate the frequency factor.
+     *
+     * Frequency = occurrences / totalLocations
+     * Represents how often the pattern appears relative to applicable locations.
+     *
+     * @param occurrences - Number of pattern occurrences
+     * @param totalLocations - Total applicable locations
+     * @returns Frequency factor (0.0 to 1.0)
+     *
+     * @requirements 5.1 - Frequency factor in confidence scoring
+     */
+    calculateFrequency(occurrences, totalLocations) {
+        // Handle edge cases
+        if (totalLocations <= 0) {
+            return 0.0;
+        }
+        if (occurrences <= 0) {
+            return 0.0;
+        }
+        // Calculate frequency ratio
+        const frequency = occurrences / totalLocations;
+        // Clamp to [0.0, 1.0] range
+        return this.clamp(frequency, 0.0, 1.0);
+    }
+    /**
+     * Calculate the consistency factor.
+     *
+     * Consistency = 1 - variance
+     * Higher consistency means less variance in pattern implementation.
+     * Variance should be normalized to [0.0, 1.0] range.
+     *
+     * @param variance - Variance in pattern implementation (0 = perfectly consistent)
+     * @returns Consistency factor (0.0 to 1.0)
+     *
+     * @requirements 5.1 - Consistency factor in confidence scoring
+     */
+    calculateConsistency(variance) {
+        // Handle edge cases
+        if (variance < 0) {
+            // Negative variance is invalid, treat as 0
+            return 1.0;
+        }
+        // Clamp variance to [0.0, 1.0] range
+        const clampedVariance = this.clamp(variance, 0.0, 1.0);
+        // Consistency is inverse of variance
+        return 1.0 - clampedVariance;
+    }
+    /**
+     * Calculate the age factor.
+     *
+     * Age factor is normalized based on days since first observation.
+     * Older patterns get higher scores (more established).
+     * Uses logarithmic scaling for diminishing returns after maxAgeDays.
+     *
+     * @param daysSinceFirstSeen - Days since pattern was first observed
+     * @returns Age factor (0.0 to 1.0)
+     *
+     * @requirements 5.1 - Age factor in confidence scoring
+     */
+    calculateAgeFactor(daysSinceFirstSeen) {
+        // Handle edge cases
+        if (daysSinceFirstSeen <= 0) {
+            return this.ageConfig.minAgeFactor;
+        }
+        // Linear scaling up to maxAgeDays
+        if (daysSinceFirstSeen >= this.ageConfig.maxAgeDays) {
+            return 1.0;
+        }
+        // Calculate normalized age factor
+        const normalizedAge = daysSinceFirstSeen / this.ageConfig.maxAgeDays;
+        // Scale between minAgeFactor and 1.0
+        const ageFactor = this.ageConfig.minAgeFactor +
+            normalizedAge * (1.0 - this.ageConfig.minAgeFactor);
+        return this.clamp(ageFactor, 0.0, 1.0);
+    }
+    /**
+     * Calculate the spread factor.
+     *
+     * Spread = fileCount / totalFiles
+     * Represents how widely the pattern is used across the codebase.
+     *
+     * @param fileCount - Number of files containing the pattern
+     * @param totalFiles - Total files in scope
+     * @returns Spread factor (0.0 to 1.0)
+     *
+     * @requirements 5.1 - Spread factor in confidence scoring
+     */
+    calculateSpread(fileCount, totalFiles) {
+        // Handle edge cases
+        if (totalFiles <= 0) {
+            return 0.0;
+        }
+        if (fileCount <= 0) {
+            return 0.0;
+        }
+        // Calculate spread ratio
+        const spread = fileCount / totalFiles;
+        // Clamp to [0.0, 1.0] range
+        return this.clamp(spread, 0.0, 1.0);
+    }
+    /**
+     * Classify a score into a confidence level.
+     *
+     * @param score - The confidence score (0.0 to 1.0)
+     * @returns The confidence level classification
+     *
+     * @requirements 5.3 - High confidence: score >= 0.85
+     * @requirements 5.4 - Medium confidence: score >= 0.70 and < 0.85
+     * @requirements 5.5 - Low confidence: score >= 0.50 and < 0.70
+     * @requirements 5.6 - Uncertain: score < 0.50
+     */
+    classifyLevel(score) {
+        if (score >= CONFIDENCE_THRESHOLDS.HIGH) {
+            return 'high';
+        }
+        if (score >= CONFIDENCE_THRESHOLDS.MEDIUM) {
+            return 'medium';
+        }
+        if (score >= CONFIDENCE_THRESHOLDS.LOW) {
+            return 'low';
+        }
+        return 'uncertain';
+    }
+    /**
+     * Get the current weights configuration.
+     *
+     * @returns The current confidence weights
+     */
+    getWeights() {
+        return { ...this.weights };
+    }
+    /**
+     * Get the current age normalization configuration.
+     *
+     * @returns The current age configuration
+     */
+    getAgeConfig() {
+        return { ...this.ageConfig };
+    }
+    /**
+     * Validate that weights sum to approximately 1.0.
+     * Throws an error if weights are invalid.
+     */
+    validateWeights() {
+        const sum = this.weights.frequency +
+            this.weights.consistency +
+            this.weights.age +
+            this.weights.spread;
+        // Allow small tolerance for floating point errors
+        const tolerance = 0.001;
+        if (Math.abs(sum - 1.0) > tolerance) {
+            throw new Error(`Confidence weights must sum to 1.0, but got ${sum.toFixed(4)}. ` +
+                `Weights: frequency=${this.weights.frequency}, consistency=${this.weights.consistency}, ` +
+                `age=${this.weights.age}, spread=${this.weights.spread}`);
+        }
+    }
+    /**
+     * Clamp a value to a range.
+     *
+     * @param value - The value to clamp
+     * @param min - Minimum value
+     * @param max - Maximum value
+     * @returns The clamped value
+     */
+    clamp(value, min, max) {
+        return Math.max(min, Math.min(max, value));
+    }
+}
+/**
+ * Create a confidence score from raw values.
+ * Utility function for creating ConfidenceScore objects directly.
+ *
+ * @param frequency - Frequency factor (0.0 to 1.0)
+ * @param consistency - Consistency factor (0.0 to 1.0)
+ * @param age - Age in days
+ * @param spread - Number of files
+ * @param score - Overall score (0.0 to 1.0)
+ * @returns A ConfidenceScore object
+ */
+export function createConfidenceScore(frequency, consistency, age, spread, score) {
+    const scorer = new ConfidenceScorer();
+    const level = scorer.classifyLevel(score);
+    return {
+        frequency,
+        consistency,
+        age,
+        spread,
+        score,
+        level,
+    };
+}
+/**
+ * Calculate confidence score using default weights.
+ * Convenience function for quick calculations.
+ *
+ * @param input - The input data for confidence calculation
+ * @returns The calculated confidence score
+ */
+export function calculateConfidence(input) {
+    const scorer = new ConfidenceScorer();
+    return scorer.calculateScore(input);
+}
+//# sourceMappingURL=confidence-scorer.js.map

package/dist/matcher/confidence-scorer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidence-scorer.js","sourceRoot":"","sources":["../../src/matcher/confidence-scorer.ts"],"names":[],"mappings":"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"}

package/dist/matcher/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Matcher module exports
+ *
+ * Provides pattern matching, confidence scoring, and outlier detection.
+ * This module is responsible for:
+ * - Matching code against pattern definitions
+ * - Calculating confidence scores based on frequency, consistency, age, and spread
+ * - Detecting statistical outliers that deviate from established patterns
+ *
+ * @requirements 5.1 - Pattern confidence scoring with frequency, consistency, age, spread factors
+ * @requirements 5.2 - Confidence score SHALL be a decimal value between 0.0 and 1.0
+ * @requirements 5.3 - High confidence: score >= 0.85
+ * @requirements 5.4 - Medium confidence: score >= 0.70 and < 0.85
+ * @requirements 5.5 - Low confidence: score >= 0.50 and < 0.70
+ * @requirements 5.6 - Uncertain: score < 0.50
+ * @requirements 5.7 - Outlier detection for code that deviates from patterns
+ */
+export * from './types.js';
+export type { Location, SourceRange, MatchType, ExtendedMatchType, ConfidenceLevel, ConfidenceScore, ConfidenceWeights, ConfidenceInput, PatternMatch, PatternMatchResult, AggregatedMatchResult, PatternDefinition, ASTMatchConfig, RegexMatchConfig, StructuralMatchConfig, PatternMetadata, OutlierInfo, OutlierType, OutlierSignificance, OutlierContext, OutlierStatistics, OutlierDetectionResult, OutlierDetectionMethod, MatcherConfig, MatcherCacheConfig, MatcherContext, MatchingResult, MatchingError, } from './types.js';
+export { CONFIDENCE_THRESHOLDS, DEFAULT_CONFIDENCE_WEIGHTS, } from './types.js';
+export { PatternMatcher, type MatchOptions } from './pattern-matcher.js';
+export { ConfidenceScorer, calculateConfidence, createConfidenceScore, type AgeNormalizationConfig, DEFAULT_AGE_CONFIG, } from './confidence-scorer.js';
+export { OutlierDetector, detectOutliers, calculateStatistics, type OutlierDetectorConfig, type DataPoint, type OutlierRule, DEFAULT_OUTLIER_CONFIG, } from './outlier-detector.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/matcher/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/matcher/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,cAAc,YAAY,CAAC;AAG3B,YAAY,EAEV,QAAQ,EACR,WAAW,EAGX,SAAS,EACT,iBAAiB,EAGjB,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,eAAe,EAGf,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EAGrB,iBAAiB,EACjB,cAAc,EACd,gBAAgB,EAChB,qBAAqB,EACrB,eAAe,EAGf,WAAW,EACX,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EACjB,sBAAsB,EACtB,sBAAsB,EAGtB,aAAa,EACb,kBAAkB,EAGlB,cAAc,EACd,cAAc,EACd,aAAa,GACd,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,qBAAqB,EACrB,0BAA0B,GAC3B,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzE,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,qBAAqB,EACrB,KAAK,sBAAsB,EAC3B,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,eAAe,EACf,cAAc,EACd,mBAAmB,EACnB,KAAK,qBAAqB,EAC1B,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,sBAAsB,GACvB,MAAM,uBAAuB,CAAC"}

package/dist/matcher/index.js

@@ -0,0 +1,26 @@
+/**
+ * Matcher module exports
+ *
+ * Provides pattern matching, confidence scoring, and outlier detection.
+ * This module is responsible for:
+ * - Matching code against pattern definitions
+ * - Calculating confidence scores based on frequency, consistency, age, and spread
+ * - Detecting statistical outliers that deviate from established patterns
+ *
+ * @requirements 5.1 - Pattern confidence scoring with frequency, consistency, age, spread factors
+ * @requirements 5.2 - Confidence score SHALL be a decimal value between 0.0 and 1.0
+ * @requirements 5.3 - High confidence: score >= 0.85
+ * @requirements 5.4 - Medium confidence: score >= 0.70 and < 0.85
+ * @requirements 5.5 - Low confidence: score >= 0.50 and < 0.70
+ * @requirements 5.6 - Uncertain: score < 0.50
+ * @requirements 5.7 - Outlier detection for code that deviates from patterns
+ */
+// Export all types
+export * from './types.js';
+// Export constants
+export { CONFIDENCE_THRESHOLDS, DEFAULT_CONFIDENCE_WEIGHTS, } from './types.js';
+// Export matcher components
+export { PatternMatcher } from './pattern-matcher.js';
+export { ConfidenceScorer, calculateConfidence, createConfidenceScore, DEFAULT_AGE_CONFIG, } from './confidence-scorer.js';
+export { OutlierDetector, detectOutliers, calculateStatistics, DEFAULT_OUTLIER_CONFIG, } from './outlier-detector.js';
+//# sourceMappingURL=index.js.map

package/dist/matcher/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/matcher/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,mBAAmB;AACnB,cAAc,YAAY,CAAC;AAiD3B,mBAAmB;AACnB,OAAO,EACL,qBAAqB,EACrB,0BAA0B,GAC3B,MAAM,YAAY,CAAC;AAEpB,4BAA4B;AAC5B,OAAO,EAAE,cAAc,EAAqB,MAAM,sBAAsB,CAAC;AACzE,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,qBAAqB,EAErB,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,eAAe,EACf,cAAc,EACd,mBAAmB,EAInB,sBAAsB,GACvB,MAAM,uBAAuB,CAAC"}

package/dist/matcher/outlier-detector.d.ts

@@ -0,0 +1,252 @@
+/**
+ * Outlier Detector - Statistical outlier detection for pattern deviations
+ *
+ * Identifies code that deviates from established patterns using statistical
+ * methods including z-score analysis, IQR (Interquartile Range) detection,
+ * and rule-based detection for specific pattern violations.
+ *
+ * @requirements 5.7 - Outlier detection for code that deviates from patterns
+ */
+import type { PatternMatchResult, OutlierInfo, OutlierType, OutlierDetectionResult, OutlierDetectionMethod } from './types.js';
+/**
+ * Configuration for outlier detection
+ */
+export interface OutlierDetectorConfig {
+    /**
+     * Sensitivity threshold for outlier detection (0.0 to 1.0)
+     * Lower values = more sensitive (more outliers detected)
+     * Default: 0.5
+     */
+    sensitivity: number;
+    /**
+     * Z-score threshold for statistical outlier detection
+     * Values with z-score above this are considered outliers
+     * Default: 2.0 (approximately 95% confidence)
+     */
+    zScoreThreshold: number;
+    /**
+     * IQR multiplier for IQR-based outlier detection
+     * Values outside Q1 - (multiplier * IQR) or Q3 + (multiplier * IQR) are outliers
+     * Default: 1.5 (standard Tukey fence)
+     */
+    iqrMultiplier: number;
+    /**
+     * Minimum sample size for statistical detection
+     * Below this, rule-based detection is used instead
+     * Default: 5
+     */
+    minSampleSize: number;
+    /**
+     * Detection method to use
+     * Default: 'statistical'
+     */
+    method: OutlierDetectionMethod;
+    /**
+     * Whether to include context information in outlier results
+     * Default: true
+     */
+    includeContext: boolean;
+}
+/**
+ * Default outlier detector configuration
+ */
+export declare const DEFAULT_OUTLIER_CONFIG: OutlierDetectorConfig;
+/**
+ * Input data point for outlier analysis
+ */
+export interface DataPoint {
+    /** The value to analyze */
+    value: number;
+    /** Associated pattern match result */
+    match: PatternMatchResult;
+    /** Optional label for the data point */
+    label?: string;
+}
+/**
+ * Rule definition for rule-based outlier detection
+ */
+export interface OutlierRule {
+    /** Rule identifier */
+    id: string;
+    /** Rule name */
+    name: string;
+    /** Outlier type this rule detects */
+    type: OutlierType;
+    /** Function to check if a match violates the rule */
+    check: (match: PatternMatchResult, allMatches: PatternMatchResult[]) => boolean;
+    /** Function to generate the reason for the outlier */
+    getReason: (match: PatternMatchResult) => string;
+    /** Expected value/structure */
+    getExpected?: (match: PatternMatchResult, allMatches: PatternMatchResult[]) => string;
+    /** Suggested fix */
+    getSuggestedFix?: (match: PatternMatchResult) => string;
+}
+/**
+ * OutlierDetector class for detecting statistical outliers in pattern matches.
+ *
+ * Supports multiple detection methods:
+ * - Statistical: Uses z-score and IQR analysis
+ * - Rule-based: Uses predefined rules for specific violations
+ * - Clustering: Groups similar matches and identifies outliers (future)
+ * - ML-based: Machine learning-based detection (future)
+ *
+ * @requirements 5.7 - Outlier detection for code that deviates from patterns
+ */
+export declare class OutlierDetector {
+    private config;
+    private rules;
+    /**
+     * Create a new OutlierDetector instance.
+     *
+     * @param config - Optional configuration for outlier detection
+     */
+    constructor(config?: Partial<OutlierDetectorConfig>);
+    /**
+     * Detect outliers in a set of pattern matches.
+     *
+     * @param matches - Array of pattern match results to analyze
+     * @param patternId - ID of the pattern being analyzed
+     * @returns Outlier detection result with all detected outliers
+     *
+     * @requirements 5.7 - Outlier detection for code that deviates from patterns
+     */
+    detect(matches: PatternMatchResult[], patternId: string): OutlierDetectionResult;
+    /**
+     * Detect outliers using statistical methods (z-score and IQR).
+     *
+     * @param matches - Pattern matches to analyze
+     * @param patternId - Pattern ID
+     * @returns Array of detected outliers
+     */
+    detectStatistical(matches: PatternMatchResult[], patternId: string): OutlierInfo[];
+    /**
+     * Detect outliers using z-score method.
+     *
+     * Z-score measures how many standard deviations a value is from the mean.
+     * Values with |z-score| > threshold are considered outliers.
+     *
+     * @param dataPoints - Data points to analyze
+     * @param patternId - Pattern ID
+     * @returns Array of detected outliers
+     */
+    detectByZScore(dataPoints: DataPoint[], patternId: string): OutlierInfo[];
+    /**
+     * Detect outliers using IQR (Interquartile Range) method.
+     *
+     * IQR is the range between Q1 (25th percentile) and Q3 (75th percentile).
+     * Values outside [Q1 - k*IQR, Q3 + k*IQR] are considered outliers.
+     *
+     * @param dataPoints - Data points to analyze
+     * @param patternId - Pattern ID
+     * @returns Array of detected outliers
+     */
+    detectByIQR(dataPoints: DataPoint[], patternId: string): OutlierInfo[];
+    /**
+     * Detect outliers using rule-based detection.
+     *
+     * @param matches - Pattern matches to analyze
+     * @param patternId - Pattern ID
+     * @returns Array of detected outliers
+     */
+    detectRuleBased(matches: PatternMatchResult[], patternId: string): OutlierInfo[];
+    /**
+     * Register a custom outlier detection rule.
+     *
+     * @param rule - The rule to register
+     */
+    registerRule(rule: OutlierRule): void;
+    /**
+     * Unregister an outlier detection rule.
+     *
+     * @param ruleId - ID of the rule to unregister
+     * @returns True if the rule was removed, false if it didn't exist
+     */
+    unregisterRule(ruleId: string): boolean;
+    /**
+     * Get all registered rules.
+     *
+     * @returns Array of registered rules
+     */
+    getRules(): OutlierRule[];
+    /**
+     * Get the current configuration.
+     *
+     * @returns Copy of the current configuration
+     */
+    getConfig(): OutlierDetectorConfig;
+    /**
+     * Update the configuration.
+     *
+     * @param config - Partial configuration to update
+     */
+    updateConfig(config: Partial<OutlierDetectorConfig>): void;
+    /**
+     * Select the appropriate detection method based on sample size and config.
+     */
+    private selectMethod;
+    /**
+     * Calculate basic statistics for a set of values.
+     */
+    private calculateStatistics;
+    /**
+     * Calculate a quartile value from sorted data.
+     */
+    private calculateQuartile;
+    /**
+     * Calculate the percentile rank of a value in a dataset.
+     */
+    private calculatePercentile;
+    /**
+     * Classify outlier significance based on z-score.
+     */
+    private classifySignificance;
+    /**
+     * Classify outlier significance based on IQR distance.
+     */
+    private classifySignificanceByIQR;
+    /**
+     * Calculate deviation score from z-score (normalized to 0-1).
+     */
+    private calculateDeviationScore;
+    /**
+     * Determine the outlier type based on match characteristics.
+     */
+    private determineOutlierType;
+    /**
+     * Create an OutlierInfo object from match data.
+     */
+    private createOutlierInfo;
+    /**
+     * Clamp a value to a range.
+     */
+    private clamp;
+    /**
+     * Register default outlier detection rules.
+     */
+    private registerDefaultRules;
+}
+/**
+ * Detect outliers using default configuration.
+ * Convenience function for quick outlier detection.
+ *
+ * @param matches - Pattern matches to analyze
+ * @param patternId - Pattern ID
+ * @returns Outlier detection result
+ */
+export declare function detectOutliers(matches: PatternMatchResult[], patternId: string): OutlierDetectionResult;
+/**
+ * Calculate statistics for a set of values.
+ * Utility function for external use.
+ *
+ * @param values - Array of numeric values
+ * @returns Statistics object with mean, stddev, and quartiles
+ */
+export declare function calculateStatistics(values: number[]): {
+    mean: number;
+    standardDeviation: number;
+    q1: number;
+    median: number;
+    q3: number;
+    iqr: number;
+};
+//# sourceMappingURL=outlier-detector.d.ts.map

package/dist/matcher/outlier-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outlier-detector.d.ts","sourceRoot":"","sources":["../../src/matcher/outlier-detector.ts"],"names":[],"mappings":"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"}