hivemind-pipeline 0.1.0

package/dist/src/core/ambiguity-detector.js

@@ -0,0 +1,286 @@
+import { execSync } from 'node:child_process';
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+const RISK_KEYWORDS = ['auth', 'payment', 'billing', 'database', 'migration', 'deploy', 'security', 'delete', 'remove'];
+const GENERIC_TERMS = ['add', 'fix', 'update', 'change', 'improve', 'make', 'do', 'create', 'build', 'handle'];
+const SPECIFIC_INDICATORS = ['.ts', '.tsx', '.js', '.py', '.go', '.rs', 'function', 'class', 'component', 'endpoint', 'api', 'route', 'hook', 'middleware', 'handler', 'service', 'module'];
+function countProjectFiles(cwd) {
+    try {
+        const output = execSync('git ls-files | wc -l', { cwd, encoding: 'utf-8', timeout: 5000 }).trim();
+        return parseInt(output, 10) || 0;
+    }
+    catch {
+        // Fallback: count files in top-level dirs (shallow)
+        try {
+            let count = 0;
+            const entries = readdirSync(cwd);
+            for (const entry of entries) {
+                if (entry.startsWith('.') || entry === 'node_modules' || entry === 'dist')
+                    continue;
+                try {
+                    const st = statSync(join(cwd, entry));
+                    if (st.isFile())
+                        count++;
+                    else if (st.isDirectory()) {
+                        count += readdirSync(join(cwd, entry)).length;
+                    }
+                }
+                catch { /* skip */ }
+            }
+            return count;
+        }
+        catch {
+            return 50; // fallback estimate
+        }
+    }
+}
+function scoreVagueness(request) {
+    let score = 0;
+    const lower = request.toLowerCase().trim();
+    const words = lower.split(/\s+/);
+    // Short requests are vague
+    if (lower.length < 20)
+        score += 35;
+    else if (lower.length < 50)
+        score += 20;
+    else if (lower.length < 100)
+        score += 10;
+    // Word count
+    if (words.length < 5)
+        score += 20;
+    else if (words.length < 10)
+        score += 10;
+    // Generic verbs without specifics
+    const startsWithGeneric = GENERIC_TERMS.some(t => lower.startsWith(t));
+    if (startsWithGeneric)
+        score += 10;
+    const genericCount = words.filter(w => GENERIC_TERMS.includes(w)).length;
+    score += Math.min(genericCount * 5, 15);
+    // Specific indicators reduce vagueness
+    const specificCount = SPECIFIC_INDICATORS.filter(s => lower.includes(s)).length;
+    score -= Math.min(specificCount * 8, 30);
+    // No file/path mentions = more vague
+    const hasPath = /[\/\\]/.test(request) || /\.\w{1,4}$/.test(request.trim());
+    if (!hasPath)
+        score += 10;
+    return Math.max(0, Math.min(100, score));
+}
+function detectRiskFactors(request) {
+    const lower = request.toLowerCase();
+    const factors = [];
+    for (const keyword of RISK_KEYWORDS) {
+        if (lower.includes(keyword)) {
+            const descriptions = {
+                auth: 'Authentication changes can break user access',
+                payment: 'Payment logic is business-critical and legally sensitive',
+                billing: 'Billing changes affect revenue and compliance',
+                database: 'Database changes can cause data loss if not migrated properly',
+                migration: 'Migrations are destructive and hard to reverse',
+                deploy: 'Deployment changes affect production availability',
+                security: 'Security changes require careful review',
+                delete: 'Deletion operations can cause permanent data loss',
+                remove: 'Removal operations can break dependent features',
+            };
+            factors.push(descriptions[keyword] || `Involves ${keyword} — requires careful review`);
+        }
+    }
+    return factors;
+}
+function findMissingContext(request) {
+    const lower = request.toLowerCase();
+    const missing = [];
+    if (!SPECIFIC_INDICATORS.some(s => lower.includes(s))) {
+        missing.push('No specific files or components mentioned');
+    }
+    if (!/\b(api|endpoint|route|page|view|component|service|model|schema)\b/.test(lower)) {
+        missing.push('No architectural layer specified (API, UI, service, model)');
+    }
+    if (!/\b(user|admin|public|internal|customer)\b/.test(lower)) {
+        missing.push('No target audience or access level specified');
+    }
+    if (!/\b(must|should|require|need|want)\b/.test(lower)) {
+        missing.push('No explicit requirements or constraints stated');
+    }
+    if (!/\b(test|verify|validate|check)\b/.test(lower)) {
+        missing.push('No success criteria or testing approach mentioned');
+    }
+    return missing;
+}
+function generateQuestions(request, missing, riskFactors) {
+    const questions = [];
+    const lower = request.toLowerCase();
+    if (missing.some(m => m.includes('files or components'))) {
+        questions.push('Which specific files or components should be changed?');
+    }
+    if (missing.some(m => m.includes('architectural layer'))) {
+        questions.push('Should this change the API, the UI, both, or just internal logic?');
+    }
+    if (missing.some(m => m.includes('audience'))) {
+        questions.push('Who is the target user for this change?');
+    }
+    if (missing.some(m => m.includes('requirements'))) {
+        questions.push('What are the must-have requirements vs nice-to-haves?');
+    }
+    if (missing.some(m => m.includes('success criteria'))) {
+        questions.push('How will you verify this change works correctly?');
+    }
+    if (riskFactors.length > 0) {
+        questions.push('Are there existing tests covering the affected area?');
+        questions.push('Is there a rollback plan if something goes wrong?');
+    }
+    if (lower.includes('add') || lower.includes('create') || lower.includes('build')) {
+        questions.push('Should this integrate with existing patterns or introduce a new approach?');
+    }
+    if (lower.includes('fix') || lower.includes('bug')) {
+        questions.push('Can you provide steps to reproduce the issue?');
+    }
+    return questions.slice(0, 6); // Cap at 6 questions
+}
+function generateOptions(request, vagueness, fileCount, riskFactors) {
+    const isRisky = riskFactors.length > 0;
+    const baseCost = fileCount > 200 ? 2.0 : fileCount > 50 ? 1.0 : 0.5;
+    const options = [];
+    // Minimal option
+    options.push({
+        name: 'Minimal',
+        description: 'Smallest viable change — only the core requirement with no extras',
+        estimatedCost: baseCost,
+        estimatedTime: fileCount > 200 ? '10-20 min' : '5-10 min',
+        risk: 'low',
+        tradeoffs: [
+            'Fastest and cheapest',
+            'May miss edge cases',
+            'No additional tests or documentation',
+            'Might need follow-up work',
+        ],
+        recommended: !isRisky && vagueness < 40,
+    });
+    // Balanced option
+    options.push({
+        name: 'Balanced',
+        description: 'Core requirement plus tests, error handling, and basic documentation',
+        estimatedCost: baseCost * 2.5,
+        estimatedTime: fileCount > 200 ? '20-40 min' : '10-25 min',
+        risk: isRisky ? 'medium' : 'low',
+        tradeoffs: [
+            'Good balance of speed and quality',
+            'Includes test coverage',
+            'Handles common edge cases',
+            'Moderate cost',
+        ],
+        recommended: true, // default recommendation
+    });
+    // Comprehensive option
+    options.push({
+        name: 'Comprehensive',
+        description: 'Full implementation with tests, docs, error handling, logging, and review',
+        estimatedCost: baseCost * 5,
+        estimatedTime: fileCount > 200 ? '40-90 min' : '25-50 min',
+        risk: isRisky ? 'medium' : 'low',
+        tradeoffs: [
+            'Most thorough approach',
+            'Full test coverage',
+            'Documentation included',
+            'Higher cost and time',
+        ],
+        recommended: isRisky,
+    });
+    // If risky, mark balanced as not recommended in favor of comprehensive
+    if (isRisky) {
+        options[1].recommended = false;
+    }
+    return options;
+}
+function classifyRequest(vagueness, riskFactors, fileCount) {
+    if (riskFactors.length > 0)
+        return 'risky';
+    if (vagueness > 50)
+        return 'ambiguous';
+    if (fileCount > 200)
+        return 'clear-large';
+    return 'clear-small';
+}
+function estimateScopeSize(fileCount, vagueness) {
+    if (fileCount > 200 || vagueness > 60)
+        return 'large';
+    if (fileCount > 50 || vagueness > 30)
+        return 'medium';
+    return 'small';
+}
+export function analyzeAmbiguity(request, cwd) {
+    const fileCount = countProjectFiles(cwd);
+    const vaguenessScore = scoreVagueness(request);
+    const riskFactors = detectRiskFactors(request);
+    const missingContext = findMissingContext(request);
+    const classification = classifyRequest(vaguenessScore, riskFactors, fileCount);
+    const scopeSize = estimateScopeSize(fileCount, vaguenessScore);
+    const questions = generateQuestions(request, missingContext, riskFactors);
+    const options = generateOptions(request, vaguenessScore, fileCount, riskFactors);
+    const baseCost = fileCount > 200 ? 2.0 : fileCount > 50 ? 1.0 : 0.5;
+    const estimatedCost = baseCost * (vaguenessScore > 50 ? 3 : vaguenessScore > 30 ? 2 : 1.5);
+    const estimatedFiles = Math.max(1, Math.round(fileCount * (vaguenessScore > 50 ? 0.1 : 0.03)));
+    return {
+        vaguenessScore,
+        scopeSize,
+        riskFactors,
+        missingContext,
+        classification,
+        estimatedCost,
+        estimatedFiles,
+        questions,
+        options,
+    };
+}
+export function generateScopeDocument(request, chosenOption, analysis) {
+    const willBuild = [];
+    const willNotBuild = [];
+    const assumptions = [];
+    // Build items based on option level
+    willBuild.push(`Core: ${request}`);
+    if (chosenOption.name === 'Balanced' || chosenOption.name === 'Comprehensive') {
+        willBuild.push('Unit tests for new/changed code');
+        willBuild.push('Error handling for common failure modes');
+    }
+    if (chosenOption.name === 'Comprehensive') {
+        willBuild.push('Integration tests');
+        willBuild.push('Documentation updates');
+        willBuild.push('Logging and observability');
+    }
+    // Will NOT build
+    if (chosenOption.name === 'Minimal') {
+        willNotBuild.push('Tests (follow up separately)');
+        willNotBuild.push('Documentation updates');
+        willNotBuild.push('Error handling beyond basic cases');
+    }
+    if (chosenOption.name !== 'Comprehensive') {
+        willNotBuild.push('Performance optimization');
+        willNotBuild.push('Migration scripts (if applicable)');
+    }
+    willNotBuild.push('Unrelated refactoring');
+    // Assumptions
+    assumptions.push('Existing codebase patterns will be followed');
+    assumptions.push('Current dependencies are sufficient');
+    if (analysis.riskFactors.length > 0) {
+        assumptions.push('Risk areas will be reviewed manually before merge');
+    }
+    if (analysis.missingContext.length > 0) {
+        assumptions.push('Ambiguous requirements will be interpreted conservatively');
+    }
+    // Risk description
+    let risk = 'Low — straightforward change with minimal dependencies';
+    if (analysis.riskFactors.length > 0) {
+        risk = `Medium-High — ${analysis.riskFactors[0]}`;
+    }
+    else if (analysis.vaguenessScore > 50) {
+        risk = 'Medium — vague requirements may lead to rework';
+    }
+    return {
+        willBuild,
+        willNotBuild,
+        assumptions,
+        estimatedCost: chosenOption.estimatedCost,
+        approach: `${chosenOption.name}: ${chosenOption.description}`,
+        risk,
+    };
+}
+//# sourceMappingURL=ambiguity-detector.js.map

