driftdetect-cortex 0.9.41

package/dist/learning/fact-extractor.js

@@ -0,0 +1,61 @@
+/**
+ * Fact Extractor
+ *
+ * Extracts facts from episodic memories.
+ */
+/**
+ * Fact extractor
+ */
+export class FactExtractor {
+    /**
+     * Extract facts from an episode
+     */
+    extract(episode) {
+        const facts = [];
+        // Extract from user query
+        const queryFacts = this.extractFromQuery(episode.interaction.userQuery);
+        facts.push(...queryFacts);
+        // Extract from outcome
+        if (episode.interaction.outcome === 'rejected') {
+            facts.push({
+                fact: `User rejected response about ${episode.context.focus || 'unknown'}`,
+                confidence: 0.8,
+                type: 'correction',
+            });
+        }
+        return facts;
+    }
+    /**
+     * Extract facts from a user query
+     */
+    extractFromQuery(query) {
+        const facts = [];
+        const lowerQuery = query.toLowerCase();
+        // Look for preference indicators
+        if (lowerQuery.includes('prefer') || lowerQuery.includes('like')) {
+            facts.push({
+                fact: query,
+                confidence: 0.7,
+                type: 'preference',
+            });
+        }
+        // Look for warnings
+        if (lowerQuery.includes('don\'t') || lowerQuery.includes('never') || lowerQuery.includes('avoid')) {
+            facts.push({
+                fact: query,
+                confidence: 0.8,
+                type: 'warning',
+            });
+        }
+        // Look for knowledge
+        if (lowerQuery.includes('always') || lowerQuery.includes('must') || lowerQuery.includes('should')) {
+            facts.push({
+                fact: query,
+                confidence: 0.7,
+                type: 'knowledge',
+            });
+        }
+        return facts;
+    }
+}
+//# sourceMappingURL=fact-extractor.js.map

package/dist/learning/fact-extractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fact-extractor.js","sourceRoot":"","sources":["../../src/learning/fact-extractor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;GAEG;AACH,MAAM,OAAO,aAAa;IACxB;;OAEG;IACH,OAAO,CAAC,OAAuB;QAC7B,MAAM,KAAK,GAAoB,EAAE,CAAC;QAElC,0BAA0B;QAC1B,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;QACxE,KAAK,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC;QAE1B,uBAAuB;QACvB,IAAI,OAAO,CAAC,WAAW,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;YAC/C,KAAK,CAAC,IAAI,CAAC;gBACT,IAAI,EAAE,gCAAgC,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,SAAS,EAAE;gBAC1E,UAAU,EAAE,GAAG;gBACf,IAAI,EAAE,YAAY;aACnB,CAAC,CAAC;QACL,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACK,gBAAgB,CAAC,KAAa;QACpC,MAAM,KAAK,GAAoB,EAAE,CAAC;QAClC,MAAM,UAAU,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;QAEvC,iCAAiC;QACjC,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACjE,KAAK,CAAC,IAAI,CAAC;gBACT,IAAI,EAAE,KAAK;gBACX,UAAU,EAAE,GAAG;gBACf,IAAI,EAAE,YAAY;aACnB,CAAC,CAAC;QACL,CAAC;QAED,oBAAoB;QACpB,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAClG,KAAK,CAAC,IAAI,CAAC;gBACT,IAAI,EAAE,KAAK;gBACX,UAAU,EAAE,GAAG;gBACf,IAAI,EAAE,SAAS;aAChB,CAAC,CAAC;QACL,CAAC;QAED,qBAAqB;QACrB,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YAClG,KAAK,CAAC,IAAI,CAAC;gBACT,IAAI,EAAE,KAAK;gBACX,UAAU,EAAE,GAAG;gBACf,IAAI,EAAE,WAAW;aAClB,CAAC,CAAC;QACL,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}

package/dist/learning/factory/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Factory Submodule
+ *
+ * Creates memories from analyzed corrections:
+ * - Tribal memories from institutional knowledge
+ * - Pattern rationale memories from pattern violations
+ * - Code smell memories from anti-patterns
+ *
+ * @module learning/factory
+ */
+export * from './tribal-creator.js';
+export * from './pattern-creator.js';
+export * from './smell-creator.js';
+export * from './memory-factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/learning/factory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/learning/factory/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/dist/learning/factory/index.js

