driftdetect-cortex 0.9.41

package/dist/learning/analysis/analyzer.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Correction Analyzer
+ *
+ * Orchestrates the full analysis of a correction:
+ * - Computes diff between original and corrected code
+ * - Categorizes the correction
+ * - Extracts generalizable principles
+ * - Suggests memory type to create
+ *
+ * @module learning/analysis/analyzer
+ */
+import type { AnalyzedCorrection, CorrectionMetadata } from '../../types/learning.js';
+import type { IMemoryStorage } from '../../storage/interface.js';
+import { DiffAnalyzer } from './diff-analyzer.js';
+import { CorrectionCategorizer } from './categorizer.js';
+import { PrincipleExtractor } from './principle-extractor.js';
+/**
+ * Options for correction analysis
+ */
+export interface AnalysisOptions {
+    /** Include related memory search */
+    findRelatedMemories?: boolean;
+    /** Maximum related memories to find */
+    maxRelatedMemories?: number;
+    /** Additional metadata */
+    metadata?: CorrectionMetadata;
+}
+/**
+ * Correction Analyzer
+ *
+ * Orchestrates the analysis of user corrections to understand
+ * what went wrong and extract learnable principles.
+ */
+export declare class CorrectionAnalyzer {
+    private categorizer;
+    private principleExtractor;
+    private diffAnalyzer;
+    private storage?;
+    constructor(categorizer: CorrectionCategorizer, principleExtractor: PrincipleExtractor, diffAnalyzer: DiffAnalyzer, storage?: IMemoryStorage | undefined);
+    /**
+     * Analyze a correction
+     */
+    analyze(original: string, feedback: string, correctedCode?: string, options?: AnalysisOptions): Promise<AnalyzedCorrection>;
+    /**
+     * Analyze multiple corrections in batch
+     */
+    analyzeBatch(corrections: Array<{
+        original: string;
+        feedback: string;
+        correctedCode?: string;
+        metadata?: CorrectionMetadata;
+    }>, options?: Omit<AnalysisOptions, 'metadata'>): Promise<AnalyzedCorrection[]>;
+    /**
+     * Suggest memory type based on category
+     */
+    private suggestMemoryType;
+    /**
+     * Find related memories
+     */
+    private findRelatedMemories;
+    /**
+     * Create analyzer with default dependencies
+     */
+    static create(storage?: IMemoryStorage): CorrectionAnalyzer;
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/learning/analysis/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../../../src/learning/analysis/analyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EACV,kBAAkB,EAElB,kBAAkB,EAEnB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,oCAAoC;IACpC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,uCAAuC;IACvC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CAC/B;AAED;;;;;GAKG;AACH,qBAAa,kBAAkB;IAE3B,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,OAAO,CAAC;gBAHR,WAAW,EAAE,qBAAqB,EAClC,kBAAkB,EAAE,kBAAkB,EACtC,YAAY,EAAE,YAAY,EAC1B,OAAO,CAAC,EAAE,cAAc,YAAA;IAGlC;;OAEG;IACG,OAAO,CACX,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,aAAa,CAAC,EAAE,MAAM,EACtB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,kBAAkB,CAAC;IAiE9B;;OAEG;IACG,YAAY,CAChB,WAAW,EAAE,KAAK,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,EAAE,kBAAkB,CAAC;KAC/B,CAAC,EACF,OAAO,GAAE,IAAI,CAAC,eAAe,EAAE,UAAU,CAAM,GAC9C,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAoBhC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAgCzB;;OAEG;YACW,mBAAmB;IA4BjC;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,kBAAkB;CAQ5D"}

package/dist/learning/analysis/analyzer.js

@@ -0,0 +1,148 @@
+/**
+ * Correction Analyzer
+ *
+ * Orchestrates the full analysis of a correction:
+ * - Computes diff between original and corrected code
+ * - Categorizes the correction
+ * - Extracts generalizable principles
+ * - Suggests memory type to create
+ *
+ * @module learning/analysis/analyzer
+ */
+import { randomUUID } from 'crypto';
+import { DiffAnalyzer } from './diff-analyzer.js';
+import { CorrectionCategorizer } from './categorizer.js';
+import { PrincipleExtractor } from './principle-extractor.js';
+/**
+ * Correction Analyzer
+ *
+ * Orchestrates the analysis of user corrections to understand
+ * what went wrong and extract learnable principles.
+ */
+export class CorrectionAnalyzer {
+    categorizer;
+    principleExtractor;
+    diffAnalyzer;
+    storage;
+    constructor(categorizer, principleExtractor, diffAnalyzer, storage) {
+        this.categorizer = categorizer;
+        this.principleExtractor = principleExtractor;
+        this.diffAnalyzer = diffAnalyzer;
+        this.storage = storage;
+    }
+    /**
+     * Analyze a correction
+     */
+    async analyze(original, feedback, correctedCode, options = {}) {
+        const id = randomUUID();
+        // Compute diff if corrected code is provided
+        const diff = correctedCode
+            ? this.diffAnalyzer.computeDiff(original, correctedCode)
+            : undefined;
+        // Categorize the correction
+        const categorizationResult = this.categorizer.categorize(original, feedback, diff || null);
+        // Extract principle
+        const principle = this.principleExtractor.extract(original, feedback, diff || null, categorizationResult.category);
+        // Determine suggested memory type
+        const suggestedMemoryType = this.suggestMemoryType(categorizationResult.category, principle.isHardRule);
+        // Find related memories if storage is available
+        let relatedMemories = [];
+        if (options.findRelatedMemories && this.storage) {
+            relatedMemories = await this.findRelatedMemories(feedback, categorizationResult.category, options.maxRelatedMemories || 5);
+        }
+        const result = {
+            id,
+            original,
+            feedback,
+            category: categorizationResult.category,
+            categoryConfidence: categorizationResult.confidence,
+            principle,
+            suggestedMemoryType,
+            relatedMemories,
+            analyzedAt: new Date().toISOString(),
+        };
+        // Add optional properties only if they have values
+        if (correctedCode) {
+            result.correctedCode = correctedCode;
+        }
+        if (diff) {
+            result.diff = diff;
+        }
+        if (options.metadata) {
+            result.metadata = options.metadata;
+        }
+        return result;
+    }
+    /**
+     * Analyze multiple corrections in batch
+     */
+    async analyzeBatch(corrections, options = {}) {
+        const results = [];
+        for (const correction of corrections) {
+            const analysisOptions = { ...options };
+            if (correction.metadata) {
+                analysisOptions.metadata = correction.metadata;
+            }
+            const result = await this.analyze(correction.original, correction.feedback, correction.correctedCode, analysisOptions);
+            results.push(result);
+        }
+        return results;
+    }
+    /**
+     * Suggest memory type based on category
+     */
+    suggestMemoryType(_category, isHardRule) {
+        switch (_category) {
+            case 'tribal_miss':
+                return 'tribal';
+            case 'pattern_violation':
+            case 'architecture_mismatch':
+                return 'pattern_rationale';
+            case 'security_issue':
+            case 'performance_issue':
+            case 'api_misuse':
+                return 'code_smell';
+            case 'constraint_violation':
+                return 'constraint_override';
+            case 'style_preference':
+            case 'naming_convention':
+                // Style preferences become tribal knowledge
+                return 'tribal';
+            case 'other':
+            default:
+                // Default to procedural for general corrections
+                return isHardRule ? 'tribal' : 'procedural';
+        }
+    }
+    /**
+     * Find related memories
+     */
+    async findRelatedMemories(feedback, _category, limit) {
+        if (!this.storage) {
+            return [];
+        }
+        try {
+            // Search for memories with similar topics
+            const keywords = feedback
+                .toLowerCase()
+                .split(/\W+/)
+                .filter(w => w.length > 3)
+                .slice(0, 5);
+            const memories = await this.storage.search({
+                tags: keywords,
+                limit,
+            });
+            return memories.map(m => m.id);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Create analyzer with default dependencies
+     */
+    static create(storage) {
+        return new CorrectionAnalyzer(new CorrectionCategorizer(), new PrincipleExtractor(), new DiffAnalyzer(), storage);
+    }
+}
+//# sourceMappingURL=analyzer.js.map

package/dist/learning/analysis/analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.js","sourceRoot":"","sources":["../../../src/learning/analysis/analyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAQpC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAc9D;;;;;GAKG;AACH,MAAM,OAAO,kBAAkB;IAEnB;IACA;IACA;IACA;IAJV,YACU,WAAkC,EAClC,kBAAsC,EACtC,YAA0B,EAC1B,OAAwB;QAHxB,gBAAW,GAAX,WAAW,CAAuB;QAClC,uBAAkB,GAAlB,kBAAkB,CAAoB;QACtC,iBAAY,GAAZ,YAAY,CAAc;QAC1B,YAAO,GAAP,OAAO,CAAiB;IAC/B,CAAC;IAEJ;;OAEG;IACH,KAAK,CAAC,OAAO,CACX,QAAgB,EAChB,QAAgB,EAChB,aAAsB,EACtB,UAA2B,EAAE;QAE7B,MAAM,EAAE,GAAG,UAAU,EAAE,CAAC;QAExB,6CAA6C;QAC7C,MAAM,IAAI,GAAG,aAAa;YACxB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,QAAQ,EAAE,aAAa,CAAC;YACxD,CAAC,CAAC,SAAS,CAAC;QAEd,4BAA4B;QAC5B,MAAM,oBAAoB,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CACtD,QAAQ,EACR,QAAQ,EACR,IAAI,IAAI,IAAI,CACb,CAAC;QAEF,oBAAoB;QACpB,MAAM,SAAS,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAC/C,QAAQ,EACR,QAAQ,EACR,IAAI,IAAI,IAAI,EACZ,oBAAoB,CAAC,QAAQ,CAC9B,CAAC;QAEF,kCAAkC;QAClC,MAAM,mBAAmB,GAAG,IAAI,CAAC,iBAAiB,CAChD,oBAAoB,CAAC,QAAQ,EAC7B,SAAS,CAAC,UAAU,CACrB,CAAC;QAEF,gDAAgD;QAChD,IAAI,eAAe,GAAa,EAAE,CAAC;QACnC,IAAI,OAAO,CAAC,mBAAmB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAChD,eAAe,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAC9C,QAAQ,EACR,oBAAoB,CAAC,QAAQ,EAC7B,OAAO,CAAC,kBAAkB,IAAI,CAAC,CAChC,CAAC;QACJ,CAAC;QAED,MAAM,MAAM,GAAuB;YACjC,EAAE;YACF,QAAQ;YACR,QAAQ;YACR,QAAQ,EAAE,oBAAoB,CAAC,QAAQ;YACvC,kBAAkB,EAAE,oBAAoB,CAAC,UAAU;YACnD,SAAS;YACT,mBAAmB;YACnB,eAAe;YACf,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACrC,CAAC;QAEF,mDAAmD;QACnD,IAAI,aAAa,EAAE,CAAC;YAClB,MAAM,CAAC,aAAa,GAAG,aAAa,CAAC;QACvC,CAAC;QACD,IAAI,IAAI,EAAE,CAAC;YACT,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC;QACrB,CAAC;QACD,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YACrB,MAAM,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QACrC,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,YAAY,CAChB,WAKE,EACF,UAA6C,EAAE;QAE/C,MAAM,OAAO,GAAyB,EAAE,CAAC;QAEzC,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;YACrC,MAAM,eAAe,GAAoB,EAAE,GAAG,OAAO,EAAE,CAAC;YACxD,IAAI,UAAU,CAAC,QAAQ,EAAE,CAAC;gBACxB,eAAe,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;YACjD,CAAC;YACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAC/B,UAAU,CAAC,QAAQ,EACnB,UAAU,CAAC,QAAQ,EACnB,UAAU,CAAC,aAAa,EACxB,eAAe,CAChB,CAAC;YACF,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACvB,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACK,iBAAiB,CACvB,SAA6B,EAC7B,UAAmB;QAEnB,QAAQ,SAAS,EAAE,CAAC;YAClB,KAAK,aAAa;gBAChB,OAAO,QAAQ,CAAC;YAElB,KAAK,mBAAmB,CAAC;YACzB,KAAK,uBAAuB;gBAC1B,OAAO,mBAAmB,CAAC;YAE7B,KAAK,gBAAgB,CAAC;YACtB,KAAK,mBAAmB,CAAC;YACzB,KAAK,YAAY;gBACf,OAAO,YAAY,CAAC;YAEtB,KAAK,sBAAsB;gBACzB,OAAO,qBAAqB,CAAC;YAE/B,KAAK,kBAAkB,CAAC;YACxB,KAAK,mBAAmB;gBACtB,4CAA4C;gBAC5C,OAAO,QAAQ,CAAC;YAElB,KAAK,OAAO,CAAC;YACb;gBACE,gDAAgD;gBAChD,OAAO,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC;QAChD,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,mBAAmB,CAC/B,QAAgB,EAChB,SAA6B,EAC7B,KAAa;QAEb,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,IAAI,CAAC;YACH,0CAA0C;YAC1C,MAAM,QAAQ,GAAG,QAAQ;iBACtB,WAAW,EAAE;iBACb,KAAK,CAAC,KAAK,CAAC;iBACZ,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;iBACzB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAEf,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;gBACzC,IAAI,EAAE,QAAQ;gBACd,KAAK;aACN,CAAC,CAAC;YAEH,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACjC,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,OAAwB;QACpC,OAAO,IAAI,kBAAkB,CAC3B,IAAI,qBAAqB,EAAE,EAC3B,IAAI,kBAAkB,EAAE,EACxB,IAAI,YAAY,EAAE,EAClB,OAAO,CACR,CAAC;IACJ,CAAC;CACF"}

package/dist/learning/analysis/categorizer.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Correction Categorizer
+ *
+ * Categorizes corrections into 10 types to understand
+ * what kind of mistake was made.
+ *
+ * @module learning/analysis/categorizer
+ */
+import type { CorrectionCategory, CorrectionDiff } from '../../types/learning.js';
+/**
+ * Categorization result with confidence
+ */
+export interface CategorizationResult {
+    /** Primary category */
+    category: CorrectionCategory;
+    /** Confidence in categorization (0-1) */
+    confidence: number;
+    /** Secondary categories that might apply */
+    secondaryCategories: CorrectionCategory[];
+    /** Reasoning for categorization */
+    reasoning: string;
+}
+/**
+ * Correction Categorizer
+ *
+ * Analyzes corrections to determine what category of mistake was made.
+ */
+export declare class CorrectionCategorizer {
+    /**
+     * Categorize a correction
+     */
+    categorize(original: string, feedback: string, diff: CorrectionDiff | null): CategorizationResult;
+    /**
+     * Check if correction is a pattern violation
+     */
+    checkPatternViolation(original: string): boolean;
+    /**
+     * Check if correction is a tribal knowledge miss
+     */
+    checkTribalMiss(feedback: string): boolean;
+    /**
+     * Check if correction is a constraint violation
+     */
+    checkConstraintViolation(original: string): boolean;
+    /**
+     * Analyze feedback text to determine category
+     */
+    analyzeFeedbackText(feedback: string): CorrectionCategory;
+    /**
+     * Score categories based on keyword matches in feedback
+     */
+    private scoreByKeywords;
+    /**
+     * Score categories based on code patterns
+     */
+    private scoreByCodePatterns;
+    /**
+     * Score categories based on diff analysis
+     */
+    private scoreByDiff;
+    /**
+     * Add score to a category
+     */
+    private addScore;
+    /**
+     * Check if modification is primarily a naming change
+     */
+    private isNamingChange;
+    /**
+     * Check if modification is security-related
+     */
+    private isSecurityRelated;
+    /**
+     * Generate reasoning for the categorization
+     */
+    private generateReasoning;
+}
+//# sourceMappingURL=categorizer.d.ts.map

package/dist/learning/analysis/categorizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"categorizer.d.ts","sourceRoot":"","sources":["../../../src/learning/analysis/categorizer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAElF;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,uBAAuB;IACvB,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,yCAAyC;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,mBAAmB,EAAE,kBAAkB,EAAE,CAAC;IAC1C,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;CACnB;AA6FD;;;;GAIG;AACH,qBAAa,qBAAqB;IAChC;;OAEG;IACH,UAAU,CACR,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,cAAc,GAAG,IAAI,GAC1B,oBAAoB;IAmDvB;;OAEG;IACH,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAKhD;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAM1C;;OAEG;IACH,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAKnD;;OAEG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB;IAKzD;;OAEG;IACH,OAAO,CAAC,eAAe;IAgBvB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAc3B;;OAEG;IACH,OAAO,CAAC,WAAW;IAyCnB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAShB;;OAEG;IACH,OAAO,CAAC,cAAc;IAOtB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAiBzB;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAsD1B"}

package/dist/learning/analysis/categorizer.js

@@ -0,0 +1,327 @@
+/**
+ * Correction Categorizer
+ *
+ * Categorizes corrections into 10 types to understand
+ * what kind of mistake was made.
+ *
+ * @module learning/analysis/categorizer
+ */
+/**
+ * Keywords associated with each category
+ */
+const CATEGORY_KEYWORDS = {
+    pattern_violation: [
+        'pattern', 'convention', 'standard', 'consistent', 'follow',
+        'established', 'existing', 'codebase', 'project',
+    ],
+    tribal_miss: [
+        'know', 'aware', 'gotcha', 'trick', 'quirk', 'legacy',
+        'historical', 'reason', 'because', 'actually', 'team',
+    ],
+    constraint_violation: [
+        'constraint', 'rule', 'must', 'required', 'mandatory',
+        'enforce', 'policy', 'compliance', 'regulation',
+    ],
+    style_preference: [
+        'prefer', 'style', 'like', 'way', 'format', 'readable',
+        'cleaner', 'better', 'nicer', 'personal',
+    ],
+    naming_convention: [
+        'name', 'naming', 'called', 'rename', 'variable', 'function',
+        'camelCase', 'snake_case', 'PascalCase', 'prefix', 'suffix',
+    ],
+    architecture_mismatch: [
+        'architecture', 'design', 'structure', 'layer', 'module',
+        'component', 'service', 'repository', 'pattern', 'separation',
+    ],
+    security_issue: [
+        'security', 'secure', 'vulnerability', 'injection', 'xss',
+        'csrf', 'auth', 'permission', 'sanitize', 'escape', 'encrypt',
+    ],
+    performance_issue: [
+        'performance', 'slow', 'fast', 'optimize', 'efficient',
+        'memory', 'cpu', 'cache', 'batch', 'lazy', 'eager',
+    ],
+    api_misuse: [
+        'api', 'method', 'function', 'parameter', 'argument',
+        'return', 'type', 'signature', 'deprecated', 'wrong',
+    ],
+    other: [],
+};
+/**
+ * Code patterns associated with each category
+ */
+const CATEGORY_CODE_PATTERNS = {
+    pattern_violation: [
+        /\/\/ TODO: follow pattern/i,
+        /inconsistent with/i,
+    ],
+    tribal_miss: [],
+    constraint_violation: [
+        /eslint-disable/i,
+        /\@ts-ignore/i,
+        /\@ts-expect-error/i,
+    ],
+    style_preference: [
+        /prettier/i,
+        /formatting/i,
+    ],
+    naming_convention: [
+        /[a-z][A-Z]/, // camelCase
+        /[a-z]_[a-z]/, // snake_case
+        /^[A-Z][a-z]/, // PascalCase
+    ],
+    architecture_mismatch: [
+        /import.*from.*\.\.\//, // Cross-layer imports
+        /circular/i,
+    ],
+    security_issue: [
+        /innerHTML/,
+        /eval\(/,
+        /dangerouslySetInnerHTML/,
+        /password/i,
+        /secret/i,
+        /token/i,
+    ],
+    performance_issue: [
+        /\.forEach\(/,
+        /new Array\(/,
+        /JSON\.parse.*JSON\.stringify/,
+        /useEffect.*\[\]/,
+    ],
+    api_misuse: [
+        /deprecated/i,
+        /\.then\(.*\.then\(/, // Promise chaining issues
+    ],
+    other: [],
+};
+/**
+ * Correction Categorizer
+ *
+ * Analyzes corrections to determine what category of mistake was made.
+ */
+export class CorrectionCategorizer {
+    /**
+     * Categorize a correction
+     */
+    categorize(original, feedback, diff) {
+        const scores = new Map();
+        // Initialize all categories with 0
+        for (const category of Object.keys(CATEGORY_KEYWORDS)) {
+            scores.set(category, 0);
+        }
+        // Score based on feedback keywords
+        this.scoreByKeywords(feedback, scores);
+        // Score based on code patterns in original
+        this.scoreByCodePatterns(original, scores);
+        // Score based on diff analysis
+        if (diff) {
+            this.scoreByDiff(diff, scores);
+        }
+        // Find the highest scoring category
+        let maxScore = 0;
+        let bestCategory = 'other';
+        const secondaryCategories = [];
+        for (const [category, score] of scores) {
+            if (score > maxScore) {
+                if (maxScore > 0) {
+                    secondaryCategories.push(bestCategory);
+                }
+                maxScore = score;
+                bestCategory = category;
+            }
+            else if (score > 0 && score >= maxScore * 0.5) {
+                secondaryCategories.push(category);
+            }
+        }
+        // Calculate confidence based on score distribution
+        const totalScore = Array.from(scores.values()).reduce((a, b) => a + b, 0);
+        const confidence = totalScore > 0 ? Math.min(maxScore / totalScore + 0.3, 1.0) : 0.5;
+        // Generate reasoning
+        const reasoning = this.generateReasoning(bestCategory, feedback, diff);
+        return {
+            category: bestCategory,
+            confidence,
+            secondaryCategories: secondaryCategories.filter(c => c !== 'other').slice(0, 2),
+            reasoning,
+        };
+    }
+    /**
+     * Check if correction is a pattern violation
+     */
+    checkPatternViolation(original) {
+        const patterns = CATEGORY_CODE_PATTERNS.pattern_violation;
+        return patterns.some(p => p.test(original));
+    }
+    /**
+     * Check if correction is a tribal knowledge miss
+     */
+    checkTribalMiss(feedback) {
+        const keywords = CATEGORY_KEYWORDS.tribal_miss;
+        const lowerFeedback = feedback.toLowerCase();
+        return keywords.some(k => lowerFeedback.includes(k));
+    }
+    /**
+     * Check if correction is a constraint violation
+     */
+    checkConstraintViolation(original) {
+        const patterns = CATEGORY_CODE_PATTERNS.constraint_violation;
+        return patterns.some(p => p.test(original));
+    }
+    /**
+     * Analyze feedback text to determine category
+     */
+    analyzeFeedbackText(feedback) {
+        const result = this.categorize('', feedback, null);
+        return result.category;
+    }
+    /**
+     * Score categories based on keyword matches in feedback
+     */
+    scoreByKeywords(feedback, scores) {
+        const lowerFeedback = feedback.toLowerCase();
+        for (const [category, keywords] of Object.entries(CATEGORY_KEYWORDS)) {
+            for (const keyword of keywords) {
+                if (lowerFeedback.includes(keyword)) {
+                    const current = scores.get(category) || 0;
+                    scores.set(category, current + 1);
+                }
+            }
+        }
+    }
+    /**
+     * Score categories based on code patterns
+     */
+    scoreByCodePatterns(code, scores) {
+        for (const [category, patterns] of Object.entries(CATEGORY_CODE_PATTERNS)) {
+            for (const pattern of patterns) {
+                if (pattern.test(code)) {
+                    const current = scores.get(category) || 0;
+                    scores.set(category, current + 2);
+                }
+            }
+        }
+    }
+    /**
+     * Score categories based on diff analysis
+     */
+    scoreByDiff(diff, scores) {
+        // Check semantic changes
+        for (const change of diff.semanticChanges) {
+            switch (change.type) {
+                case 'add_error_handling':
+                    this.addScore(scores, 'pattern_violation', 1);
+                    break;
+                case 'add_validation':
+                    this.addScore(scores, 'security_issue', 1);
+                    this.addScore(scores, 'api_misuse', 1);
+                    break;
+                case 'rename':
+                    this.addScore(scores, 'naming_convention', 2);
+                    break;
+                case 'refactor':
+                    this.addScore(scores, 'architecture_mismatch', 1);
+                    this.addScore(scores, 'style_preference', 1);
+                    break;
+                case 'change_logic':
+                    this.addScore(scores, 'api_misuse', 1);
+                    break;
+            }
+        }
+        // Check modifications for specific patterns
+        for (const mod of diff.modifications) {
+            // Check for naming changes
+            if (this.isNamingChange(mod.originalContent, mod.newContent)) {
+                this.addScore(scores, 'naming_convention', 2);
+            }
+            // Check for security-related changes
+            if (this.isSecurityRelated(mod.originalContent, mod.newContent)) {
+                this.addScore(scores, 'security_issue', 2);
+            }
+        }
+    }
+    /**
+     * Add score to a category
+     */
+    addScore(scores, category, amount) {
+        const current = scores.get(category) || 0;
+        scores.set(category, current + amount);
+    }
+    /**
+     * Check if modification is primarily a naming change
+     */
+    isNamingChange(original, corrected) {
+        // Remove whitespace and compare structure
+        const originalStructure = original.replace(/[a-zA-Z_][a-zA-Z0-9_]*/g, 'ID');
+        const correctedStructure = corrected.replace(/[a-zA-Z_][a-zA-Z0-9_]*/g, 'ID');
+        return originalStructure === correctedStructure && original !== corrected;
+    }
+    /**
+     * Check if modification is security-related
+     */
+    isSecurityRelated(original, corrected) {
+        const securityPatterns = [
+            /innerHTML/i,
+            /eval/i,
+            /password/i,
+            /secret/i,
+            /token/i,
+            /sanitize/i,
+            /escape/i,
+            /encode/i,
+        ];
+        return securityPatterns.some(p => p.test(original) || p.test(corrected));
+    }
+    /**
+     * Generate reasoning for the categorization
+     */
+    generateReasoning(category, _feedback, diff) {
+        const reasons = [];
+        switch (category) {
+            case 'pattern_violation':
+                reasons.push('The correction suggests following an established pattern or convention.');
+                break;
+            case 'tribal_miss':
+                reasons.push('The feedback indicates institutional knowledge that was not applied.');
+                break;
+            case 'constraint_violation':
+                reasons.push('A project constraint or rule was violated.');
+                break;
+            case 'style_preference':
+                reasons.push('The correction reflects a style or formatting preference.');
+                break;
+            case 'naming_convention':
+                reasons.push('The correction involves naming conventions.');
+                if (diff?.semanticChanges.some(c => c.type === 'rename')) {
+                    reasons.push('Identifiers were renamed in the correction.');
+                }
+                break;
+            case 'architecture_mismatch':
+                reasons.push('The correction addresses architectural concerns.');
+                break;
+            case 'security_issue':
+                reasons.push('The correction addresses a security concern.');
+                break;
+            case 'performance_issue':
+                reasons.push('The correction addresses a performance concern.');
+                break;
+            case 'api_misuse':
+                reasons.push('The correction fixes incorrect API usage.');
+                break;
+            case 'other':
+                reasons.push('The correction does not fit a specific category.');
+                break;
+        }
+        // Add diff-based reasoning
+        if (diff) {
+            if (diff.additions.length > diff.removals.length) {
+                reasons.push('Code was added to address the issue.');
+            }
+            else if (diff.removals.length > diff.additions.length) {
+                reasons.push('Code was removed to address the issue.');
+            }
+        }
+        return reasons.join(' ');
+    }
+}
+//# sourceMappingURL=categorizer.js.map

package/dist/learning/analysis/categorizer.js.map

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