tryassay 0.29.0 → 0.31.0

package/dist/lib/learned-rules/category-map.js

@@ -0,0 +1,110 @@
+/**
+ * Canonical Category Map — normalizes the fragmented claim categories
+ * (37 variants) down to ~12 canonical categories.
+ *
+ * Used in two places:
+ *   1. Rule creation (harvester + pattern extractor) — new rules get canonical categories
+ *   2. Rule loading (catalog) — existing rules get mapped at load time
+ */
+/**
+ * The canonical set of claim categories for all learned rules.
+ */
+export const CANONICAL_CATEGORIES = [
+    'security',
+    'error-handling',
+    'data-validation',
+    'async',
+    'resource-management',
+    'api-contract',
+    'state-management',
+    'i18n',
+    'performance',
+    'type-safety',
+    'ui-logic',
+    'code-quality',
+];
+/**
+ * Maps every known raw category string to its canonical form.
+ *
+ * When adding new mappings, keep the keys lowercase and hyphenated.
+ */
+export const CATEGORY_MAP = {
+    // ── security ────────────────────────────────────────────────
+    'security': 'security',
+    // ── error-handling ──────────────────────────────────────────
+    'error-handling': 'error-handling',
+    'null-safety': 'error-handling',
+    'logging': 'error-handling',
+    // ── data-validation ─────────────────────────────────────────
+    'data-validation': 'data-validation',
+    'validation-safety': 'data-validation',
+    'data-integrity': 'data-validation',
+    'data-accuracy': 'data-validation',
+    'data-consistency': 'data-validation',
+    'database-integrity': 'data-validation',
+    // ── async ───────────────────────────────────────────────────
+    'async': 'async',
+    'concurrency': 'async',
+    'race-condition': 'async',
+    'race-conditions': 'async',
+    // ── resource-management ─────────────────────────────────────
+    'resource-management': 'resource-management',
+    // ── api-contract ────────────────────────────────────────────
+    'api-contract': 'api-contract',
+    'dependency-injection': 'api-contract',
+    // ── state-management ────────────────────────────────────────
+    'state-management': 'state-management',
+    // ── i18n ────────────────────────────────────────────────────
+    'i18n': 'i18n',
+    'i18n-compliance': 'i18n',
+    'i18n-safety': 'i18n',
+    'i18n-support': 'i18n',
+    'internationalization': 'i18n',
+    'localization': 'i18n',
+    // ── performance ─────────────────────────────────────────────
+    'performance': 'performance',
+    'react-optimization': 'performance',
+    // ── type-safety ─────────────────────────────────────────────
+    'type-safety': 'type-safety',
+    // ── ui-logic ────────────────────────────────────────────────
+    'ui-logic': 'ui-logic',
+    'ui-ux': 'ui-logic',
+    'react-antipatterns': 'ui-logic',
+    'react-best-practices': 'ui-logic',
+    'react-patterns': 'ui-logic',
+    // ── code-quality ────────────────────────────────────────────
+    'code-quality': 'code-quality',
+    'code-convention': 'code-quality',
+    'documentation': 'code-quality',
+    'test-reliability': 'code-quality',
+    'test-robustness': 'code-quality',
+    // ── catch-all for logic variants ────────────────────────────
+    'logic': 'error-handling',
+    'logic-error': 'error-handling',
+    'logic-flow': 'error-handling',
+    'logic-control-flow': 'error-handling',
+    'bug-fix': 'error-handling',
+    'business-logic': 'data-validation',
+};
+/**
+ * Normalize a raw category string to its canonical form.
+ *
+ * Lookup order:
+ *   1. Exact match in CATEGORY_MAP
+ *   2. Lowercase + trim exact match
+ *   3. Fallback to 'code-quality' (the broadest bucket)
+ */
+export function normalizeCategory(raw) {
+    // 1. Exact match
+    const exact = CATEGORY_MAP[raw];
+    if (exact)
+        return exact;
+    // 2. Normalized match (lowercase, trimmed)
+    const normalized = raw.toLowerCase().trim();
+    const normMatch = CATEGORY_MAP[normalized];
+    if (normMatch)
+        return normMatch;
+    // 3. Fallback
+    return 'code-quality';
+}
+//# sourceMappingURL=category-map.js.map