package/dist/src/core/ambiguity-detector.js.map

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

package/dist/src/core/anomaly-detector.d.ts

@@ -0,0 +1,30 @@
+import type { MetricDataPoint, DeployMarker, AnomalyAlert, PredictiveAlert } from '../types.js';
+export declare class AnomalyDetector {
+    private sigma;
+    constructor(sigma?: number);
+    /** Detect anomalies in a set of metric data points using Z-score */
+    detect(metrics: MetricDataPoint[]): AnomalyAlert[];
+    /** Correlate an anomaly with nearby deploys */
+    correlateWithDeploys(anomaly: AnomalyAlert, deploys: DeployMarker[], windowMs?: number): AnomalyAlert;
+    /** Predict future issues based on metric trends */
+    predict(metrics: MetricDataPoint[]): PredictiveAlert[];
+    /** Compute baseline statistics for a set of values */
+    private computeBaseline;
+    /** Classify severity based on Z-score magnitude */
+    private classifySeverity;
+    /** Detect sustained trend drift */
+    private detectTrend;
+    /** Detect periodic patterns (e.g., daily spikes) */
+    private detectPattern;
+    /** Get the next occurrence of a given hour */
+    private nextOccurrence;
+    /** Simple linear regression */
+    private linearRegression;
+    /** Deduplicate alerts: keep most severe per metric per hour */
+    private deduplicateAlerts;
+    /** Format a duration in milliseconds to human-readable */
+    private formatDuration;
+    /** Group metric data points by name */
+    private groupByName;
+}
+//# sourceMappingURL=anomaly-detector.d.ts.map

