elsabro 2.3.0 → 3.7.0

package/references/ai-code-suggestions.md

@@ -0,0 +1,2413 @@
+# AI Code Suggestions (v3.7)
+
+Sistema de sugerencias de codigo impulsado por AI para ELSABRO, proporcionando autocompletado inteligente, refactoring, deteccion de patrones, y analisis de seguridad.
+
+## Arquitectura General
+
+```
++------------------------------------------------------------------+
+|                    AI CODE SUGGESTIONS ENGINE                      |
++------------------------------------------------------------------+
+|                                                                    |
+|  +--------------------+    +--------------------+                  |
+|  | Context Gatherer   |    | Embedding Cache    |                  |
+|  | - Current file     |    | - Vector store     |                  |
+|  | - Imports/types    |    | - Similarity search|                  |
+|  | - Sibling files    |    | - TTL management   |                  |
+|  +--------+-----------+    +--------+-----------+                  |
+|           |                         |                              |
+|           v                         v                              |
+|  +--------------------------------------------------+             |
+|  |              SUGGESTION RANKER                    |             |
+|  |  - Relevance scoring  - Context matching          |             |
+|  |  - Type inference     - Usage patterns            |             |
+|  +--------------------------------------------------+             |
+|           |                                                        |
+|           v                                                        |
+|  +--------------------------------------------------+             |
+|  |                 PROVIDER LAYER                    |             |
+|  +--------------------------------------------------+             |
+|  | Completion | Refactor | Pattern | Docs | Test    |             |
+|  | Provider   | Advisor  | Detector| Gen  | Suggest |             |
+|  +--------------------------------------------------+             |
+|           |                                                        |
+|           v                                                        |
+|  +--------------------------------------------------+             |
+|  |              SECURITY & PERFORMANCE               |             |
+|  |  - OWASP scanning   - N+1 detection               |             |
+|  |  - Secret detection - Memory leak patterns        |             |
+|  +--------------------------------------------------+             |
+|                                                                    |
++------------------------------------------------------------------+
+```
+
+---
+
+## 1. CodeSuggestionEngine
+
+Motor principal que coordina todas las sugerencias de codigo.
+
+### Arquitectura del Motor
+
+```typescript
+interface CodeSuggestionEngine {
+  context: ContextGatherer;
+  embeddings: EmbeddingCache;
+  ranker: SuggestionRanker;
+  providers: Map<string, SuggestionProvider>;
+}
+
+interface ContextGatherer {
+  currentFile: FileContext;
+  imports: ImportGraph;
+  types: TypeRegistry;
+  siblings: FileContext[];
+  history: EditHistory;
+}
+
+interface SuggestionRanker {
+  score(suggestion: Suggestion, context: Context): number;
+  rank(suggestions: Suggestion[]): Suggestion[];
+  filter(suggestions: Suggestion[], threshold: number): Suggestion[];
+}
+```
+
+### Implementacion Principal
+
+```typescript
+class CodeSuggestionEngine {
+  private contextGatherer: ContextGatherer;
+  private embeddingCache: EmbeddingCache;
+  private ranker: SuggestionRanker;
+  private providers: Map<string, SuggestionProvider>;
+
+  constructor(config: SuggestionConfig) {
+    this.contextGatherer = new ContextGatherer(config.context);
+    this.embeddingCache = new EmbeddingCache(config.cache);
+    this.ranker = new SuggestionRanker(config.ranking);
+    this.providers = this.initializeProviders(config);
+  }
+
+  async getSuggestions(request: SuggestionRequest): Promise<Suggestion[]> {
+    // 1. Gather context
+    const context = await this.contextGatherer.gather({
+      file: request.file,
+      position: request.position,
+      prefix: request.prefix,
+      suffix: request.suffix
+    });
+
+    // 2. Get embeddings for similarity search
+    const embeddings = await this.embeddingCache.getOrCompute(
+      context.relevantCode,
+      context.fileHash
+    );
+
+    // 3. Query all relevant providers in parallel
+    const providerResults = await Promise.all(
+      Array.from(this.providers.entries())
+        .filter(([name]) => this.shouldQueryProvider(name, request))
+        .map(([name, provider]) =>
+          provider.suggest(context, embeddings)
+            .catch(err => {
+              console.error(`Provider ${name} failed:`, err);
+              return [];
+            })
+        )
+    );
+
+    // 4. Flatten and rank suggestions
+    const allSuggestions = providerResults.flat();
+    const ranked = this.ranker.rank(allSuggestions);
+
+    // 5. Apply filters and limits
+    return ranked
+      .filter(s => s.score >= request.minScore || 0.5)
+      .slice(0, request.maxSuggestions || 5);
+  }
+
+  private shouldQueryProvider(
+    name: string,
+    request: SuggestionRequest
+  ): boolean {
+    const providerMap: Record<string, SuggestionType[]> = {
+      completion: ['inline', 'multiline', 'fim'],
+      refactoring: ['extract', 'rename', 'move'],
+      patterns: ['antipattern', 'smell', 'solid'],
+      documentation: ['jsdoc', 'readme', 'changelog'],
+      testing: ['unit', 'integration', 'edge'],
+      security: ['owasp', 'secrets', 'deps'],
+      performance: ['n1', 'memory', 'bundle']
+    };
+
+    return !request.types ||
+      request.types.some(t => providerMap[name]?.includes(t));
+  }
+}
+```
+
+### Context Gathering
+
+```typescript
+class ContextGatherer {
+  private parser: CodeParser;
+  private typeResolver: TypeResolver;
+  private importResolver: ImportResolver;
+
+  async gather(request: GatherRequest): Promise<GatheredContext> {
+    const fileContent = await this.readFile(request.file);
+    const ast = this.parser.parse(fileContent);
+
+    // Get cursor position context
+    const cursorContext = this.getCursorContext(ast, request.position);
+
+    // Resolve imports and their exports
+    const imports = await this.importResolver.resolve(ast);
+
+    // Get type information
+    const types = await this.typeResolver.resolveAtPosition(
+      ast,
+      request.position,
+      imports
+    );
+
+    // Get sibling files for additional context
+    const siblings = await this.getSiblingContext(request.file);
+
+    // Get recent edit history
+    const history = await this.getEditHistory(request.file);
+
+    return {
+      file: {
+        path: request.file,
+        content: fileContent,
+        language: this.detectLanguage(request.file),
+        ast
+      },
+      cursor: cursorContext,
+      imports,
+      types,
+      siblings,
+      history,
+      prefix: request.prefix,
+      suffix: request.suffix
+    };
+  }
+
+  private getCursorContext(ast: AST, position: Position): CursorContext {
+    const node = this.findNodeAtPosition(ast, position);
+
+    return {
+      node,
+      scope: this.getScopeAtNode(node),
+      parentFunction: this.findParentFunction(node),
+      parentClass: this.findParentClass(node),
+      localVariables: this.getLocalVariables(node),
+      availableSymbols: this.getAvailableSymbols(node)
+    };
+  }
+
+  private async getSiblingContext(filePath: string): Promise<FileContext[]> {
+    const dir = path.dirname(filePath);
+    const files = await fs.readdir(dir);
+
+    return Promise.all(
+      files
+        .filter(f => this.isSupportedFile(f) && f !== path.basename(filePath))
+        .slice(0, 3) // Limit to 3 siblings
+        .map(async f => ({
+          path: path.join(dir, f),
+          content: await fs.readFile(path.join(dir, f), 'utf-8'),
+          exports: await this.extractExports(path.join(dir, f))
+        }))
+    );
+  }
+}
+```
+
+### Embedding Cache
+
+```typescript
+class EmbeddingCache {
+  private cache: LRUCache<string, Float32Array>;
+  private vectorStore: VectorStore;
+  private embeddingModel: EmbeddingModel;
+
+  constructor(config: CacheConfig) {
+    this.cache = new LRUCache({
+      max: config.maxEntries || 10000,
+      ttl: config.ttlSeconds * 1000
+    });
+    this.vectorStore = new VectorStore(config.embeddingsDir);
+    this.embeddingModel = new EmbeddingModel(config.model);
+  }
+
+  async getOrCompute(code: string, hash: string): Promise<Float32Array> {
+    // Check memory cache first
+    const cached = this.cache.get(hash);
+    if (cached) return cached;
+
+    // Check persistent store
+    const stored = await this.vectorStore.get(hash);
+    if (stored) {
+      this.cache.set(hash, stored);
+      return stored;
+    }
+
+    // Compute new embedding
+    const embedding = await this.embeddingModel.embed(code);
+
+    // Store in both caches
+    this.cache.set(hash, embedding);
+    await this.vectorStore.set(hash, embedding);
+
+    return embedding;
+  }
+
+  async findSimilar(
+    embedding: Float32Array,
+    topK: number = 10
+  ): Promise<SimilarResult[]> {
+    return this.vectorStore.similaritySearch(embedding, topK);
+  }
+}
+```
+
+### Ranking de Sugerencias
+
+```typescript
+class SuggestionRanker {
+  private weights: RankingWeights;
+
+  constructor(config: RankerConfig) {
+    this.weights = config.weights || {
+      relevance: 0.35,
+      confidence: 0.25,
+      recency: 0.15,
+      popularity: 0.15,
+      typeMatch: 0.10
+    };
+  }
+
+  score(suggestion: Suggestion, context: Context): number {
+    const scores = {
+      relevance: this.computeRelevance(suggestion, context),
+      confidence: suggestion.confidence,
+      recency: this.computeRecency(suggestion, context),
+      popularity: this.computePopularity(suggestion),
+      typeMatch: this.computeTypeMatch(suggestion, context)
+    };
+
+    return Object.entries(scores).reduce(
+      (total, [key, value]) => total + value * this.weights[key],
+      0
+    );
+  }
+
+  rank(suggestions: Suggestion[]): Suggestion[] {
+    return suggestions
+      .map(s => ({ ...s, finalScore: s.score }))
+      .sort((a, b) => b.finalScore - a.finalScore);
+  }
+
+  private computeRelevance(s: Suggestion, ctx: Context): number {
+    // Cosine similarity between suggestion and context embeddings
+    const similarity = cosineSimilarity(s.embedding, ctx.embedding);
+
+    // Boost for matching identifiers
+    const identifierBoost = this.countMatchingIdentifiers(s, ctx) * 0.1;
+
+    // Boost for matching types
+    const typeBoost = this.hasMatchingTypes(s, ctx) ? 0.2 : 0;
+
+    return Math.min(1, similarity + identifierBoost + typeBoost);
+  }
+
+  private computeTypeMatch(s: Suggestion, ctx: Context): number {
+    if (!ctx.expectedType) return 0.5;
+
+    const suggestionType = this.inferType(s);
+    return this.typesCompatible(suggestionType, ctx.expectedType) ? 1 : 0;
+  }
+}
+```
+
+---
+
+## 2. CompletionProvider
+
+Proveedor de autocompletado inline estilo Copilot.
+
+### Arquitectura
+
+```
++----------------------------------------------------------+
+|                  COMPLETION PROVIDER                       |
++----------------------------------------------------------+
+|                                                            |
+|  +------------------+  +------------------+                |
+|  | Inline Completer |  | Multiline Engine |                |
+|  | - Single tokens  |  | - Block suggest  |                |
+|  | - Property access|  | - Function body  |                |
+|  +--------+---------+  +--------+---------+                |
+|           |                     |                          |
+|           v                     v                          |
+|  +--------------------------------------------------+     |
+|  |              FILL-IN-MIDDLE (FIM)                 |     |
+|  |  - Prefix analysis  - Suffix analysis             |     |
+|  |  - Gap detection    - Context bridging            |     |
+|  +--------------------------------------------------+     |
+|                          |                                 |
+|                          v                                 |
+|  +--------------------------------------------------+     |
+|  |               GHOST TEXT RENDERER                 |     |
+|  |  - Preview display  - Accept/reject handling      |     |
+|  |  - Partial accept   - Tab completion              |     |
+|  +--------------------------------------------------+     |
+|                                                            |
++----------------------------------------------------------+
+```
+
+### Implementacion
+
+```typescript
+class CompletionProvider implements SuggestionProvider {
+  private llm: LLMClient;
+  private tokenizer: Tokenizer;
+  private fimEngine: FillInMiddleEngine;
+
+  async suggest(
+    context: GatheredContext,
+    embeddings: Float32Array
+  ): Promise<Suggestion[]> {
+    const completionType = this.detectCompletionType(context);
+
+    switch (completionType) {
+      case 'inline':
+        return this.getInlineCompletions(context);
+      case 'multiline':
+        return this.getMultilineCompletions(context);
+      case 'fim':
+        return this.getFillInMiddleCompletions(context);
+      default:
+        return [];
+    }
+  }
+
+  private detectCompletionType(context: GatheredContext): CompletionType {
+    const { cursor, prefix, suffix } = context;
+
+    // FIM if there's meaningful code after cursor
+    if (suffix && suffix.trim().length > 10) {
+      return 'fim';
+    }
+
+    // Multiline if at end of line after control structure
+    if (this.isAfterControlStructure(cursor)) {
+      return 'multiline';
+    }
+
+    // Multiline if inside empty function/method body
+    if (this.isEmptyFunctionBody(cursor)) {
+      return 'multiline';
+    }
+
+    return 'inline';
+  }
+
+  private async getInlineCompletions(
+    context: GatheredContext
+  ): Promise<Suggestion[]> {
+    const prompt = this.buildInlinePrompt(context);
+
+    const response = await this.llm.complete({
+      prompt,
+      maxTokens: 50,
+      temperature: 0.2,
+      stopSequences: ['\n', ';', '{', '}']
+    });
+
+    return response.completions.map(c => ({
+      type: 'inline',
+      text: c.text,
+      confidence: c.logprob ? Math.exp(c.logprob) : 0.8,
+      range: {
+        start: context.cursor.position,
+        end: context.cursor.position
+      },
+      preview: this.formatGhostText(c.text)
+    }));
+  }
+
+  private async getMultilineCompletions(
+    context: GatheredContext
+  ): Promise<Suggestion[]> {
+    const prompt = this.buildMultilinePrompt(context);
+
+    const response = await this.llm.complete({
+      prompt,
+      maxTokens: 500,
+      temperature: 0.3,
+      stopSequences: ['}\n\n', '\n\n\n']
+    });
+
+    return response.completions.map(c => ({
+      type: 'multiline',
+      text: c.text,
+      confidence: this.computeMultilineConfidence(c),
+      range: {
+        start: context.cursor.position,
+        end: context.cursor.position
+      },
+      preview: this.formatMultilineGhostText(c.text),
+      lines: c.text.split('\n').length
+    }));
+  }
+
+  private buildInlinePrompt(context: GatheredContext): string {
+    return `
+// File: ${context.file.path}
+// Language: ${context.file.language}
+
+// Imports
+${context.imports.map(i => i.statement).join('\n')}
+
+// Available types
+${this.formatTypes(context.types)}
+
+// Current code context
+${context.prefix}
+<CURSOR>
+${context.suffix?.slice(0, 200) || ''}
+
+// Complete the code at <CURSOR>:
+`.trim();
+  }
+}
+```
+
+### Fill-in-the-Middle (FIM)
+
+```typescript
+class FillInMiddleEngine {
+  private llm: LLMClient;
+
+  async complete(context: FIMContext): Promise<FIMResult[]> {
+    // Special FIM prompt format
+    const prompt = this.buildFIMPrompt(context);
+
+    const response = await this.llm.complete({
+      prompt,
+      maxTokens: 200,
+      temperature: 0.2,
+      fim: true // Enable FIM mode if supported
+    });
+
+    return response.completions.map(c => ({
+      text: c.text,
+      bridgesContext: this.validateBridge(c.text, context),
+      confidence: this.computeFIMConfidence(c, context)
+    }));
+  }
+
+  private buildFIMPrompt(context: FIMContext): string {
+    // Standard FIM format: <PRE>prefix<SUF>suffix<MID>
+    return `<PRE>${context.prefix}<SUF>${context.suffix}<MID>`;
+  }
+
+  private validateBridge(completion: string, context: FIMContext): boolean {
+    // Check if completion logically connects prefix and suffix
+    const combined = context.prefix + completion + context.suffix;
+
+    try {
+      // Try to parse combined code
+      const ast = parse(combined, { errorRecovery: true });
+      return ast.errors.length === 0;
+    } catch {
+      return false;
+    }
+  }
+}
+```
+
+### Ghost Text Preview
+
+```typescript
+class GhostTextRenderer {
+  private decorationType: TextEditorDecorationType;
+
+  constructor(editor: TextEditor) {
+    this.decorationType = window.createTextEditorDecorationType({
+      after: {
+        color: new ThemeColor('editorGhostText.foreground'),
+        fontStyle: 'italic'
+      }
+    });
+  }
+
+  show(suggestion: Suggestion, position: Position): void {
+    const decoration: DecorationOptions = {
+      range: new Range(position, position),
+      renderOptions: {
+        after: {
+          contentText: suggestion.preview,
+          color: 'rgba(128, 128, 128, 0.6)'
+        }
+      }
+    };
+
+    this.editor.setDecorations(this.decorationType, [decoration]);
+  }
+
+  hide(): void {
+    this.editor.setDecorations(this.decorationType, []);
+  }
+
+  acceptFull(suggestion: Suggestion): void {
+    this.editor.edit(builder => {
+      builder.insert(this.currentPosition, suggestion.text);
+    });
+    this.hide();
+  }
+
+  acceptPartial(suggestion: Suggestion, chars: number): void {
+    const partial = suggestion.text.slice(0, chars);
+    this.editor.edit(builder => {
+      builder.insert(this.currentPosition, partial);
+    });
+
+    // Update ghost text with remainder
+    const remainder = suggestion.text.slice(chars);
+    if (remainder) {
+      this.show({ ...suggestion, preview: remainder },
+        this.currentPosition.translate(0, chars));
+    } else {
+      this.hide();
+    }
+  }
+}
+```
+
+---
+
+## 3. RefactoringAdvisor
+
+Detecta oportunidades de refactoring y sugiere mejoras.
+
+### Arquitectura
+
+```
++----------------------------------------------------------+
+|                  REFACTORING ADVISOR                       |
++----------------------------------------------------------+
+|                                                            |
+|  +---------------------------------------------------+    |
+|  |              CODE ANALYZER                         |    |
+|  |  - AST traversal    - Complexity metrics           |    |
+|  |  - Duplication      - Dependency analysis          |    |
+|  +---------------------------------------------------+    |
+|                          |                                 |
+|           +--------------+---------------+                 |
+|           v              v               v                 |
+|  +-------------+  +-------------+  +-------------+        |
+|  | Extract     |  | Rename      |  | Move        |        |
+|  | - Function  |  | - Symbol    |  | - To file   |        |
+|  | - Variable  |  | - Semantic  |  | - Organize  |        |
+|  | - Constant  |  | - Consistent|  | - Split     |        |
+|  +-------------+  +-------------+  +-------------+        |
+|                                                            |
++----------------------------------------------------------+
+```
+
+### Implementacion
+
+```typescript
+class RefactoringAdvisor implements SuggestionProvider {
+  private analyzer: CodeAnalyzer;
+  private extractors: Map<string, Extractor>;
+
+  async suggest(
+    context: GatheredContext,
+    embeddings: Float32Array
+  ): Promise<Suggestion[]> {
+    const suggestions: Suggestion[] = [];
+
+    // Analyze code for refactoring opportunities
+    const analysis = await this.analyzer.analyze(context.file.ast);
+
+    // Check for extractable code
+    if (analysis.hasLongFunctions) {
+      suggestions.push(...this.suggestExtractFunction(analysis, context));
+    }
+
+    if (analysis.hasRepeatedExpressions) {
+      suggestions.push(...this.suggestExtractVariable(analysis, context));
+    }
+
+    // Check for rename opportunities
+    if (analysis.hasInconsistentNaming) {
+      suggestions.push(...this.suggestRename(analysis, context));
+    }
+
+    // Check for move opportunities
+    if (analysis.hasFileOrganizationIssues) {
+      suggestions.push(...this.suggestMove(analysis, context));
+    }
+
+    return suggestions;
+  }
+
+  private suggestExtractFunction(
+    analysis: CodeAnalysis,
+    context: GatheredContext
+  ): Suggestion[] {
+    return analysis.longFunctions.map(fn => {
+      const extractable = this.findExtractableBlock(fn);
+
+      return {
+        type: 'refactor',
+        subtype: 'extract-function',
+        title: `Extract function from ${fn.name}`,
+        description: `Lines ${extractable.start}-${extractable.end} can be extracted`,
+        confidence: this.computeExtractConfidence(extractable),
+        range: extractable.range,
+        preview: this.generateExtractPreview(extractable, context),
+        apply: async () => this.applyExtractFunction(extractable, context)
+      };
+    });
+  }
+
+  private findExtractableBlock(fn: FunctionNode): ExtractableBlock {
+    // Find coherent block that can be extracted
+    const blocks = this.identifyLogicalBlocks(fn.body);
+
+    return blocks
+      .filter(b => b.statements.length >= 3)
+      .filter(b => this.hasCleanDependencies(b))
+      .sort((a, b) => b.cohesion - a.cohesion)[0];
+  }
+
+  private generateExtractPreview(
+    block: ExtractableBlock,
+    context: GatheredContext
+  ): string {
+    const params = this.computeParameters(block);
+    const returnType = this.inferReturnType(block);
+    const name = this.suggestFunctionName(block);
+
+    return `
+// Extracted function
+function ${name}(${params.map(p => `${p.name}: ${p.type}`).join(', ')}): ${returnType} {
+${block.statements.map(s => '  ' + s.text).join('\n')}
+}
+
+// Updated call site
+const result = ${name}(${params.map(p => p.name).join(', ')});
+`.trim();
+  }
+}
+```
+
+### Extract Function
+
+```typescript
+class FunctionExtractor implements Extractor {
+  async extract(block: ExtractableBlock, context: GatheredContext): Promise<RefactorResult> {
+    // Analyze dependencies
+    const deps = this.analyzeDependencies(block);
+
+    // Determine parameters (variables used but not defined in block)
+    const params = deps.reads.filter(v => !deps.writes.includes(v));
+
+    // Determine return value (variables written and used after block)
+    const returns = deps.writes.filter(v => deps.usedAfter.includes(v));
+
+    // Generate function signature
+    const signature = this.generateSignature(params, returns, context);
+
+    // Generate function body
+    const body = this.transformToFunctionBody(block, params, returns);
+
+    // Generate call site
+    const callSite = this.generateCallSite(signature, params, returns);
+
+    return {
+      newFunction: {
+        signature,
+        body,
+        location: this.findBestLocation(context)
+      },
+      callSite,
+      removedLines: block.range
+    };
+  }
+
+  private analyzeDependencies(block: ExtractableBlock): Dependencies {
+    const reads = new Set<string>();
+    const writes = new Set<string>();
+
+    for (const stmt of block.statements) {
+      // Find all identifier references
+      traverse(stmt.ast, {
+        Identifier(path) {
+          if (isRead(path)) reads.add(path.node.name);
+          if (isWrite(path)) writes.add(path.node.name);
+        }
+      });
+    }
+
+    return {
+      reads: Array.from(reads),
+      writes: Array.from(writes),
+      usedAfter: this.findUsagesAfterBlock(block)
+    };
+  }
+}
+```
+
+### Rename Suggestions
+
+```typescript
+class RenameAdvisor {
+  private namingConventions: NamingConventions;
+
+  suggestRenames(analysis: CodeAnalysis, context: GatheredContext): Suggestion[] {
+    const suggestions: Suggestion[] = [];
+
+    // Check each symbol against naming conventions
+    for (const symbol of analysis.symbols) {
+      const issues = this.checkNamingConventions(symbol);
+
+      if (issues.length > 0) {
+        const suggestedName = this.suggestBetterName(symbol, issues);
+
+        suggestions.push({
+          type: 'refactor',
+          subtype: 'rename',
+          title: `Rename ${symbol.name} to ${suggestedName}`,
+          description: issues.join(', '),
+          confidence: 0.8,
+          preview: this.generateRenamePreview(symbol, suggestedName, context),
+          apply: async () => this.applyRename(symbol, suggestedName, context)
+        });
+      }
+    }
+
+    // Check for semantic improvements
+    for (const fn of analysis.functions) {
+      if (!this.isDescriptiveName(fn.name, fn)) {
+        const betterName = this.inferBetterFunctionName(fn);
+
+        suggestions.push({
+          type: 'refactor',
+          subtype: 'rename',
+          title: `Rename function ${fn.name} to ${betterName}`,
+          description: 'Name does not describe function behavior',
+          confidence: 0.7,
+          preview: `${fn.name} -> ${betterName}`
+        });
+      }
+    }
+
+    return suggestions;
+  }
+
+  private checkNamingConventions(symbol: Symbol): string[] {
+    const issues: string[] = [];
+
+    switch (symbol.kind) {
+      case 'class':
+        if (!isPascalCase(symbol.name)) {
+          issues.push('Classes should use PascalCase');
+        }
+        break;
+      case 'function':
+      case 'variable':
+        if (!isCamelCase(symbol.name)) {
+          issues.push('Should use camelCase');
+        }
+        break;
+      case 'constant':
+        if (!isUpperSnakeCase(symbol.name) && !isCamelCase(symbol.name)) {
+          issues.push('Constants should use UPPER_SNAKE_CASE or camelCase');
+        }
+        break;
+    }
+
+    // Check for common anti-patterns
+    if (symbol.name.length < 3 && !this.isAcceptableShortName(symbol)) {
+      issues.push('Name too short - not descriptive');
+    }
+
+    if (symbol.name.match(/^(data|info|item|thing|obj|val)$/i)) {
+      issues.push('Generic name - be more specific');
+    }
+
+    return issues;
+  }
+}
+```
+
+---
+
+## 4. PatternDetector
+
+Detecta anti-patterns, code smells, y violaciones SOLID.
+
+### Arquitectura
+
+```
++----------------------------------------------------------+
+|                   PATTERN DETECTOR                         |
++----------------------------------------------------------+
+|                                                            |
+|  +---------------------------------------------------+    |
+|  |               PATTERN ANALYZERS                    |    |
+|  +---------------------------------------------------+    |
+|  |                                                     |   |
+|  |  +---------------+  +---------------+              |   |
+|  |  | Anti-Pattern  |  | Code Smell    |              |   |
+|  |  | Detector      |  | Detector      |              |   |
+|  |  +---------------+  +---------------+              |   |
+|  |                                                     |   |
+|  |  +---------------+  +---------------+              |   |
+|  |  | SOLID         |  | Framework     |              |   |
+|  |  | Analyzer      |  | Patterns      |              |   |
+|  |  +---------------+  +---------------+              |   |
+|  |                                                     |   |
+|  +---------------------------------------------------+    |
+|                          |                                 |
+|                          v                                 |
+|  +---------------------------------------------------+    |
+|  |              FIX SUGGESTION ENGINE                 |    |
+|  +---------------------------------------------------+    |
+|                                                            |
++----------------------------------------------------------+
+```
+
+### Anti-Pattern Detection
+
+```typescript
+class AntiPatternDetector {
+  private patterns: AntiPattern[] = [
+    {
+      name: 'callback-hell',
+      detect: (ast) => this.detectCallbackHell(ast),
+      severity: 'warning',
+      fix: 'Convert to async/await'
+    },
+    {
+      name: 'god-object',
+      detect: (ast) => this.detectGodObject(ast),
+      severity: 'error',
+      fix: 'Split into smaller, focused classes'
+    },
+    {
+      name: 'magic-numbers',
+      detect: (ast) => this.detectMagicNumbers(ast),
+      severity: 'info',
+      fix: 'Extract to named constants'
+    },
+    {
+      name: 'feature-envy',
+      detect: (ast) => this.detectFeatureEnvy(ast),
+      severity: 'warning',
+      fix: 'Move method to class it uses most'
+    }
+  ];
+
+  async detect(context: GatheredContext): Promise<DetectedPattern[]> {
+    const results: DetectedPattern[] = [];
+
+    for (const pattern of this.patterns) {
+      const matches = pattern.detect(context.file.ast);
+
+      for (const match of matches) {
+        results.push({
+          pattern: pattern.name,
+          severity: pattern.severity,
+          location: match.location,
+          description: this.describeMatch(pattern, match),
+          suggestedFix: pattern.fix,
+          fixPreview: this.generateFixPreview(pattern, match, context)
+        });
+      }
+    }
+
+    return results;
+  }
+
+  private detectCallbackHell(ast: AST): PatternMatch[] {
+    const matches: PatternMatch[] = [];
+    let currentDepth = 0;
+    const threshold = 3;
+
+    traverse(ast, {
+      CallExpression: {
+        enter(path) {
+          // Check if callback argument
+          const lastArg = path.node.arguments.at(-1);
+          if (lastArg?.type === 'ArrowFunctionExpression' ||
+              lastArg?.type === 'FunctionExpression') {
+            currentDepth++;
+
+            if (currentDepth >= threshold) {
+              matches.push({
+                location: path.node.loc,
+                depth: currentDepth,
+                suggestion: 'Nested callbacks detected'
+              });
+            }
+          }
+        },
+        exit() {
+          currentDepth = Math.max(0, currentDepth - 1);
+        }
+      }
+    });
+
+    return matches;
+  }
+
+  private detectGodObject(ast: AST): PatternMatch[] {
+    const matches: PatternMatch[] = [];
+    const thresholds = {
+      methods: 20,
+      properties: 15,
+      lines: 500,
+      responsibilities: 5
+    };
+
+    traverse(ast, {
+      ClassDeclaration(path) {
+        const cls = path.node;
+        const methods = cls.body.body.filter(m => m.type === 'MethodDefinition');
+        const properties = cls.body.body.filter(m => m.type === 'PropertyDefinition');
+
+        const issues: string[] = [];
+
+        if (methods.length > thresholds.methods) {
+          issues.push(`${methods.length} methods (threshold: ${thresholds.methods})`);
+        }
+
+        if (properties.length > thresholds.properties) {
+          issues.push(`${properties.length} properties (threshold: ${thresholds.properties})`);
+        }
+
+        if (issues.length > 0) {
+          matches.push({
+            location: cls.loc,
+            className: cls.id?.name,
+            issues,
+            suggestion: 'Class has too many responsibilities'
+          });
+        }
+      }
+    });
+
+    return matches;
+  }
+}
+```
+
+### Code Smell Detection
+
+```typescript
+class CodeSmellDetector {
+  async detect(context: GatheredContext): Promise<CodeSmell[]> {
+    const smells: CodeSmell[] = [];
+
+    // Long functions
+    smells.push(...this.detectLongFunctions(context.file.ast));
+
+    // Deep nesting
+    smells.push(...this.detectDeepNesting(context.file.ast));
+
+    // Long parameter lists
+    smells.push(...this.detectLongParameterLists(context.file.ast));
+
+    // Duplicate code
+    smells.push(...this.detectDuplicateCode(context.file.ast));
+
+    // Complex conditionals
+    smells.push(...this.detectComplexConditionals(context.file.ast));
+
+    return smells;
+  }
+
+  private detectLongFunctions(ast: AST): CodeSmell[] {
+    const smells: CodeSmell[] = [];
+    const threshold = 50;
+
+    traverse(ast, {
+      'FunctionDeclaration|FunctionExpression|ArrowFunctionExpression'(path) {
+        const lines = path.node.loc.end.line - path.node.loc.start.line;
+
+        if (lines > threshold) {
+          smells.push({
+            type: 'long-function',
+            severity: lines > threshold * 2 ? 'error' : 'warning',
+            location: path.node.loc,
+            message: `Function has ${lines} lines (threshold: ${threshold})`,
+            metric: { lines, threshold },
+            fix: 'Extract smaller functions with single responsibilities'
+          });
+        }
+      }
+    });
+
+    return smells;
+  }
+
+  private detectDeepNesting(ast: AST): CodeSmell[] {
+    const smells: CodeSmell[] = [];
+    const threshold = 4;
+    let currentDepth = 0;
+    let maxDepth = 0;
+    let deepestNode: any = null;
+
+    const nestingNodes = [
+      'IfStatement',
+      'ForStatement',
+      'WhileStatement',
+      'DoWhileStatement',
+      'SwitchStatement',
+      'TryStatement'
+    ];
+
+    traverse(ast, {
+      enter(path) {
+        if (nestingNodes.includes(path.node.type)) {
+          currentDepth++;
+          if (currentDepth > maxDepth) {
+            maxDepth = currentDepth;
+            deepestNode = path.node;
+          }
+        }
+      },
+      exit(path) {
+        if (nestingNodes.includes(path.node.type)) {
+          currentDepth--;
+        }
+      }
+    });
+
+    if (maxDepth > threshold && deepestNode) {
+      smells.push({
+        type: 'deep-nesting',
+        severity: 'warning',
+        location: deepestNode.loc,
+        message: `Nesting depth ${maxDepth} exceeds threshold ${threshold}`,
+        metric: { depth: maxDepth, threshold },
+        fix: 'Use early returns, extract methods, or flatten logic'
+      });
+    }
+
+    return smells;
+  }
+}
+```
+
+### SOLID Analyzer
+
+```typescript
+class SOLIDAnalyzer {
+  async analyze(context: GatheredContext): Promise<SOLIDViolation[]> {
+    const violations: SOLIDViolation[] = [];
+
+    // Single Responsibility Principle
+    violations.push(...this.checkSRP(context.file.ast));
+
+    // Open/Closed Principle
+    violations.push(...this.checkOCP(context.file.ast));
+
+    // Liskov Substitution Principle
+    violations.push(...this.checkLSP(context.file.ast));
+
+    // Interface Segregation Principle
+    violations.push(...this.checkISP(context.file.ast));
+
+    // Dependency Inversion Principle
+    violations.push(...this.checkDIP(context.file.ast));
+
+    return violations;
+  }
+
+  private checkSRP(ast: AST): SOLIDViolation[] {
+    const violations: SOLIDViolation[] = [];
+
+    traverse(ast, {
+      ClassDeclaration(path) {
+        const cls = path.node;
+        const methods = cls.body.body.filter(m => m.type === 'MethodDefinition');
+
+        // Cluster methods by functionality
+        const clusters = clusterMethodsBySemantics(methods);
+
+        if (clusters.length > 2) {
+          violations.push({
+            principle: 'SRP',
+            severity: 'warning',
+            location: cls.loc,
+            message: `Class ${cls.id?.name} has ${clusters.length} distinct responsibilities`,
+            details: clusters.map(c => c.name),
+            fix: `Split into ${clusters.length} focused classes`
+          });
+        }
+      }
+    });
+
+    return violations;
+  }
+}
+```
+
+### Framework Pattern Detection (React)
+
+```typescript
+class ReactPatternAnalyzer implements FrameworkAnalyzer {
+  analyze(context: GatheredContext): FrameworkIssue[] {
+    const issues: FrameworkIssue[] = [];
+
+    // Check hook rules
+    issues.push(...this.checkHookRules(context.file.ast));
+
+    // Check for missing dependencies
+    issues.push(...this.checkMissingDependencies(context.file.ast));
+
+    // Check for prop drilling
+    issues.push(...this.checkPropDrilling(context.file.ast));
+
+    return issues;
+  }
+
+  private checkHookRules(ast: AST): FrameworkIssue[] {
+    const issues: FrameworkIssue[] = [];
+
+    traverse(ast, {
+      CallExpression(path) {
+        const callee = path.node.callee;
+
+        // Check if it's a hook call
+        if (callee.type === 'Identifier' && callee.name.startsWith('use')) {
+          // Rule 1: Only call hooks at top level
+          if (this.isInsideConditional(path) || this.isInsideLoop(path)) {
+            issues.push({
+              pattern: 'hooks/rules-of-hooks',
+              severity: 'error',
+              location: path.node.loc,
+              message: `Hook ${callee.name} called conditionally`,
+              fix: 'Move hook call to top level of component'
+            });
+          }
+
+          // Rule 2: Only call hooks from React functions
+          if (!this.isInsideReactComponent(path)) {
+            issues.push({
+              pattern: 'hooks/rules-of-hooks',
+              severity: 'error',
+              location: path.node.loc,
+              message: `Hook ${callee.name} called outside React component`,
+              fix: 'Only call hooks from React function components or custom hooks'
+            });
+          }
+        }
+      }
+    });
+
+    return issues;
+  }
+
+  private checkMissingDependencies(ast: AST): FrameworkIssue[] {
+    const issues: FrameworkIssue[] = [];
+
+    traverse(ast, {
+      CallExpression(path) {
+        const callee = path.node.callee;
+
+        if (callee.type === 'Identifier' &&
+            ['useEffect', 'useCallback', 'useMemo'].includes(callee.name)) {
+
+          const callback = path.node.arguments[0];
+          const deps = path.node.arguments[1];
+
+          if (callback && deps?.type === 'ArrayExpression') {
+            const usedVars = this.findUsedVariables(callback);
+            const declaredDeps = deps.elements.map(e => e.name).filter(Boolean);
+
+            const missing = usedVars.filter(v =>
+              !declaredDeps.includes(v) && !this.isStableReference(v)
+            );
+
+            if (missing.length > 0) {
+              issues.push({
+                pattern: 'hooks/exhaustive-deps',
+                severity: 'warning',
+                location: deps.loc,
+                message: `Missing dependencies: ${missing.join(', ')}`,
+                fix: `Add [${missing.join(', ')}] to dependency array`
+              });
+            }
+          }
+        }
+      }
+    });
+
+    return issues;
+  }
+}
+```
+
+---
+
+## 5. DocumentationGenerator
+
+Genera documentacion automatica para codigo.
+
+### Arquitectura
+
+```
++----------------------------------------------------------+
+|                DOCUMENTATION GENERATOR                     |
++----------------------------------------------------------+
+|                                                            |
+|  +---------------------------------------------------+    |
+|  |              CODE ANALYZER                         |    |
+|  |  - Function signatures   - Type extraction         |    |
+|  |  - Parameter analysis    - Return type inference   |    |
+|  +---------------------------------------------------+    |
+|                          |                                 |
+|           +--------------+---------------+                 |
+|           v              v               v                 |
+|  +-------------+  +-------------+  +-------------+        |
+|  | JSDoc/TSDoc |  | README      |  | API Docs    |        |
+|  | Generator   |  | Generator   |  | Generator   |        |
+|  +-------------+  +-------------+  +-------------+        |
+|           |              |               |                 |
+|           v              v               v                 |
+|  +---------------------------------------------------+    |
+|  |              CHANGELOG GENERATOR                   |    |
+|  +---------------------------------------------------+    |
+|                                                            |
++----------------------------------------------------------+
+```
+
+### JSDoc Generator
+
+```typescript
+class JSDocGenerator {
+  private llm: LLMClient;
+
+  async generate(fn: FunctionNode, context: GatheredContext): Promise<string> {
+    // Extract function information
+    const info = this.extractFunctionInfo(fn);
+
+    // Use LLM to generate description
+    const description = await this.generateDescription(fn, context);
+
+    // Build JSDoc
+    const lines = ['/**'];
+
+    // Description
+    lines.push(` * ${description}`);
+    lines.push(' *');
+
+    // Parameters
+    for (const param of info.params) {
+      const paramDesc = await this.describeParameter(param, fn, context);
+      lines.push(` * @param {${param.type}} ${param.name} - ${paramDesc}`);
+    }
+
+    // Return type
+    if (info.returnType && info.returnType !== 'void') {
+      const returnDesc = await this.describeReturn(fn, context);
+      lines.push(` * @returns {${info.returnType}} ${returnDesc}`);
+    }
+
+    // Throws
+    const throws = this.detectThrows(fn);
+    for (const thrown of throws) {
+      lines.push(` * @throws {${thrown.type}} ${thrown.description}`);
+    }
+
+    // Examples
+    if (info.complexity > 5) {
+      const example = await this.generateExample(fn, context);
+      lines.push(' *');
+      lines.push(' * @example');
+      for (const exLine of example.split('\n')) {
+        lines.push(` * ${exLine}`);
+      }
+    }
+
+    lines.push(' */');
+
+    return lines.join('\n');
+  }
+
+  private extractFunctionInfo(fn: FunctionNode): FunctionInfo {
+    const params = fn.params.map(p => ({
+      name: this.getParamName(p),
+      type: this.getParamType(p),
+      optional: p.optional || false,
+      defaultValue: p.default ? this.getDefaultValue(p.default) : undefined
+    }));
+
+    return {
+      name: fn.id?.name || 'anonymous',
+      params,
+      returnType: this.inferReturnType(fn),
+      isAsync: fn.async,
+      isGenerator: fn.generator,
+      complexity: this.computeComplexity(fn)
+    };
+  }
+}
+```
+
+### README Generator
+
+```typescript
+class ReadmeGenerator {
+  private llm: LLMClient;
+
+  async generate(projectContext: ProjectContext): Promise<string> {
+    const sections = await Promise.all([
+      this.generateTitle(projectContext),
+      this.generateDescription(projectContext),
+      this.generateInstallation(projectContext),
+      this.generateUsage(projectContext),
+      this.generateAPI(projectContext),
+      this.generateContributing(projectContext),
+      this.generateLicense(projectContext)
+    ]);
+
+    return sections.join('\n\n');
+  }
+
+  private async generateTitle(ctx: ProjectContext): Promise<string> {
+    const name = ctx.packageJson?.name || path.basename(ctx.rootDir);
+    const badges = this.generateBadges(ctx);
+
+    return `# ${name}\n\n${badges}`;
+  }
+
+  private generateBadges(ctx: ProjectContext): string {
+    const badges: string[] = [];
+
+    if (ctx.packageJson?.version) {
+      badges.push(`![Version](https://img.shields.io/badge/version-${ctx.packageJson.version}-blue)`);
+    }
+
+    if (ctx.hasTests) {
+      badges.push('![Tests](https://img.shields.io/badge/tests-passing-green)');
+    }
+
+    if (ctx.packageJson?.license) {
+      badges.push(`![License](https://img.shields.io/badge/license-${ctx.packageJson.license}-blue)`);
+    }
+
+    return badges.join(' ');
+  }
+}
+```
+
+### Changelog Generator
+
+```typescript
+class ChangelogGenerator {
+  async generate(commits: Commit[], previousVersion: string): Promise<string> {
+    // Categorize commits
+    const categories = this.categorizeCommits(commits);
+
+    const lines = [
+      `## [${this.nextVersion(previousVersion, categories)}] - ${this.today()}`,
+      ''
+    ];
+
+    // Breaking changes first
+    if (categories.breaking.length > 0) {
+      lines.push('### BREAKING CHANGES');
+      lines.push('');
+      for (const commit of categories.breaking) {
+        lines.push(`- ${commit.message}`);
+      }
+      lines.push('');
+    }
+
+    // Features
+    if (categories.features.length > 0) {
+      lines.push('### Added');
+      lines.push('');
+      for (const commit of categories.features) {
+        lines.push(`- ${commit.message}`);
+      }
+      lines.push('');
+    }
+
+    // Fixes
+    if (categories.fixes.length > 0) {
+      lines.push('### Fixed');
+      lines.push('');
+      for (const commit of categories.fixes) {
+        lines.push(`- ${commit.message}`);
+      }
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+
+  private categorizeCommits(commits: Commit[]): CategorizedCommits {
+    return {
+      breaking: commits.filter(c =>
+        c.message.includes('BREAKING') || c.message.includes('!')
+      ),
+      features: commits.filter(c =>
+        c.message.startsWith('feat') || c.message.startsWith('add')
+      ),
+      fixes: commits.filter(c =>
+        c.message.startsWith('fix') || c.message.startsWith('bug')
+      ),
+      other: commits.filter(c =>
+        !c.message.startsWith('feat') &&
+        !c.message.startsWith('fix') &&
+        !c.message.includes('BREAKING')
+      )
+    };
+  }
+}
+```
+
+---
+
+## 6. TestSuggester
+
+Sugiere tests unitarios y de integracion.
+
+### Arquitectura
+
+```
++----------------------------------------------------------+
+|                    TEST SUGGESTER                          |
++----------------------------------------------------------+
+|                                                            |
+|  +---------------------------------------------------+    |
+|  |              FUNCTION ANALYZER                     |    |
+|  |  - Input analysis     - Output analysis            |    |
+|  |  - Branch detection   - Edge case identification   |    |
+|  +---------------------------------------------------+    |
+|                          |                                 |
+|           +--------------+---------------+                 |
+|           v              v               v                 |
+|  +-------------+  +-------------+  +-------------+        |
+|  | Unit Test   |  | Edge Case   |  | Integration |        |
+|  | Generator   |  | Generator   |  | Generator   |        |
+|  +-------------+  +-------------+  +-------------+        |
+|                          |                                 |
+|                          v                                 |
+|  +---------------------------------------------------+    |
+|  |                 MOCK GENERATOR                     |    |
+|  +---------------------------------------------------+    |
+|                                                            |
++----------------------------------------------------------+
+```
+
+### Unit Test Generator
+
+```typescript
+class UnitTestGenerator {
+  private llm: LLMClient;
+
+  async generate(fn: FunctionNode, context: GatheredContext): Promise<GeneratedTests> {
+    // Analyze function
+    const analysis = this.analyzeFunction(fn);
+
+    // Generate test cases
+    const testCases = await this.generateTestCases(fn, analysis, context);
+
+    // Generate mocks if needed
+    const mocks = await this.generateMocks(fn, context);
+
+    // Build test file
+    const code = this.buildTestCode(fn, testCases, mocks, context);
+
+    return { code, cases: testCases, mocks };
+  }
+
+  private analyzeFunction(fn: FunctionNode): FunctionAnalysis {
+    return {
+      params: this.extractParams(fn),
+      returnType: this.inferReturnType(fn),
+      branches: this.countBranches(fn),
+      dependencies: this.extractDependencies(fn),
+      sideEffects: this.detectSideEffects(fn),
+      purity: this.assessPurity(fn)
+    };
+  }
+
+  private buildTestCode(
+    fn: FunctionNode,
+    cases: TestCase[],
+    mocks: Mock[],
+    context: GatheredContext
+  ): string {
+    const imports = this.generateImports(fn, context);
+    const mockSetup = this.generateMockSetup(mocks);
+    const testSuite = this.generateTestSuite(fn, cases);
+
+    return `
+${imports}
+
+${mockSetup}
+
+describe('${fn.name}', () => {
+${testSuite}
+});
+`.trim();
+  }
+
+  private generateTestSuite(fn: FunctionNode, cases: TestCase[]): string {
+    return cases.map(tc => `
+  ${tc.type === 'error' ? 'it' : 'it'}('${tc.description}', ${tc.async ? 'async ' : ''}() => {
+    // Arrange
+    ${tc.arrange.join('\n    ')}
+
+    // Act
+    ${tc.act}
+
+    // Assert
+    ${tc.assertions.join('\n    ')}
+  });
+`).join('\n');
+  }
+}
+```
+
+### Edge Case Generator
+
+```typescript
+class EdgeCaseGenerator {
+  async identify(fn: FunctionNode, context: GatheredContext): Promise<EdgeCase[]> {
+    const edgeCases: EdgeCase[] = [];
+    const params = this.extractParams(fn);
+
+    for (const param of params) {
+      // Type-specific edge cases
+      switch (param.type) {
+        case 'string':
+          edgeCases.push(
+            { param: param.name, value: '""', description: 'Empty string' },
+            { param: param.name, value: '" "', description: 'Whitespace only' },
+            { param: param.name, value: '"a".repeat(10000)', description: 'Very long string' }
+          );
+          break;
+
+        case 'number':
+          edgeCases.push(
+            { param: param.name, value: '0', description: 'Zero' },
+            { param: param.name, value: '-1', description: 'Negative number' },
+            { param: param.name, value: 'Number.MAX_SAFE_INTEGER', description: 'Max safe integer' },
+            { param: param.name, value: 'NaN', description: 'NaN value' },
+            { param: param.name, value: 'Infinity', description: 'Infinity' }
+          );
+          break;
+
+        case 'array':
+          edgeCases.push(
+            { param: param.name, value: '[]', description: 'Empty array' },
+            { param: param.name, value: '[null]', description: 'Array with null' },
+            { param: param.name, value: 'new Array(10000).fill(1)', description: 'Large array' }
+          );
+          break;
+
+        case 'object':
+          edgeCases.push(
+            { param: param.name, value: '{}', description: 'Empty object' },
+            { param: param.name, value: 'null', description: 'Null value' },
+            { param: param.name, value: 'Object.create(null)', description: 'Object without prototype' }
+          );
+          break;
+      }
+    }
+
+    return edgeCases;
+  }
+}
+```
+
+### Mock Generator
+
+```typescript
+class MockGenerator {
+  async generate(fn: FunctionNode, context: GatheredContext): Promise<Mock[]> {
+    const mocks: Mock[] = [];
+    const dependencies = this.extractDependencies(fn, context);
+
+    for (const dep of dependencies) {
+      const mock = await this.createMock(dep, context);
+      mocks.push(mock);
+    }
+
+    return mocks;
+  }
+
+  private generateMockSetup(dep: Dependency, methods: Method[]): string {
+    if (dep.type === 'module') {
+      return `
+jest.mock('${dep.path}', () => ({
+  ${methods.map(m => `${m.name}: jest.fn()`).join(',\n  ')}
+}));
+`.trim();
+    }
+
+    return `
+const mock${dep.name} = {
+  ${methods.map(m => `${m.name}: jest.fn()`).join(',\n  ')}
+};
+`.trim();
+  }
+}
+```
+
+---
+
+## 7. SecurityScanner
+
+Escanea codigo en busca de vulnerabilidades de seguridad.
+
+### Arquitectura
+
+```
++----------------------------------------------------------+
+|                   SECURITY SCANNER                         |
++----------------------------------------------------------+
+|                                                            |
+|  +---------------------------------------------------+    |
+|  |                 OWASP TOP 10                       |    |
+|  |  A01: Broken Access Control                        |    |
+|  |  A02: Cryptographic Failures                       |    |
+|  |  A03: Injection                                    |    |
+|  |  A07: XSS                                          |    |
+|  +---------------------------------------------------+    |
+|                          |                                 |
+|  +---------------------------------------------------+    |
+|  |              SECRETS DETECTION                     |    |
+|  |  - API keys         - Passwords                    |    |
+|  |  - Tokens           - Private keys                 |    |
+|  +---------------------------------------------------+    |
+|                          |                                 |
+|  +---------------------------------------------------+    |
+|  |           DEPENDENCY VULNERABILITIES               |    |
+|  |  - CVE database     - Version checking             |    |
+|  |  - Severity levels  - Upgrade paths                |    |
+|  +---------------------------------------------------+    |
+|                                                            |
++----------------------------------------------------------+
+```
+
+### OWASP Scanner
+
+```typescript
+class OWASPScanner {
+  private rules: SecurityRule[] = [
+    // A03: Injection
+    {
+      id: 'A03-SQL-INJECTION',
+      category: 'injection',
+      severity: 'critical',
+      pattern: /\.(query|execute)\s*\(\s*[`'"].*\$\{/,
+      message: 'Potential SQL injection - use parameterized queries',
+      fix: 'Use prepared statements with parameter binding'
+    },
+    {
+      id: 'A03-COMMAND-INJECTION',
+      category: 'injection',
+      severity: 'critical',
+      detect: (ast) => this.detectCommandInjection(ast),
+      message: 'Potential command injection',
+      fix: 'Validate and sanitize user input, use safe APIs'
+    },
+    // A07: XSS
+    {
+      id: 'A07-XSS-INNERHTML',
+      category: 'xss',
+      severity: 'high',
+      pattern: /\.innerHTML\s*=(?!\s*['"`])/,
+      message: 'Potential XSS via innerHTML',
+      fix: 'Use textContent or sanitize HTML input'
+    },
+    // A02: Cryptographic Failures
+    {
+      id: 'A02-WEAK-CRYPTO',
+      category: 'crypto',
+      severity: 'high',
+      pattern: /crypto\.createHash\(['"]md5['"]\)|crypto\.createHash\(['"]sha1['"]\)/,
+      message: 'Weak cryptographic algorithm',
+      fix: 'Use SHA-256 or stronger algorithms'
+    }
+  ];
+
+  async scan(context: GatheredContext): Promise<SecurityIssue[]> {
+    const issues: SecurityIssue[] = [];
+
+    for (const rule of this.rules) {
+      let matches: Match[] = [];
+
+      if (rule.pattern) {
+        matches = this.scanWithPattern(context.file.content, rule.pattern);
+      } else if (rule.detect) {
+        matches = rule.detect(context.file.ast);
+      }
+
+      for (const match of matches) {
+        issues.push({
+          rule: rule.id,
+          category: rule.category,
+          severity: rule.severity,
+          location: match.location,
+          message: rule.message,
+          fix: rule.fix,
+          cwe: this.getCWE(rule.id),
+          owasp: this.getOWASPCategory(rule.category)
+        });
+      }
+    }
+
+    return issues;
+  }
+}
+```
+
+### Secrets Detector
+
+```typescript
+class SecretsDetector {
+  private patterns: SecretPattern[] = [
+    {
+      name: 'AWS Access Key',
+      pattern: /AKIA[0-9A-Z]{16}/,
+      severity: 'critical'
+    },
+    {
+      name: 'AWS Secret Key',
+      pattern: /[A-Za-z0-9/+=]{40}/,
+      context: /aws|secret|key/i,
+      severity: 'critical'
+    },
+    {
+      name: 'GitHub Token',
+      pattern: /ghp_[A-Za-z0-9]{36}|github_pat_[A-Za-z0-9]{22}_[A-Za-z0-9]{59}/,
+      severity: 'critical'
+    },
+    {
+      name: 'Generic API Key',
+      pattern: /api[_-]?key\s*[:=]\s*['"][A-Za-z0-9]{20,}['"]/i,
+      severity: 'high'
+    },
+    {
+      name: 'Private Key',
+      pattern: /-----BEGIN (RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/,
+      severity: 'critical'
+    },
+    {
+      name: 'Password in Code',
+      pattern: /password\s*[:=]\s*['"][^'"]{8,}['"]/i,
+      severity: 'high'
+    }
+  ];
+
+  async detect(context: GatheredContext): Promise<DetectedSecret[]> {
+    const secrets: DetectedSecret[] = [];
+    const lines = context.file.content.split('\n');
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Skip comments
+      if (this.isComment(line)) continue;
+
+      for (const pattern of this.patterns) {
+        const match = line.match(pattern.pattern);
+
+        if (match) {
+          // Check context if required
+          if (pattern.context && !pattern.context.test(line)) continue;
+
+          secrets.push({
+            type: pattern.name,
+            severity: pattern.severity,
+            location: {
+              line: i + 1,
+              column: match.index!,
+              length: match[0].length
+            },
+            masked: this.maskSecret(match[0]),
+            fix: this.generateFix(pattern.name)
+          });
+        }
+      }
+    }
+
+    return secrets;
+  }
+
+  private maskSecret(secret: string): string {
+    if (secret.length <= 8) return '*'.repeat(secret.length);
+    return secret.slice(0, 4) + '*'.repeat(secret.length - 8) + secret.slice(-4);
+  }
+
+  private generateFix(secretType: string): string {
+    const fixes: Record<string, string> = {
+      'AWS Access Key': 'Use environment variables: process.env.AWS_ACCESS_KEY_ID',
+      'AWS Secret Key': 'Use environment variables: process.env.AWS_SECRET_ACCESS_KEY',
+      'GitHub Token': 'Use GitHub Secrets or environment variables',
+      'Generic API Key': 'Store in .env file and add to .gitignore',
+      'Private Key': 'Store in secure vault (AWS Secrets Manager, HashiCorp Vault)',
+      'Password in Code': 'Use environment variables or secrets manager'
+    };
+
+    return fixes[secretType] || 'Remove secret and use secure storage';
+  }
+}
+```
+
+### Dependency Scanner
+
+```typescript
+class DependencyScanner {
+  private vulnDatabase: VulnerabilityDatabase;
+
+  async scan(context: GatheredContext): Promise<DependencyVulnerability[]> {
+    const vulnerabilities: DependencyVulnerability[] = [];
+
+    // Read package.json
+    const packageJson = await this.readPackageJson(context);
+    if (!packageJson) return [];
+
+    const allDeps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+
+    for (const [name, version] of Object.entries(allDeps)) {
+      const vulns = await this.vulnDatabase.query(name, version as string);
+
+      for (const vuln of vulns) {
+        vulnerabilities.push({
+          package: name,
+          installedVersion: version as string,
+          vulnerability: {
+            id: vuln.id,
+            severity: vuln.severity,
+            title: vuln.title,
+            description: vuln.description,
+            cve: vuln.cve,
+            cvss: vuln.cvss
+          },
+          fix: {
+            recommendedVersion: vuln.patchedVersion,
+            breaking: this.isBreakingChange(version as string, vuln.patchedVersion),
+            command: `npm update ${name}@${vuln.patchedVersion}`
+          }
+        });
+      }
+    }
+
+    return vulnerabilities.sort((a, b) =>
+      this.severityScore(b.vulnerability.severity) -
+      this.severityScore(a.vulnerability.severity)
+    );
+  }
+
+  private severityScore(severity: string): number {
+    const scores: Record<string, number> = {
+      critical: 4,
+      high: 3,
+      medium: 2,
+      low: 1
+    };
+    return scores[severity] || 0;
+  }
+}
+```
+
+---
+
+## 8. PerformanceAdvisor
+
+Detecta problemas de rendimiento y sugiere optimizaciones.
+
+### Arquitectura
+
+```
++----------------------------------------------------------+
+|                  PERFORMANCE ADVISOR                       |
++----------------------------------------------------------+
+|                                                            |
+|  +---------------------------------------------------+    |
+|  |                N+1 QUERY DETECTOR                  |    |
+|  |  - Loop analysis     - Query tracking              |    |
+|  |  - Batch suggestions - Eager loading               |    |
+|  +---------------------------------------------------+    |
+|                                                            |
+|  +---------------------------------------------------+    |
+|  |              MEMORY LEAK DETECTOR                  |    |
+|  |  - Event listeners   - Closures                    |    |
+|  |  - Uncleared timers  - Growing collections         |    |
+|  +---------------------------------------------------+    |
+|                                                            |
+|  +---------------------------------------------------+    |
+|  |              BUNDLE SIZE ANALYZER                  |    |
+|  |  - Import analysis   - Tree shaking                |    |
+|  |  - Dynamic imports   - Code splitting              |    |
+|  +---------------------------------------------------+    |
+|                                                            |
+|  +---------------------------------------------------+    |
+|  |             LAZY LOADING OPPORTUNITIES             |    |
+|  |  - Route analysis    - Component analysis          |    |
+|  |  - Heavy modules     - Conditional features        |    |
+|  +---------------------------------------------------+    |
+|                                                            |
++----------------------------------------------------------+
+```
+
+### N+1 Query Detector
+
+```typescript
+class N1QueryDetector {
+  async detect(context: GatheredContext): Promise<N1Issue[]> {
+    const issues: N1Issue[] = [];
+
+    traverse(context.file.ast, {
+      // Check for queries inside loops
+      ForStatement: (path) => this.checkLoopForQueries(path, issues),
+      ForOfStatement: (path) => this.checkLoopForQueries(path, issues),
+      ForInStatement: (path) => this.checkLoopForQueries(path, issues),
+      WhileStatement: (path) => this.checkLoopForQueries(path, issues),
+
+      // Check for queries inside map/forEach
+      CallExpression(path) {
+        const callee = path.node.callee;
+
+        if (callee.type === 'MemberExpression' &&
+            ['map', 'forEach', 'filter', 'reduce'].includes(callee.property.name)) {
+
+          const callback = path.node.arguments[0];
+          if (callback) {
+            const queries = this.findQueriesInNode(callback);
+
+            if (queries.length > 0) {
+              issues.push({
+                type: 'n1-in-iterator',
+                location: path.node.loc,
+                iteratorMethod: callee.property.name,
+                queries,
+                estimatedCalls: 'N times per iteration',
+                fix: this.generateBatchFix(queries, path)
+              });
+            }
+          }
+        }
+      }
+    });
+
+    return issues;
+  }
+
+  private generateBatchFix(queries: QueryCall[], loopPath: NodePath): string {
+    const orm = queries[0]?.orm || 'unknown';
+
+    const fixes: Record<string, string> = {
+      prisma: `
+// Instead of querying in a loop:
+// for (const id of ids) { await prisma.user.findUnique({ where: { id } }) }
+
+// Use batch query:
+const users = await prisma.user.findMany({
+  where: { id: { in: ids } }
+});
+`,
+      mongoose: `
+// Instead of querying in a loop, use $in operator:
+const users = await User.find({ _id: { $in: ids } });
+`
+    };
+
+    return fixes[orm] || 'Batch queries together to reduce database round trips';
+  }
+}
+```
+
+### Memory Leak Detector
+
+```typescript
+class MemoryLeakDetector {
+  async detect(context: GatheredContext): Promise<MemoryLeakIssue[]> {
+    const issues: MemoryLeakIssue[] = [];
+
+    // Check for unremoved event listeners
+    issues.push(...this.detectUnremovedListeners(context.file.ast));
+
+    // Check for uncleared intervals/timeouts
+    issues.push(...this.detectUnclearedTimers(context.file.ast));
+
+    // Check for closures holding references
+    issues.push(...this.detectClosureLeaks(context.file.ast));
+
+    return issues;
+  }
+
+  private detectUnclearedTimers(ast: AST): MemoryLeakIssue[] {
+    const issues: MemoryLeakIssue[] = [];
+    const setTimers: Map<string, NodePath> = new Map();
+    const clearedTimers: Set<string> = new Set();
+
+    traverse(ast, {
+      VariableDeclarator(path) {
+        const init = path.node.init;
+
+        if (init?.type === 'CallExpression') {
+          const callee = init.callee;
+
+          if (callee.type === 'Identifier' &&
+              ['setInterval', 'setTimeout'].includes(callee.name)) {
+
+            const varName = path.node.id.name;
+            setTimers.set(varName, path);
+          }
+        }
+      },
+      CallExpression(path) {
+        const callee = path.node.callee;
+
+        if (callee.type === 'Identifier' &&
+            ['clearInterval', 'clearTimeout'].includes(callee.name)) {
+
+          const arg = path.node.arguments[0];
+          if (arg?.type === 'Identifier') {
+            clearedTimers.add(arg.name);
+          }
+        }
+      }
+    });
+
+    // Find timers that are set but never cleared
+    for (const [varName, path] of setTimers) {
+      const init = path.node.init;
+      const isInterval = init.callee.name === 'setInterval';
+
+      if (isInterval && !clearedTimers.has(varName)) {
+        issues.push({
+          type: 'uncleared-interval',
+          severity: 'error',
+          location: path.node.loc,
+          message: 'setInterval never cleared - will cause memory leak',
+          fix: `Add cleanup: clearInterval(${varName})`
+        });
+      }
+    }
+
+    return issues;
+  }
+}
+```
+
+### Bundle Size Analyzer
+
+```typescript
+class BundleSizeAnalyzer {
+  private heavyPackages: Map<string, number> = new Map([
+    ['moment', 290],
+    ['lodash', 70],
+    ['rxjs', 150],
+    ['@material-ui/core', 300],
+    ['antd', 400],
+    ['chart.js', 200]
+  ]);
+
+  async analyze(context: GatheredContext): Promise<BundleIssue[]> {
+    const issues: BundleIssue[] = [];
+    const imports = this.extractImports(context.file.ast);
+
+    for (const imp of imports) {
+      // Check for heavy packages
+      if (this.heavyPackages.has(imp.source)) {
+        const size = this.heavyPackages.get(imp.source)!;
+
+        issues.push({
+          type: 'heavy-import',
+          severity: size > 200 ? 'warning' : 'info',
+          location: imp.location,
+          package: imp.source,
+          estimatedSize: `~${size}KB`,
+          fix: this.suggestLighterAlternative(imp.source)
+        });
+      }
+    }
+
+    return issues;
+  }
+
+  private suggestLighterAlternative(pkg: string): string {
+    const alternatives: Record<string, string> = {
+      'moment': 'Use date-fns (~20KB) or dayjs (~2KB)',
+      'lodash': 'Use lodash-es with tree shaking or native methods',
+      'rxjs': 'Import specific operators: import { map } from "rxjs/operators"',
+      '@material-ui/core': 'Use specific imports: import Button from "@material-ui/core/Button"',
+      'antd': 'Use babel-plugin-import for automatic tree shaking',
+      'chart.js': 'Use specific chart types: import { LineChart } from "chart.js"'
+    };
+
+    return alternatives[pkg] || 'Consider lighter alternatives or code splitting';
+  }
+}
+```
+
+### Lazy Loading Advisor
+
+```typescript
+class LazyLoadingAdvisor {
+  async identify(context: GatheredContext): Promise<LazyLoadingOpportunity[]> {
+    const opportunities: LazyLoadingOpportunity[] = [];
+
+    // Check for route-level code splitting
+    opportunities.push(...this.identifyRouteSplitting(context));
+
+    // Check for conditionally rendered components
+    opportunities.push(...this.identifyConditionalComponents(context));
+
+    // Check for heavy imports
+    opportunities.push(...this.identifyHeavyImports(context));
+
+    return opportunities;
+  }
+
+  private identifyRouteSplitting(context: GatheredContext): LazyLoadingOpportunity[] {
+    const opportunities: LazyLoadingOpportunity[] = [];
+
+    traverse(context.file.ast, {
+      JSXElement(path) {
+        const element = path.node.openingElement;
+
+        // Check for React Router routes
+        if (element.name.name === 'Route') {
+          const componentProp = element.attributes.find(
+            a => a.name?.name === 'component' || a.name?.name === 'element'
+          );
+
+          if (componentProp && !this.isLazyImport(componentProp)) {
+            opportunities.push({
+              type: 'route-splitting',
+              location: path.node.loc,
+              component: this.getComponentName(componentProp),
+              impact: 'high',
+              suggestion: `
+// Use React.lazy for route-level code splitting:
+const MyComponent = React.lazy(() => import('./MyComponent'));
+
+// In your route:
+<Route path="/path" element={
+  <Suspense fallback={<Loading />}>
+    <MyComponent />
+  </Suspense>
+} />
+`.trim()
+            });
+          }
+        }
+      }
+    });
+
+    return opportunities;
+  }
+}
+```
+
+---
+
+## 9. Comandos
+
+Comandos disponibles para el sistema de sugerencias.
+
+### /elsabro:suggest
+
+```
+/elsabro:suggest <subcommand> [options]
+
+Subcommands:
+  enable              Enable AI suggestions
+  disable             Disable AI suggestions
+  settings            Configure suggestion settings
+  stats               Show suggestion statistics
+
+Options:
+  --completion        Toggle completion suggestions
+  --refactor          Toggle refactoring suggestions
+  --patterns          Toggle pattern detection
+  --docs              Toggle documentation generation
+  --tests             Toggle test suggestions
+  --security          Toggle security scanning
+  --performance       Toggle performance analysis
+```
+
+### Ejemplos de Uso
+
+```bash
+# Enable all suggestions
+/elsabro:suggest enable
+
+# Disable only security scanning
+/elsabro:suggest settings --security=false
+
+# View statistics
+/elsabro:suggest stats
+
+# Configure completion settings
+/elsabro:suggest settings --completion.debounce=200 --completion.maxSuggestions=3
+```
+
+### Implementacion de Comandos
+
+```typescript
+class SuggestCommand implements ElsabroCommand {
+  name = 'suggest';
+  description = 'AI Code Suggestions management';
+
+  async execute(args: string[], context: CommandContext): Promise<void> {
+    const [subcommand, ...options] = args;
+
+    switch (subcommand) {
+      case 'enable':
+        await this.enable(context);
+        break;
+      case 'disable':
+        await this.disable(context);
+        break;
+      case 'settings':
+        await this.settings(options, context);
+        break;
+      case 'stats':
+        await this.stats(context);
+        break;
+      default:
+        this.showHelp();
+    }
+  }
+
+  private async enable(context: CommandContext): Promise<void> {
+    const config = await context.loadConfig('ai-suggestions-config.json');
+    config.aiCodeSuggestions.enabled = true;
+    await context.saveConfig(config);
+
+    context.output.success('AI Code Suggestions enabled');
+    context.output.info('Providers active: completion, refactoring, patterns, docs, tests, security, performance');
+  }
+
+  private async stats(context: CommandContext): Promise<void> {
+    const stats = await context.telemetry.getSuggestionStats();
+
+    context.output.table([
+      ['Metric', 'Value'],
+      ['Total Suggestions', stats.total.toString()],
+      ['Accepted', `${stats.accepted} (${(stats.accepted/stats.total*100).toFixed(1)}%)`],
+      ['Avg Latency', `${stats.avgLatency}ms`],
+      ['By Type', ''],
+      ['  Completion', stats.byType.completion.toString()],
+      ['  Refactoring', stats.byType.refactoring.toString()],
+      ['  Patterns', stats.byType.patterns.toString()],
+      ['  Documentation', stats.byType.documentation.toString()],
+      ['  Tests', stats.byType.tests.toString()],
+      ['  Security', stats.byType.security.toString()],
+      ['  Performance', stats.byType.performance.toString()]
+    ]);
+  }
+}
+```
+
+---
+
+## Configuracion
+
+Ver archivo de configuracion: `templates/ai-suggestions-config.json`
+
+### Variables de Entorno
+
+```bash
+# Model configuration
+ELSABRO_SUGGESTION_MODEL=claude-3-sonnet
+ELSABRO_SUGGESTION_FALLBACK=claude-3-haiku
+
+# Performance tuning
+ELSABRO_SUGGESTION_TIMEOUT=5000
+ELSABRO_SUGGESTION_CACHE_TTL=3600
+
+# Feature flags
+ELSABRO_SUGGESTION_SECURITY=true
+ELSABRO_SUGGESTION_PERFORMANCE=true
+```
+
+---
+
+## Metricas y Telemetria
+
+```typescript
+interface SuggestionMetrics {
+  // Latency
+  p50Latency: number;
+  p95Latency: number;
+  p99Latency: number;
+
+  // Acceptance
+  totalSuggestions: number;
+  acceptedSuggestions: number;
+  acceptanceRate: number;
+
+  // By provider
+  byProvider: Record<string, ProviderMetrics>;
+
+  // Errors
+  errorRate: number;
+  errorsByType: Record<string, number>;
+
+  // Cost
+  tokensUsed: number;
+  estimatedCost: number;
+}
+```
+
+---
+
+## Integracion con Editores
+
+### VS Code Extension
+
+```typescript
+class ElsabroSuggestionsProvider implements CompletionItemProvider {
+  async provideCompletionItems(
+    document: TextDocument,
+    position: Position,
+    token: CancellationToken
+  ): Promise<CompletionList> {
+    const suggestions = await this.engine.getSuggestions({
+      file: document.uri.fsPath,
+      position: { line: position.line, column: position.character },
+      prefix: document.getText(new Range(new Position(0, 0), position)),
+      suffix: document.getText(new Range(position, document.positionAt(document.getText().length)))
+    });
+
+    return new CompletionList(
+      suggestions.map(s => this.toCompletionItem(s))
+    );
+  }
+}
+```
+
+---
+
+## Referencias
+
+- [LLM Inference Optimization](/references/llm-inference.md)
+- [Multi-LLM Router](/references/multi-llm-router.md)
+- [Error Contracts](/references/error-contracts.md)
+- [Telemetry System](/references/telemetry.md)