package/dist/lib/learned-rules/category-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"category-map.js","sourceRoot":"","sources":["../../../src/lib/learned-rules/category-map.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,UAAU;IACV,gBAAgB;IAChB,iBAAiB;IACjB,OAAO;IACP,qBAAqB;IACrB,cAAc;IACd,kBAAkB;IAClB,MAAM;IACN,aAAa;IACb,aAAa;IACb,UAAU;IACV,cAAc;CACN,CAAC;AAIX;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAgD;IACvE,+DAA+D;IAC/D,UAAU,EAAE,UAAU;IAEtB,+DAA+D;IAC/D,gBAAgB,EAAE,gBAAgB;IAClC,aAAa,EAAE,gBAAgB;IAC/B,SAAS,EAAE,gBAAgB;IAE3B,+DAA+D;IAC/D,iBAAiB,EAAE,iBAAiB;IACpC,mBAAmB,EAAE,iBAAiB;IACtC,gBAAgB,EAAE,iBAAiB;IACnC,eAAe,EAAE,iBAAiB;IAClC,kBAAkB,EAAE,iBAAiB;IACrC,oBAAoB,EAAE,iBAAiB;IAEvC,+DAA+D;IAC/D,OAAO,EAAE,OAAO;IAChB,aAAa,EAAE,OAAO;IACtB,gBAAgB,EAAE,OAAO;IACzB,iBAAiB,EAAE,OAAO;IAE1B,+DAA+D;IAC/D,qBAAqB,EAAE,qBAAqB;IAE5C,+DAA+D;IAC/D,cAAc,EAAE,cAAc;IAC9B,sBAAsB,EAAE,cAAc;IAEtC,+DAA+D;IAC/D,kBAAkB,EAAE,kBAAkB;IAEtC,+DAA+D;IAC/D,MAAM,EAAE,MAAM;IACd,iBAAiB,EAAE,MAAM;IACzB,aAAa,EAAE,MAAM;IACrB,cAAc,EAAE,MAAM;IACtB,sBAAsB,EAAE,MAAM;IAC9B,cAAc,EAAE,MAAM;IAEtB,+DAA+D;IAC/D,aAAa,EAAE,aAAa;IAC5B,oBAAoB,EAAE,aAAa;IAEnC,+DAA+D;IAC/D,aAAa,EAAE,aAAa;IAE5B,+DAA+D;IAC/D,UAAU,EAAE,UAAU;IACtB,OAAO,EAAE,UAAU;IACnB,oBAAoB,EAAE,UAAU;IAChC,sBAAsB,EAAE,UAAU;IAClC,gBAAgB,EAAE,UAAU;IAE5B,+DAA+D;IAC/D,cAAc,EAAE,cAAc;IAC9B,iBAAiB,EAAE,cAAc;IACjC,eAAe,EAAE,cAAc;IAC/B,kBAAkB,EAAE,cAAc;IAClC,iBAAiB,EAAE,cAAc;IAEjC,+DAA+D;IAC/D,OAAO,EAAE,gBAAgB;IACzB,aAAa,EAAE,gBAAgB;IAC/B,YAAY,EAAE,gBAAgB;IAC9B,oBAAoB,EAAE,gBAAgB;IACtC,SAAS,EAAE,gBAAgB;IAC3B,gBAAgB,EAAE,iBAAiB;CACpC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAW;IAC3C,iBAAiB;IACjB,MAAM,KAAK,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IAChC,IAAI,KAAK;QAAE,OAAO,KAAK,CAAC;IAExB,2CAA2C;IAC3C,MAAM,UAAU,GAAG,GAAG,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC;IAC5C,MAAM,SAAS,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC;IAC3C,IAAI,SAAS;QAAE,OAAO,SAAS,CAAC;IAEhC,cAAc;IACd,OAAO,cAAc,CAAC;AACxB,CAAC"}