package/dist/src/core/anomaly-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anomaly-detector.d.ts","sourceRoot":"","sources":["../../../src/core/anomaly-detector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EACf,YAAY,EACZ,YAAY,EACZ,eAAe,EAChB,MAAM,aAAa,CAAC;AAUrB,qBAAa,eAAe;IAC1B,OAAO,CAAC,KAAK,CAAS;gBAEV,KAAK,GAAE,MAAU;IAI7B,oEAAoE;IACpE,MAAM,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,YAAY,EAAE;IAoDlD,+CAA+C;IAC/C,oBAAoB,CAClB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,YAAY,EAAE,EACvB,QAAQ,GAAE,MAAgB,GACzB,YAAY;IA6Bf,mDAAmD;IACnD,OAAO,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE;IAoEtD,sDAAsD;IACtD,OAAO,CAAC,eAAe;IAmBvB,mDAAmD;IACnD,OAAO,CAAC,gBAAgB;IAMxB,mCAAmC;IACnC,OAAO,CAAC,WAAW;IA0BnB,oDAAoD;IACpD,OAAO,CAAC,aAAa;IA4CrB,8CAA8C;IAC9C,OAAO,CAAC,cAAc;IAUtB,+BAA+B;IAC/B,OAAO,CAAC,gBAAgB;IA4BxB,+DAA+D;IAC/D,OAAO,CAAC,iBAAiB;IAiBzB,0DAA0D;IAC1D,OAAO,CAAC,cAAc;IAYtB,uCAAuC;IACvC,OAAO,CAAC,WAAW;CAQpB"}

