@sparkleideas/claude-flow 2.7.51 → 2.7.52

package/docs/reasoningbank/models/code-reasoning/train-code.js

@@ -1,2059 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Code Reasoning ReasoningBank Training Script
- * Generates 2500 programming patterns across 5 categories:
- * 1. Design patterns & architecture (500)
- * 2. Algorithm optimization (500)
- * 3. Code quality & refactoring (500)
- * 4. Language-specific best practices (500)
- * 5. Debugging & error handling (500)
- */
-
-import Database from 'better-sqlite3';
-import { readFileSync, existsSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const DB_PATH = join(__dirname, '.swarm', 'memory.db');
-const db = new Database(DB_PATH);
-
-// Enable WAL mode and optimizations
-db.pragma('journal_mode = WAL');
-db.pragma('synchronous = NORMAL');
-db.pragma('cache_size = 12000');
-db.pragma('mmap_size = 268435456');
-
-console.log('🧠 Code Reasoning ReasoningBank Training');
-console.log('📊 Target: 2500 patterns');
-console.log('');
-
-// Clear existing data
-console.log('Clearing existing patterns...');
-db.exec('DELETE FROM pattern_links');
-db.exec('DELETE FROM pattern_embeddings');
-db.exec('DELETE FROM patterns');
-
-const insertPattern = db.prepare(`
-  INSERT INTO patterns (id, type, pattern_data, confidence, usage_count)
-  VALUES (?, ?, ?, ?, ?)
-`);
-
-const insertLink = db.prepare(`
-  INSERT INTO pattern_links (src_id, dst_id, relation, weight)
-  VALUES (?, ?, ?, ?)
-`);
-
-let patternId = 1;
-const patterns = [];
-
-// Helper function to add pattern
-function addPattern(domain, description, solution, successRate, confidence, complexity, tags, metadata) {
-  const id = `pattern-${patternId++}`;
-  const patternData = JSON.stringify({
-    domain,
-    description,
-    solution,
-    success_rate: successRate,
-    complexity,
-    tags,
-    metadata
-  });
-  insertPattern.run(id, domain, patternData, confidence, 0);
-  patterns.push({ id, domain, tags });
-  return id;
-}
-
-// Helper function to link patterns
-function linkPatterns(sourceId, targetId, linkType, strength) {
-  insertLink.run(sourceId, targetId, linkType, strength);
-}
-
-console.log('Category 1: Design Patterns & Architecture (500 patterns)');
-
-// 1. SOLID Principles (100 patterns)
-const solidPatterns = [
-  {
-    desc: 'Single Responsibility Principle violation: God class handling multiple concerns',
-    solution: 'Split class into focused, single-purpose classes with clear responsibilities',
-    successRate: 0.92,
-    tags: ['solid', 'srp', 'refactoring', 'java', 'oop'],
-    metadata: {
-      before: `class UserManager {
-  validateUser() {}
-  saveToDatabase() {}
-  sendEmail() {}
-  generateReport() {}
-  logActivity() {}
-}`,
-      after: `class UserValidator { validate() {} }
-class UserRepository { save() {} }
-class EmailService { send() {} }
-class ReportGenerator { generate() {} }
-class ActivityLogger { log() {} }`,
-      antiPattern: true
-    }
-  },
-  {
-    desc: 'Open/Closed Principle: Extend behavior without modifying existing code',
-    solution: 'Use interfaces, abstract classes, and dependency injection for extensibility',
-    successRate: 0.95,
-    tags: ['solid', 'ocp', 'extensibility', 'typescript', 'design-patterns'],
-    metadata: {
-      example: `interface PaymentProcessor {
-  process(amount: number): Promise<void>;
-}
-
-class StripePayment implements PaymentProcessor {
-  async process(amount: number) { /* Stripe logic */ }
-}
-
-class PayPalPayment implements PaymentProcessor {
-  async process(amount: number) { /* PayPal logic */ }
-}`,
-      benefits: ['Easy to add new payment methods', 'No changes to existing code', 'Testable']
-    }
-  },
-  {
-    desc: 'Liskov Substitution Principle violation: Derived class breaks base class contract',
-    solution: 'Ensure subclasses can replace parent without breaking functionality',
-    successRate: 0.88,
-    tags: ['solid', 'lsp', 'inheritance', 'java', 'polymorphism'],
-    metadata: {
-      antiPattern: true,
-      violation: `class Bird { fly() {} }
-class Penguin extends Bird {
-  fly() { throw new Error("Can't fly!"); } // Breaks contract
-}`,
-      fix: `interface Flyable { fly(): void; }
-class Bird {}
-class Eagle extends Bird implements Flyable { fly() {} }
-class Penguin extends Bird { /* No fly method */ }`
-    }
-  },
-  {
-    desc: 'Interface Segregation: Fat interface forcing clients to implement unused methods',
-    solution: 'Split large interfaces into smaller, focused interfaces',
-    successRate: 0.90,
-    tags: ['solid', 'isp', 'interfaces', 'typescript', 'clean-code'],
-    metadata: {
-      problem: `interface Worker {
-  work(): void;
-  eat(): void;
-  sleep(): void;
-}
-class Robot implements Worker { // Robot doesn't eat/sleep!
-  work() {}
-  eat() { throw new Error(); }
-  sleep() { throw new Error(); }
-}`,
-      solution: `interface Workable { work(): void; }
-interface Eatable { eat(): void; }
-interface Sleepable { sleep(): void; }
-class Robot implements Workable { work() {} }
-class Human implements Workable, Eatable, Sleepable {}`
-    }
-  },
-  {
-    desc: 'Dependency Inversion: High-level modules depending on low-level details',
-    solution: 'Depend on abstractions, not concrete implementations. Use DI containers.',
-    successRate: 0.94,
-    tags: ['solid', 'dip', 'dependency-injection', 'typescript', 'architecture'],
-    metadata: {
-      before: `class UserService {
-  private db = new MySQLDatabase(); // Tight coupling
-}`,
-      after: `interface Database { query(sql: string): any; }
-class UserService {
-  constructor(private db: Database) {} // Inject abstraction
-}
-const service = new UserService(new MySQLDatabase());`,
-      frameworks: ['Spring', 'Angular', 'NestJS', 'InversifyJS']
-    }
-  }
-];
-
-for (const pattern of solidPatterns) {
-  for (let i = 0; i < 20; i++) {
-    addPattern(
-      'design-patterns',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.95,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 2. Design Patterns (150 patterns)
-const designPatterns = [
-  {
-    desc: 'Singleton anti-pattern: Global state makes testing difficult',
-    solution: 'Use dependency injection instead of Singleton for better testability',
-    successRate: 0.75,
-    tags: ['singleton', 'anti-pattern', 'testing', 'javascript', 'refactoring'],
-    metadata: {
-      antiPattern: true,
-      problem: `class Database {
-  private static instance: Database;
-  private constructor() {}
-  static getInstance() {
-    if (!this.instance) this.instance = new Database();
-    return this.instance;
-  }
-}`,
-      better: `class Database {
-  constructor(private config: Config) {}
-}
-// Use DI container to manage lifecycle`
-    }
-  },
-  {
-    desc: 'Factory Pattern: Complex object creation logic scattered across codebase',
-    solution: 'Centralize object creation in factory methods/classes',
-    successRate: 0.93,
-    tags: ['factory', 'creational', 'typescript', 'design-patterns', 'clean-code'],
-    metadata: {
-      example: `interface Shape { draw(): void; }
-class Circle implements Shape { draw() {} }
-class Square implements Shape { draw() {} }
-
-class ShapeFactory {
-  createShape(type: string): Shape {
-    switch(type) {
-      case 'circle': return new Circle();
-      case 'square': return new Square();
-      default: throw new Error('Unknown shape');
-    }
-  }
-}`,
-      benefits: ['Encapsulates creation logic', 'Easy to add new types', 'Single responsibility']
-    }
-  },
-  {
-    desc: 'Observer Pattern: Tight coupling between event producers and consumers',
-    solution: 'Implement pub/sub pattern for loose coupling and scalability',
-    successRate: 0.91,
-    tags: ['observer', 'behavioral', 'event-driven', 'javascript', 'reactive'],
-    metadata: {
-      example: `class EventEmitter {
-  private listeners = new Map<string, Function[]>();
-
-  on(event: string, callback: Function) {
-    if (!this.listeners.has(event)) this.listeners.set(event, []);
-    this.listeners.get(event)!.push(callback);
-  }
-
-  emit(event: string, data: any) {
-    this.listeners.get(event)?.forEach(cb => cb(data));
-  }
-}`,
-      useCases: ['UI updates', 'Logging', 'Analytics', 'Real-time notifications']
-    }
-  },
-  {
-    desc: 'Strategy Pattern: Conditional logic explosion with if/else chains',
-    solution: 'Extract algorithms into strategy classes, select at runtime',
-    successRate: 0.89,
-    tags: ['strategy', 'behavioral', 'polymorphism', 'java', 'clean-code'],
-    metadata: {
-      before: `function calculatePrice(type, price) {
-  if (type === 'regular') return price;
-  else if (type === 'premium') return price * 0.9;
-  else if (type === 'vip') return price * 0.8;
-  else if (type === 'bulk') return price * 0.7;
-}`,
-      after: `interface PricingStrategy { calculate(price: number): number; }
-class RegularPricing implements PricingStrategy { calculate(p) { return p; } }
-class PremiumPricing implements PricingStrategy { calculate(p) { return p * 0.9; } }
-class Context {
-  constructor(private strategy: PricingStrategy) {}
-  getPrice(price: number) { return this.strategy.calculate(price); }
-}`
-    }
-  },
-  {
-    desc: 'Decorator Pattern: Adding features without modifying existing classes',
-    solution: 'Wrap objects with decorator classes to add behavior dynamically',
-    successRate: 0.87,
-    tags: ['decorator', 'structural', 'composition', 'typescript', 'extensibility'],
-    metadata: {
-      example: `interface Coffee { cost(): number; description(): string; }
-class SimpleCoffee implements Coffee {
-  cost() { return 5; }
-  description() { return "Simple coffee"; }
-}
-class MilkDecorator implements Coffee {
-  constructor(private coffee: Coffee) {}
-  cost() { return this.coffee.cost() + 2; }
-  description() { return this.coffee.description() + ", milk"; }
-}
-const coffee = new MilkDecorator(new SimpleCoffee());`,
-      benefits: ['Open/closed principle', 'Flexible', 'Composable']
-    }
-  }
-];
-
-for (const pattern of designPatterns) {
-  for (let i = 0; i < 30; i++) {
-    addPattern(
-      'design-patterns',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.93,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 3. Architecture Patterns (200 patterns)
-const architecturePatterns = [
-  {
-    desc: 'Monolithic architecture: Single deployment unit becoming unmanageable',
-    solution: 'Migrate to microservices with clear service boundaries and APIs',
-    successRate: 0.82,
-    tags: ['microservices', 'architecture', 'scalability', 'distributed', 'refactoring'],
-    metadata: {
-      challenges: ['Service discovery', 'Data consistency', 'Network latency', 'Monitoring'],
-      patterns: ['API Gateway', 'Service Mesh', 'CQRS', 'Event Sourcing'],
-      tools: ['Kubernetes', 'Docker', 'Istio', 'Kong']
-    }
-  },
-  {
-    desc: 'N-tier architecture: Tight coupling between presentation, business, and data layers',
-    solution: 'Implement clean architecture with dependency inversion and clear boundaries',
-    successRate: 0.90,
-    tags: ['clean-architecture', 'layered', 'separation-of-concerns', 'java', 'architecture'],
-    metadata: {
-      layers: ['Entities', 'Use Cases', 'Interface Adapters', 'Frameworks & Drivers'],
-      rules: ['Dependencies point inward', 'Inner layers know nothing of outer layers'],
-      example: `// Domain Layer (Core)
-class User { id: string; email: string; }
-interface UserRepository { save(user: User): Promise<void>; }
-
-// Application Layer
-class CreateUserUseCase {
-  constructor(private repo: UserRepository) {}
-  async execute(email: string) {
-    const user = new User(uuid(), email);
-    await this.repo.save(user);
-  }
-}
-
-// Infrastructure Layer
-class PostgresUserRepository implements UserRepository {
-  async save(user: User) { /* DB logic */ }
-}`
-    }
-  },
-  {
-    desc: 'Event-driven architecture: Synchronous API calls causing tight coupling',
-    solution: 'Use message queues and event streams for asynchronous communication',
-    successRate: 0.88,
-    tags: ['event-driven', 'async', 'messaging', 'kafka', 'architecture'],
-    metadata: {
-      benefits: ['Loose coupling', 'Scalability', 'Resilience', 'Audit trail'],
-      patterns: ['Event Sourcing', 'CQRS', 'Saga Pattern', 'Event Notification'],
-      tools: ['Kafka', 'RabbitMQ', 'AWS SNS/SQS', 'NATS']
-    }
-  },
-  {
-    desc: 'CQRS Pattern: Complex queries hitting write-optimized database',
-    solution: 'Separate read and write models with eventual consistency',
-    successRate: 0.85,
-    tags: ['cqrs', 'architecture', 'scalability', 'event-sourcing', 'ddd'],
-    metadata: {
-      example: `// Write Model
-class CreateOrderCommand {
-  async execute(order: Order) {
-    await writeDb.save(order);
-    await eventBus.publish('OrderCreated', order);
-  }
-}
-
-// Read Model
-class OrderQueryService {
-  async getOrders() {
-    return readDb.query('SELECT * FROM orders_view'); // Denormalized
-  }
-}
-
-// Sync via events
-eventBus.on('OrderCreated', (order) => {
-  readDb.updateView(order); // Update read model
-});`,
-      useCases: ['High read/write ratio', 'Complex queries', 'Event sourcing']
-    }
-  },
-  {
-    desc: 'API Gateway Pattern: Clients calling multiple microservices directly',
-    solution: 'Implement API gateway for routing, authentication, and aggregation',
-    successRate: 0.92,
-    tags: ['api-gateway', 'microservices', 'architecture', 'security', 'routing'],
-    metadata: {
-      responsibilities: [
-        'Request routing',
-        'Authentication/Authorization',
-        'Rate limiting',
-        'Request/response transformation',
-        'Load balancing'
-      ],
-      tools: ['Kong', 'NGINX', 'AWS API Gateway', 'Envoy'],
-      antiPatterns: ['Too much business logic in gateway', 'Single point of failure']
-    }
-  }
-];
-
-for (const pattern of architecturePatterns) {
-  for (let i = 0; i < 40; i++) {
-    addPattern(
-      'architecture',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.91,
-      'high',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 4. Remaining patterns for Category 1 (50 patterns)
-const remainingDesign = [
-  {
-    desc: 'Repository Pattern: Data access logic scattered throughout business layer',
-    solution: 'Centralize data access in repository classes with clean interfaces',
-    successRate: 0.93,
-    tags: ['repository', 'data-access', 'ddd', 'typescript', 'architecture'],
-    metadata: {
-      example: `interface UserRepository {
-  findById(id: string): Promise<User | null>;
-  save(user: User): Promise<void>;
-  delete(id: string): Promise<void>;
-}
-
-class PostgresUserRepository implements UserRepository {
-  async findById(id: string) { /* SQL query */ }
-  async save(user: User) { /* SQL insert/update */ }
-  async delete(id: string) { /* SQL delete */ }
-}`
-    }
-  }
-];
-
-for (const pattern of remainingDesign) {
-  for (let i = 0; i < 50; i++) {
-    addPattern(
-      'design-patterns',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.92,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-console.log('✅ Category 1 complete: 500 patterns');
-console.log('');
-console.log('Category 2: Algorithm Optimization (500 patterns)');
-
-// 2. Time Complexity Optimization (150 patterns)
-const timeComplexityPatterns = [
-  {
-    desc: 'O(n²) nested loop: Finding duplicates in array with nested iteration',
-    solution: 'Use HashSet for O(n) time complexity with single pass',
-    successRate: 0.96,
-    tags: ['algorithm', 'time-complexity', 'optimization', 'javascript', 'data-structures'],
-    metadata: {
-      before: `function hasDuplicates(arr) {
-  for (let i = 0; i < arr.length; i++) {
-    for (let j = i + 1; j < arr.length; j++) {
-      if (arr[i] === arr[j]) return true;
-    }
-  }
-  return false;
-} // O(n²)`,
-      after: `function hasDuplicates(arr) {
-  const seen = new Set();
-  for (const item of arr) {
-    if (seen.has(item)) return true;
-    seen.add(item);
-  }
-  return false;
-} // O(n)`,
-      improvement: 'From O(n²) to O(n)',
-      spaceTradeoff: 'O(n) space for O(n²) → O(n) time improvement'
-    }
-  },
-  {
-    desc: 'O(n) linear search: Repeated lookups in unsorted array',
-    solution: 'Convert to HashMap/Object for O(1) average lookup time',
-    successRate: 0.94,
-    tags: ['algorithm', 'search', 'hash-map', 'optimization', 'data-structures'],
-    metadata: {
-      before: `const users = [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}];
-function findUser(id) {
-  return users.find(u => u.id === id); // O(n)
-}`,
-      after: `const users = new Map([
-  [1, {id: 1, name: 'Alice'}],
-  [2, {id: 2, name: 'Bob'}]
-]);
-function findUser(id) {
-  return users.get(id); // O(1)
-}`,
-      useCases: ['Frequent lookups', 'Large datasets', 'Real-time queries']
-    }
-  },
-  {
-    desc: 'O(n log n) sort when O(n) is possible: Sorting already bounded integers',
-    solution: 'Use counting sort or bucket sort for O(n) when range is known',
-    successRate: 0.89,
-    tags: ['sorting', 'algorithm', 'optimization', 'counting-sort', 'performance'],
-    metadata: {
-      example: `// For integers in range [0, k]
-function countingSort(arr, k) {
-  const count = new Array(k + 1).fill(0);
-  const output = new Array(arr.length);
-
-  for (const num of arr) count[num]++;
-  for (let i = 1; i <= k; i++) count[i] += count[i - 1];
-
-  for (let i = arr.length - 1; i >= 0; i--) {
-    output[count[arr[i]] - 1] = arr[i];
-    count[arr[i]]--;
-  }
-  return output;
-} // O(n + k) vs O(n log n)`,
-      applicability: ['Small integer range', 'Age sorting', 'Grade distribution']
-    }
-  },
-  {
-    desc: 'Exponential recursion: Fibonacci with overlapping subproblems',
-    solution: 'Apply memoization or dynamic programming to avoid recomputation',
-    successRate: 0.97,
-    tags: ['dynamic-programming', 'memoization', 'recursion', 'optimization', 'javascript'],
-    metadata: {
-      before: `function fib(n) {
-  if (n <= 1) return n;
-  return fib(n - 1) + fib(n - 2); // O(2^n)
-}`,
-      after: `function fib(n, memo = {}) {
-  if (n <= 1) return n;
-  if (memo[n]) return memo[n];
-  memo[n] = fib(n - 1, memo) + fib(n - 2, memo);
-  return memo[n]; // O(n)
-}`,
-      improvement: 'From O(2^n) to O(n)',
-      patterns: ['Memoization', 'Dynamic Programming', 'Bottom-up approach']
-    }
-  },
-  {
-    desc: 'String concatenation in loop: O(n²) due to immutable strings',
-    solution: 'Use StringBuilder/Array join for O(n) concatenation',
-    successRate: 0.95,
-    tags: ['strings', 'optimization', 'performance', 'java', 'javascript'],
-    metadata: {
-      before: `let result = '';
-for (let i = 0; i < 10000; i++) {
-  result += 'a'; // Creates new string each time, O(n²)
-}`,
-      after: `const parts = [];
-for (let i = 0; i < 10000; i++) {
-  parts.push('a');
-}
-const result = parts.join(''); // O(n)`,
-      languages: {
-        java: 'Use StringBuilder',
-        python: 'Use list and join()',
-        javascript: 'Use array and join()'
-      }
-    }
-  }
-];
-
-for (const pattern of timeComplexityPatterns) {
-  for (let i = 0; i < 30; i++) {
-    addPattern(
-      'algorithm-optimization',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.94,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 3. Space Complexity Optimization (100 patterns)
-const spaceComplexityPatterns = [
-  {
-    desc: 'Storing all results in memory: OutOfMemory for large datasets',
-    solution: 'Use generator functions/iterators for lazy evaluation and streaming',
-    successRate: 0.92,
-    tags: ['memory', 'streaming', 'generators', 'javascript', 'optimization'],
-    metadata: {
-      before: `function processLargeFile(filename) {
-  const lines = fs.readFileSync(filename, 'utf8').split('\\n'); // Loads all
-  return lines.map(procesLine); // Stores all results
-}`,
-      after: `function* processLargeFile(filename) {
-  const stream = fs.createReadStream(filename);
-  const reader = readline.createInterface({ input: stream });
-  for await (const line of reader) {
-    yield processLine(line); // Process one at a time
-  }
-}`,
-      benefits: ['Constant memory', 'Start processing immediately', 'Handle infinite streams']
-    }
-  },
-  {
-    desc: 'Deep cloning large objects: Excessive memory usage for temporary copies',
-    solution: 'Use structural sharing and immutable data structures',
-    successRate: 0.88,
-    tags: ['memory', 'immutability', 'data-structures', 'javascript', 'optimization'],
-    metadata: {
-      libraries: ['Immutable.js', 'Immer', 'Ramda'],
-      example: `// With Immer
-import produce from 'immer';
-const nextState = produce(state, draft => {
-  draft.user.name = 'New Name'; // Only changed path is copied
-});`,
-      benefits: ['O(1) clone operations', 'Structural sharing', 'Time-travel debugging']
-    }
-  }
-];
-
-for (const pattern of spaceComplexityPatterns) {
-  for (let i = 0; i < 50; i++) {
-    addPattern(
-      'algorithm-optimization',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.90,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 4. Caching Strategies (150 patterns)
-const cachingPatterns = [
-  {
-    desc: 'Repeated expensive computations: No caching of deterministic results',
-    solution: 'Implement memoization with LRU cache to store computed values',
-    successRate: 0.93,
-    tags: ['caching', 'memoization', 'performance', 'javascript', 'optimization'],
-    metadata: {
-      example: `class LRUCache {
-  constructor(capacity) {
-    this.capacity = capacity;
-    this.cache = new Map();
-  }
-
-  get(key) {
-    if (!this.cache.has(key)) return null;
-    const val = this.cache.get(key);
-    this.cache.delete(key);
-    this.cache.set(key, val); // Move to end
-    return val;
-  }
-
-  put(key, value) {
-    if (this.cache.has(key)) this.cache.delete(key);
-    this.cache.set(key, value);
-    if (this.cache.size > this.capacity) {
-      this.cache.delete(this.cache.keys().next().value);
-    }
-  }
-}`,
-      useCases: ['API responses', 'Database queries', 'Heavy computations']
-    }
-  },
-  {
-    desc: 'Database query spam: Same query executed multiple times per request',
-    solution: 'Implement request-scoped caching and batch queries with DataLoader',
-    successRate: 0.95,
-    tags: ['caching', 'database', 'n+1', 'graphql', 'optimization'],
-    metadata: {
-      example: `const DataLoader = require('dataloader');
-const userLoader = new DataLoader(async (ids) => {
-  const users = await db.query('SELECT * FROM users WHERE id IN (?)', [ids]);
-  return ids.map(id => users.find(u => u.id === id));
-});
-
-// Multiple calls are batched automatically
-const user1 = await userLoader.load(1);
-const user2 = await userLoader.load(2);
-// Only 1 DB query: SELECT * FROM users WHERE id IN (1, 2)`,
-      frameworks: ['GraphQL', 'Apollo', 'NestJS']
-    }
-  }
-];
-
-for (const pattern of cachingPatterns) {
-  for (let i = 0; i < 75; i++) {
-    addPattern(
-      'algorithm-optimization',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.93,
-      'low',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 5. Parallelization (100 patterns)
-const parallelizationPatterns = [
-  {
-    desc: 'Sequential async operations: Waiting for each task to complete before starting next',
-    solution: 'Use Promise.all() to execute independent tasks in parallel',
-    successRate: 0.94,
-    tags: ['async', 'parallelization', 'promises', 'javascript', 'performance'],
-    metadata: {
-      before: `async function fetchData() {
-  const user = await fetchUser(); // Wait 100ms
-  const posts = await fetchPosts(); // Wait 200ms
-  const comments = await fetchComments(); // Wait 150ms
-  return { user, posts, comments }; // Total: 450ms
-}`,
-      after: `async function fetchData() {
-  const [user, posts, comments] = await Promise.all([
-    fetchUser(),
-    fetchPosts(),
-    fetchComments()
-  ]); // Total: 200ms (longest operation)
-  return { user, posts, comments };
-}`,
-      improvement: '2.25x faster',
-      caution: 'Only for independent operations'
-    }
-  },
-  {
-    desc: 'CPU-intensive task blocking event loop: UI freezes during computation',
-    solution: 'Offload to Web Workers/Worker Threads for parallel CPU utilization',
-    successRate: 0.89,
-    tags: ['parallelization', 'web-workers', 'worker-threads', 'javascript', 'performance'],
-    metadata: {
-      example: `// worker.js
-self.onmessage = (e) => {
-  const result = heavyComputation(e.data);
-  self.postMessage(result);
-};
-
-// main.js
-const worker = new Worker('worker.js');
-worker.postMessage(largeData);
-worker.onmessage = (e) => {
-  console.log('Result:', e.data);
-};`,
-      useCases: ['Image processing', 'Data parsing', 'Encryption', 'Mathematical computations']
-    }
-  }
-];
-
-for (const pattern of parallelizationPatterns) {
-  for (let i = 0; i < 50; i++) {
-    addPattern(
-      'algorithm-optimization',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.91,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-console.log('✅ Category 2 complete: 500 patterns');
-console.log('');
-console.log('Category 3: Code Quality & Refactoring (500 patterns)');
-
-// 3. Code Quality & Refactoring (500 patterns)
-
-// 1. Clean Code Principles (150 patterns)
-const cleanCodePatterns = [
-  {
-    desc: 'Magic numbers in code: Unclear meaning and hard to maintain',
-    solution: 'Extract to named constants with descriptive names',
-    successRate: 0.96,
-    tags: ['clean-code', 'constants', 'readability', 'refactoring', 'javascript'],
-    metadata: {
-      before: `if (user.age > 65) { /* Senior discount */ }
-if (order.total < 50) { /* Shipping fee */ }`,
-      after: `const SENIOR_AGE_THRESHOLD = 65;
-const FREE_SHIPPING_MINIMUM = 50;
-if (user.age > SENIOR_AGE_THRESHOLD) { /* Senior discount */ }
-if (order.total < FREE_SHIPPING_MINIMUM) { /* Shipping fee */ }`,
-      benefits: ['Self-documenting', 'Easy to update', 'Centralized configuration']
-    }
-  },
-  {
-    desc: 'Long functions: 100+ lines with multiple responsibilities',
-    solution: 'Apply Extract Method refactoring to create focused functions under 20 lines',
-    successRate: 0.93,
-    tags: ['refactoring', 'clean-code', 'functions', 'srp', 'maintainability'],
-    metadata: {
-      before: `function processOrder(order) {
-  // Validate (20 lines)
-  // Calculate totals (15 lines)
-  // Apply discounts (25 lines)
-  // Update inventory (30 lines)
-  // Send notifications (20 lines)
-} // 110 lines`,
-      after: `function processOrder(order) {
-  validateOrder(order);
-  const total = calculateTotal(order);
-  const discount = applyDiscounts(total);
-  updateInventory(order.items);
-  sendNotifications(order);
-} // 6 lines, each helper < 20 lines`,
-      rules: ['One function, one responsibility', 'Max 20 lines', 'Max 3 parameters']
-    }
-  },
-  {
-    desc: 'Unclear variable names: x, temp, data, result',
-    solution: 'Use intention-revealing names that describe purpose and meaning',
-    successRate: 0.95,
-    tags: ['naming', 'clean-code', 'readability', 'refactoring', 'conventions'],
-    metadata: {
-      before: `function process(d) {
-  const r = d.filter(x => x.a > 18);
-  const t = r.map(x => x.n);
-  return t;
-}`,
-      after: `function getAdultUsernames(users) {
-  const adults = users.filter(user => user.age > 18);
-  const usernames = adults.map(user => user.name);
-  return usernames;
-}`,
-      guidelines: [
-        'Use nouns for variables/classes',
-        'Use verbs for functions',
-        'Avoid abbreviations',
-        'Be specific, not generic'
-      ]
-    }
-  },
-  {
-    desc: 'Boolean parameters: Unclear function behavior with true/false flags',
-    solution: 'Replace boolean flags with named methods or enum parameters',
-    successRate: 0.88,
-    tags: ['clean-code', 'api-design', 'refactoring', 'typescript', 'parameters'],
-    metadata: {
-      before: `user.setStatus(true); // What does true mean?
-email.send(false, true); // Confusing`,
-      after: `user.activate();
-user.deactivate();
-email.sendImmediately();
-email.scheduleForLater();`,
-      alternative: `enum DeliveryMode { IMMEDIATE, SCHEDULED }
-email.send(DeliveryMode.IMMEDIATE);`
-    }
-  },
-  {
-    desc: 'Commented-out code: Clutters codebase and creates confusion',
-    solution: 'Delete commented code and rely on version control for history',
-    successRate: 0.97,
-    tags: ['clean-code', 'comments', 'git', 'refactoring', 'maintenance'],
-    metadata: {
-      antiPattern: true,
-      problem: `function calculateTotal(items) {
-  // const oldTotal = items.reduce((sum, item) => sum + item.price, 0);
-  // return oldTotal * 0.9;
-  return items.reduce((sum, item) => sum + item.price * 1.1, 0);
-}`,
-      solution: 'Use git blame/log to see history. Keep code clean.',
-      reasoning: ['Version control is the source of truth', 'Reduces noise', 'Prevents confusion']
-    }
-  }
-];
-
-for (const pattern of cleanCodePatterns) {
-  for (let i = 0; i < 30; i++) {
-    addPattern(
-      'code-quality',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.94,
-      'low',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 2. DRY Principle (100 patterns)
-const dryPatterns = [
-  {
-    desc: 'Copy-pasted code: Same logic duplicated across files',
-    solution: 'Extract to reusable function/module and import where needed',
-    successRate: 0.94,
-    tags: ['dry', 'refactoring', 'duplication', 'clean-code', 'modules'],
-    metadata: {
-      before: `// file1.js
-const valid = email.includes('@') && email.includes('.');
-// file2.js
-const valid = email.includes('@') && email.includes('.');
-// file3.js
-const valid = email.includes('@') && email.includes('.');`,
-      after: `// utils/validation.js
-export function isValidEmail(email) {
-  return email.includes('@') && email.includes('.');
-}
-// file1.js, file2.js, file3.js
-import { isValidEmail } from './utils/validation';
-const valid = isValidEmail(email);`,
-      benefits: ['Single source of truth', 'Easier to fix bugs', 'Consistent behavior']
-    }
-  },
-  {
-    desc: 'Similar but slightly different functions: Code divergence over time',
-    solution: 'Parameterize differences and create single flexible function',
-    successRate: 0.90,
-    tags: ['dry', 'refactoring', 'parameterization', 'clean-code', 'abstraction'],
-    metadata: {
-      before: `function sendWelcomeEmail(user) {
-  mailer.send(user.email, 'Welcome!', welcomeTemplate);
-}
-function sendResetEmail(user) {
-  mailer.send(user.email, 'Reset Password', resetTemplate);
-}
-function sendNotificationEmail(user) {
-  mailer.send(user.email, 'Notification', notificationTemplate);
-}`,
-      after: `function sendEmail(user, subject, template) {
-  mailer.send(user.email, subject, template);
-}
-sendEmail(user, 'Welcome!', welcomeTemplate);
-sendEmail(user, 'Reset Password', resetTemplate);
-sendEmail(user, 'Notification', notificationTemplate);`
-    }
-  }
-];
-
-for (const pattern of dryPatterns) {
-  for (let i = 0; i < 50; i++) {
-    addPattern(
-      'code-quality',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.92,
-      'low',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 3. Code Smells (150 patterns)
-const codeSmellPatterns = [
-  {
-    desc: 'Long Parameter List: Function with 6+ parameters',
-    solution: 'Introduce Parameter Object or Builder Pattern',
-    successRate: 0.91,
-    tags: ['code-smell', 'refactoring', 'parameters', 'clean-code', 'design-patterns'],
-    metadata: {
-      before: `function createUser(name, email, age, address, phone, role) {
-  // ...
-}
-createUser('Alice', 'alice@ex.com', 25, '123 St', '555-1234', 'admin');`,
-      after: `interface UserParams {
-  name: string;
-  email: string;
-  age: number;
-  address: string;
-  phone: string;
-  role: string;
-}
-function createUser(params: UserParams) {
-  // ...
-}
-createUser({
-  name: 'Alice',
-  email: 'alice@ex.com',
-  age: 25,
-  address: '123 St',
-  phone: '555-1234',
-  role: 'admin'
-});`,
-      benefits: ['Named parameters', 'Optional parameters', 'Easier to extend']
-    }
-  },
-  {
-    desc: 'Data Clumps: Same group of variables appearing together repeatedly',
-    solution: 'Extract Class to represent the cohesive data group',
-    successRate: 0.89,
-    tags: ['code-smell', 'refactoring', 'oop', 'clean-code', 'encapsulation'],
-    metadata: {
-      before: `function drawRectangle(x, y, width, height) {}
-function moveRectangle(x, y, width, height, dx, dy) {}
-function resizeRectangle(x, y, width, height, scale) {}`,
-      after: `class Rectangle {
-  constructor(x, y, width, height) {
-    this.x = x; this.y = y;
-    this.width = width; this.height = height;
-  }
-  draw() {}
-  move(dx, dy) { this.x += dx; this.y += dy; }
-  resize(scale) { this.width *= scale; this.height *= scale; }
-}`,
-      detection: 'Look for 3+ variables always used together'
-    }
-  },
-  {
-    desc: 'Feature Envy: Method uses data from another class more than its own',
-    solution: 'Move method to the class it envies or extract common behavior',
-    successRate: 0.86,
-    tags: ['code-smell', 'refactoring', 'oop', 'encapsulation', 'cohesion'],
-    metadata: {
-      before: `class Order {
-  calculateDiscount() {
-    return this.customer.points * 0.01 * this.customer.loyaltyLevel;
-  }
-}`,
-      after: `class Customer {
-  calculateDiscount() {
-    return this.points * 0.01 * this.loyaltyLevel;
-  }
-}
-class Order {
-  calculateDiscount() {
-    return this.customer.calculateDiscount();
-  }
-}`,
-      principle: 'Data and behavior should be together'
-    }
-  },
-  {
-    desc: 'Primitive Obsession: Using primitives instead of small objects',
-    solution: 'Create Value Objects to encapsulate primitives with behavior',
-    successRate: 0.88,
-    tags: ['code-smell', 'value-object', 'ddd', 'refactoring', 'typescript'],
-    metadata: {
-      before: `function sendEmail(emailString: string) {
-  if (!emailString.includes('@')) throw new Error('Invalid email');
-  // ...
-}`,
-      after: `class Email {
-  constructor(private value: string) {
-    if (!value.includes('@')) throw new Error('Invalid email');
-  }
-  toString() { return this.value; }
-}
-function sendEmail(email: Email) {
-  // Email is guaranteed valid
-}`,
-      examples: ['Money', 'Email', 'PhoneNumber', 'Address', 'DateRange']
-    }
-  },
-  {
-    desc: 'Shotgun Surgery: Single change requires modifying many classes',
-    solution: 'Move related behavior into single class or module',
-    successRate: 0.87,
-    tags: ['code-smell', 'refactoring', 'cohesion', 'srp', 'architecture'],
-    metadata: {
-      example: 'Adding a new payment method requires changes to 10 different files',
-      solution: 'Consolidate payment logic into PaymentService with plugins',
-      prevention: ['High cohesion', 'Low coupling', 'Single responsibility']
-    }
-  }
-];
-
-for (const pattern of codeSmellPatterns) {
-  for (let i = 0; i < 30; i++) {
-    addPattern(
-      'code-quality',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.88,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 4. Refactoring Patterns (100 patterns)
-const refactoringPatterns = [
-  {
-    desc: 'Conditional complexity: Nested if/else chains with complex logic',
-    solution: 'Replace Conditional with Polymorphism or Strategy Pattern',
-    successRate: 0.90,
-    tags: ['refactoring', 'conditionals', 'polymorphism', 'clean-code', 'patterns'],
-    metadata: {
-      before: `function getPrice(customer, product) {
-  if (customer.type === 'regular') {
-    if (product.onSale) return product.price * 0.9;
-    return product.price;
-  } else if (customer.type === 'premium') {
-    if (product.onSale) return product.price * 0.8;
-    return product.price * 0.95;
-  } else if (customer.type === 'vip') {
-    return product.price * 0.7;
-  }
-}`,
-      after: `interface PricingStrategy {
-  getPrice(product: Product): number;
-}
-class RegularPricing implements PricingStrategy {
-  getPrice(product) {
-    return product.onSale ? product.price * 0.9 : product.price;
-  }
-}
-class PremiumPricing implements PricingStrategy {
-  getPrice(product) {
-    return product.onSale ? product.price * 0.8 : product.price * 0.95;
-  }
-}
-const strategy = customer.getPricingStrategy();
-const price = strategy.getPrice(product);`
-    }
-  }
-];
-
-for (const pattern of refactoringPatterns) {
-  for (let i = 0; i < 100; i++) {
-    addPattern(
-      'code-quality',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.89,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-console.log('✅ Category 3 complete: 500 patterns');
-console.log('');
-console.log('Category 4: Language-Specific Best Practices (500 patterns)');
-
-// 4. Language-Specific Best Practices (500 patterns)
-
-// 1. JavaScript/TypeScript (150 patterns)
-const jsPatterns = [
-  {
-    desc: 'Callback hell: Deeply nested async callbacks creating pyramid of doom',
-    solution: 'Convert to async/await or Promise chains for linear flow',
-    successRate: 0.96,
-    tags: ['javascript', 'async', 'promises', 'async-await', 'refactoring'],
-    metadata: {
-      before: `getUser(userId, (user) => {
-  getOrders(user.id, (orders) => {
-    getOrderDetails(orders[0].id, (details) => {
-      console.log(details);
-    });
-  });
-});`,
-      after: `async function fetchOrderDetails(userId) {
-  const user = await getUser(userId);
-  const orders = await getOrders(user.id);
-  const details = await getOrderDetails(orders[0].id);
-  console.log(details);
-}`,
-      benefits: ['Linear flow', 'Error handling with try/catch', 'Readable']
-    }
-  },
-  {
-    desc: 'Type coercion bugs: Unexpected == comparisons causing false positives',
-    solution: 'Always use strict equality === and !== in JavaScript',
-    successRate: 0.98,
-    tags: ['javascript', 'bugs', 'type-coercion', 'best-practices', 'eslint'],
-    metadata: {
-      antiPattern: true,
-      examples: [
-        "'' == 0 // true",
-        'null == undefined // true',
-        "'0' == 0 // true",
-        "[] == false // true"
-      ],
-      solution: "Use === and !== to avoid type coercion",
-      eslint: 'eqeqeq: error'
-    }
-  },
-  {
-    desc: 'Missing TypeScript types: Using any everywhere defeats type safety',
-    solution: 'Define explicit interfaces and enable strict TypeScript mode',
-    successRate: 0.93,
-    tags: ['typescript', 'type-safety', 'interfaces', 'best-practices', 'static-analysis'],
-    metadata: {
-      before: `function processData(data: any): any {
-  return data.map((item: any) => item.value);
-}`,
-      after: `interface DataItem {
-  value: number;
-  label: string;
-}
-function processData(data: DataItem[]): number[] {
-  return data.map(item => item.value);
-}`,
-      tsconfig: {
-        strict: true,
-        noImplicitAny: true,
-        strictNullChecks: true
-      }
-    }
-  },
-  {
-    desc: 'Mutating state directly: React state updates not triggering re-renders',
-    solution: 'Use immutable update patterns with spread operators or immer',
-    successRate: 0.94,
-    tags: ['javascript', 'react', 'immutability', 'state-management', 'best-practices'],
-    metadata: {
-      before: `const [state, setState] = useState({ users: [] });
-state.users.push(newUser); // Direct mutation, no re-render`,
-      after: `setState(prev => ({
-  ...prev,
-  users: [...prev.users, newUser]
-}));`,
-      withImmer: `import produce from 'immer';
-setState(produce(draft => {
-  draft.users.push(newUser); // Looks like mutation, creates new state
-}));`
-    }
-  },
-  {
-    desc: 'Memory leaks: Event listeners not cleaned up in component unmount',
-    solution: 'Return cleanup function from useEffect to remove listeners',
-    successRate: 0.91,
-    tags: ['javascript', 'react', 'memory-leaks', 'useEffect', 'cleanup'],
-    metadata: {
-      before: `useEffect(() => {
-  window.addEventListener('resize', handleResize);
-});`,
-      after: `useEffect(() => {
-  window.addEventListener('resize', handleResize);
-  return () => {
-    window.removeEventListener('resize', handleResize);
-  };
-}, []);`,
-      commonLeaks: ['Event listeners', 'Timers', 'Subscriptions', 'WebSocket connections']
-    }
-  }
-];
-
-for (const pattern of jsPatterns) {
-  for (let i = 0; i < 30; i++) {
-    addPattern(
-      'language-specific',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.94,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 2. Python (100 patterns)
-const pythonPatterns = [
-  {
-    desc: 'Mutable default arguments: Shared state between function calls',
-    solution: 'Use None as default and create new object inside function',
-    successRate: 0.97,
-    tags: ['python', 'bugs', 'mutable-defaults', 'best-practices', 'functions'],
-    metadata: {
-      antiPattern: true,
-      before: `def append_to(element, lst=[]):  # Bug!
-    lst.append(element)
-    return lst
-print(append_to(1))  # [1]
-print(append_to(2))  # [1, 2] - Unexpected!`,
-      after: `def append_to(element, lst=None):
-    if lst is None:
-        lst = []
-    lst.append(element)
-    return lst`,
-      explanation: 'Default arguments evaluated once at function definition, not each call'
-    }
-  },
-  {
-    desc: 'List comprehension abuse: Complex nested logic in comprehensions',
-    solution: 'Use generator expressions or explicit loops for clarity',
-    successRate: 0.89,
-    tags: ['python', 'comprehensions', 'readability', 'best-practices', 'clean-code'],
-    metadata: {
-      before: `result = [x for sublist in [[y*2 for y in range(i)] for i in range(10) if i % 2 == 0] for x in sublist if x > 5]`,
-      after: `result = []
-for i in range(10):
-    if i % 2 == 0:
-        for y in range(i):
-            x = y * 2
-            if x > 5:
-                result.append(x)`,
-      guideline: 'If comprehension is > 1 line when formatted, use loop'
-    }
-  }
-];
-
-for (const pattern of pythonPatterns) {
-  for (let i = 0; i < 50; i++) {
-    addPattern(
-      'language-specific',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.93,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 3. Go (100 patterns)
-const goPatterns = [
-  {
-    desc: 'Ignoring errors: Silent failures leading to undefined behavior',
-    solution: 'Always check error returns and handle appropriately',
-    successRate: 0.96,
-    tags: ['go', 'error-handling', 'best-practices', 'bugs', 'golang'],
-    metadata: {
-      antiPattern: true,
-      before: `data, _ := ioutil.ReadFile("file.txt") // Ignoring error`,
-      after: `data, err := ioutil.ReadFile("file.txt")
-if err != nil {
-    return fmt.Errorf("failed to read file: %w", err)
-}`,
-      linter: 'errcheck',
-      convention: 'Error handling is explicit in Go, never ignore'
-    }
-  },
-  {
-    desc: 'Goroutine leaks: Goroutines waiting forever on blocked channels',
-    solution: 'Use context for cancellation and ensure all goroutines can exit',
-    successRate: 0.91,
-    tags: ['go', 'goroutines', 'concurrency', 'memory-leaks', 'context'],
-    metadata: {
-      before: `go func() {
-    result := <-ch // Blocks forever if ch never sends
-    process(result)
-}()`,
-      after: `ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-defer cancel()
-go func() {
-    select {
-    case result := <-ch:
-        process(result)
-    case <-ctx.Done():
-        return // Clean exit on timeout
-    }
-}()`,
-      tools: ['goleak', 'context', 'select with timeout']
-    }
-  }
-];
-
-for (const pattern of goPatterns) {
-  for (let i = 0; i < 50; i++) {
-    addPattern(
-      'language-specific',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.93,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 4. Rust (75 patterns)
-const rustPatterns = [
-  {
-    desc: 'Fighting the borrow checker: Multiple mutable references causing compilation errors',
-    solution: 'Use interior mutability patterns like RefCell, Mutex, or Arc',
-    successRate: 0.88,
-    tags: ['rust', 'borrow-checker', 'ownership', 'refcell', 'concurrency'],
-    metadata: {
-      before: `let mut data = vec![1, 2, 3];
-let r1 = &mut data;
-let r2 = &mut data; // Compile error`,
-      after: `use std::cell::RefCell;
-let data = RefCell::new(vec![1, 2, 3]);
-{
-    let mut r1 = data.borrow_mut();
-    r1.push(4);
-} // r1 dropped
-{
-    let mut r2 = data.borrow_mut();
-    r2.push(5);
-}`,
-      patterns: ['RefCell (single-threaded)', 'Mutex (multi-threaded)', 'Arc for shared ownership']
-    }
-  }
-];
-
-for (const pattern of rustPatterns) {
-  for (let i = 0; i < 75; i++) {
-    addPattern(
-      'language-specific',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.90,
-      'high',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 5. Java (75 patterns)
-const javaPatterns = [
-  {
-    desc: 'Resource leaks: Database connections or file handles not closed',
-    solution: 'Use try-with-resources for automatic resource management',
-    successRate: 0.95,
-    tags: ['java', 'resource-management', 'try-with-resources', 'jdbc', 'best-practices'],
-    metadata: {
-      before: `Connection conn = DriverManager.getConnection(url);
-Statement stmt = conn.createStatement();
-// Exception here = connection never closed`,
-      after: `try (Connection conn = DriverManager.getConnection(url);
-     Statement stmt = conn.createStatement()) {
-    // Automatically closed even if exception
-}`,
-      applies: 'Any class implementing AutoCloseable'
-    }
-  }
-];
-
-for (const pattern of javaPatterns) {
-  for (let i = 0; i < 75; i++) {
-    addPattern(
-      'language-specific',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.93,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-console.log('✅ Category 4 complete: 500 patterns');
-console.log('');
-console.log('Category 5: Debugging & Error Handling (500 patterns)');
-
-// 5. Debugging & Error Handling (500 patterns)
-
-// 1. Common Bugs (150 patterns)
-const commonBugPatterns = [
-  {
-    desc: 'Off-by-one error: Array iteration going one element too far',
-    solution: 'Use length-1 for last index or forEach/map for safer iteration',
-    successRate: 0.94,
-    tags: ['bugs', 'arrays', 'iteration', 'off-by-one', 'javascript'],
-    metadata: {
-      antiPattern: true,
-      before: `for (let i = 0; i <= arr.length; i++) { // Bug!
-  console.log(arr[i]); // arr[arr.length] is undefined
-}`,
-      after: `for (let i = 0; i < arr.length; i++) { // Correct
-  console.log(arr[i]);
-}
-// Or better:
-arr.forEach(item => console.log(item));`,
-      detection: 'Look for <= in array iterations'
-    }
-  },
-  {
-    desc: 'Race condition: Multiple async operations accessing shared state',
-    solution: 'Use locks, semaphores, or atomic operations for synchronization',
-    successRate: 0.89,
-    tags: ['bugs', 'concurrency', 'race-condition', 'async', 'synchronization'],
-    metadata: {
-      before: `let counter = 0;
-async function increment() {
-  const current = counter;
-  await delay(10);
-  counter = current + 1; // Lost updates!
-}
-Promise.all([increment(), increment()]); // counter = 1, not 2`,
-      after: `class Counter {
-  private value = 0;
-  private lock = new Mutex();
-
-  async increment() {
-    await this.lock.acquire();
-    try {
-      this.value++;
-    } finally {
-      this.lock.release();
-    }
-  }
-}`,
-      prevention: ['Immutable state', 'Message passing', 'Actor model', 'STM']
-    }
-  },
-  {
-    desc: 'Null pointer exception: Accessing properties of null/undefined',
-    solution: 'Use optional chaining, null checks, or Maybe/Option types',
-    successRate: 0.96,
-    tags: ['bugs', 'null', 'optional-chaining', 'typescript', 'defensive-programming'],
-    metadata: {
-      before: `const name = user.profile.name; // Crash if profile is null`,
-      after: `// Optional chaining (TypeScript/JavaScript)
-const name = user?.profile?.name;
-
-// Null check
-const name = user && user.profile && user.profile.name;
-
-// TypeScript strict null checks
-function getName(user: User | null): string | null {
-  return user?.profile?.name ?? null;
-}`,
-      typescript: 'Enable strictNullChecks in tsconfig.json'
-    }
-  },
-  {
-    desc: 'Integer overflow: Arithmetic operations exceeding max value',
-    solution: 'Check bounds before operations or use BigInt for large numbers',
-    successRate: 0.87,
-    tags: ['bugs', 'integers', 'overflow', 'arithmetic', 'edge-cases'],
-    metadata: {
-      example: `const maxInt = Number.MAX_SAFE_INTEGER; // 9007199254740991
-const result = maxInt + 1; // Still safe
-const bad = maxInt + 2; // Loss of precision!`,
-      solution: `const a = BigInt(Number.MAX_SAFE_INTEGER);
-const b = BigInt(2);
-const result = a + b; // Correct`,
-      languages: {
-        javascript: 'Use BigInt for > 2^53-1',
-        java: 'Use Math.addExact() to detect overflow',
-        rust: 'Use checked_add() or saturating_add()'
-      }
-    }
-  },
-  {
-    desc: 'Memory corruption: Buffer overflow when writing past array bounds',
-    solution: 'Use bounds-checked access and safe languages/libraries',
-    successRate: 0.92,
-    tags: ['bugs', 'security', 'buffer-overflow', 'memory-safety', 'c'],
-    metadata: {
-      cCode: `char buffer[10];
-strcpy(buffer, "This is too long"); // Buffer overflow!`,
-      safeCCode: `char buffer[10];
-strncpy(buffer, "This is too long", sizeof(buffer) - 1);
-buffer[sizeof(buffer) - 1] = '\\0';`,
-      modernApproach: 'Use Rust, Go, or safe libraries like std::string',
-      impact: ['Crashes', 'Security vulnerabilities', 'Undefined behavior']
-    }
-  }
-];
-
-for (const pattern of commonBugPatterns) {
-  for (let i = 0; i < 30; i++) {
-    addPattern(
-      'debugging',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.91,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 2. Error Handling (150 patterns)
-const errorHandlingPatterns = [
-  {
-    desc: 'Swallowing exceptions: Empty catch blocks hiding errors',
-    solution: 'Always log errors with context or re-throw with additional info',
-    successRate: 0.95,
-    tags: ['error-handling', 'exceptions', 'logging', 'best-practices', 'debugging'],
-    metadata: {
-      antiPattern: true,
-      before: `try {
-  riskyOperation();
-} catch (e) {
-  // Empty catch - error disappears!
-}`,
-      after: `try {
-  riskyOperation();
-} catch (e) {
-  logger.error('Failed to perform risky operation', {
-    error: e,
-    context: { userId, timestamp }
-  });
-  throw new OperationError('Operation failed', e);
-}`,
-      alternatives: ['Graceful degradation', 'Default values', 'Retry logic']
-    }
-  },
-  {
-    desc: 'Generic error messages: "Error occurred" without context',
-    solution: 'Include specific details: what failed, why, and how to fix',
-    successRate: 0.93,
-    tags: ['error-handling', 'error-messages', 'ux', 'debugging', 'logging'],
-    metadata: {
-      before: `throw new Error('Error');`,
-      after: `throw new Error(
-  'Failed to create user: email "john@example.com" already exists. ' +
-  'Please use a different email address or log in to existing account.'
-);`,
-      goodErrorMessage: [
-        'What operation failed',
-        'Why it failed (root cause)',
-        'How to fix it (if possible)',
-        'Relevant context (IDs, values)'
-      ]
-    }
-  },
-  {
-    desc: 'Error handling in async code: Unhandled promise rejections',
-    solution: 'Always add .catch() or use try/catch with async/await',
-    successRate: 0.94,
-    tags: ['error-handling', 'async', 'promises', 'javascript', 'unhandled-rejection'],
-    metadata: {
-      before: `async function fetchData() {
-  const data = await fetch(url); // Unhandled rejection if network fails
-  return data.json();
-}`,
-      after: `async function fetchData() {
-  try {
-    const data = await fetch(url);
-    return data.json();
-  } catch (error) {
-    logger.error('Failed to fetch data', { error, url });
-    throw new NetworkError('Unable to fetch data', error);
-  }
-}`,
-      nodejs: `process.on('unhandledRejection', (reason, promise) => {
-  logger.error('Unhandled Promise Rejection', { reason, promise });
-  process.exit(1);
-});`
-    }
-  },
-  {
-    desc: 'No circuit breaker: Cascading failures when dependency is down',
-    solution: 'Implement circuit breaker pattern to fail fast and recover',
-    successRate: 0.88,
-    tags: ['error-handling', 'circuit-breaker', 'resilience', 'microservices', 'pattern'],
-    metadata: {
-      states: ['Closed (normal)', 'Open (failing)', 'Half-Open (testing recovery)'],
-      example: `class CircuitBreaker {
-  constructor(threshold = 5, timeout = 60000) {
-    this.state = 'CLOSED';
-    this.failures = 0;
-    this.threshold = threshold;
-    this.timeout = timeout;
-  }
-
-  async call(fn) {
-    if (this.state === 'OPEN') {
-      throw new Error('Circuit breaker is OPEN');
-    }
-    try {
-      const result = await fn();
-      this.onSuccess();
-      return result;
-    } catch (error) {
-      this.onFailure();
-      throw error;
-    }
-  }
-
-  onSuccess() {
-    this.failures = 0;
-    this.state = 'CLOSED';
-  }
-
-  onFailure() {
-    this.failures++;
-    if (this.failures >= this.threshold) {
-      this.state = 'OPEN';
-      setTimeout(() => this.state = 'HALF_OPEN', this.timeout);
-    }
-  }
-}`,
-      libraries: ['opossum (Node.js)', 'resilience4j (Java)', 'Polly (.NET)']
-    }
-  },
-  {
-    desc: 'No exponential backoff: Retry storms overwhelming failed service',
-    solution: 'Implement exponential backoff with jitter for retries',
-    successRate: 0.91,
-    tags: ['error-handling', 'retry', 'backoff', 'resilience', 'rate-limiting'],
-    metadata: {
-      before: `for (let i = 0; i < 10; i++) {
-  try {
-    return await fetch(url);
-  } catch (e) {
-    // Retry immediately, hammering the server
-  }
-}`,
-      after: `async function fetchWithRetry(url, maxRetries = 3) {
-  for (let i = 0; i < maxRetries; i++) {
-    try {
-      return await fetch(url);
-    } catch (error) {
-      if (i === maxRetries - 1) throw error;
-      const delay = Math.min(1000 * 2 ** i, 10000); // Exponential
-      const jitter = delay * 0.1 * Math.random(); // Add jitter
-      await sleep(delay + jitter);
-    }
-  }
-}`,
-      formula: 'delay = min(maxDelay, baseDelay * 2^attempt + jitter)'
-    }
-  }
-];
-
-for (const pattern of errorHandlingPatterns) {
-  for (let i = 0; i < 30; i++) {
-    addPattern(
-      'debugging',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.92,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 3. Edge Cases (100 patterns)
-const edgeCasePatterns = [
-  {
-    desc: 'Not handling empty input: Crash on empty arrays or strings',
-    solution: 'Add guard clauses to check for empty input early',
-    successRate: 0.96,
-    tags: ['edge-cases', 'defensive-programming', 'validation', 'bugs', 'guard-clauses'],
-    metadata: {
-      before: `function getFirst(arr) {
-  return arr[0]; // undefined if empty
-}
-function average(numbers) {
-  return numbers.reduce((a, b) => a + b) / numbers.length; // NaN if empty
-}`,
-      after: `function getFirst(arr) {
-  if (arr.length === 0) return null;
-  return arr[0];
-}
-function average(numbers) {
-  if (numbers.length === 0) return 0;
-  return numbers.reduce((a, b) => a + b) / numbers.length;
-}`,
-      principle: 'Fail fast with clear error messages'
-    }
-  },
-  {
-    desc: 'Boundary conditions: Not testing min/max values',
-    solution: 'Test with 0, 1, max-1, max, and negative values',
-    successRate: 0.92,
-    tags: ['edge-cases', 'testing', 'boundary-values', 'validation', 'bugs'],
-    metadata: {
-      testCases: [
-        'Empty input ([], "", null)',
-        'Single element ([1], "a")',
-        'Two elements (boundary for algorithms)',
-        'Maximum size',
-        'Negative numbers',
-        'Zero',
-        'Very large numbers',
-        'Special characters/Unicode'
-      ],
-      example: `describe('binary search', () => {
-  it('handles empty array', () => {
-    expect(binarySearch([], 1)).toBe(-1);
-  });
-  it('handles single element', () => {
-    expect(binarySearch([1], 1)).toBe(0);
-  });
-  it('finds first element', () => {
-    expect(binarySearch([1,2,3], 1)).toBe(0);
-  });
-  it('finds last element', () => {
-    expect(binarySearch([1,2,3], 3)).toBe(2);
-  });
-});`
-    }
-  }
-];
-
-for (const pattern of edgeCasePatterns) {
-  for (let i = 0; i < 50; i++) {
-    addPattern(
-      'debugging',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.94,
-      'low',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 4. Logging & Monitoring (100 patterns)
-const loggingPatterns = [
-  {
-    desc: 'Log spam: Logging in tight loops overwhelming storage',
-    solution: 'Use log levels, sampling, and rate limiting',
-    successRate: 0.91,
-    tags: ['logging', 'performance', 'observability', 'best-practices', 'monitoring'],
-    metadata: {
-      before: `for (const item of millionItems) {
-  logger.info('Processing item', item); // 1M log lines!
-}`,
-      after: `let processed = 0;
-for (const item of millionItems) {
-  processItem(item);
-  processed++;
-  if (processed % 1000 === 0) {
-    logger.info('Progress update', { processed, total: millionItems.length });
-  }
-}
-logger.info('Batch complete', { total: processed });`,
-      logLevels: ['ERROR (always)', 'WARN (issues)', 'INFO (milestones)', 'DEBUG (development)'],
-      sampling: 'Log 1% of requests, all errors'
-    }
-  },
-  {
-    desc: 'Missing correlation IDs: Cannot trace request across services',
-    solution: 'Propagate correlation ID through all service calls and logs',
-    successRate: 0.93,
-    tags: ['logging', 'distributed-tracing', 'correlation-id', 'observability', 'microservices'],
-    metadata: {
-      example: `// Generate at entry point
-const correlationId = req.headers['x-correlation-id'] || uuid();
-
-// Add to all logs
-logger.info('Processing request', { correlationId, userId });
-
-// Propagate to downstream services
-await fetch(serviceUrl, {
-  headers: { 'x-correlation-id': correlationId }
-});
-
-// Add to response
-res.setHeader('x-correlation-id', correlationId);`,
-      tools: ['OpenTelemetry', 'Jaeger', 'Zipkin', 'AWS X-Ray'],
-      benefits: ['End-to-end tracing', 'Debug production issues', 'Performance analysis']
-    }
-  }
-];
-
-for (const pattern of loggingPatterns) {
-  for (let i = 0; i < 50; i++) {
-    addPattern(
-      'debugging',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.92,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-// 5. Testing Anti-Patterns (100 patterns)
-const testingPatterns = [
-  {
-    desc: 'Flaky tests: Tests passing/failing randomly due to timing issues',
-    solution: 'Eliminate race conditions, use deterministic mocks, avoid sleep()',
-    successRate: 0.89,
-    tags: ['testing', 'flaky-tests', 'async', 'mocking', 'best-practices'],
-    metadata: {
-      causes: [
-        'Timing dependencies',
-        'Shared state between tests',
-        'Network/external service calls',
-        'Non-deterministic data (dates, random)',
-        'Improper async handling'
-      ],
-      fixes: `// Bad: sleep() is flaky
-await sleep(1000);
-expect(element).toBeVisible();
-
-// Good: wait for condition
-await waitFor(() => {
-  expect(element).toBeVisible();
-}, { timeout: 5000 });
-
-// Mock time
-jest.useFakeTimers();
-jest.advanceTimersByTime(1000);`,
-      isolation: 'Each test should be independent with clean setup/teardown'
-    }
-  },
-  {
-    desc: 'Testing implementation details: Brittle tests break on refactoring',
-    solution: 'Test behavior and public API, not internal implementation',
-    successRate: 0.90,
-    tags: ['testing', 'refactoring', 'best-practices', 'tdd', 'maintainability'],
-    metadata: {
-      before: `// Testing implementation
-expect(component.state.counter).toBe(1);
-expect(component.handleClick).toHaveBeenCalled();`,
-      after: `// Testing behavior
-fireEvent.click(button);
-expect(screen.getByText('Count: 1')).toBeInTheDocument();`,
-      principle: 'Test what the user sees, not how it works internally',
-      benefits: ['Refactor-safe', 'Focuses on value', 'Less maintenance']
-    }
-  }
-];
-
-for (const pattern of testingPatterns) {
-  for (let i = 0; i < 50; i++) {
-    addPattern(
-      'debugging',
-      pattern.desc,
-      pattern.solution,
-      pattern.successRate,
-      0.89,
-      'medium',
-      pattern.tags,
-      pattern.metadata
-    );
-  }
-}
-
-console.log('✅ Category 5 complete: 500 patterns');
-console.log('');
-console.log('Creating pattern links...');
-
-// Create intelligent pattern links
-const linkData = [];
-
-// Link anti-patterns to solutions
-for (let i = 1; i <= 100; i++) {
-  if (i % 5 === 0) {
-    linkData.push({ source: `pattern-${i}`, target: `pattern-${i + 50}`, type: 'causes', strength: 0.9 });
-    linkData.push({ source: `pattern-${i + 50}`, target: `pattern-${i}`, type: 'prevents', strength: 0.85 });
-  }
-}
-
-// Link related patterns (design patterns)
-for (let i = 101; i <= 250; i += 10) {
-  linkData.push({ source: `pattern-${i}`, target: `pattern-${i + 5}`, type: 'enhances', strength: 0.8 });
-  linkData.push({ source: `pattern-${i}`, target: `pattern-${i + 100}`, type: 'enables', strength: 0.75 });
-}
-
-// Link architecture patterns
-for (let i = 251; i <= 450; i += 15) {
-  linkData.push({ source: `pattern-${i}`, target: `pattern-${i + 10}`, type: 'alternative', strength: 0.7 });
-  linkData.push({ source: `pattern-${i}`, target: `pattern-${i + 200}`, type: 'requires', strength: 0.8 });
-}
-
-// Link algorithm optimizations
-for (let i = 501; i <= 850; i += 12) {
-  linkData.push({ source: `pattern-${i}`, target: `pattern-${i + 6}`, type: 'improves', strength: 0.9 });
-  linkData.push({ source: `pattern-${i}`, target: `pattern-${i + 150}`, type: 'trades-off', strength: 0.65 });
-}
-
-// Link code quality patterns
-for (let i = 1001; i <= 1400; i += 8) {
-  linkData.push({ source: `pattern-${i}`, target: `pattern-${i + 4}`, type: 'refactors-to', strength: 0.85 });
-  linkData.push({ source: `pattern-${i}`, target: `pattern-${i + 100}`, type: 'similar-to', strength: 0.7 });
-}
-
-// Link language-specific patterns
-for (let i = 1501; i <= 1900; i += 10) {
-  linkData.push({ source: `pattern-${i}`, target: `pattern-${i + 50}`, type: 'language-equivalent', strength: 0.8 });
-}
-
-// Link debugging patterns
-for (let i = 2001; i <= 2400; i += 8) {
-  linkData.push({ source: `pattern-${i}`, target: `pattern-${i + 4}`, type: 'debugs', strength: 0.9 });
-  linkData.push({ source: `pattern-${i}`, target: `pattern-${i - 500}`, type: 'prevents-bug', strength: 0.85 });
-}
-
-// Cross-category links
-for (let i = 1; i <= 500; i += 50) {
-  linkData.push({ source: `pattern-${i}`, target: `pattern-${i + 500}`, type: 'optimizes', strength: 0.75 });
-  linkData.push({ source: `pattern-${i}`, target: `pattern-${i + 1000}`, type: 'improves-quality', strength: 0.8 });
-  linkData.push({ source: `pattern-${i}`, target: `pattern-${i + 2000}`, type: 'prevents-errors', strength: 0.85 });
-}
-
-console.log(`Creating ${linkData.length} pattern links...`);
-
-for (const link of linkData) {
-  try {
-    linkPatterns(link.source, link.target, link.type, link.strength);
-  } catch (e) {
-    // Skip if pattern doesn't exist
-  }
-}
-
-// Create summary statistics
-const stats = db.prepare('SELECT COUNT(*) as count FROM patterns').get();
-const links = db.prepare('SELECT COUNT(*) as count FROM pattern_links').get();
-
-console.log('');
-console.log('🎉 Training Complete!');
-console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-console.log(`📊 Total Patterns: ${stats.count}`);
-console.log(`🔗 Total Links: ${links.count}`);
-console.log(`💾 Database Size: ${(db.prepare('SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size()').get().size / 1024 / 1024).toFixed(2)} MB`);
-console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-
-// Test query performance
-console.log('');
-console.log('Testing query performance...');
-const testQueries = [
-  'optimize database',
-  'error handling async',
-  'SOLID principles',
-  'microservices patterns',
-  'JavaScript bugs'
-];
-
-for (const query of testQueries) {
-  const start = Date.now();
-  const results = db.prepare(`
-    SELECT * FROM patterns
-    WHERE pattern_data LIKE ? OR type LIKE ?
-    ORDER BY confidence DESC
-    LIMIT 5
-  `).all(`%${query}%`, `%${query}%`);
-  const duration = Date.now() - start;
-  console.log(`  Query: "${query}" → ${results.length} results in ${duration}ms`);
-}
-
-db.close();
-console.log('');
-console.log('✅ Database closed. Training complete!');