package/dist/lib/learned-rules/index.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Self-Expanding Formal Verification — Phase 1 Entry Point
+ *
+ * Pipeline: LLM finds bug → pattern extractor → rule codifier → validation → catalog
+ *
+ * Usage:
+ *   // After a scan confirms a finding:
+ *   const result = await learnFromFinding(projectPath, input);
+ *
+ *   // During a scan, run learned rules alongside hand-crafted ones:
+ *   const findings = await runLearnedRules(projectPath, code, language);
+ */
+export { extractPattern, getSupportedCategories, resetPatternCounter } from './pattern-extractor.js';
+export { normalizeCategory, CANONICAL_CATEGORIES, CATEGORY_MAP } from './category-map.js';
+export type { CanonicalCategory } from './category-map.js';
+export { codifyRule, executeRule, updateRuleStatus, recordRuleFire, resetRuleCounter } from './rule-codifier.js';
+export { validateRule, getValidationThresholds } from './validation-harness.js';
+export { STARTER_RULES } from './starter-catalog.js';
+export { loadRules, saveRules, addRule, updateRule, getPromotedRules, getCandidateRules, getRulesByCategory, loadStats, } from './learned-catalog.js';
+export type { ExtractedPattern, LearnedRule, LearnedRuleStatus, PatternExtractionInput, PatternExtractionResult, SourceFinding, ValidationResult, TestCase, PatternKind, PRReviewComment, DiscoveredPR, DiffHunk, ParsedPRDiff, GeneralizedRule, } from './types.js';
+import type { PatternExtractionInput, LearnedRule } from './types.js';
+/**
+ * Tracks per-rule fire counts across files within a single `assay assess` run.
+ *
+ * After a rule fires in >30% of files scanned so far (minimum 5 files),
+ * it is suppressed for the remainder of the scan.
+ *
+ * Create one per scan run and pass it to `runLearnedRules()`.
+ */
+export declare class ScanSession {
+    /** Total files processed so far. */
+    private fileCount;
+    /** ruleId → number of files where the rule fired. */
+    private readonly fireCounts;
+    /** Rules that have been permanently suppressed for this session. */
+    private readonly suppressed;
+    /** Call once per file, before running rules on that file. */
+    recordFile(): void;
+    /** Record that a rule fired on the current file. */
+    recordFire(ruleId: string): void;
+    /** Check whether a rule should be suppressed. */
+    isSuppressed(ruleId: string): boolean;
+    /** Snapshot of session stats (useful for diagnostics). */
+    stats(): ScanSessionStats;
+}
+/** Diagnostic snapshot of a scan session. */
+export interface ScanSessionStats {
+    readonly filesScanned: number;
+    readonly suppressedRules: string[];
+    readonly fireCounts: Record<string, number>;
+}
+export interface LearnResult {
+    /** Whether a new rule was created. */
+    readonly learned: boolean;
+    /** The rule, if created. */
+    readonly rule?: LearnedRule;
+    /** Why learning didn't produce a rule. */
+    readonly reason?: string;
+}
+/**
+ * Full pipeline: extract pattern → codify rule → validate → store.
+ *
+ * Call this after confirming an LLM finding is correct.
+ * The system will try to extract a generalizable pattern and
+ * create a formal rule that catches future instances.
+ *
+ * @param projectPath - Root of the project being scanned.
+ * @param input - The confirmed finding with code context.
+ * @returns Whether a rule was learned and stored.
+ */
+export declare function learnFromFinding(projectPath: string, input: PatternExtractionInput): Promise<LearnResult>;
+/**
+ * Run all promoted learned rules against code.
+ *
+ * Returns findings from rules that fire.
+ * These run alongside the hand-crafted formal checks.
+ *
+ * @param session - Optional scan session for noise suppression.
+ *   When provided, rules that fire on >30% of files (min 5 files)
+ *   are suppressed for the remainder of the scan. The caller must
+ *   call `session.recordFile()` before each invocation.
+ */
+export declare function runLearnedRules(projectPath: string, code: string, language: string, session?: ScanSession): Promise<LearnedRuleFinding[]>;
+/** A finding produced by a learned rule. */
+export interface LearnedRuleFinding {
+    readonly ruleId: string;
+    readonly description: string;
+    readonly severity: 'critical' | 'high' | 'medium';
+    readonly category: string;
+    readonly evidence: string;
+    readonly matches: string[];
+    /** Confidence based on the rule's track record. */
+    readonly confidence: number;
+    /** Whether this finding came from the server catalog or local starter rules. */
+    readonly source?: 'server' | 'local';
+}
+/**
+ * Get a summary of the learned rule system status.
+ */
+export declare function getLearnedRulesSummary(projectPath: string): Promise<{
+    total: number;
+    promoted: number;
+    candidates: number;
+    rejected: number;
+    categories: string[];
+    totalFires: number;
+}>;