@@ -0,0 +1,15 @@
+/**
+ * Factory Submodule
+ *
+ * Creates memories from analyzed corrections:
+ * - Tribal memories from institutional knowledge
+ * - Pattern rationale memories from pattern violations
+ * - Code smell memories from anti-patterns
+ *
+ * @module learning/factory
+ */
+export * from './tribal-creator.js';
+export * from './pattern-creator.js';
+export * from './smell-creator.js';
+export * from './memory-factory.js';
+//# sourceMappingURL=index.js.map

package/dist/learning/factory/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/learning/factory/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/dist/learning/factory/memory-factory.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Learning Memory Factory
+ *
+ * Creates appropriate memories from analyzed corrections
+ * by delegating to specialized creators.
+ *
+ * @module learning/factory/memory-factory
+ */
+import type { Memory } from '../../types/memory.js';
+import type { TribalMemory } from '../../types/tribal-memory.js';
+import type { PatternRationaleMemory } from '../../types/pattern-rationale.js';
+import type { CodeSmellMemory } from '../../types/code-smell.js';
+import type { AnalyzedCorrection, CorrectionCategory } from '../../types/learning.js';
+import type { IMemoryStorage } from '../../storage/interface.js';
+import { TribalMemoryCreator, type MemoryCreator } from './tribal-creator.js';
+import { PatternRationaleCreator } from './pattern-creator.js';
+import { CodeSmellCreator } from './smell-creator.js';
+/**
+ * Factory result
+ */
+export interface FactoryResult {
+    /** Created memory */
+    memory: Memory;
+    /** Memory type created */
+    memoryType: string;
+    /** Whether memory was stored */
+    stored: boolean;
+    /** Storage ID if stored */
+    storageId?: string;
+}
+/**
+ * Learning Memory Factory
+ *
+ * Creates memories from analyzed corrections using the appropriate
+ * specialized creator based on correction category.
+ */
+export declare class LearningMemoryFactory {
+    private storage?;
+    private tribalCreator;
+    private patternCreator;
+    private smellCreator;
+    constructor(tribalCreator?: TribalMemoryCreator, patternCreator?: PatternRationaleCreator, smellCreator?: CodeSmellCreator, storage?: IMemoryStorage | undefined);
+    /**
+     * Create a memory from an analyzed correction
+     */
+    createFromCorrection(analysis: AnalyzedCorrection): Promise<FactoryResult>;
+    /**
+     * Create memories from multiple corrections
+     */
+    createFromCorrections(analyses: AnalyzedCorrection[]): Promise<FactoryResult[]>;
+    /**
+     * Select the appropriate creator based on category
+     */
+    selectCreator(category: CorrectionCategory): MemoryCreator<TribalMemory | PatternRationaleMemory | CodeSmellMemory>;
+    /**
+     * Create a tribal memory directly
+     */
+    createTribalMemory(analysis: AnalyzedCorrection): TribalMemory;
+    /**
+     * Create a pattern rationale memory directly
+     */
+    createPatternRationaleMemory(analysis: AnalyzedCorrection): PatternRationaleMemory;
+    /**
+     * Create a code smell memory directly
+     */
+    createCodeSmellMemory(analysis: AnalyzedCorrection): CodeSmellMemory;
+    /**
+     * Get suggested memory type for a category
+     */
+    getSuggestedType(category: CorrectionCategory): string;
+    /**
+     * Create factory with default dependencies
+     */
+    static create(storage?: IMemoryStorage): LearningMemoryFactory;
+}
+//# sourceMappingURL=memory-factory.d.ts.map

