neuronlayer 0.1.0

package/src/core/architecture/duplicate-detector.ts

@@ -0,0 +1,288 @@
+import type { Tier2Storage } from '../../storage/tier2.js';
+import type { EmbeddingGenerator } from '../../indexing/embeddings.js';
+import type { ExistingFunction, FunctionIndex } from '../../types/documentation.js';
+
+// Common function purpose keywords
+const PURPOSE_KEYWORDS: Record<string, string[]> = {
+  authentication: ['auth', 'login', 'logout', 'token', 'session', 'jwt', 'credential'],
+  validation: ['validate', 'check', 'verify', 'assert', 'ensure', 'is', 'has'],
+  formatting: ['format', 'parse', 'stringify', 'serialize', 'convert', 'transform'],
+  fetching: ['fetch', 'get', 'load', 'retrieve', 'request', 'api', 'http'],
+  storage: ['save', 'store', 'persist', 'cache', 'set', 'put'],
+  utility: ['util', 'helper', 'tool', 'common', 'shared'],
+  error: ['error', 'exception', 'throw', 'catch', 'handle'],
+  logging: ['log', 'logger', 'debug', 'info', 'warn', 'error'],
+  date: ['date', 'time', 'moment', 'day', 'month', 'year', 'timestamp']
+};
+
+export class DuplicateDetector {
+  private tier2: Tier2Storage;
+  private embeddingGenerator: EmbeddingGenerator;
+  private functionIndex: Map<string, FunctionIndex> = new Map();
+
+  constructor(tier2: Tier2Storage, embeddingGenerator: EmbeddingGenerator) {
+    this.tier2 = tier2;
+    this.embeddingGenerator = embeddingGenerator;
+    this.buildFunctionIndex();
+  }
+
+  // Build index of all functions in codebase
+  private buildFunctionIndex(): void {
+    const files = this.tier2.getAllFiles();
+
+    for (const file of files) {
+      const symbols = this.tier2.getSymbolsByFile(file.id);
+
+      for (const symbol of symbols) {
+        if (symbol.kind === 'function' || symbol.kind === 'method') {
+          const key = `${file.path}:${symbol.name}`;
+          const dependents = this.tier2.getFileDependents(file.path);
+
+          this.functionIndex.set(key, {
+            name: symbol.name,
+            file: file.path,
+            line: symbol.lineStart,
+            signature: symbol.signature || `${symbol.name}()`,
+            exported: symbol.exported,
+            usageCount: dependents.length + 1,
+            parameters: this.extractParameters(symbol.signature || ''),
+            returnType: this.extractReturnType(symbol.signature || ''),
+            docstring: symbol.docstring
+          });
+        }
+      }
+    }
+  }
+
+  // Find duplicate or similar functions
+  findDuplicates(code: string, threshold: number = 60): Array<FunctionIndex & { similarity: number }> {
+    const duplicates: Array<FunctionIndex & { similarity: number }> = [];
+
+    // Extract function name from code
+    const funcNameMatch = code.match(/(?:function|const|let|var)\s+(\w+)/);
+    const funcName = funcNameMatch ? funcNameMatch[1] : null;
+
+    // Extract purpose from code
+    const purpose = this.detectPurpose(code);
+
+    for (const [_key, func] of this.functionIndex) {
+      let similarity = 0;
+
+      // Check name similarity
+      if (funcName) {
+        const nameSimilarity = this.calculateNameSimilarity(funcName, func.name);
+        similarity += nameSimilarity * 0.3;
+      }
+
+      // Check purpose similarity
+      const funcPurpose = this.detectPurpose(func.signature + ' ' + (func.docstring || ''));
+      if (purpose && funcPurpose && purpose === funcPurpose) {
+        similarity += 40;
+      }
+
+      // Check code structure similarity
+      const structureSimilarity = this.calculateStructureSimilarity(code, func.signature);
+      similarity += structureSimilarity * 0.3;
+
+      if (similarity >= threshold) {
+        duplicates.push({
+          ...func,
+          similarity: Math.round(similarity)
+        });
+      }
+    }
+
+    // Sort by similarity
+    duplicates.sort((a, b) => b.similarity - a.similarity);
+
+    return duplicates.slice(0, 5);
+  }
+
+  // Suggest existing functions based on intent
+  suggestExisting(intent: string, limit: number = 5): ExistingFunction[] {
+    const suggestions: Array<FunctionIndex & { relevance: number }> = [];
+    const intentLower = intent.toLowerCase();
+    const intentWords = intentLower.split(/\s+/);
+
+    for (const [_key, func] of this.functionIndex) {
+      if (!func.exported) continue;
+
+      let relevance = 0;
+      const funcLower = func.name.toLowerCase();
+      const docLower = (func.docstring || '').toLowerCase();
+      const combined = `${funcLower} ${docLower}`;
+
+      // Check direct name match
+      for (const word of intentWords) {
+        if (word.length < 3) continue;
+
+        if (funcLower.includes(word)) {
+          relevance += 30;
+        }
+        if (docLower.includes(word)) {
+          relevance += 20;
+        }
+      }
+
+      // Check purpose match
+      const purpose = this.detectPurpose(intent);
+      const funcPurpose = this.detectPurpose(combined);
+      if (purpose && funcPurpose && purpose === funcPurpose) {
+        relevance += 25;
+      }
+
+      // Boost for commonly used functions
+      relevance += Math.min(func.usageCount * 2, 15);
+
+      if (relevance > 20) {
+        suggestions.push({ ...func, relevance });
+      }
+    }
+
+    // Sort by relevance
+    suggestions.sort((a, b) => b.relevance - a.relevance);
+
+    return suggestions.slice(0, limit).map(s => ({
+      name: s.name,
+      file: s.file,
+      line: s.line,
+      signature: s.signature,
+      description: s.docstring,
+      usageCount: s.usageCount,
+      purpose: this.detectPurpose(s.name + ' ' + (s.docstring || '')) || 'utility',
+      similarity: s.relevance
+    }));
+  }
+
+  // Detect the purpose of code/function
+  private detectPurpose(text: string): string | null {
+    const lower = text.toLowerCase();
+
+    for (const [purpose, keywords] of Object.entries(PURPOSE_KEYWORDS)) {
+      if (keywords.some(k => lower.includes(k))) {
+        return purpose;
+      }
+    }
+
+    return null;
+  }
+
+  // Calculate name similarity
+  private calculateNameSimilarity(name1: string, name2: string): number {
+    const lower1 = name1.toLowerCase();
+    const lower2 = name2.toLowerCase();
+
+    // Exact match
+    if (lower1 === lower2) return 100;
+
+    // Contains
+    if (lower1.includes(lower2) || lower2.includes(lower1)) return 70;
+
+    // Token overlap
+    const tokens1 = this.camelCaseToTokens(name1);
+    const tokens2 = this.camelCaseToTokens(name2);
+
+    let matches = 0;
+    for (const t1 of tokens1) {
+      for (const t2 of tokens2) {
+        if (t1 === t2) matches++;
+      }
+    }
+
+    const totalTokens = Math.max(tokens1.length, tokens2.length);
+    return totalTokens > 0 ? (matches / totalTokens) * 100 : 0;
+  }
+
+  // Calculate structure similarity
+  private calculateStructureSimilarity(code1: string, code2: string): number {
+    // Extract structural elements
+    const struct1 = this.extractStructure(code1);
+    const struct2 = this.extractStructure(code2);
+
+    let matches = 0;
+    let total = 0;
+
+    for (const key of Object.keys(struct1) as Array<keyof typeof struct1>) {
+      total++;
+      if (struct1[key] === struct2[key]) matches++;
+    }
+
+    return total > 0 ? (matches / total) * 100 : 0;
+  }
+
+  // Extract structural features
+  private extractStructure(code: string): {
+    hasAsync: boolean;
+    hasReturn: boolean;
+    hasTryCatch: boolean;
+    hasLoop: boolean;
+    hasConditional: boolean;
+    paramCount: number;
+  } {
+    return {
+      hasAsync: /async\s+/.test(code),
+      hasReturn: /return\s+/.test(code),
+      hasTryCatch: /try\s*\{/.test(code),
+      hasLoop: /(?:for|while|do)\s*[\(\{]/.test(code),
+      hasConditional: /if\s*\(/.test(code),
+      paramCount: (code.match(/\([^)]*\)/)?.[0]?.split(',').length || 0)
+    };
+  }
+
+  // Split camelCase to tokens
+  private camelCaseToTokens(name: string): string[] {
+    return name
+      .replace(/([a-z])([A-Z])/g, '$1 $2')
+      .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+      .toLowerCase()
+      .split(/\s+/)
+      .filter(t => t.length > 1);
+  }
+
+  // Extract parameters from signature
+  private extractParameters(signature: string): string[] {
+    const match = signature.match(/\(([^)]*)\)/);
+    if (!match) return [];
+
+    return match[1]
+      .split(',')
+      .map(p => p.trim())
+      .filter(Boolean)
+      .map(p => p.split(':')[0].trim());
+  }
+
+  // Extract return type from signature
+  private extractReturnType(signature: string): string | undefined {
+    const match = signature.match(/\):\s*(.+)$/);
+    return match ? match[1].trim() : undefined;
+  }
+
+  // Refresh the function index
+  refresh(): void {
+    this.functionIndex.clear();
+    this.buildFunctionIndex();
+  }
+
+  // Get index statistics
+  getStats(): {
+    totalFunctions: number;
+    exportedFunctions: number;
+    byPurpose: Record<string, number>;
+  } {
+    let exportedFunctions = 0;
+    const byPurpose: Record<string, number> = {};
+
+    for (const [_key, func] of this.functionIndex) {
+      if (func.exported) exportedFunctions++;
+
+      const purpose = this.detectPurpose(func.name) || 'other';
+      byPurpose[purpose] = (byPurpose[purpose] || 0) + 1;
+    }
+
+    return {
+      totalFunctions: this.functionIndex.size,
+      exportedFunctions,
+      byPurpose
+    };
+  }
+}

package/src/core/architecture/index.ts

@@ -0,0 +1,6 @@
+// Architecture Enforcement Module - Phase 10
+export { ArchitectureEnforcement } from './architecture-enforcement.js';
+export { PatternLibrary } from './pattern-library.js';
+export { PatternLearner } from './pattern-learner.js';
+export { PatternValidator } from './pattern-validator.js';
+export { DuplicateDetector } from './duplicate-detector.js';

package/src/core/architecture/pattern-learner.ts

@@ -0,0 +1,306 @@
+import type { Tier2Storage } from '../../storage/tier2.js';
+import type { PatternCategory, CodeExample, PatternRule } from '../../types/documentation.js';
+import type { PatternLibrary } from './pattern-library.js';
+
+// Pattern detection rules
+const PATTERN_DETECTORS: Array<{
+  category: PatternCategory;
+  name: string;
+  detect: RegExp;
+  extractExample: (code: string) => string | null;
+  rules: PatternRule[];
+}> = [
+  {
+    category: 'error_handling',
+    name: 'Try-Catch Pattern',
+    detect: /try\s*\{[\s\S]*?\}\s*catch\s*\(/,
+    extractExample: (code: string) => {
+      const match = code.match(/try\s*\{[\s\S]*?\}\s*catch\s*\([^)]*\)\s*\{[\s\S]*?\}/);
+      return match ? match[0] : null;
+    },
+    rules: [
+      { rule: 'Use try-catch for error-prone operations', severity: 'warning' },
+      { rule: 'Log errors with context', severity: 'warning' }
+    ]
+  },
+  {
+    category: 'api_call',
+    name: 'Fetch API Pattern',
+    detect: /fetch\s*\(|axios\.|api\./,
+    extractExample: (code: string) => {
+      const match = code.match(/(?:await\s+)?(?:fetch|axios\.\w+|api\.\w+)\s*\([^)]*\)[\s\S]*?(?:\.json\(\)|;)/);
+      return match ? match[0] : null;
+    },
+    rules: [
+      { rule: 'Check response status', severity: 'critical' },
+      { rule: 'Handle network errors', severity: 'critical' }
+    ]
+  },
+  {
+    category: 'component',
+    name: 'React Component Pattern',
+    detect: /(?:function|const)\s+\w+\s*(?::\s*React\.FC|\([^)]*\))\s*(?:=>|{)/,
+    extractExample: (code: string) => {
+      const match = code.match(/(?:interface|type)\s+\w*Props[\s\S]*?}[\s\S]*?(?:function|const)\s+\w+[\s\S]*?(?:return\s*\([\s\S]*?\);|\))/);
+      return match ? match[0] : null;
+    },
+    rules: [
+      { rule: 'Define Props interface', severity: 'warning' },
+      { rule: 'Use functional components', severity: 'info' }
+    ]
+  },
+  {
+    category: 'validation',
+    name: 'Input Validation Pattern',
+    detect: /if\s*\(\s*!?\w+\s*(?:===?|!==?)\s*(?:null|undefined|''|""|0)\s*\)/,
+    extractExample: (code: string) => {
+      const match = code.match(/if\s*\([^)]*(?:null|undefined)[^)]*\)\s*\{[^}]*\}/);
+      return match ? match[0] : null;
+    },
+    rules: [
+      { rule: 'Validate inputs before use', severity: 'warning' },
+      { rule: 'Use optional chaining for nested access', severity: 'info' }
+    ]
+  },
+  {
+    category: 'data_fetching',
+    name: 'Async/Await Pattern',
+    detect: /async\s+(?:function|\([^)]*\)\s*=>)/,
+    extractExample: (code: string) => {
+      const match = code.match(/async\s+(?:function\s+\w+)?\s*\([^)]*\)\s*(?::\s*Promise<[^>]+>)?\s*\{[\s\S]*?await[\s\S]*?\}/);
+      return match ? match[0] : null;
+    },
+    rules: [
+      { rule: 'Use async/await for asynchronous code', severity: 'info' },
+      { rule: 'Always await promises', severity: 'warning' }
+    ]
+  },
+  {
+    category: 'logging',
+    name: 'Logging Pattern',
+    detect: /console\.(log|error|warn|info)|logger\./,
+    extractExample: (code: string) => {
+      const match = code.match(/(?:console|logger)\.\w+\s*\([^)]*\)/);
+      return match ? match[0] : null;
+    },
+    rules: [
+      { rule: 'Use structured logging', severity: 'info' },
+      { rule: 'Include context in log messages', severity: 'info' }
+    ]
+  }
+];
+
+export class PatternLearner {
+  private tier2: Tier2Storage;
+  private patternLibrary: PatternLibrary;
+
+  constructor(tier2: Tier2Storage, patternLibrary: PatternLibrary) {
+    this.tier2 = tier2;
+    this.patternLibrary = patternLibrary;
+  }
+
+  // Learn patterns from the entire codebase
+  learnFromCodebase(): {
+    patternsLearned: number;
+    examplesAdded: number;
+    categories: Record<string, number>;
+  } {
+    const files = this.tier2.getAllFiles();
+    const categories: Record<string, number> = {};
+    let patternsLearned = 0;
+    let examplesAdded = 0;
+
+    for (const file of files) {
+      if (!file.preview) continue;
+
+      const filePatterns = this.detectPatterns(file.preview);
+
+      for (const detected of filePatterns) {
+        categories[detected.category] = (categories[detected.category] || 0) + 1;
+
+        // Check if we already have this pattern
+        const existingPatterns = this.patternLibrary.getPatternsByCategory(detected.category);
+        const existing = existingPatterns.find(p => p.name === detected.name);
+
+        if (existing) {
+          // Add as example if different enough
+          if (detected.example && !this.isDuplicate(existing.examples, detected.example)) {
+            this.patternLibrary.addExample(existing.id, {
+              code: detected.example,
+              explanation: `Extracted from ${file.path}`,
+              file: file.path
+            });
+            examplesAdded++;
+          }
+        } else {
+          // Create new pattern
+          this.patternLibrary.addPattern(
+            detected.name,
+            detected.category,
+            `${detected.name} detected in codebase`,
+            detected.example ? [{
+              code: detected.example,
+              explanation: `Extracted from ${file.path}`,
+              file: file.path
+            }] : [],
+            [],
+            detected.rules
+          );
+          patternsLearned++;
+        }
+      }
+    }
+
+    return { patternsLearned, examplesAdded, categories };
+  }
+
+  // Detect patterns in a code snippet
+  detectPatterns(code: string): Array<{
+    category: PatternCategory;
+    name: string;
+    example: string | null;
+    rules: PatternRule[];
+  }> {
+    const detected: Array<{
+      category: PatternCategory;
+      name: string;
+      example: string | null;
+      rules: PatternRule[];
+    }> = [];
+
+    for (const detector of PATTERN_DETECTORS) {
+      if (detector.detect.test(code)) {
+        detected.push({
+          category: detector.category,
+          name: detector.name,
+          example: detector.extractExample(code),
+          rules: detector.rules
+        });
+      }
+    }
+
+    return detected;
+  }
+
+  // Learn a specific pattern from user input
+  learnPattern(
+    code: string,
+    name: string,
+    description?: string,
+    category?: PatternCategory
+  ): { success: boolean; patternId?: string; message: string } {
+    // Auto-detect category if not provided
+    const detectedCategory = category || this.inferCategory(code);
+
+    // Check for existing similar pattern
+    const existingPatterns = this.patternLibrary.searchPatterns(name);
+    if (existingPatterns.some(p => p.name.toLowerCase() === name.toLowerCase())) {
+      return {
+        success: false,
+        message: `Pattern "${name}" already exists. Use add_example to add to existing pattern.`
+      };
+    }
+
+    // Extract rules from code
+    const rules = this.extractRules(code);
+
+    // Create the pattern
+    const pattern = this.patternLibrary.addPattern(
+      name,
+      detectedCategory,
+      description || `User-defined pattern: ${name}`,
+      [{
+        code,
+        explanation: 'User-provided example'
+      }],
+      [],
+      rules
+    );
+
+    return {
+      success: true,
+      patternId: pattern.id,
+      message: `Pattern "${name}" created successfully`
+    };
+  }
+
+  // Infer category from code
+  private inferCategory(code: string): PatternCategory {
+    for (const detector of PATTERN_DETECTORS) {
+      if (detector.detect.test(code)) {
+        return detector.category;
+      }
+    }
+    return 'custom';
+  }
+
+  // Extract rules from code patterns
+  private extractRules(code: string): PatternRule[] {
+    const rules: PatternRule[] = [];
+
+    // Detect common patterns and generate rules
+    if (/try\s*\{/.test(code)) {
+      rules.push({ rule: 'Use try-catch for error handling', severity: 'warning' });
+    }
+    if (/catch\s*\([^)]*\)\s*\{[\s\S]*console\.error/.test(code)) {
+      rules.push({ rule: 'Log errors in catch blocks', severity: 'info' });
+    }
+    if (/async\s+/.test(code)) {
+      rules.push({ rule: 'Use async functions for asynchronous operations', severity: 'info' });
+    }
+    if (/await\s+/.test(code)) {
+      rules.push({ rule: 'Await all promises', severity: 'warning' });
+    }
+    if (/interface\s+\w+Props/.test(code)) {
+      rules.push({ rule: 'Define Props interfaces for components', severity: 'warning' });
+    }
+    if (/\?\.\w+/.test(code)) {
+      rules.push({ rule: 'Use optional chaining for safe property access', severity: 'info' });
+    }
+    if (/\?\?/.test(code)) {
+      rules.push({ rule: 'Use nullish coalescing for default values', severity: 'info' });
+    }
+
+    return rules;
+  }
+
+  // Check if example is duplicate
+  private isDuplicate(examples: CodeExample[], newExample: string): boolean {
+    const normalized = this.normalizeCode(newExample);
+    return examples.some(e => this.normalizeCode(e.code) === normalized);
+  }
+
+  // Normalize code for comparison
+  private normalizeCode(code: string): string {
+    return code
+      .replace(/\s+/g, ' ')
+      .replace(/['"`]/g, '"')
+      .trim()
+      .toLowerCase();
+  }
+
+  // Get learning statistics
+  getStats(): {
+    totalPatterns: number;
+    byCategory: Record<string, number>;
+    topPatterns: Array<{ name: string; usageCount: number }>;
+  } {
+    const patterns = this.patternLibrary.getAllPatterns();
+    const byCategory: Record<string, number> = {};
+
+    for (const pattern of patterns) {
+      byCategory[pattern.category] = (byCategory[pattern.category] || 0) + 1;
+    }
+
+    const topPatterns = patterns
+      .sort((a, b) => b.usageCount - a.usageCount)
+      .slice(0, 5)
+      .map(p => ({ name: p.name, usageCount: p.usageCount }));
+
+    return {
+      totalPatterns: patterns.length,
+      byCategory,
+      topPatterns
+    };
+  }
+}