corpus-core 0.1.0

package/dist/pattern-learner.js

@@ -0,0 +1,420 @@
+/**
+ * Corpus Pattern Learner
+ *
+ * Analyzes findings across multiple repos to learn which patterns
+ * are real issues vs false positives. Builds a statistical model
+ * that evolves as more repos are scanned.
+ *
+ * This is the "learning" part of the immune system.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import path from 'path';
+const TEST_INDICATORS = ['test', 'spec', '__tests__', '__mocks__', 'fixture', 'mock', 'stub', 'e2e', 'integration-test'];
+const BUILD_INDICATORS = ['build', 'scripts', 'tools', 'bin', 'cli', 'webpack', 'rollup', 'esbuild', 'vite.config', 'jest.config'];
+function isTestFile(filepath) {
+    const lower = filepath.toLowerCase();
+    return TEST_INDICATORS.some(t => lower.includes(t));
+}
+function isBuildFile(filepath) {
+    const lower = filepath.toLowerCase();
+    return BUILD_INDICATORS.some(t => lower.includes(t));
+}
+/**
+ * Classify the semantic context of a file based on its path and content.
+ */
+export function classifyContext(filepath, content) {
+    const lowerPath = filepath.toLowerCase();
+    const lowerContent = content.toLowerCase();
+    // webpack/rollup/vite config
+    if (/webpack|rollup|vite\.config|vite\./.test(lowerPath))
+        return 'webpack-config';
+    // Route handler patterns (express, hono, koa, etc.)
+    if (/\bapp\.(get|post|put|delete|patch|use)\s*\(|\brouter\.(get|post|put|delete|patch|use)\s*\(/.test(content))
+        return 'route-handler';
+    // Middleware patterns
+    if (/\b(req|request)\s*,\s*(res|response)\s*,\s*next\b/.test(content))
+        return 'middleware';
+    // Auth module
+    if (/auth|login|session|passport|jwt|oauth/i.test(lowerPath) || /\b(authenticate|authorize|login|logout|session|jwt|oauth|passport)\b/i.test(content))
+        return 'auth-module';
+    // Test harness
+    if (isTestFile(filepath))
+        return 'test-harness';
+    // Build script
+    if (isBuildFile(filepath))
+        return 'build-script';
+    // Database access
+    if (/\b(SELECT|INSERT|UPDATE|DELETE|CREATE TABLE)\b/.test(content) || /\b(prisma|sequelize|typeorm|knex|mongoose|mongodb)\b/i.test(content))
+        return 'database-access';
+    // API client
+    if (/\bfetch\s*\(|\baxios\b|\bhttp\.(get|post|put|delete)\b|\bgot\b|\brequest\s*\(/i.test(content))
+        return 'api-client';
+    return 'production';
+}
+/**
+ * Learn patterns from a set of findings across multiple repos.
+ * Updates the learned patterns file.
+ */
+export function learnFromFindings(projectRoot, findings) {
+    // Load existing patterns
+    const patternsPath = path.join(projectRoot, '.corpus', 'patterns.json');
+    let existing;
+    if (existsSync(patternsPath)) {
+        existing = JSON.parse(readFileSync(patternsPath, 'utf-8'));
+        // Ensure new fields exist on loaded data
+        if (!existing.knownPackages)
+            existing.knownPackages = [];
+        if (!existing.repoCategories)
+            existing.repoCategories = {};
+    }
+    else {
+        existing = {
+            version: 1,
+            learnedFrom: 0,
+            totalFindings: 0,
+            patterns: [],
+            lastUpdated: new Date().toISOString(),
+            knownPackages: [],
+            repoCategories: {},
+        };
+    }
+    // Group findings by type
+    const byType = new Map();
+    for (const f of findings) {
+        if (!byType.has(f.type))
+            byType.set(f.type, []);
+        byType.get(f.type).push(f);
+    }
+    // Update or create pattern signatures
+    for (const [type, typeFindings] of byType) {
+        let pattern = existing.patterns.find(p => p.type === type);
+        if (!pattern) {
+            pattern = {
+                type,
+                totalOccurrences: 0,
+                inTestFiles: 0,
+                inProductionFiles: 0,
+                inBuildTools: 0,
+                falsePositiveRate: 0,
+                severity: typeFindings[0].severity,
+                adjustedSeverity: typeFindings[0].severity,
+                description: typeFindings[0].message,
+                examples: [],
+                repoCount: 0,
+                repoPrevalence: 0,
+                contextBreakdown: {},
+                coOccursWith: [],
+                linkedCVEs: [],
+                categoryWeights: {},
+            };
+            existing.patterns.push(pattern);
+        }
+        // Ensure new fields exist on patterns loaded from disk
+        if (!pattern.contextBreakdown)
+            pattern.contextBreakdown = {};
+        if (!pattern.coOccursWith)
+            pattern.coOccursWith = [];
+        if (!pattern.linkedCVEs)
+            pattern.linkedCVEs = [];
+        if (!pattern.categoryWeights)
+            pattern.categoryWeights = {};
+        if (pattern.repoCount === undefined)
+            pattern.repoCount = 0;
+        if (pattern.repoPrevalence === undefined)
+            pattern.repoPrevalence = 0;
+        // Track unique repos for this pattern
+        const uniqueRepos = new Set();
+        for (const f of typeFindings) {
+            pattern.totalOccurrences++;
+            if (isTestFile(f.file))
+                pattern.inTestFiles++;
+            else if (isBuildFile(f.file))
+                pattern.inBuildTools++;
+            else
+                pattern.inProductionFiles++;
+            if (pattern.examples.length < 5) {
+                pattern.examples.push({ repo: f.repo, file: f.file });
+            }
+            uniqueRepos.add(f.repo);
+            // Classify context and update breakdown
+            const context = classifyContext(f.file, f.message);
+            pattern.contextBreakdown[context] = (pattern.contextBreakdown[context] || 0) + 1;
+        }
+        // Update repo count and prevalence
+        pattern.repoCount += uniqueRepos.size;
+        // Calculate false positive rate and adjust severity
+        const nonProd = pattern.inTestFiles + pattern.inBuildTools;
+        pattern.falsePositiveRate = pattern.totalOccurrences > 0
+            ? Math.round((nonProd / pattern.totalOccurrences) * 100)
+            : 0;
+        // Adjust severity based on false positive rate
+        if (pattern.falsePositiveRate > 80) {
+            pattern.adjustedSeverity = 'SUPPRESSED';
+        }
+        else if (pattern.falsePositiveRate > 50) {
+            // Downgrade severity by one level
+            if (pattern.severity === 'CRITICAL')
+                pattern.adjustedSeverity = 'WARNING';
+            else if (pattern.severity === 'WARNING')
+                pattern.adjustedSeverity = 'INFO';
+        }
+        else {
+            pattern.adjustedSeverity = pattern.severity;
+        }
+        // CVE-linked patterns should never be suppressed
+        if (pattern.linkedCVEs.length > 0) {
+            if (pattern.adjustedSeverity === 'SUPPRESSED' || pattern.adjustedSeverity === 'INFO') {
+                pattern.adjustedSeverity = 'WARNING';
+            }
+        }
+    }
+    // Update repo prevalence for all patterns now that learnedFrom is updated
+    const updatedLearnedFrom = existing.learnedFrom + new Set(findings.map(f => f.repo)).size;
+    for (const pattern of existing.patterns) {
+        pattern.repoPrevalence = updatedLearnedFrom > 0
+            ? Math.round((pattern.repoCount / updatedLearnedFrom) * 100)
+            : 0;
+        // Aggressive suppression: high prevalence + mostly non-production
+        const totalContext = Object.values(pattern.contextBreakdown).reduce((a, b) => a + b, 0);
+        const prodContext = pattern.contextBreakdown['production'] || 0;
+        const routeContext = pattern.contextBreakdown['route-handler'] || 0;
+        const authContext = pattern.contextBreakdown['auth-module'] || 0;
+        const dbContext = pattern.contextBreakdown['database-access'] || 0;
+        const productionContextCount = prodContext + routeContext + authContext + dbContext;
+        const nonProductionRatio = totalContext > 0 ? (totalContext - productionContextCount) / totalContext : 0;
+        if (pattern.repoPrevalence > 60 && nonProductionRatio > 0.7 && pattern.linkedCVEs.length === 0) {
+            pattern.adjustedSeverity = 'SUPPRESSED';
+        }
+    }
+    // Compute co-occurrence: patterns appearing in the same file
+    const fileToPatterns = new Map();
+    for (const f of findings) {
+        const key = `${f.repo}::${f.file}`;
+        if (!fileToPatterns.has(key))
+            fileToPatterns.set(key, new Set());
+        fileToPatterns.get(key).add(f.type);
+    }
+    const coOccurrenceCount = new Map();
+    const patternFileCount = new Map();
+    for (const patternSet of fileToPatterns.values()) {
+        const types = Array.from(patternSet);
+        for (const t of types) {
+            patternFileCount.set(t, (patternFileCount.get(t) || 0) + 1);
+        }
+        for (let i = 0; i < types.length; i++) {
+            for (let j = i + 1; j < types.length; j++) {
+                const key = [types[i], types[j]].sort().join('::');
+                coOccurrenceCount.set(key, (coOccurrenceCount.get(key) || 0) + 1);
+            }
+        }
+    }
+    // Update co-occurrence on each pattern
+    for (const pattern of existing.patterns) {
+        const newCoOccurs = [];
+        for (const [key, count] of coOccurrenceCount) {
+            const [a, b] = key.split('::');
+            const other = a === pattern.type ? b : b === pattern.type ? a : null;
+            if (!other)
+                continue;
+            const myFiles = patternFileCount.get(pattern.type) || 1;
+            const correlation = Math.round((count / myFiles) * 100) / 100;
+            const combinedRisk = correlation > 0.5 ? 'ELEVATED' : 'NORMAL';
+            newCoOccurs.push({ pattern: other, correlation, combinedRisk });
+        }
+        if (newCoOccurs.length > 0) {
+            pattern.coOccursWith = newCoOccurs;
+        }
+        // If two co-occurring patterns both have ELEVATED risk, upgrade severity
+        const hasElevated = pattern.coOccursWith.some(co => co.combinedRisk === 'ELEVATED');
+        if (hasElevated && pattern.adjustedSeverity === 'INFO') {
+            pattern.adjustedSeverity = 'WARNING';
+        }
+        else if (hasElevated && pattern.adjustedSeverity === 'WARNING') {
+            pattern.adjustedSeverity = 'CRITICAL';
+        }
+    }
+    // Sort by production occurrences (most important first)
+    existing.patterns.sort((a, b) => b.inProductionFiles - a.inProductionFiles);
+    existing.learnedFrom += new Set(findings.map(f => f.repo)).size;
+    existing.totalFindings += findings.length;
+    existing.lastUpdated = new Date().toISOString();
+    // Save
+    const corpusDir = path.join(projectRoot, '.corpus');
+    if (!existsSync(corpusDir))
+        mkdirSync(corpusDir, { recursive: true });
+    writeFileSync(patternsPath, JSON.stringify(existing, null, 2));
+    return existing;
+}
+/**
+ * Get learned patterns for display.
+ */
+export function getLearnedPatterns(projectRoot) {
+    const patternsPath = path.join(projectRoot, '.corpus', 'patterns.json');
+    if (!existsSync(patternsPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(patternsPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a finding should be suppressed based on learned patterns.
+ */
+// Contexts where certain pattern types are always safe (always suppress)
+const SAFE_CONTEXT_OVERRIDES = {
+    'webpack-config': ['eval_usage', 'dynamic_require', 'process_env_access'],
+    'build-script': ['eval_usage', 'dynamic_require', 'shell_exec', 'process_env_access'],
+    'test-harness': ['eval_usage', 'hardcoded_secret', 'shell_exec', 'dynamic_require'],
+};
+// Contexts where certain pattern types are always dangerous (never suppress)
+const DANGEROUS_CONTEXT_OVERRIDES = {
+    'route-handler': ['eval_usage', 'shell_exec', 'sql_injection', 'prototype_pollution'],
+    'auth-module': ['hardcoded_secret', 'weak_crypto', 'eval_usage'],
+    'middleware': ['eval_usage', 'shell_exec', 'prototype_pollution'],
+    'database-access': ['sql_injection', 'eval_usage'],
+    'api-client': ['hardcoded_secret', 'ssrf'],
+};
+export function shouldSuppress(projectRoot, type, file, content) {
+    const patterns = getLearnedPatterns(projectRoot);
+    if (!patterns)
+        return { suppress: false };
+    const pattern = patterns.patterns.find(p => p.type === type);
+    if (!pattern)
+        return { suppress: false };
+    // Determine the context of this specific file
+    const context = classifyContext(file, content || '');
+    // Context-aware overrides: certain patterns in safe contexts always suppress
+    const safePatterns = SAFE_CONTEXT_OVERRIDES[context];
+    if (safePatterns && safePatterns.includes(type)) {
+        return {
+            suppress: true,
+            reason: `Pattern '${type}' in '${context}' context is a known safe usage. Suppressed.`,
+        };
+    }
+    // Context-aware overrides: certain patterns in dangerous contexts never suppress
+    const dangerousPatterns = DANGEROUS_CONTEXT_OVERRIDES[context];
+    if (dangerousPatterns && dangerousPatterns.includes(type)) {
+        return { suppress: false };
+    }
+    // CVE-linked patterns are never suppressed
+    if (pattern.linkedCVEs && pattern.linkedCVEs.length > 0) {
+        return { suppress: false };
+    }
+    if (pattern.adjustedSeverity === 'SUPPRESSED') {
+        return {
+            suppress: true,
+            reason: `Pattern '${type}' has ${pattern.falsePositiveRate}% false positive rate across ${pattern.totalOccurrences} occurrences in ${patterns.learnedFrom} repos. Likely not a real issue.`,
+        };
+    }
+    if (isTestFile(file) && pattern.inTestFiles > pattern.inProductionFiles) {
+        return {
+            suppress: true,
+            reason: `Pattern '${type}' is ${Math.round((pattern.inTestFiles / pattern.totalOccurrences) * 100)}% test-only. Suppressed in test files.`,
+        };
+    }
+    return { suppress: false };
+}
+/**
+ * Get intelligence verdict for a specific pattern type.
+ */
+export function getPatternIntelligence(projectRoot, type) {
+    const patterns = getLearnedPatterns(projectRoot);
+    if (!patterns)
+        return null;
+    const pattern = patterns.patterns.find(p => p.type === type);
+    if (!pattern)
+        return null;
+    // Confidence is based on sample size
+    const sampleConfidence = Math.min(100, Math.round((pattern.totalOccurrences / 50) * 100));
+    const repoConfidence = Math.min(100, Math.round((pattern.repoCount / 10) * 100));
+    const confidence = Math.round((sampleConfidence + repoConfidence) / 2);
+    const reasons = [];
+    reasons.push(`Seen ${pattern.totalOccurrences} times across ${pattern.repoCount} repos (${pattern.repoPrevalence}% prevalence).`);
+    if (pattern.falsePositiveRate > 50) {
+        reasons.push(`High false positive rate: ${pattern.falsePositiveRate}%.`);
+    }
+    if (pattern.linkedCVEs.length > 0) {
+        reasons.push(`Linked to CVEs: ${pattern.linkedCVEs.join(', ')}.`);
+    }
+    const elevatedCoOccurs = pattern.coOccursWith.filter(co => co.combinedRisk === 'ELEVATED');
+    if (elevatedCoOccurs.length > 0) {
+        reasons.push(`Elevated risk when combined with: ${elevatedCoOccurs.map(co => co.pattern).join(', ')}.`);
+    }
+    const topContexts = Object.entries(pattern.contextBreakdown)
+        .sort(([, a], [, b]) => b - a)
+        .slice(0, 3)
+        .map(([ctx, count]) => `${ctx}(${count})`)
+        .join(', ');
+    if (topContexts) {
+        reasons.push(`Top contexts: ${topContexts}.`);
+    }
+    return {
+        verdict: pattern.adjustedSeverity,
+        confidence,
+        reasoning: reasons.join(' '),
+    };
+}
+/**
+ * Register known legitimate npm packages to reduce false positives.
+ */
+export function addKnownPackages(projectRoot, packages) {
+    const patternsPath = path.join(projectRoot, '.corpus', 'patterns.json');
+    let existing;
+    if (existsSync(patternsPath)) {
+        existing = JSON.parse(readFileSync(patternsPath, 'utf-8'));
+        if (!existing.knownPackages)
+            existing.knownPackages = [];
+    }
+    else {
+        existing = {
+            version: 1,
+            learnedFrom: 0,
+            totalFindings: 0,
+            patterns: [],
+            lastUpdated: new Date().toISOString(),
+            knownPackages: [],
+            repoCategories: {},
+        };
+    }
+    const packageSet = new Set(existing.knownPackages);
+    for (const pkg of packages) {
+        packageSet.add(pkg);
+    }
+    existing.knownPackages = Array.from(packageSet);
+    existing.lastUpdated = new Date().toISOString();
+    const corpusDir = path.join(projectRoot, '.corpus');
+    if (!existsSync(corpusDir))
+        mkdirSync(corpusDir, { recursive: true });
+    writeFileSync(patternsPath, JSON.stringify(existing, null, 2));
+}
+/**
+ * Categorize a repo for context-weighted pattern analysis.
+ */
+export function categorizeRepo(projectRoot, repo, category) {
+    const patternsPath = path.join(projectRoot, '.corpus', 'patterns.json');
+    let existing;
+    if (existsSync(patternsPath)) {
+        existing = JSON.parse(readFileSync(patternsPath, 'utf-8'));
+        if (!existing.repoCategories)
+            existing.repoCategories = {};
+    }
+    else {
+        existing = {
+            version: 1,
+            learnedFrom: 0,
+            totalFindings: 0,
+            patterns: [],
+            lastUpdated: new Date().toISOString(),
+            knownPackages: [],
+            repoCategories: {},
+        };
+    }
+    existing.repoCategories[repo] = category;
+    existing.lastUpdated = new Date().toISOString();
+    const corpusDir = path.join(projectRoot, '.corpus');
+    if (!existsSync(corpusDir))
+        mkdirSync(corpusDir, { recursive: true });
+    writeFileSync(patternsPath, JSON.stringify(existing, null, 2));
+}

package/dist/scanners/code-safety.d.ts

@@ -0,0 +1,13 @@
+export type SafetySeverity = 'CRITICAL' | 'WARNING' | 'INFO';
+export interface SafetyFinding {
+    severity: SafetySeverity;
+    rule: string;
+    line: number;
+    file: string;
+    message: string;
+    suggestion: string;
+}
+/**
+ * Scans file content for unsafe code patterns.
+ */
+export declare function checkCodeSafety(content: string, filepath: string): SafetyFinding[];

package/dist/scanners/code-safety.js

@@ -0,0 +1,114 @@
+const SAFETY_RULES = [
+    // Security
+    {
+        name: 'eval_usage',
+        regex: /\beval\s*\(/g,
+        severity: 'CRITICAL',
+        message: 'eval() usage detected. This enables arbitrary code execution.',
+        suggestion: 'Use JSON.parse() for data, or Function() constructor if dynamic code is unavoidable.',
+    },
+    {
+        name: 'innerHTML_assignment',
+        regex: /\.innerHTML\s*=/g,
+        severity: 'WARNING',
+        message: 'Direct innerHTML assignment. Risk of XSS if content is user-controlled.',
+        suggestion: 'Use textContent for text, or sanitize HTML with DOMPurify before insertion.',
+    },
+    {
+        name: 'sql_concatenation',
+        regex: /(?:SELECT|INSERT|UPDATE|DELETE|DROP)\s+.*\+\s*(?:req\.|params\.|query\.|body\.)/gi,
+        severity: 'CRITICAL',
+        message: 'SQL query built with string concatenation. SQL injection risk.',
+        suggestion: 'Use parameterized queries or an ORM.',
+    },
+    {
+        name: 'exec_usage',
+        regex: /(?:child_process\.)?exec\s*\(\s*(?:`[^`]*\$\{|['"][^'"]*\+)/g,
+        severity: 'CRITICAL',
+        message: 'Shell command built with dynamic input. Command injection risk.',
+        suggestion: 'Use execFile() with an argument array instead of exec() with string interpolation.',
+    },
+    {
+        name: 'disabled_auth',
+        regex: /(?:auth|authentication|authorize)\s*[=:]\s*(?:false|null|undefined|'none'|"none")/gi,
+        severity: 'WARNING',
+        message: 'Authentication appears to be disabled.',
+        suggestion: 'Ensure this is intentional and only in development/test environments.',
+    },
+    {
+        name: 'hardcoded_ip',
+        regex: /['"](?:0\.0\.0\.0|127\.0\.0\.1)(?::\d+)?['"]/g,
+        severity: 'INFO',
+        message: 'Hardcoded IP address. May bind to all interfaces (0.0.0.0) in production.',
+        suggestion: 'Use environment variable for host binding. 0.0.0.0 exposes the service to all network interfaces.',
+    },
+    {
+        name: 'chmod_777',
+        regex: /chmod\s+777/g,
+        severity: 'WARNING',
+        message: 'chmod 777 gives all users read/write/execute permissions.',
+        suggestion: 'Use the minimum required permissions (e.g., 755 for executables, 644 for files).',
+    },
+    {
+        name: 'console_log_sensitive',
+        regex: /console\.log\s*\([^)]*(?:password|secret|token|key|credential|auth)[^)]*\)/gi,
+        severity: 'WARNING',
+        message: 'console.log may be logging sensitive data.',
+        suggestion: 'Remove or redact sensitive values before logging.',
+    },
+    {
+        name: 'todo_security',
+        regex: /\/\/\s*TODO:?\s*(?:fix|add|implement)\s*(?:auth|security|validation|sanitiz)/gi,
+        severity: 'INFO',
+        message: 'Security-related TODO found. This may indicate incomplete security implementation.',
+        suggestion: 'Address security TODOs before shipping to production.',
+    },
+    {
+        name: 'no_verify_flag',
+        regex: /--no-verify|--no-check|--insecure|--skip-ssl/g,
+        severity: 'WARNING',
+        message: 'Security verification bypass flag detected.',
+        suggestion: 'Remove bypass flags before shipping to production.',
+        fileFilter: /\.(sh|bash|yml|yaml|json|toml)$/,
+    },
+    {
+        name: 'debug_endpoint',
+        regex: /(?:app|router|server)\.\s*(?:get|post|use)\s*\(\s*['"]\/(?:debug|test|admin|internal)/g,
+        severity: 'WARNING',
+        message: 'Debug/admin endpoint detected. May be accessible in production.',
+        suggestion: 'Gate behind authentication or remove before deployment.',
+    },
+    {
+        name: 'wildcard_permissions',
+        regex: /"(?:Action|Resource)"\s*:\s*"\*"/g,
+        severity: 'CRITICAL',
+        message: 'Wildcard IAM permission detected. Overly permissive.',
+        suggestion: 'Use least-privilege permissions. Specify exact actions and resources.',
+        fileFilter: /\.(json|yaml|yml|tf)$/,
+    },
+];
+/**
+ * Scans file content for unsafe code patterns.
+ */
+export function checkCodeSafety(content, filepath) {
+    const findings = [];
+    for (const rule of SAFETY_RULES) {
+        if (rule.fileFilter && !rule.fileFilter.test(filepath))
+            continue;
+        rule.regex.lastIndex = 0;
+        let match;
+        while ((match = rule.regex.exec(content)) !== null) {
+            const beforeMatch = content.slice(0, match.index);
+            const line = beforeMatch.split('\n').length;
+            findings.push({
+                severity: rule.severity,
+                rule: rule.name,
+                line,
+                file: filepath,
+                message: rule.message,
+                suggestion: rule.suggestion,
+            });
+        }
+    }
+    return findings;
+}

package/dist/scanners/confidence-calibrator.d.ts

@@ -0,0 +1,25 @@
+export interface CalibrationEntry {
+    intent: string;
+    confidence: number;
+    verdict: string;
+    userDecision: 'CONFIRMED' | 'CANCELLED' | null;
+}
+export interface CalibrationResult {
+    intent: string;
+    totalActions: number;
+    meanConfidence: number;
+    overconfidentCount: number;
+    underconfidentCount: number;
+    recommendedThreshold: number;
+    isMiscalibrated: boolean;
+}
+export interface CalibrationReport {
+    results: CalibrationResult[];
+    miscalibratedIntents: string[];
+    summary: string;
+}
+/**
+ * Analyzes action logs for per-intent confidence calibration.
+ * Requires at least `minSampleSize` entries per intent to produce results.
+ */
+export declare function auditCalibration(actionLog: CalibrationEntry[], minSampleSize?: number): CalibrationReport;

package/dist/scanners/confidence-calibrator.js

@@ -0,0 +1,58 @@
+/**
+ * Analyzes action logs for per-intent confidence calibration.
+ * Requires at least `minSampleSize` entries per intent to produce results.
+ */
+export function auditCalibration(actionLog, minSampleSize = 20) {
+    const byIntent = new Map();
+    for (const entry of actionLog) {
+        const intent = entry.intent || 'unknown';
+        if (!byIntent.has(intent))
+            byIntent.set(intent, []);
+        byIntent.get(intent).push(entry);
+    }
+    const results = [];
+    const miscalibrated = [];
+    for (const [intent, entries] of byIntent) {
+        if (entries.length < minSampleSize)
+            continue;
+        const total = entries.length;
+        const meanConf = entries.reduce((s, e) => s + e.confidence, 0) / total;
+        const overconfident = entries.filter((e) => e.confidence > 0.72 && e.userDecision === 'CANCELLED');
+        const underconfident = entries.filter((e) => e.confidence < 0.72 && e.userDecision === 'CONFIRMED');
+        const ocRate = overconfident.length / total;
+        const ucRate = underconfident.length / total;
+        const isMiscalibrated = ocRate > 0.15 || ucRate > 0.15;
+        const cancelled = entries
+            .filter((e) => e.userDecision === 'CANCELLED')
+            .map((e) => e.confidence);
+        const confirmed = entries
+            .filter((e) => e.userDecision === 'CONFIRMED')
+            .map((e) => e.confidence);
+        let recommended = 0.72;
+        if (cancelled.length > 0) {
+            recommended = Math.max(...cancelled) + 0.05;
+        }
+        else if (confirmed.length > 0) {
+            recommended = Math.min(...confirmed) - 0.05;
+        }
+        recommended = Math.max(0.3, Math.min(0.95, recommended));
+        if (isMiscalibrated)
+            miscalibrated.push(intent);
+        results.push({
+            intent,
+            totalActions: total,
+            meanConfidence: Math.round(meanConf * 1000) / 1000,
+            overconfidentCount: overconfident.length,
+            underconfidentCount: underconfident.length,
+            recommendedThreshold: Math.round(recommended * 100) / 100,
+            isMiscalibrated,
+        });
+    }
+    return {
+        results,
+        miscalibratedIntents: miscalibrated,
+        summary: miscalibrated.length > 0
+            ? `${miscalibrated.length} intent(s) miscalibrated: ${miscalibrated.join(', ')}`
+            : 'All intents well-calibrated',
+    };
+}

package/dist/scanners/context-poisoning.d.ts

@@ -0,0 +1,18 @@
+export type PoisoningSeverity = 'CLEAN' | 'SUSPICIOUS' | 'POISONED';
+export interface PoisoningScanResult {
+    severity: PoisoningSeverity;
+    pattern: string | null;
+    chunkId: string;
+    message: string;
+}
+/**
+ * Scans a memory chunk for poisoning signatures.
+ */
+export declare function scanMemoryChunk(content: string, chunkId?: string, retrievalQuery?: string): PoisoningScanResult;
+/**
+ * Batch scan multiple memory chunks. Returns only problematic ones.
+ */
+export declare function scanMemoryChunks(chunks: {
+    content: string;
+    id?: string;
+}[], retrievalQuery?: string): PoisoningScanResult[];