package/dist/src/core/anomaly-detector.js

@@ -0,0 +1,300 @@
+import { randomUUID } from 'node:crypto';
+export class AnomalyDetector {
+    sigma;
+    constructor(sigma = 3) {
+        this.sigma = sigma;
+    }
+    /** Detect anomalies in a set of metric data points using Z-score */
+    detect(metrics) {
+        if (metrics.length < 5)
+            return [];
+        const alerts = [];
+        // Group metrics by name
+        const grouped = this.groupByName(metrics);
+        for (const [name, points] of Object.entries(grouped)) {
+            if (points.length < 5)
+                continue;
+            // Sort by timestamp
+            const sorted = [...points].sort((a, b) => a.timestamp - b.timestamp);
+            // Use the first 80% as baseline, check the last 20%
+            const splitIdx = Math.floor(sorted.length * 0.8);
+            const baseline = sorted.slice(0, splitIdx);
+            const recent = sorted.slice(splitIdx);
+            const stats = this.computeBaseline(baseline.map(p => p.value));
+            if (stats.stddev === 0)
+                continue;
+            for (const point of recent) {
+                const zScore = Math.abs((point.value - stats.mean) / stats.stddev);
+                if (zScore >= this.sigma) {
+                    const isSpike = point.value > stats.mean;
+                    alerts.push({
+                        id: randomUUID(),
+                        metric: name,
+                        type: isSpike ? 'spike' : 'drop',
+                        severity: this.classifySeverity(zScore),
+                        value: point.value,
+                        baseline: stats.mean,
+                        deviation: zScore,
+                        timestamp: point.timestamp,
+                        resolved: false,
+                    });
+                }
+            }
+            // Check for trend anomalies (consistent drift)
+            const trendAlert = this.detectTrend(name, sorted, stats);
+            if (trendAlert) {
+                alerts.push(trendAlert);
+            }
+        }
+        // Deduplicate: keep only the most severe alert per metric per hour
+        return this.deduplicateAlerts(alerts);
+    }
+    /** Correlate an anomaly with nearby deploys */
+    correlateWithDeploys(anomaly, deploys, windowMs = 3600000) {
+        const nearbyDeploys = deploys.filter(d => Math.abs(d.timestamp - anomaly.timestamp) <= windowMs);
+        if (nearbyDeploys.length === 0)
+            return anomaly;
+        // Find the closest deploy
+        const closest = nearbyDeploys.reduce((best, d) => {
+            const dist = Math.abs(d.timestamp - anomaly.timestamp);
+            const bestDist = Math.abs(best.timestamp - anomaly.timestamp);
+            return dist < bestDist ? d : best;
+        });
+        // Confidence is higher when deploy is closer in time
+        const timeDiff = Math.abs(closest.timestamp - anomaly.timestamp);
+        const confidence = Math.max(0.1, 1 - timeDiff / windowMs);
+        return {
+            ...anomaly,
+            type: 'correlation',
+            deployCorrelation: {
+                sha: closest.sha,
+                confidence: Math.round(confidence * 100) / 100,
+                filesChanged: closest.filesChanged,
+            },
+        };
+    }
+    /** Predict future issues based on metric trends */
+    predict(metrics) {
+        if (metrics.length < 10)
+            return [];
+        const alerts = [];
+        const grouped = this.groupByName(metrics);
+        for (const [name, points] of Object.entries(grouped)) {
+            if (points.length < 10)
+                continue;
+            const sorted = [...points].sort((a, b) => a.timestamp - b.timestamp);
+            const values = sorted.map(p => p.value);
+            const timestamps = sorted.map(p => p.timestamp);
+            // Linear regression for trend extrapolation
+            const regression = this.linearRegression(timestamps, values);
+            if (Math.abs(regression.slope) < 0.0001)
+                continue;
+            const stats = this.computeBaseline(values);
+            // Capacity alert: predict when metric will exceed 2 sigma
+            const upperThreshold = stats.mean + this.sigma * stats.stddev;
+            const lowerThreshold = stats.mean - this.sigma * stats.stddev;
+            if (regression.slope > 0) {
+                // Growing trend — predict when it crosses upper threshold
+                const currentValue = regression.slope * timestamps[timestamps.length - 1] + regression.intercept;
+                if (currentValue < upperThreshold) {
+                    const timeToThreshold = (upperThreshold - currentValue) / regression.slope;
+                    if (timeToThreshold > 0 && timeToThreshold < 7 * 86400000) {
+                        alerts.push({
+                            metric: name,
+                            type: 'capacity',
+                            message: `${name} is trending up — predicted to breach threshold in ${this.formatDuration(timeToThreshold)}`,
+                            predictedAt: Date.now() + timeToThreshold,
+                            confidence: Math.min(0.95, regression.r2),
+                            timeToImpact: this.formatDuration(timeToThreshold),
+                        });
+                    }
+                }
+            }
+            else {
+                // Decreasing trend — predict when it crosses lower threshold
+                const currentValue = regression.slope * timestamps[timestamps.length - 1] + regression.intercept;
+                if (currentValue > lowerThreshold) {
+                    const timeToThreshold = (lowerThreshold - currentValue) / regression.slope;
+                    if (timeToThreshold > 0 && timeToThreshold < 7 * 86400000) {
+                        alerts.push({
+                            metric: name,
+                            type: 'trend',
+                            message: `${name} is trending down — predicted to breach threshold in ${this.formatDuration(timeToThreshold)}`,
+                            predictedAt: Date.now() + timeToThreshold,
+                            confidence: Math.min(0.95, regression.r2),
+                            timeToImpact: this.formatDuration(timeToThreshold),
+                        });
+                    }
+                }
+            }
+            // Pattern detection: check for periodic spikes
+            const patternAlert = this.detectPattern(name, sorted);
+            if (patternAlert) {
+                alerts.push(patternAlert);
+            }
+        }
+        return alerts;
+    }
+    /** Compute baseline statistics for a set of values */
+    computeBaseline(values) {
+        if (values.length === 0) {
+            return { mean: 0, stddev: 0, count: 0, min: 0, max: 0 };
+        }
+        const count = values.length;
+        const mean = values.reduce((sum, v) => sum + v, 0) / count;
+        const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / count;
+        const stddev = Math.sqrt(variance);
+        return {
+            mean,
+            stddev,
+            count,
+            min: Math.min(...values),
+            max: Math.max(...values),
+        };
+    }
+    /** Classify severity based on Z-score magnitude */
+    classifySeverity(zScore) {
+        if (zScore >= this.sigma * 2)
+            return 'critical';
+        if (zScore >= this.sigma * 1.5)
+            return 'warning';
+        return 'info';
+    }
+    /** Detect sustained trend drift */
+    detectTrend(name, sorted, stats) {
+        if (sorted.length < 10)
+            return null;
+        // Check if the last 5 points are all above or below the mean
+        const lastN = sorted.slice(-5);
+        const allAbove = lastN.every(p => p.value > stats.mean + stats.stddev);
+        const allBelow = lastN.every(p => p.value < stats.mean - stats.stddev);
+        if (!allAbove && !allBelow)
+            return null;
+        const avgRecent = lastN.reduce((s, p) => s + p.value, 0) / lastN.length;
+        const deviation = Math.abs((avgRecent - stats.mean) / (stats.stddev || 1));
+        return {
+            id: randomUUID(),
+            metric: name,
+            type: 'trend',
+            severity: deviation >= this.sigma * 1.5 ? 'warning' : 'info',
+            value: avgRecent,
+            baseline: stats.mean,
+            deviation,
+            timestamp: lastN[lastN.length - 1].timestamp,
+            resolved: false,
+        };
+    }
+    /** Detect periodic patterns (e.g., daily spikes) */
+    detectPattern(name, sorted) {
+        if (sorted.length < 24)
+            return null;
+        // Simple approach: check if there's a clear hourly periodicity
+        const hourBuckets = {};
+        for (const p of sorted) {
+            const hour = new Date(p.timestamp).getHours();
+            if (!hourBuckets[hour])
+                hourBuckets[hour] = [];
+            hourBuckets[hour].push(p.value);
+        }
+        // Find the hour with the highest average
+        let peakHour = -1;
+        let peakAvg = -Infinity;
+        let overallAvg = 0;
+        let totalPoints = 0;
+        for (const [hour, values] of Object.entries(hourBuckets)) {
+            const avg = values.reduce((s, v) => s + v, 0) / values.length;
+            overallAvg += values.reduce((s, v) => s + v, 0);
+            totalPoints += values.length;
+            if (avg > peakAvg) {
+                peakAvg = avg;
+                peakHour = parseInt(hour);
+            }
+        }
+        overallAvg /= totalPoints;
+        // If peak hour is >50% above overall average, report pattern
+        if (peakAvg > overallAvg * 1.5 && peakHour >= 0) {
+            return {
+                metric: name,
+                type: 'pattern',
+                message: `${name} shows recurring peak at hour ${peakHour}:00 (${((peakAvg / overallAvg - 1) * 100).toFixed(0)}% above avg)`,
+                predictedAt: this.nextOccurrence(peakHour),
+                confidence: 0.6,
+                timeToImpact: this.formatDuration(this.nextOccurrence(peakHour) - Date.now()),
+            };
+        }
+        return null;
+    }
+    /** Get the next occurrence of a given hour */
+    nextOccurrence(hour) {
+        const now = new Date();
+        const next = new Date(now);
+        next.setHours(hour, 0, 0, 0);
+        if (next.getTime() <= now.getTime()) {
+            next.setDate(next.getDate() + 1);
+        }
+        return next.getTime();
+    }
+    /** Simple linear regression */
+    linearRegression(x, y) {
+        const n = x.length;
+        if (n < 2)
+            return { slope: 0, intercept: 0, r2: 0 };
+        // Normalize x values to avoid numerical overflow
+        const xMin = x[0];
+        const xNorm = x.map(v => v - xMin);
+        const sumX = xNorm.reduce((s, v) => s + v, 0);
+        const sumY = y.reduce((s, v) => s + v, 0);
+        const sumXY = xNorm.reduce((s, v, i) => s + v * y[i], 0);
+        const sumX2 = xNorm.reduce((s, v) => s + v * v, 0);
+        const denom = n * sumX2 - sumX * sumX;
+        if (Math.abs(denom) < 1e-10)
+            return { slope: 0, intercept: sumY / n, r2: 0 };
+        const slope = (n * sumXY - sumX * sumY) / denom;
+        const intercept = (sumY - slope * sumX) / n;
+        // R-squared
+        const meanY = sumY / n;
+        const ssRes = y.reduce((s, v, i) => s + (v - (slope * xNorm[i] + intercept)) ** 2, 0);
+        const ssTot = y.reduce((s, v) => s + (v - meanY) ** 2, 0);
+        const r2 = ssTot > 0 ? 1 - ssRes / ssTot : 0;
+        return { slope, intercept, r2: Math.max(0, r2) };
+    }
+    /** Deduplicate alerts: keep most severe per metric per hour */
+    deduplicateAlerts(alerts) {
+        const byKey = new Map();
+        const severityRank = { critical: 3, warning: 2, info: 1 };
+        for (const alert of alerts) {
+            const hourBucket = Math.floor(alert.timestamp / 3600000);
+            const key = `${alert.metric}:${hourBucket}`;
+            const existing = byKey.get(key);
+            if (!existing || severityRank[alert.severity] > severityRank[existing.severity]) {
+                byKey.set(key, alert);
+            }
+        }
+        return [...byKey.values()].sort((a, b) => b.timestamp - a.timestamp);
+    }
+    /** Format a duration in milliseconds to human-readable */
+    formatDuration(ms) {
+        if (ms < 0)
+            return 'now';
+        const hours = Math.floor(ms / 3600000);
+        if (hours < 1) {
+            const mins = Math.floor(ms / 60000);
+            return `${mins}m`;
+        }
+        if (hours < 24)
+            return `${hours}h`;
+        const days = Math.floor(hours / 24);
+        return `${days}d`;
+    }
+    /** Group metric data points by name */
+    groupByName(metrics) {
+        const grouped = {};
+        for (const m of metrics) {
+            if (!grouped[m.name])
+                grouped[m.name] = [];
+            grouped[m.name].push(m);
+        }
+        return grouped;
+    }
+}
+//# sourceMappingURL=anomaly-detector.js.map