package/dist/lib/learned-rules/index.js

@@ -0,0 +1,198 @@
+/**
+ * Self-Expanding Formal Verification — Phase 1 Entry Point
+ *
+ * Pipeline: LLM finds bug → pattern extractor → rule codifier → validation → catalog
+ *
+ * Usage:
+ *   // After a scan confirms a finding:
+ *   const result = await learnFromFinding(projectPath, input);
+ *
+ *   // During a scan, run learned rules alongside hand-crafted ones:
+ *   const findings = await runLearnedRules(projectPath, code, language);
+ */
+export { extractPattern, getSupportedCategories, resetPatternCounter } from './pattern-extractor.js';
+export { normalizeCategory, CANONICAL_CATEGORIES, CATEGORY_MAP } from './category-map.js';
+export { codifyRule, executeRule, updateRuleStatus, recordRuleFire, resetRuleCounter } from './rule-codifier.js';
+export { validateRule, getValidationThresholds } from './validation-harness.js';
+export { STARTER_RULES } from './starter-catalog.js';
+export { loadRules, saveRules, addRule, updateRule, getPromotedRules, getCandidateRules, getRulesByCategory, loadStats, } from './learned-catalog.js';
+import { extractPattern } from './pattern-extractor.js';
+import { codifyRule, executeRule } from './rule-codifier.js';
+import { validateRule } from './validation-harness.js';
+import { addRule, getPromotedRules, updateRule } from './learned-catalog.js';
+import { updateRuleStatus } from './rule-codifier.js';
+// ── Scan Session (Noise Suppression) ────────────────────────
+/** Minimum files scanned before noise suppression kicks in. */
+const NOISE_MIN_FILES = 5;
+/** If a rule fires on more than this fraction of files, suppress it. */
+const NOISE_THRESHOLD = 0.3;
+/**
+ * Tracks per-rule fire counts across files within a single `assay assess` run.
+ *
+ * After a rule fires in >30% of files scanned so far (minimum 5 files),
+ * it is suppressed for the remainder of the scan.
+ *
+ * Create one per scan run and pass it to `runLearnedRules()`.
+ */
+export class ScanSession {
+    /** Total files processed so far. */
+    fileCount = 0;
+    /** ruleId → number of files where the rule fired. */
+    fireCounts = new Map();
+    /** Rules that have been permanently suppressed for this session. */
+    suppressed = new Set();
+    /** Call once per file, before running rules on that file. */
+    recordFile() {
+        this.fileCount++;
+    }
+    /** Record that a rule fired on the current file. */
+    recordFire(ruleId) {
+        this.fireCounts.set(ruleId, (this.fireCounts.get(ruleId) ?? 0) + 1);
+    }
+    /** Check whether a rule should be suppressed. */
+    isSuppressed(ruleId) {
+        if (this.suppressed.has(ruleId))
+            return true;
+        if (this.fileCount >= NOISE_MIN_FILES) {
+            const fires = this.fireCounts.get(ruleId) ?? 0;
+            if (fires / this.fileCount > NOISE_THRESHOLD) {
+                this.suppressed.add(ruleId);
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Snapshot of session stats (useful for diagnostics). */
+    stats() {
+        return {
+            filesScanned: this.fileCount,
+            suppressedRules: [...this.suppressed],
+            fireCounts: Object.fromEntries(this.fireCounts),
+        };
+    }
+}
+/**
+ * Full pipeline: extract pattern → codify rule → validate → store.
+ *
+ * Call this after confirming an LLM finding is correct.
+ * The system will try to extract a generalizable pattern and
+ * create a formal rule that catches future instances.
+ *
+ * @param projectPath - Root of the project being scanned.
+ * @param input - The confirmed finding with code context.
+ * @returns Whether a rule was learned and stored.
+ */
+export async function learnFromFinding(projectPath, input) {
+    // Step 1: Extract pattern
+    const extraction = extractPattern(input);
+    if (!extraction.success || !extraction.pattern) {
+        return {
+            learned: false,
+            reason: extraction.failureReason ?? 'Pattern extraction failed',
+        };
+    }
+    // Step 2: Codify as a rule
+    const rule = codifyRule(extraction.pattern, input);
+    // Step 3: Validate against synthetic test cases
+    const validation = validateRule(rule);
+    const validatedRule = {
+        ...rule,
+        validationResults: validation,
+    };
+    if (!validation.passed) {
+        // Store as rejected for record-keeping
+        const rejectedRule = updateRuleStatus(validatedRule, 'rejected');
+        await addRule(projectPath, rejectedRule);
+        return {
+            learned: false,
+            rule: rejectedRule,
+            reason: `Validation failed: precision=${validation.precision.toFixed(2)}, recall=${validation.recall.toFixed(2)}`,
+        };
+    }
+    // Step 4: Promote to validated and store
+    const promotedRule = updateRuleStatus(validatedRule, 'promoted');
+    await addRule(projectPath, promotedRule);
+    return {
+        learned: true,
+        rule: promotedRule,
+    };
+}
+/**
+ * Run all promoted learned rules against code.
+ *
+ * Returns findings from rules that fire.
+ * These run alongside the hand-crafted formal checks.
+ *
+ * @param session - Optional scan session for noise suppression.
+ *   When provided, rules that fire on >30% of files (min 5 files)
+ *   are suppressed for the remainder of the scan. The caller must
+ *   call `session.recordFile()` before each invocation.
+ */
+export async function runLearnedRules(projectPath, code, language, session) {
+    const rules = await getPromotedRules(projectPath);
+    const findings = [];
+    for (const rule of rules) {
+        // Skip rules the session has already flagged as noise
+        if (session?.isSuppressed(rule.id))
+            continue;
+        const { fires, matches } = executeRule(rule, code, language);
+        if (fires) {
+            // Record the fire in the session before checking suppression
+            if (session) {
+                session.recordFire(rule.id);
+                // Re-check: this fire may have pushed the rule over the threshold
+                if (session.isSuppressed(rule.id))
+                    continue;
+            }
+            findings.push({
+                ruleId: rule.id,
+                description: rule.pattern.description,
+                severity: rule.pattern.severity,
+                category: rule.pattern.claimCategory,
+                evidence: rule.pattern.evidenceTemplate
+                    .replace('{match}', matches[0] ?? 'pattern detected')
+                    .replace('{file}', 'current file'),
+                matches,
+                confidence: computeConfidence(rule),
+            });
+            // Track the fire (async, don't block)
+            updateRule(projectPath, rule.id, r => ({
+                ...r,
+                fireCount: r.fireCount + 1,
+                updatedAt: new Date().toISOString(),
+            })).catch(() => { });
+        }
+    }
+    return findings;
+}
+/**
+ * Compute confidence for a rule based on its track record.
+ * New rules start at 0.7, confidence grows with confirmed true positives.
+ */
+function computeConfidence(rule) {
+    if (rule.fireCount === 0)
+        return 0.7; // New rule, moderate confidence
+    const precision = rule.truePositiveCount + rule.falsePositiveCount > 0
+        ? rule.truePositiveCount / (rule.truePositiveCount + rule.falsePositiveCount)
+        : 0.7;
+    // Scale: min 0.5, max 0.95
+    // More fires with high precision → higher confidence
+    const fireBoost = Math.min(rule.fireCount / 100, 0.15);
+    return Math.min(0.95, Math.max(0.5, precision * 0.8 + fireBoost + 0.1));
+}
+/**
+ * Get a summary of the learned rule system status.
+ */
+export async function getLearnedRulesSummary(projectPath) {
+    const { loadRules } = await import('./learned-catalog.js');
+    const rules = await loadRules(projectPath);
+    return {
+        total: rules.length,
+        promoted: rules.filter(r => r.status === 'promoted').length,
+        candidates: rules.filter(r => r.status === 'candidate').length,
+        rejected: rules.filter(r => r.status === 'rejected').length,
+        categories: [...new Set(rules.map(r => r.pattern.claimCategory))],
+        totalFires: rules.reduce((sum, r) => sum + r.fireCount, 0),
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/lib/learned-rules/index.js.map

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

package/dist/lib/learned-rules/learned-catalog.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Learned Rule Catalog — stores, loads, and queries auto-generated formal rules.
+ *
+ * Rules are stored as JSON in the `learned/` subdirectory alongside
+ * hand-crafted rules in check-catalog.ts. This separation ensures
+ * auto-generated rules are clearly distinguishable.
+ *
+ * Storage structure:
+ *   .assay/learned/
+ *     rules.json       — all learned rules
+ *     stats.json       — catalog statistics over time
+ */
+import type { LearnedRule, LearnedRuleStatus } from './types.js';
+export interface CatalogStats {
+    totalRules: number;
+    byStatus: Record<LearnedRuleStatus, number>;
+    byCategory: Record<string, number>;
+    bySeverity: Record<string, number>;
+    totalFires: number;
+    totalTruePositives: number;
+    totalFalsePositives: number;
+    overallPrecision: number;
+    lastUpdated: string;
+}
+/**
+ * Load all learned rules from the project's catalog,
+ * merged with the bundled starter catalog.
+ *
+ * Local rules (from .assay/learned/rules.json) take precedence over
+ * starter rules when IDs collide. Starter rules provide out-of-the-box
+ * coverage even when no local catalog exists.
+ */
+export declare function loadRules(projectPath: string): Promise<LearnedRule[]>;
+/**
+ * Save all learned rules to the project's catalog.
+ */
+export declare function saveRules(projectPath: string, rules: LearnedRule[]): Promise<void>;
+/**
+ * Add a new rule to the catalog.
+ * Returns the updated rule list.
+ */
+export declare function addRule(projectPath: string, rule: LearnedRule): Promise<LearnedRule[]>;
+/**
+ * Update a rule in the catalog by ID.
+ */
+export declare function updateRule(projectPath: string, ruleId: string, updater: (rule: LearnedRule) => LearnedRule): Promise<LearnedRule | null>;
+/**
+ * Get all promoted rules (ready to run in the formal verifier).
+ */
+export declare function getPromotedRules(projectPath: string): Promise<LearnedRule[]>;
+/**
+ * Get all candidate rules (awaiting validation).
+ */
+export declare function getCandidateRules(projectPath: string): Promise<LearnedRule[]>;
+/**
+ * Get rules by category.
+ */
+export declare function getRulesByCategory(projectPath: string, category: string): Promise<LearnedRule[]>;
+/**
+ * Load catalog statistics.
+ */
+export declare function loadStats(projectPath: string): Promise<CatalogStats | null>;

package/dist/lib/learned-rules/learned-catalog.js

@@ -0,0 +1,161 @@
+/**
+ * Learned Rule Catalog — stores, loads, and queries auto-generated formal rules.
+ *
+ * Rules are stored as JSON in the `learned/` subdirectory alongside
+ * hand-crafted rules in check-catalog.ts. This separation ensures
+ * auto-generated rules are clearly distinguishable.
+ *
+ * Storage structure:
+ *   .assay/learned/
+ *     rules.json       — all learned rules
+ *     stats.json       — catalog statistics over time
+ */
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { normalizeCategory } from './category-map.js';
+import { STARTER_RULES } from './starter-catalog.js';
+// ── File Paths ───────────────────────────────────────────────
+function rulesPath(projectPath) {
+    return join(projectPath, '.assay', 'learned', 'rules.json');
+}
+function statsPath(projectPath) {
+    return join(projectPath, '.assay', 'learned', 'stats.json');
+}
+// ── CRUD Operations ──────────────────────────────────────────
+/**
+ * Load all learned rules from the project's catalog,
+ * merged with the bundled starter catalog.
+ *
+ * Local rules (from .assay/learned/rules.json) take precedence over
+ * starter rules when IDs collide. Starter rules provide out-of-the-box
+ * coverage even when no local catalog exists.
+ */
+export async function loadRules(projectPath) {
+    // Load local rules from disk
+    let localRules = [];
+    try {
+        const content = await readFile(rulesPath(projectPath), 'utf-8');
+        const data = JSON.parse(content);
+        if (Array.isArray(data)) {
+            localRules = data.map((rule) => ({
+                ...rule,
+                pattern: {
+                    ...rule.pattern,
+                    claimCategory: normalizeCategory(rule.pattern.claimCategory),
+                },
+            }));
+        }
+    }
+    catch {
+        // No local catalog yet — starter rules will provide base coverage
+    }
+    // Merge: local rules take precedence over starter rules with same ID
+    const localIds = new Set(localRules.map(r => r.id));
+    const starterRulesFiltered = STARTER_RULES.filter(r => !localIds.has(r.id));
+    return [...localRules, ...starterRulesFiltered];
+}
+/**
+ * Save all learned rules to the project's catalog.
+ */
+export async function saveRules(projectPath, rules) {
+    const dir = join(projectPath, '.assay', 'learned');
+    await mkdir(dir, { recursive: true });
+    await writeFile(rulesPath(projectPath), JSON.stringify(rules, null, 2));
+    await saveStats(projectPath, computeStats(rules));
+}
+/**
+ * Add a new rule to the catalog.
+ * Returns the updated rule list.
+ */
+export async function addRule(projectPath, rule) {
+    const rules = await loadRules(projectPath);
+    // Check for duplicate patterns
+    const isDuplicate = rules.some(r => r.pattern.regexPattern === rule.pattern.regexPattern &&
+        r.pattern.claimCategory === rule.pattern.claimCategory &&
+        r.status !== 'rejected' && r.status !== 'deprecated');
+    if (isDuplicate) {
+        return rules; // Don't add duplicates
+    }
+    rules.push(rule);
+    await saveRules(projectPath, rules);
+    return rules;
+}
+/**
+ * Update a rule in the catalog by ID.
+ */
+export async function updateRule(projectPath, ruleId, updater) {
+    const rules = await loadRules(projectPath);
+    const index = rules.findIndex(r => r.id === ruleId);
+    if (index === -1)
+        return null;
+    rules[index] = updater(rules[index]);
+    await saveRules(projectPath, rules);
+    return rules[index];
+}
+/**
+ * Get all promoted rules (ready to run in the formal verifier).
+ */
+export async function getPromotedRules(projectPath) {
+    const rules = await loadRules(projectPath);
+    return rules.filter(r => r.status === 'promoted');
+}
+/**
+ * Get all candidate rules (awaiting validation).
+ */
+export async function getCandidateRules(projectPath) {
+    const rules = await loadRules(projectPath);
+    return rules.filter(r => r.status === 'candidate');
+}
+/**
+ * Get rules by category.
+ */
+export async function getRulesByCategory(projectPath, category) {
+    const rules = await loadRules(projectPath);
+    return rules.filter(r => r.pattern.claimCategory === category);
+}
+// ── Statistics ───────────────────────────────────────────────
+function computeStats(rules) {
+    const byStatus = {};
+    const byCategory = {};
+    const bySeverity = {};
+    let totalFires = 0;
+    let totalTP = 0;
+    let totalFP = 0;
+    for (const rule of rules) {
+        byStatus[rule.status] = (byStatus[rule.status] ?? 0) + 1;
+        byCategory[rule.pattern.claimCategory] = (byCategory[rule.pattern.claimCategory] ?? 0) + 1;
+        bySeverity[rule.pattern.severity] = (bySeverity[rule.pattern.severity] ?? 0) + 1;
+        totalFires += rule.fireCount;
+        totalTP += rule.truePositiveCount;
+        totalFP += rule.falsePositiveCount;
+    }
+    return {
+        totalRules: rules.length,
+        byStatus: byStatus,
+        byCategory,
+        bySeverity,
+        totalFires,
+        totalTruePositives: totalTP,
+        totalFalsePositives: totalFP,
+        overallPrecision: totalTP + totalFP > 0 ? totalTP / (totalTP + totalFP) : 1,
+        lastUpdated: new Date().toISOString(),
+    };
+}
+async function saveStats(projectPath, stats) {
+    const dir = join(projectPath, '.assay', 'learned');
+    await mkdir(dir, { recursive: true });
+    await writeFile(statsPath(projectPath), JSON.stringify(stats, null, 2));
+}
+/**
+ * Load catalog statistics.
+ */
+export async function loadStats(projectPath) {
+    try {
+        const content = await readFile(statsPath(projectPath), 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=learned-catalog.js.map

package/dist/lib/learned-rules/learned-catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"learned-catalog.js","sourceRoot":"","sources":["../../../src/lib/learned-rules/learned-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAgBrD,gEAAgE;AAEhE,SAAS,SAAS,CAAC,WAAmB;IACpC,OAAO,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;AAC9D,CAAC;AAED,SAAS,SAAS,CAAC,WAAmB;IACpC,OAAO,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;AAC9D,CAAC;AAED,gEAAgE;AAEhE;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,WAAmB;IACjD,6BAA6B;IAC7B,IAAI,UAAU,GAAkB,EAAE,CAAC;IACnC,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,CAAC;QAChE,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACjC,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACxB,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,IAAiB,EAAE,EAAE,CAAC,CAAC;gBAC5C,GAAG,IAAI;gBACP,OAAO,EAAE;oBACP,GAAG,IAAI,CAAC,OAAO;oBACf,aAAa,EAAE,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC;iBAC7D;aACF,CAAC,CAAC,CAAC;QACN,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,kEAAkE;IACpE,CAAC;IAED,qEAAqE;IACrE,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACpD,MAAM,oBAAoB,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAE5E,OAAO,CAAC,GAAG,UAAU,EAAE,GAAG,oBAAoB,CAAC,CAAC;AAClD,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,WAAmB,EACnB,KAAoB;IAEpB,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IACnD,MAAM,KAAK,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACtC,MAAM,SAAS,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IACxE,MAAM,SAAS,CAAC,WAAW,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;AACpD,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,WAAmB,EACnB,IAAiB;IAEjB,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,WAAW,CAAC,CAAC;IAE3C,+BAA+B;IAC/B,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CACjC,CAAC,CAAC,OAAO,CAAC,YAAY,KAAK,IAAI,CAAC,OAAO,CAAC,YAAY;QACpD,CAAC,CAAC,OAAO,CAAC,aAAa,KAAK,IAAI,CAAC,OAAO,CAAC,aAAa;QACtD,CAAC,CAAC,MAAM,KAAK,UAAU,IAAI,CAAC,CAAC,MAAM,KAAK,YAAY,CACrD,CAAC;IAEF,IAAI,WAAW,EAAE,CAAC;QAChB,OAAO,KAAK,CAAC,CAAC,uBAAuB;IACvC,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACjB,MAAM,SAAS,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IACpC,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAC9B,WAAmB,EACnB,MAAc,EACd,OAA2C;IAE3C,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,WAAW,CAAC,CAAC;IAC3C,MAAM,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,CAAC;IACpD,IAAI,KAAK,KAAK,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAE9B,KAAK,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IACrC,MAAM,SAAS,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IACpC,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC;AACtB,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,WAAmB;IACxD,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,WAAW,CAAC,CAAC;IAC3C,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC;AACpD,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,WAAmB;IACzD,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,WAAW,CAAC,CAAC;IAC3C,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,WAAW,CAAC,CAAC;AACrD,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,WAAmB,EACnB,QAAgB;IAEhB,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,WAAW,CAAC,CAAC;IAC3C,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,KAAK,QAAQ,CAAC,CAAC;AACjE,CAAC;AAED,gEAAgE;AAEhE,SAAS,YAAY,CAAC,KAAoB;IACxC,MAAM,QAAQ,GAA2B,EAAE,CAAC;IAC5C,MAAM,UAAU,GAA2B,EAAE,CAAC;IAC9C,MAAM,UAAU,GAA2B,EAAE,CAAC;IAC9C,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,IAAI,OAAO,GAAG,CAAC,CAAC;IAEhB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACzD,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QAC3F,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACjF,UAAU,IAAI,IAAI,CAAC,SAAS,CAAC;QAC7B,OAAO,IAAI,IAAI,CAAC,iBAAiB,CAAC;QAClC,OAAO,IAAI,IAAI,CAAC,kBAAkB,CAAC;IACrC,CAAC;IAED,OAAO;QACL,UAAU,EAAE,KAAK,CAAC,MAAM;QACxB,QAAQ,EAAE,QAA6C;QACvD,UAAU;QACV,UAAU;QACV,UAAU;QACV,kBAAkB,EAAE,OAAO;QAC3B,mBAAmB,EAAE,OAAO;QAC5B,gBAAgB,EAAE,OAAO,GAAG,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,CAAC,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3E,WAAW,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;KACtC,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,SAAS,CAAC,WAAmB,EAAE,KAAmB;IAC/D,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IACnD,MAAM,KAAK,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACtC,MAAM,SAAS,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;AAC1E,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,WAAmB;IACjD,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,CAAC;QAChE,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}