package/dist/learning/factory/memory-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-factory.d.ts","sourceRoot":"","sources":["../../../src/learning/factory/memory-factory.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC/E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC9E,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,qBAAqB;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,0BAA0B;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,gCAAgC;IAChC,MAAM,EAAE,OAAO,CAAC;IAChB,2BAA2B;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,qBAAa,qBAAqB;IAS9B,OAAO,CAAC,OAAO,CAAC;IARlB,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,cAAc,CAA0B;IAChD,OAAO,CAAC,YAAY,CAAmB;gBAGrC,aAAa,CAAC,EAAE,mBAAmB,EACnC,cAAc,CAAC,EAAE,uBAAuB,EACxC,YAAY,CAAC,EAAE,gBAAgB,EACvB,OAAO,CAAC,EAAE,cAAc,YAAA;IAOlC;;OAEG;IACG,oBAAoB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,aAAa,CAAC;IAiChF;;OAEG;IACG,qBAAqB,CACzB,QAAQ,EAAE,kBAAkB,EAAE,GAC7B,OAAO,CAAC,aAAa,EAAE,CAAC;IAW3B;;OAEG;IACH,aAAa,CACX,QAAQ,EAAE,kBAAkB,GAC3B,aAAa,CAAC,YAAY,GAAG,sBAAsB,GAAG,eAAe,CAAC;IA2BzE;;OAEG;IACH,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,YAAY;IAI9D;;OAEG;IACH,4BAA4B,CAAC,QAAQ,EAAE,kBAAkB,GAAG,sBAAsB;IAIlF;;OAEG;IACH,qBAAqB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,eAAe;IAIpE;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM;IAiBtD;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,qBAAqB;CAQ/D"}

package/dist/learning/factory/memory-factory.js

@@ -0,0 +1,139 @@
+/**
+ * Learning Memory Factory
+ *
+ * Creates appropriate memories from analyzed corrections
+ * by delegating to specialized creators.
+ *
+ * @module learning/factory/memory-factory
+ */
+import { TribalMemoryCreator } from './tribal-creator.js';
+import { PatternRationaleCreator } from './pattern-creator.js';
+import { CodeSmellCreator } from './smell-creator.js';
+/**
+ * Learning Memory Factory
+ *
+ * Creates memories from analyzed corrections using the appropriate
+ * specialized creator based on correction category.
+ */
+export class LearningMemoryFactory {
+    storage;
+    tribalCreator;
+    patternCreator;
+    smellCreator;
+    constructor(tribalCreator, patternCreator, smellCreator, storage) {
+        this.storage = storage;
+        this.tribalCreator = tribalCreator || new TribalMemoryCreator();
+        this.patternCreator = patternCreator || new PatternRationaleCreator();
+        this.smellCreator = smellCreator || new CodeSmellCreator();
+    }
+    /**
+     * Create a memory from an analyzed correction
+     */
+    async createFromCorrection(analysis) {
+        // Select appropriate creator
+        const creator = this.selectCreator(analysis.category);
+        // Create memory
+        const memory = creator.create(analysis);
+        // Store if storage is available
+        let stored = false;
+        let storageId;
+        if (this.storage) {
+            try {
+                storageId = await this.storage.create(memory);
+                stored = true;
+            }
+            catch (error) {
+                console.error('Failed to store memory:', error);
+            }
+        }
+        const result = {
+            memory,
+            memoryType: memory.type,
+            stored,
+        };
+        if (storageId) {
+            result.storageId = storageId;
+        }
+        return result;
+    }
+    /**
+     * Create memories from multiple corrections
+     */
+    async createFromCorrections(analyses) {
+        const results = [];
+        for (const analysis of analyses) {
+            const result = await this.createFromCorrection(analysis);
+            results.push(result);
+        }
+        return results;
+    }
+    /**
+     * Select the appropriate creator based on category
+     */
+    selectCreator(category) {
+        switch (category) {
+            // Tribal knowledge categories
+            case 'tribal_miss':
+            case 'style_preference':
+            case 'naming_convention':
+                return this.tribalCreator;
+            // Pattern rationale categories
+            case 'pattern_violation':
+            case 'architecture_mismatch':
+            case 'constraint_violation':
+                return this.patternCreator;
+            // Code smell categories
+            case 'security_issue':
+            case 'performance_issue':
+            case 'api_misuse':
+                return this.smellCreator;
+            // Default to tribal for uncategorized
+            case 'other':
+            default:
+                return this.tribalCreator;
+        }
+    }
+    /**
+     * Create a tribal memory directly
+     */
+    createTribalMemory(analysis) {
+        return this.tribalCreator.create(analysis);
+    }
+    /**
+     * Create a pattern rationale memory directly
+     */
+    createPatternRationaleMemory(analysis) {
+        return this.patternCreator.create(analysis);
+    }
+    /**
+     * Create a code smell memory directly
+     */
+    createCodeSmellMemory(analysis) {
+        return this.smellCreator.create(analysis);
+    }
+    /**
+     * Get suggested memory type for a category
+     */
+    getSuggestedType(category) {
+        const typeMap = {
+            tribal_miss: 'tribal',
+            style_preference: 'tribal',
+            naming_convention: 'tribal',
+            pattern_violation: 'pattern_rationale',
+            architecture_mismatch: 'pattern_rationale',
+            constraint_violation: 'pattern_rationale',
+            security_issue: 'code_smell',
+            performance_issue: 'code_smell',
+            api_misuse: 'code_smell',
+            other: 'tribal',
+        };
+        return typeMap[category];
+    }
+    /**
+     * Create factory with default dependencies
+     */
+    static create(storage) {
+        return new LearningMemoryFactory(new TribalMemoryCreator(), new PatternRationaleCreator(), new CodeSmellCreator(), storage);
+    }
+}
+//# sourceMappingURL=memory-factory.js.map

