neuronlayer 0.1.9 → 0.2.0

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

@@ -1,288 +0,0 @@
-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

@@ -1,6 +0,0 @@
-// 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

@@ -1,306 +0,0 @@
-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
-    };
-  }
-}