@merlean/analyzer 2.0.0 → 2.2.0

package/lib/analyzer.js

@@ -1,66 +1,107 @@
 /**
- * Frontend-focused Codebase Scanner
+ * Framework-Agnostic Codebase Scanner
  * 
- * Scans FRONTEND code to learn how it communicates with the backend.
- * Extracts: fetch(), axios, $.ajax, API calls, form submissions
+ * Scans ANY codebase (frontend or backend) to extract API patterns:
+ * - Express/Fastify/Koa/Hapi route definitions
+ * - NestJS decorators (@Get, @Post, @Body, @Query, etc.)
+ * - Frontend HTTP calls (fetch, axios, HttpClient, etc.)
+ * - Swagger/OpenAPI annotations
+ * - Request body schemas and query parameters
+ * - TypeScript interfaces/DTOs
+ * - Validation schemas (Zod, Joi, class-validator)
  * 
- * This is what the bot needs - it runs in the browser and should know
- * what API calls the frontend already makes.
+ * The goal is to understand what APIs exist, their parameters,
+ * and body structures - regardless of framework or code style.
  */
 
 const fs = require('fs');
 const path = require('path');
 const { glob } = require('glob');
 
-// Frontend file patterns (prioritize frontend code)
-const FRONTEND_PATTERNS = [
+// File patterns to scan (be inclusive)
+const FILE_PATTERNS = [
   '**/*.js',
   '**/*.jsx',
   '**/*.ts',
   '**/*.tsx',
   '**/*.vue',
   '**/*.svelte',
-  '**/app.js',
-  '**/main.js',
-  '**/index.js',
-  '**/*api*.js',
-  '**/*service*.js',
-  '**/*fetch*.js',
-  '**/*http*.js'
+  '**/*.mjs',
+  '**/*.cjs'
 ];
 
-// Directories to ignore
+// Only ignore truly irrelevant directories
 const IGNORE_PATTERNS = [
   '**/node_modules/**',
   '**/vendor/**',
   '**/.git/**',
   '**/dist/**',
   '**/build/**',
+  '**/coverage/**',
   '**/__pycache__/**',
   '**/venv/**',
   '**/*.min.js',
   '**/*.map',
-  '**/server.js',      // Skip backend files
-  '**/server/**',
-  '**/backend/**',
-  '**/api/**',         // Skip backend API folders
-  '**/controllers/**'
+  '**/*.d.ts',           // TypeScript declaration files
+  '**/*.spec.ts',        // Test files
+  '**/*.spec.js',
+  '**/*.test.ts',
+  '**/*.test.js',
+  '**/__tests__/**',
+  '**/__mocks__/**'
 ];
 
-// Keywords to prioritize files
-const PRIORITY_KEYWORDS = [
-  'fetch', 'axios', 'api', 'service', 'http', 'request',
-  'ajax', 'client', 'frontend', 'app', 'main', 'store'
+// Files that are highly likely to contain API definitions
+const HIGH_PRIORITY_PATTERNS = [
+  /routes?\.ts$/i,
+  /routes?\.js$/i,
+  /router\.ts$/i,
+  /router\.js$/i,
+  /controller\.ts$/i,
+  /controller\.js$/i,
+  /\.controller\.ts$/i,
+  /\.controller\.js$/i,
+  /service\.ts$/i,
+  /service\.js$/i,
+  /\.service\.ts$/i,
+  /\.service\.js$/i,
+  /api\.ts$/i,
+  /api\.js$/i,
+  /endpoints?\.ts$/i,
+  /endpoints?\.js$/i,
+  /http\.ts$/i,
+  /http\.js$/i,
+  /client\.ts$/i,
+  /client\.js$/i,
+  /dto\.ts$/i,
+  /\.dto\.ts$/i,
+  /interfaces?\.ts$/i,
+  /types?\.ts$/i,
+  /schema\.ts$/i,
+  /schemas?\.ts$/i,
+  /validation\.ts$/i
+];
+
+// Medium priority - might contain API patterns
+const MEDIUM_PRIORITY_PATTERNS = [
+  /index\.ts$/i,
+  /index\.js$/i,
+  /app\.ts$/i,
+  /app\.js$/i,
+  /main\.ts$/i,
+  /main\.js$/i,
+  /server\.ts$/i,
+  /server\.js$/i
 ];
 
 /**
- * Scan codebase and collect frontend API patterns
+ * Scan codebase and collect API patterns from any framework
  */
 async function scanCodebase(codebasePath) {
-  console.log('   Scanning frontend files...');
+  console.log('   Scanning files...');
 
-  // Get files to scan
-  const files = await glob(FRONTEND_PATTERNS, {
+  // Get all matching files
+  const files = await glob(FILE_PATTERNS, {
     cwd: codebasePath,
     ignore: IGNORE_PATTERNS,
     absolute: true
@@ -68,23 +109,34 @@ async function scanCodebase(codebasePath) {
 
   console.log(`   Found ${files.length} files`);
 
-  // Prioritize frontend-focused files
-  const prioritizedFiles = prioritizeFiles(files, codebasePath);
-  const filesToAnalyze = prioritizedFiles.slice(0, 30); // Fewer files, but more content
+  // Categorize and prioritize files
+  const { highPriority, mediumPriority, other } = categorizeFiles(files, codebasePath);
+  
+  console.log(`   High priority: ${highPriority.length}, Medium: ${mediumPriority.length}, Other: ${other.length}`);
+
+  // Analyze high priority files first (routes, controllers, services, DTOs)
+  // Then medium priority, then scan others for API patterns
+  const filesToAnalyze = [
+    ...highPriority,
+    ...mediumPriority.slice(0, 20),
+    ...other.slice(0, 50)
+  ];
 
-  console.log(`   Analyzing ${filesToAnalyze.length} frontend files...`);
+  console.log(`   Analyzing ${filesToAnalyze.length} files for API patterns...`);
 
-  // Read and extract API patterns from files
   const fileContents = [];
+  let filesWithPatterns = 0;
+
   for (const file of filesToAnalyze) {
     try {
       const content = fs.readFileSync(file, 'utf-8');
       const relativePath = path.relative(codebasePath, file);
       
-      // Extract API calls from the file
-      const extracted = extractApiPatterns(content, relativePath);
+      // Extract API patterns from the file
+      const extracted = extractApiPatterns(content, relativePath, file);
       
-      if (extracted.hasApiCalls) {
+      if (extracted.hasApiPatterns) {
+        filesWithPatterns++;
         fileContents.push({
           path: relativePath,
           content: extracted.content
@@ -95,61 +147,367 @@ async function scanCodebase(codebasePath) {
     }
   }
 
-  console.log(`   Found API patterns in ${fileContents.length} files`);
+  console.log(`   Found API patterns in ${filesWithPatterns} files`);
 
   return fileContents;
 }
 
 /**
- * Extract API call patterns from file content
+ * Categorize files by priority
+ */
+function categorizeFiles(files, basePath) {
+  const highPriority = [];
+  const mediumPriority = [];
+  const other = [];
+
+  for (const file of files) {
+    const relativePath = path.relative(basePath, file);
+    
+    if (HIGH_PRIORITY_PATTERNS.some(p => p.test(relativePath))) {
+      highPriority.push(file);
+    } else if (MEDIUM_PRIORITY_PATTERNS.some(p => p.test(relativePath))) {
+      mediumPriority.push(file);
+    } else {
+      other.push(file);
+    }
+  }
+
+  return { highPriority, mediumPriority, other };
+}
+
+/**
+ * Extract Swagger/OpenAPI documentation blocks
+ */
+function extractSwaggerBlocks(content) {
+  const swaggerBlocks = [];
+  
+  // Match JSDoc blocks with @swagger
+  const swaggerRegex = /\/\*\*[\s\S]*?@swagger[\s\S]*?\*\//g;
+  let match;
+  
+  while ((match = swaggerRegex.exec(content)) !== null) {
+    swaggerBlocks.push(match[0]);
+  }
+  
+  return swaggerBlocks;
+}
+
+/**
+ * Extract TypeScript interfaces and types that look like DTOs/schemas
  */
-function extractApiPatterns(content, filePath) {
-  const apiPatterns = [];
+function extractTypeDefinitions(content, filePath) {
+  const typeBlocks = [];
   const lines = content.split('\n');
   
-  // Patterns that indicate API calls
-  const patterns = [
-    // fetch() calls
-    { regex: /fetch\s*\(\s*[`'"](.*?)[`'"]/g, type: 'fetch' },
-    { regex: /fetch\s*\(\s*`([^`]*)`/g, type: 'fetch-template' },
-    { regex: /fetch\s*\(\s*(['"])?\/api\//g, type: 'fetch-api' },
+  // Look for interfaces and types that might be request/response schemas
+  const typeKeywords = [
+    /interface\s+\w*(Request|Response|Dto|Body|Query|Params|Payload|Input|Output)\w*\s*\{/i,
+    /type\s+\w*(Request|Response|Dto|Body|Query|Params|Payload|Input|Output)\w*\s*=/i,
+    /interface\s+\w+\s*\{/,  // Any interface in DTO/schema files
+    /type\s+\w+\s*=/         // Any type in DTO/schema files
+  ];
+  
+  // Only extract type definitions from files that look like DTOs/types
+  const isDtoFile = /dto|interface|type|schema|model/i.test(filePath);
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
     
-    // axios calls
-    { regex: /axios\.(get|post|put|patch|delete)\s*\(\s*[`'"](.*?)[`'"]/g, type: 'axios' },
-    { regex: /axios\s*\(\s*\{[^}]*url\s*:\s*[`'"](.*?)[`'"]/g, type: 'axios-config' },
+    const isTypeDefinition = typeKeywords.some(regex => regex.test(line));
     
-    // jQuery ajax
-    { regex: /\$\.(ajax|get|post)\s*\(\s*[`'"](.*?)[`'"]/g, type: 'jquery' },
+    if (isTypeDefinition || (isDtoFile && /^(export\s+)?(interface|type)\s+/.test(line))) {
+      // Find the complete type block (until closing brace at same indent level)
+      let braceCount = 0;
+      let started = false;
+      let endLine = i;
+      
+      for (let j = i; j < lines.length && j < i + 50; j++) {
+        const l = lines[j];
+        for (const char of l) {
+          if (char === '{') {
+            braceCount++;
+            started = true;
+          } else if (char === '}') {
+            braceCount--;
+          }
+        }
+        endLine = j;
+        if (started && braceCount === 0) break;
+      }
+      
+      const block = lines.slice(i, endLine + 1)
+        .map((l, idx) => `${i + idx + 1}: ${l}`)
+        .join('\n');
+      
+      typeBlocks.push(block);
+      i = endLine; // Skip processed lines
+    }
+  }
+  
+  return typeBlocks;
+}
+
+/**
+ * Extract request body and query parameter patterns
+ */
+function extractRequestPatterns(content) {
+  const patterns = [];
+  const lines = content.split('\n');
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
     
-    // Generic API URLs
-    { regex: /['"`](\/api\/[^'"`\s]+)['"`]/g, type: 'api-url' },
-    { regex: /['"`](https?:\/\/[^'"`\s]*\/api[^'"`\s]*)['"`]/g, type: 'full-url' },
+    // Destructuring patterns for req.body, req.query, req.params
+    if (/(?:const|let|var)\s*\{[^}]+\}\s*=\s*req\.(body|query|params)/i.test(line) ||
+        /req\.(body|query|params)\s*[;.]/.test(line)) {
+      
+      // Get context around it
+      const startLine = Math.max(0, i - 2);
+      const endLine = Math.min(lines.length - 1, i + 5);
+      
+      const block = lines.slice(startLine, endLine + 1)
+        .map((l, idx) => `${startLine + idx + 1}: ${l}`)
+        .join('\n');
+      
+      patterns.push(`// Request parameter extraction:\n${block}`);
+      i = endLine;
+    }
     
-    // Method + URL patterns
-    { regex: /(GET|POST|PUT|PATCH|DELETE)\s*[,:]?\s*['"`](\/[^'"`]+)['"`]/gi, type: 'method-url' },
-  ];
+    // NestJS decorators: @Body(), @Query(), @Param()
+    if (/@(Body|Query|Param|Headers)\s*\(/i.test(line)) {
+      const startLine = Math.max(0, i - 1);
+      const endLine = Math.min(lines.length - 1, i + 3);
+      
+      const block = lines.slice(startLine, endLine + 1)
+        .map((l, idx) => `${startLine + idx + 1}: ${l}`)
+        .join('\n');
+      
+      patterns.push(`// NestJS parameter decorator:\n${block}`);
+      i = endLine;
+    }
+    
+    // Validation schemas: Joi, Zod, class-validator
+    if (/Joi\.(object|string|number|array|boolean)\s*\(/i.test(line) ||
+        /z\.(object|string|number|array|boolean)\s*\(/i.test(line) ||
+        /@(IsString|IsNumber|IsArray|IsBoolean|IsOptional|ValidateNested)/i.test(line)) {
+      
+      const startLine = Math.max(0, i - 2);
+      const endLine = Math.min(lines.length - 1, i + 10);
+      
+      const block = lines.slice(startLine, endLine + 1)
+        .map((l, idx) => `${startLine + idx + 1}: ${l}`)
+        .join('\n');
+      
+      patterns.push(`// Validation schema:\n${block}`);
+      i = endLine;
+    }
+  }
+  
+  return patterns;
+}
 
-  let hasApiCalls = false;
+/**
+ * Extract API patterns from file content - framework agnostic
+ */
+function extractApiPatterns(content, filePath, absolutePath) {
+  const lines = content.split('\n');
+  let hasApiPatterns = false;
   const extractedBlocks = [];
 
+  // Check if this is a route/controller file - if so, include more context
+  const isRouteFile = HIGH_PRIORITY_PATTERNS.some(p => p.test(filePath));
+  const isDtoFile = /dto|interface|types?|schema/i.test(filePath);
+  
+  // ============================================
+  // PATTERN 0: Swagger/OpenAPI documentation
+  // ============================================
+  const swaggerBlocks = extractSwaggerBlocks(content);
+  if (swaggerBlocks.length > 0) {
+    hasApiPatterns = true;
+    extractedBlocks.push(`// Swagger/OpenAPI documentation found:\n${swaggerBlocks.join('\n\n')}`);
+  }
+  
+  // ============================================
+  // PATTERN 1: TypeScript interfaces/types (DTOs, schemas)
+  // ============================================
+  const typeBlocks = extractTypeDefinitions(content, filePath);
+  if (typeBlocks.length > 0) {
+    hasApiPatterns = true;
+    extractedBlocks.push(`// TypeScript type definitions:\n${typeBlocks.join('\n\n')}`);
+  }
+  
+  // ============================================
+  // PATTERN 2: Request body/query extraction
+  // ============================================
+  const requestPatterns = extractRequestPatterns(content);
+  if (requestPatterns.length > 0) {
+    hasApiPatterns = true;
+    extractedBlocks.push(requestPatterns.join('\n\n'));
+  }
+
+  // ============================================
+  // PATTERN 3: Express/Koa/Fastify Router definitions
+  // ============================================
+  const routerPatterns = [
+    // Express Router: router.get('/path', handler)
+    /\.(get|post|put|patch|delete|all|use)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+    // Express app: app.get('/path', handler)
+    /app\.(get|post|put|patch|delete|all|use)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+    // Fastify: fastify.get('/path', handler)
+    /fastify\.(get|post|put|patch|delete|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+  ];
+
+  // ============================================
+  // PATTERN 4: NestJS/Decorators
+  // ============================================
+  const decoratorPatterns = [
+    /@(Get|Post|Put|Patch|Delete|All)\s*\(\s*['"`]?([^'"`\)]*)/gi,
+    /@Controller\s*\(\s*['"`]([^'"`]+)/gi,
+  ];
+
+  // ============================================
+  // PATTERN 5: Frontend HTTP calls
+  // ============================================
+  const httpCallPatterns = [
+    // fetch() calls
+    /fetch\s*\(\s*[`'"](.*?)[`'"]/g,
+    /fetch\s*\(\s*`([^`]*)`/g,
+    // axios calls
+    /axios\.(get|post|put|patch|delete)\s*\(\s*[`'"](.*?)[`'"]/g,
+    /axios\s*\(\s*\{[^}]*url\s*:\s*[`'"](.*?)[`'"]/g,
+    // Angular HttpClient
+    /this\.http\.(get|post|put|patch|delete)\s*[<(]/g,
+    /httpClient\.(get|post|put|patch|delete)\s*[<(]/g,
+    // jQuery ajax
+    /\$\.(ajax|get|post)\s*\(\s*[`'"](.*?)[`'"]/g,
+    // Generic request libraries
+    /request\.(get|post|put|patch|delete)\s*\(/g,
+    /got\.(get|post|put|patch|delete)\s*\(/g,
+    /superagent\.(get|post|put|patch|delete)\s*\(/g,
+  ];
+
+  // ============================================
+  // PATTERN 6: API URL definitions
+  // ============================================
+  const urlPatterns = [
+    // API endpoints in strings
+    /['"`](\/api\/[^'"`\s]+)['"`]/g,
+    /['"`](\/v\d+\/[^'"`\s]+)['"`]/g,
+    /['"`](https?:\/\/[^'"`\s]*\/api[^'"`\s]*)['"`]/g,
+    // Base URL definitions
+    /(?:API_BASE|API_URL|BASE_URL|baseURL|apiUrl|apiBase|API_ENDPOINT|BACKEND_URL)\s*[:=]\s*['"`]([^'"`]+)['"`]/gi,
+  ];
+
+  // ============================================
+  // PATTERN 7: Method + URL combinations
+  // ============================================
+  const methodUrlPatterns = [
+    /(GET|POST|PUT|PATCH|DELETE)\s*[,:]?\s*['"`](\/[^'"`]+)['"`]/gi,
+    /method:\s*['"`](GET|POST|PUT|PATCH|DELETE)['"`]/gi,
+  ];
+
+  // Combine all patterns for line scanning
+  const allPatterns = [
+    ...routerPatterns,
+    ...decoratorPatterns,
+    ...httpCallPatterns,
+    ...urlPatterns,
+    ...methodUrlPatterns
+  ];
+
+  // If this is a route/controller file with swagger docs, include the whole file
+  if (isRouteFile && swaggerBlocks.length > 0) {
+    hasApiPatterns = true;
+    // Include entire file content (truncated if too long)
+    const maxLines = 300;
+    const truncatedContent = lines.length > maxLines 
+      ? lines.slice(0, maxLines).join('\n') + `\n// ... ${lines.length - maxLines} more lines ...`
+      : content;
+    
+    return {
+      hasApiPatterns: true,
+      content: `// File: ${filePath}\n// Route/Controller file with Swagger docs - full content:\n\n${truncatedContent}`
+    };
+  }
+  
+  // If this is a route file without swagger, still include more content
+  if (isRouteFile) {
+    const hasRouteContent = allPatterns.some(p => {
+      p.lastIndex = 0;
+      return p.test(content);
+    });
+    
+    if (hasRouteContent) {
+      hasApiPatterns = true;
+      const maxLines = 200;
+      const truncatedContent = lines.length > maxLines 
+        ? lines.slice(0, maxLines).join('\n') + `\n// ... ${lines.length - maxLines} more lines ...`
+        : content;
+      
+      return {
+        hasApiPatterns: true,
+        content: `// File: ${filePath}\n// Route/Controller file - full content:\n\n${truncatedContent}`
+      };
+    }
+  }
+  
+  // If this is a DTO/types file, include full content
+  if (isDtoFile && typeBlocks.length > 0) {
+    hasApiPatterns = true;
+    const maxLines = 150;
+    const truncatedContent = lines.length > maxLines 
+      ? lines.slice(0, maxLines).join('\n') + `\n// ... ${lines.length - maxLines} more lines ...`
+      : content;
+    
+    return {
+      hasApiPatterns: true,
+      content: `// File: ${filePath}\n// DTO/Types file - full content:\n\n${truncatedContent}`
+    };
+  }
+
+  // For non-route files, extract relevant sections
+  // First, extract imports and base URL definitions
+  const baseUrlLines = [];
+  
+  for (let i = 0; i < Math.min(lines.length, 50); i++) {
+    const line = lines[i];
+    if (/(?:API_BASE|API_URL|BASE_URL|baseURL|apiUrl|BACKEND)/i.test(line)) {
+      baseUrlLines.push(`${i + 1}: ${line}`);
+    }
+  }
+
+  if (baseUrlLines.length > 0) {
+    extractedBlocks.push('// Base URL definitions:\n' + baseUrlLines.join('\n'));
+    hasApiPatterns = true;
+  }
+
   // Line-by-line extraction with context
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     
-    // Check for API patterns
-    const hasPattern = patterns.some(p => p.regex.test(line));
-    // Reset regex lastIndex
-    patterns.forEach(p => p.regex.lastIndex = 0);
+    // Check all patterns
+    let hasPattern = false;
+    for (const pattern of allPatterns) {
+      pattern.lastIndex = 0;
+      if (pattern.test(line)) {
+        hasPattern = true;
+        break;
+      }
+    }
     
     // Also check for common API keywords
-    const hasKeyword = /fetch|axios|\.ajax|\.get\(|\.post\(|\.put\(|\.delete\(|\/api\/|endpoint|baseURL/i.test(line);
+    const hasKeyword = /\.get\(|\.post\(|\.put\(|\.patch\(|\.delete\(|fetch\(|axios|\/api\/|endpoint|@Get|@Post|@Put|@Delete/i.test(line);
     
     if (hasPattern || hasKeyword) {
-      hasApiCalls = true;
+      hasApiPatterns = true;
       
-      // Get context: 3 lines before and 5 lines after
-      const startLine = Math.max(0, i - 3);
-      const endLine = Math.min(lines.length - 1, i + 5);
+      // Determine context needed
+      const isPostOrPut = /post|put|patch/i.test(line);
+      const contextBefore = isPostOrPut ? 20 : 5;  // More context for mutations
+      const contextAfter = isPostOrPut ? 10 : 5;
+      
+      const startLine = Math.max(0, i - contextBefore);
+      const endLine = Math.min(lines.length - 1, i + contextAfter);
       
       const block = lines.slice(startLine, endLine + 1)
         .map((l, idx) => `${startLine + idx + 1}: ${l}`)
@@ -162,49 +520,16 @@ function extractApiPatterns(content, filePath) {
     }
   }
 
-  // If we found API patterns, return extracted content
-  if (hasApiCalls && extractedBlocks.length > 0) {
+  if (hasApiPatterns && extractedBlocks.length > 0) {
+    // Deduplicate blocks
+    const uniqueBlocks = [...new Set(extractedBlocks)];
     return {
-      hasApiCalls: true,
-      content: `// File: ${filePath}\n// API patterns found:\n\n${extractedBlocks.join('\n\n// ---\n\n')}`
+      hasApiPatterns: true,
+      content: `// File: ${filePath}\n// API patterns extracted:\n\n${uniqueBlocks.join('\n\n// ---\n\n')}`
     };
   }
 
-  // Fallback: include first 5000 chars if file looks relevant
-  if (/api|fetch|axios|service|http/i.test(filePath)) {
-    return {
-      hasApiCalls: true,
-      content: `// File: ${filePath}\n${content.slice(0, 5000)}`
-    };
-  }
-
-  return { hasApiCalls: false, content: '' };
-}
-
-/**
- * Prioritize frontend files based on keywords
- */
-function prioritizeFiles(files, basePath) {
-  return files.sort((a, b) => {
-    const aPath = path.relative(basePath, a).toLowerCase();
-    const bPath = path.relative(basePath, b).toLowerCase();
-    
-    // Deprioritize test files
-    if (aPath.includes('test') || aPath.includes('spec')) return 1;
-    if (bPath.includes('test') || bPath.includes('spec')) return -1;
-    
-    // Prioritize src/frontend folders
-    if (aPath.includes('src/') || aPath.includes('frontend/')) {
-      if (!bPath.includes('src/') && !bPath.includes('frontend/')) return -1;
-    }
-    
-    const aScore = PRIORITY_KEYWORDS.reduce((score, kw) => 
-      aPath.includes(kw) ? score + 1 : score, 0);
-    const bScore = PRIORITY_KEYWORDS.reduce((score, kw) => 
-      bPath.includes(kw) ? score + 1 : score, 0);
-    
-    return bScore - aScore;
-  });
+  return { hasApiPatterns: false, content: '' };
 }
 
 module.exports = { scanCodebase };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merlean/analyzer",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "AI Bot codebase analyzer - generates site maps for AI assistant integration",
   "keywords": ["ai", "bot", "analyzer", "claude", "anthropic", "widget"],
   "author": "zmaren",