package/dist/learning/factory/memory-factory.js.map

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

package/dist/learning/factory/pattern-creator.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Pattern Rationale Creator
+ *
+ * Creates pattern rationale memories from corrections that
+ * reveal why patterns exist or should be followed.
+ *
+ * @module learning/factory/pattern-creator
+ */
+import type { PatternRationaleMemory } from '../../types/pattern-rationale.js';
+import type { AnalyzedCorrection } from '../../types/learning.js';
+import type { MemoryCreator } from './tribal-creator.js';
+/**
+ * Pattern Rationale Creator
+ *
+ * Creates pattern rationale memories from corrections that
+ * indicate pattern violations or architectural mismatches.
+ */
+export declare class PatternRationaleCreator implements MemoryCreator<PatternRationaleMemory> {
+    /**
+     * Create a pattern rationale memory from an analyzed correction
+     */
+    create(analysis: AnalyzedCorrection): PatternRationaleMemory;
+    /**
+     * Find related pattern ID from analysis
+     */
+    findRelatedPattern(analysis: AnalyzedCorrection): string | null;
+    /**
+     * Build the rationale from the analysis
+     */
+    buildRationale(analysis: AnalyzedCorrection): string;
+    /**
+     * Infer pattern name from analysis
+     */
+    private inferPatternName;
+    /**
+     * Infer pattern category from analysis
+     */
+    private inferPatternCategory;
+    /**
+     * Extract business context from analysis
+     */
+    private extractBusinessContext;
+    /**
+     * Extract technical context from analysis
+     */
+    private extractTechnicalContext;
+    /**
+     * Extract rejected alternatives from analysis
+     */
+    private extractAlternatives;
+    /**
+     * Extract tradeoffs from analysis
+     */
+    private extractTradeoffs;
+    /**
+     * Generate a summary for the memory
+     */
+    private generateSummary;
+    /**
+     * Determine importance based on analysis
+     */
+    private determineImportance;
+}
+//# sourceMappingURL=pattern-creator.d.ts.map

package/dist/learning/factory/pattern-creator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-creator.d.ts","sourceRoot":"","sources":["../../../src/learning/factory/pattern-creator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC/E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;GAKG;AACH,qBAAa,uBAAwB,YAAW,aAAa,CAAC,sBAAsB,CAAC;IACnF;;OAEG;IACH,MAAM,CAAC,QAAQ,EAAE,kBAAkB,GAAG,sBAAsB;IA2D5D;;OAEG;IACH,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,GAAG,IAAI;IAW/D;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM;IAwBpD;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA6BxB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAe5B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAmB9B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAwB/B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA2B3B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAuBxB;;OAEG;IACH,OAAO,CAAC,eAAe;IAUvB;;OAEG;IACH,OAAO,CAAC,mBAAmB;CAuB5B"}

package/dist/learning/factory/pattern-creator.js

@@ -0,0 +1,271 @@
+/**
+ * Pattern Rationale Creator
+ *
+ * Creates pattern rationale memories from corrections that
+ * reveal why patterns exist or should be followed.
+ *
+ * @module learning/factory/pattern-creator
+ */
+import { randomUUID } from 'crypto';
+/**
+ * Pattern Rationale Creator
+ *
+ * Creates pattern rationale memories from corrections that
+ * indicate pattern violations or architectural mismatches.
+ */
+export class PatternRationaleCreator {
+    /**
+     * Create a pattern rationale memory from an analyzed correction
+     */
+    create(analysis) {
+        const patternId = this.findRelatedPattern(analysis);
+        const patternName = this.inferPatternName(analysis);
+        const patternCategory = this.inferPatternCategory(analysis);
+        const rationale = this.buildRationale(analysis);
+        const businessContext = this.extractBusinessContext(analysis);
+        const technicalContext = this.extractTechnicalContext(analysis);
+        const alternativesRejected = this.extractAlternatives(analysis);
+        const tradeoffs = this.extractTradeoffs(analysis);
+        const now = new Date().toISOString();
+        const memory = {
+            id: randomUUID(),
+            type: 'pattern_rationale',
+            patternId: patternId ?? `inferred-${randomUUID().slice(0, 8)}`,
+            patternName,
+            patternCategory,
+            rationale,
+            summary: this.generateSummary(patternName, rationale),
+            confidence: analysis.principle.confidence,
+            importance: this.determineImportance(analysis),
+            transactionTime: {
+                recordedAt: now,
+            },
+            validTime: {
+                validFrom: now,
+            },
+            accessCount: 0,
+            createdAt: now,
+            updatedAt: now,
+            tags: [...analysis.principle.keywords, patternCategory],
+        };
+        // Add optional properties only if they have values
+        if (businessContext) {
+            memory.businessContext = businessContext;
+        }
+        if (technicalContext) {
+            memory.technicalContext = technicalContext;
+        }
+        if (alternativesRejected) {
+            memory.alternativesRejected = alternativesRejected;
+        }
+        if (tradeoffs) {
+            memory.tradeoffs = tradeoffs;
+        }
+        if (analysis.metadata?.filePath) {
+            memory.linkedFiles = [analysis.metadata.filePath];
+        }
+        if (patternId) {
+            memory.linkedPatterns = [patternId];
+        }
+        else if (analysis.metadata?.relatedPatterns) {
+            memory.linkedPatterns = analysis.metadata.relatedPatterns;
+        }
+        return memory;
+    }
+    /**
+     * Find related pattern ID from analysis
+     */
+    findRelatedPattern(analysis) {
+        // Check metadata for related patterns
+        const firstPattern = analysis.metadata?.relatedPatterns?.[0];
+        if (firstPattern) {
+            return firstPattern;
+        }
+        // No pattern ID available
+        return null;
+    }
+    /**
+     * Build the rationale from the analysis
+     */
+    buildRationale(analysis) {
+        const parts = [];
+        // Start with the principle
+        parts.push(analysis.principle.statement);
+        // Add explanation if different
+        if (analysis.principle.explanation !== analysis.principle.statement) {
+            parts.push(analysis.principle.explanation);
+        }
+        // Add context from feedback
+        if (analysis.feedback.length > analysis.principle.statement.length) {
+            const additionalContext = analysis.feedback
+                .replace(analysis.principle.statement, '')
+                .trim();
+            if (additionalContext.length > 20) {
+                parts.push(additionalContext);
+            }
+        }
+        return parts.join('\n\n');
+    }
+    /**
+     * Infer pattern name from analysis
+     */
+    inferPatternName(analysis) {
+        // Look for pattern names in feedback
+        const patternKeywords = [
+            'repository', 'factory', 'singleton', 'observer', 'strategy',
+            'decorator', 'adapter', 'facade', 'proxy', 'middleware',
+            'controller', 'service', 'model', 'view', 'presenter',
+            'barrel', 'module', 'component', 'hook', 'context',
+        ];
+        const lowerFeedback = analysis.feedback.toLowerCase();
+        for (const pattern of patternKeywords) {
+            if (lowerFeedback.includes(pattern)) {
+                return pattern.charAt(0).toUpperCase() + pattern.slice(1) + ' Pattern';
+            }
+        }
+        // Generate name from category
+        const categoryNames = {
+            pattern_violation: 'Coding Pattern',
+            architecture_mismatch: 'Architecture Pattern',
+            api_misuse: 'API Usage Pattern',
+            naming_convention: 'Naming Pattern',
+            style_preference: 'Style Pattern',
+        };
+        return categoryNames[analysis.category] || 'Code Pattern';
+    }
+    /**
+     * Infer pattern category from analysis
+     */
+    inferPatternCategory(analysis) {
+        // Map correction category to pattern category
+        const categoryMap = {
+            pattern_violation: 'structural',
+            architecture_mismatch: 'structural',
+            api_misuse: 'api',
+            naming_convention: 'structural',
+            style_preference: 'styling',
+            security_issue: 'security',
+            performance_issue: 'performance',
+        };
+        return categoryMap[analysis.category] || 'structural';
+    }
+    /**
+     * Extract business context from analysis
+     */
+    extractBusinessContext(analysis) {
+        // Look for business-related phrases
+        const businessPatterns = [
+            /business\s+([^.!?]+)/gi,
+            /requirement[s]?\s+([^.!?]+)/gi,
+            /stakeholder[s]?\s+([^.!?]+)/gi,
+            /user[s]?\s+need[s]?\s+([^.!?]+)/gi,
+        ];
+        for (const pattern of businessPatterns) {
+            const match = analysis.feedback.match(pattern);
+            if (match) {
+                return match[0];
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Extract technical context from analysis
+     */
+    extractTechnicalContext(analysis) {
+        // Look for technical explanations
+        const technicalPatterns = [
+            /because\s+([^.!?]+)/gi,
+            /since\s+([^.!?]+)/gi,
+            /due\s+to\s+([^.!?]+)/gi,
+            /technically\s+([^.!?]+)/gi,
+        ];
+        for (const pattern of technicalPatterns) {
+            const match = analysis.feedback.match(pattern);
+            if (match) {
+                return match[0];
+            }
+        }
+        // Use diff summary if available
+        if (analysis.diff?.summary) {
+            return `Changes: ${analysis.diff.summary}`;
+        }
+        return undefined;
+    }
+    /**
+     * Extract rejected alternatives from analysis
+     */
+    extractAlternatives(analysis) {
+        const alternatives = [];
+        // Look for "instead of" patterns
+        const alternativePatterns = [
+            /instead\s+of\s+([^.!?,]+)/gi,
+            /rather\s+than\s+([^.!?,]+)/gi,
+            /not\s+([^.!?,]+)/gi,
+        ];
+        for (const pattern of alternativePatterns) {
+            const matches = analysis.feedback.matchAll(pattern);
+            for (const match of matches) {
+                if (match[1] && match[1].length > 5) {
+                    alternatives.push(match[1].trim());
+                }
+            }
+        }
+        // Add original code as rejected alternative if we have corrected code
+        if (analysis.correctedCode && analysis.original) {
+            alternatives.push(`Original approach: ${analysis.original.slice(0, 100)}...`);
+        }
+        return alternatives.length > 0 ? alternatives : undefined;
+    }
+    /**
+     * Extract tradeoffs from analysis
+     */
+    extractTradeoffs(analysis) {
+        const tradeoffs = [];
+        // Look for tradeoff indicators
+        const tradeoffPatterns = [
+            /tradeoff[s]?\s*[:\s]+([^.!?]+)/gi,
+            /downside[s]?\s*[:\s]+([^.!?]+)/gi,
+            /however\s+([^.!?]+)/gi,
+            /but\s+([^.!?]+)/gi,
+        ];
+        for (const pattern of tradeoffPatterns) {
+            const matches = analysis.feedback.matchAll(pattern);
+            for (const match of matches) {
+                if (match[1] && match[1].length > 10) {
+                    tradeoffs.push(match[1].trim());
+                }
+            }
+        }
+        return tradeoffs.length > 0 ? tradeoffs : undefined;
+    }
+    /**
+     * Generate a summary for the memory
+     */
+    generateSummary(patternName, rationale) {
+        const shortRationale = rationale.split('\n')[0] ?? rationale;
+        if (shortRationale.length <= 80) {
+            return `[${patternName}] ${shortRationale}`;
+        }
+        return `[${patternName}] ${shortRationale.slice(0, 77)}...`;
+    }
+    /**
+     * Determine importance based on analysis
+     */
+    determineImportance(analysis) {
+        // Architecture and security patterns are high importance
+        if (analysis.category === 'architecture_mismatch' ||
+            analysis.category === 'security_issue') {
+            return 'high';
+        }
+        // Hard rules are high importance
+        if (analysis.principle.isHardRule) {
+            return 'high';
+        }
+        // High confidence principles are normal importance
+        if (analysis.principle.confidence > 0.7) {
+            return 'normal';
+        }
+        return 'low';
+    }
+}
+//# sourceMappingURL=pattern-creator.js.map