create-claude-context 1.0.0 → 1.2.1

package/lib/detector.js

@@ -1,373 +1,456 @@
-/**
- * Claude Context Engineering - Tech Stack Detector
- *
- * Auto-detects technology stack from project files.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { glob } = require('glob');
-
-/**
- * Tech stack detection signatures
- */
-const TECH_SIGNATURES = {
-  // Languages
-  languages: {
-    python: {
-      files: ['requirements.txt', 'pyproject.toml', 'setup.py', 'Pipfile', 'poetry.lock'],
-      extensions: ['.py'],
-    },
-    javascript: {
-      files: ['package.json', 'yarn.lock', 'pnpm-lock.yaml'],
-      extensions: ['.js', '.mjs', '.cjs'],
-    },
-    typescript: {
-      files: ['tsconfig.json'],
-      extensions: ['.ts', '.tsx'],
-    },
-    go: {
-      files: ['go.mod', 'go.sum'],
-      extensions: ['.go'],
-    },
-    rust: {
-      files: ['Cargo.toml', 'Cargo.lock'],
-      extensions: ['.rs'],
-    },
-    java: {
-      files: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
-      extensions: ['.java'],
-    },
-    csharp: {
-      files: ['*.csproj', '*.sln'],
-      extensions: ['.cs'],
-    },
-    ruby: {
-      files: ['Gemfile', 'Gemfile.lock'],
-      extensions: ['.rb'],
-    },
-    php: {
-      files: ['composer.json', 'composer.lock'],
-      extensions: ['.php'],
-    },
-  },
-
-  // Frameworks
-  frameworks: {
-    // Python
-    fastapi: {
-      language: 'python',
-      patterns: ['fastapi', 'FastAPI', '@router', 'APIRouter'],
-      files: [],
-    },
-    django: {
-      language: 'python',
-      patterns: ['django.conf', 'INSTALLED_APPS', 'from django'],
-      files: ['manage.py'],
-    },
-    flask: {
-      language: 'python',
-      patterns: ['Flask(__name__)', '@app.route', 'from flask'],
-      files: [],
-    },
-
-    // JavaScript/TypeScript
-    react: {
-      language: 'javascript',
-      patterns: ['react', 'React', 'useState', 'useEffect'],
-      packageDeps: ['react', 'react-dom'],
-    },
-    nextjs: {
-      language: 'javascript',
-      patterns: ['next/'],
-      files: ['next.config.js', 'next.config.mjs'],
-      packageDeps: ['next'],
-    },
-    express: {
-      language: 'javascript',
-      patterns: ['express()', 'app.use', 'app.get', 'router.'],
-      packageDeps: ['express'],
-    },
-    nestjs: {
-      language: 'typescript',
-      patterns: ['@nestjs/', '@Controller', '@Injectable'],
-      packageDeps: ['@nestjs/core'],
-    },
-    vue: {
-      language: 'javascript',
-      patterns: ['<template>', 'Vue.'],
-      packageDeps: ['vue'],
-    },
-
-    // Go
-    gin: {
-      language: 'go',
-      patterns: ['gin.', 'gin-gonic'],
-      files: [],
-    },
-    echo: {
-      language: 'go',
-      patterns: ['echo.', 'labstack/echo'],
-      files: [],
-    },
-
-    // Ruby
-    rails: {
-      language: 'ruby',
-      patterns: ['Rails.application', 'ActionController', 'ActiveRecord'],
-      files: ['config/routes.rb'],
-    },
-
-    // Rust
-    actix: {
-      language: 'rust',
-      patterns: ['actix_web', 'actix-web'],
-      files: [],
-    },
-    axum: {
-      language: 'rust',
-      patterns: ['axum::'],
-      files: [],
-    },
-  },
-
-  // Databases
-  databases: {
-    postgresql: {
-      patterns: ['postgresql', 'postgres', 'psycopg', 'pg'],
-      envVars: ['DATABASE_URL', 'POSTGRES_'],
-    },
-    mysql: {
-      patterns: ['mysql', 'mariadb'],
-      envVars: ['MYSQL_'],
-    },
-    mongodb: {
-      patterns: ['mongodb', 'mongoose', 'pymongo'],
-      envVars: ['MONGO_'],
-    },
-    redis: {
-      patterns: ['redis', 'ioredis'],
-      envVars: ['REDIS_'],
-    },
-    sqlite: {
-      patterns: ['sqlite', 'sqlite3'],
-      files: ['*.db', '*.sqlite'],
-    },
-  },
-};
-
-/**
- * Detect technology stack
- */
-async function detectTechStack(projectRoot, options = {}) {
-  const { hint = null } = options;
-
-  const result = {
-    stack: '',
-    summary: '',
-    languages: [],
-    frameworks: [],
-    databases: [],
-    projectName: path.basename(projectRoot),
-    fileCount: 0,
-    loc: 0,
-  };
-
-  // If hint provided, use it
-  if (hint) {
-    result.stack = hint;
-    result.summary = hint;
-    return result;
-  }
-
-  // Detect languages
-  for (const [lang, signature] of Object.entries(TECH_SIGNATURES.languages)) {
-    // Check for signature files
-    for (const sigFile of signature.files) {
-      if (fs.existsSync(path.join(projectRoot, sigFile))) {
-        if (!result.languages.includes(lang)) {
-          result.languages.push(lang);
-        }
-        break;
-      }
-    }
-
-    // Check for file extensions
-    if (signature.extensions) {
-      for (const ext of signature.extensions) {
-        try {
-          const files = await glob(`**/*${ext}`, {
-            cwd: projectRoot,
-            ignore: ['node_modules/**', 'vendor/**', '.git/**', 'dist/**', 'build/**'],
-            nodir: true,
-          });
-
-          if (files.length > 0) {
-            if (!result.languages.includes(lang)) {
-              result.languages.push(lang);
-            }
-            result.fileCount += files.length;
-            break;
-          }
-        } catch {
-          // Ignore glob errors
-        }
-      }
-    }
-  }
-
-  // Detect frameworks
-  for (const [framework, signature] of Object.entries(TECH_SIGNATURES.frameworks)) {
-    // Check for package.json dependencies
-    if (signature.packageDeps) {
-      const pkgPath = path.join(projectRoot, 'package.json');
-      if (fs.existsSync(pkgPath)) {
-        try {
-          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-          const allDeps = {
-            ...pkg.dependencies,
-            ...pkg.devDependencies,
-          };
-
-          for (const dep of signature.packageDeps) {
-            if (allDeps[dep]) {
-              if (!result.frameworks.includes(framework)) {
-                result.frameworks.push(framework);
-              }
-              break;
-            }
-          }
-        } catch {
-          // Ignore JSON parse errors
-        }
-      }
-    }
-
-    // Check for signature files
-    if (signature.files) {
-      for (const sigFile of signature.files) {
-        if (fs.existsSync(path.join(projectRoot, sigFile))) {
-          if (!result.frameworks.includes(framework)) {
-            result.frameworks.push(framework);
-          }
-          break;
-        }
-      }
-    }
-
-    // Check for patterns in source files (sample)
-    if (signature.patterns && result.languages.includes(signature.language)) {
-      // Sample a few source files
-      const ext = TECH_SIGNATURES.languages[signature.language]?.extensions?.[0];
-      if (ext) {
-        try {
-          const sampleFiles = await glob(`**/*${ext}`, {
-            cwd: projectRoot,
-            ignore: ['node_modules/**', 'vendor/**', '.git/**'],
-            nodir: true,
-          });
-
-          // Check first 5 files
-          for (const file of sampleFiles.slice(0, 5)) {
-            try {
-              const content = fs.readFileSync(path.join(projectRoot, file), 'utf8');
-
-              for (const pattern of signature.patterns) {
-                if (content.includes(pattern)) {
-                  if (!result.frameworks.includes(framework)) {
-                    result.frameworks.push(framework);
-                  }
-                  break;
-                }
-              }
-            } catch {
-              // Ignore file read errors
-            }
-          }
-        } catch {
-          // Ignore glob errors
-        }
-      }
-    }
-  }
-
-  // Detect databases
-  for (const [db, signature] of Object.entries(TECH_SIGNATURES.databases)) {
-    // Check environment files
-    const envFiles = ['.env', '.env.example', '.env.local'];
-    for (const envFile of envFiles) {
-      const envPath = path.join(projectRoot, envFile);
-      if (fs.existsSync(envPath)) {
-        try {
-          const content = fs.readFileSync(envPath, 'utf8');
-
-          if (signature.envVars) {
-            for (const envVar of signature.envVars) {
-              if (content.includes(envVar)) {
-                if (!result.databases.includes(db)) {
-                  result.databases.push(db);
-                }
-                break;
-              }
-            }
-          }
-        } catch {
-          // Ignore read errors
-        }
-      }
-    }
-
-    // Check for patterns in config files
-    if (signature.patterns) {
-      const configFiles = ['package.json', 'requirements.txt', 'pyproject.toml', 'Cargo.toml'];
-      for (const configFile of configFiles) {
-        const configPath = path.join(projectRoot, configFile);
-        if (fs.existsSync(configPath)) {
-          try {
-            const content = fs.readFileSync(configPath, 'utf8').toLowerCase();
-
-            for (const pattern of signature.patterns) {
-              if (content.includes(pattern.toLowerCase())) {
-                if (!result.databases.includes(db)) {
-                  result.databases.push(db);
-                }
-                break;
-              }
-            }
-          } catch {
-            // Ignore read errors
-          }
-        }
-      }
-    }
-  }
-
-  // Build stack string
-  const stackParts = [];
-  if (result.languages.length > 0) {
-    stackParts.push(result.languages.map(l => capitalize(l)).join(', '));
-  }
-  if (result.frameworks.length > 0) {
-    stackParts.push(result.frameworks.map(f => capitalize(f)).join(', '));
-  }
-  if (result.databases.length > 0) {
-    stackParts.push(result.databases.map(d => capitalize(d)).join(', '));
-  }
-
-  result.stack = stackParts.join(' + ') || 'Unknown';
-  result.summary = result.stack;
-
-  return result;
-}
-
-/**
- * Capitalize first letter
- */
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-module.exports = {
-  detectTechStack,
-  TECH_SIGNATURES,
-};
+/**
+ * Claude Context Engineering - Tech Stack Detector
+ *
+ * Auto-detects technology stack from project files.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { glob } = require('glob');
+
+/**
+ * Tech stack detection signatures
+ */
+const TECH_SIGNATURES = {
+  // Languages
+  languages: {
+    python: {
+      files: ['requirements.txt', 'pyproject.toml', 'setup.py', 'Pipfile', 'poetry.lock'],
+      extensions: ['.py'],
+    },
+    javascript: {
+      files: ['package.json', 'yarn.lock', 'pnpm-lock.yaml'],
+      extensions: ['.js', '.mjs', '.cjs'],
+    },
+    typescript: {
+      files: ['tsconfig.json'],
+      extensions: ['.ts', '.tsx'],
+    },
+    go: {
+      files: ['go.mod', 'go.sum'],
+      extensions: ['.go'],
+    },
+    rust: {
+      files: ['Cargo.toml', 'Cargo.lock'],
+      extensions: ['.rs'],
+    },
+    java: {
+      files: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
+      extensions: ['.java'],
+    },
+    csharp: {
+      files: ['*.csproj', '*.sln'],
+      extensions: ['.cs'],
+    },
+    ruby: {
+      files: ['Gemfile', 'Gemfile.lock'],
+      extensions: ['.rb'],
+    },
+    php: {
+      files: ['composer.json', 'composer.lock'],
+      extensions: ['.php'],
+    },
+  },
+
+  // Frameworks
+  frameworks: {
+    // Python
+    fastapi: {
+      language: 'python',
+      patterns: ['fastapi', 'FastAPI', '@router', 'APIRouter'],
+      files: [],
+    },
+    django: {
+      language: 'python',
+      patterns: ['django.conf', 'INSTALLED_APPS', 'from django'],
+      files: ['manage.py'],
+    },
+    flask: {
+      language: 'python',
+      patterns: ['Flask(__name__)', '@app.route', 'from flask'],
+      files: [],
+    },
+
+    // JavaScript/TypeScript
+    react: {
+      language: 'javascript',
+      patterns: ['react', 'React', 'useState', 'useEffect'],
+      packageDeps: ['react', 'react-dom'],
+    },
+    nextjs: {
+      language: 'javascript',
+      patterns: ['next/'],
+      files: ['next.config.js', 'next.config.mjs'],
+      packageDeps: ['next'],
+    },
+    express: {
+      language: 'javascript',
+      patterns: ['express()', 'app.use', 'app.get', 'router.'],
+      packageDeps: ['express'],
+    },
+    nestjs: {
+      language: 'typescript',
+      patterns: ['@nestjs/', '@Controller', '@Injectable'],
+      packageDeps: ['@nestjs/core'],
+    },
+    vue: {
+      language: 'javascript',
+      patterns: ['<template>', 'Vue.'],
+      packageDeps: ['vue'],
+    },
+
+    // Go
+    gin: {
+      language: 'go',
+      patterns: ['gin.', 'gin-gonic'],
+      files: [],
+    },
+    echo: {
+      language: 'go',
+      patterns: ['echo.', 'labstack/echo'],
+      files: [],
+    },
+
+    // Ruby
+    rails: {
+      language: 'ruby',
+      patterns: ['Rails.application', 'ActionController', 'ActiveRecord'],
+      files: ['config/routes.rb'],
+    },
+
+    // Rust
+    actix: {
+      language: 'rust',
+      patterns: ['actix_web', 'actix-web'],
+      files: [],
+    },
+    axum: {
+      language: 'rust',
+      patterns: ['axum::'],
+      files: [],
+    },
+  },
+
+  // Databases
+  databases: {
+    postgresql: {
+      patterns: ['postgresql', 'postgres', 'psycopg', 'pg'],
+      envVars: ['DATABASE_URL', 'POSTGRES_'],
+    },
+    mysql: {
+      patterns: ['mysql', 'mariadb'],
+      envVars: ['MYSQL_'],
+    },
+    mongodb: {
+      patterns: ['mongodb', 'mongoose', 'pymongo'],
+      envVars: ['MONGO_'],
+    },
+    redis: {
+      patterns: ['redis', 'ioredis'],
+      envVars: ['REDIS_'],
+    },
+    sqlite: {
+      patterns: ['sqlite', 'sqlite3'],
+      files: ['*.db', '*.sqlite'],
+    },
+  },
+};
+
+/**
+ * Entry point patterns for different frameworks
+ */
+const ENTRY_POINT_PATTERNS = {
+  express: {
+    regex: /app\.(get|post|put|delete|patch)\s*\(\s*['"`]([^'"`]+)['"`]/g,
+    extractor: (match) => ({ method: match[1].toUpperCase(), route: match[2] })
+  },
+  fastapi: {
+    regex: /@app\.(get|post|put|delete|patch)\s*\(\s*['"`]([^'"`]+)['"`]/g,
+    extractor: (match) => ({ method: match[1].toUpperCase(), route: match[2] })
+  },
+  nextjs: {
+    regex: /export\s+(async\s+)?function\s+(GET|POST|PUT|DELETE|PATCH)/g,
+    extractor: (match) => ({ method: match[2], route: 'app-router' })
+  },
+  django: {
+    regex: /path\s*\(\s*['"`]([^'"`]+)['"`]/g,
+    extractor: (match) => ({ method: 'ANY', route: match[1] })
+  },
+  rails: {
+    regex: /(get|post|put|delete|patch)\s+['"`]([^'"`]+)['"`]/g,
+    extractor: (match) => ({ method: match[1].toUpperCase(), route: match[2] })
+  },
+  nestjs: {
+    regex: /@(Get|Post|Put|Delete|Patch)\s*\(\s*['"`]?([^'"`)\s]*)['"`]?\s*\)/g,
+    extractor: (match) => ({ method: match[1].toUpperCase(), route: match[2] || '/' })
+  }
+};
+
+/**
+ * Detect entry points in source files
+ */
+async function detectEntryPoints(projectRoot, frameworks) {
+  const entryPoints = [];
+
+  for (const framework of frameworks) {
+    const pattern = ENTRY_POINT_PATTERNS[framework];
+    if (!pattern) continue;
+
+    // Get appropriate file extension
+    const lang = TECH_SIGNATURES.frameworks[framework]?.language || 'javascript';
+    const ext = TECH_SIGNATURES.languages[lang]?.extensions?.[0] || '.js';
+
+    try {
+      const files = await glob(`**/*${ext}`, {
+        cwd: projectRoot,
+        ignore: ['node_modules/**', 'vendor/**', '.git/**', 'dist/**', 'build/**', '__pycache__/**'],
+        nodir: true,
+      });
+
+      for (const file of files.slice(0, 20)) { // Limit to 20 files
+        try {
+          const content = fs.readFileSync(path.join(projectRoot, file), 'utf8');
+          let match;
+
+          while ((match = pattern.regex.exec(content)) !== null) {
+            const entry = pattern.extractor(match);
+            entryPoints.push({
+              ...entry,
+              file,
+              line: content.substring(0, match.index).split('\n').length,
+              framework
+            });
+          }
+          pattern.regex.lastIndex = 0; // Reset regex
+        } catch {
+          // Skip unreadable files
+        }
+      }
+    } catch {
+      // Skip glob errors
+    }
+  }
+
+  return entryPoints;
+}
+
+/**
+ * Detect technology stack
+ */
+async function detectTechStack(projectRoot, options = {}) {
+  const { hint = null } = options;
+
+  const result = {
+    stack: '',
+    summary: '',
+    languages: [],
+    frameworks: [],
+    databases: [],
+    projectName: path.basename(projectRoot),
+    fileCount: 0,
+    loc: 0,
+  };
+
+  // If hint provided, use it
+  if (hint) {
+    result.stack = hint;
+    result.summary = hint;
+    return result;
+  }
+
+  // Detect languages
+  for (const [lang, signature] of Object.entries(TECH_SIGNATURES.languages)) {
+    // Check for signature files
+    for (const sigFile of signature.files) {
+      if (fs.existsSync(path.join(projectRoot, sigFile))) {
+        if (!result.languages.includes(lang)) {
+          result.languages.push(lang);
+        }
+        break;
+      }
+    }
+
+    // Check for file extensions
+    if (signature.extensions) {
+      for (const ext of signature.extensions) {
+        try {
+          const files = await glob(`**/*${ext}`, {
+            cwd: projectRoot,
+            ignore: ['node_modules/**', 'vendor/**', '.git/**', 'dist/**', 'build/**'],
+            nodir: true,
+          });
+
+          if (files.length > 0) {
+            if (!result.languages.includes(lang)) {
+              result.languages.push(lang);
+            }
+            result.fileCount += files.length;
+            break;
+          }
+        } catch {
+          // Ignore glob errors
+        }
+      }
+    }
+  }
+
+  // Detect frameworks
+  for (const [framework, signature] of Object.entries(TECH_SIGNATURES.frameworks)) {
+    // Check for package.json dependencies
+    if (signature.packageDeps) {
+      const pkgPath = path.join(projectRoot, 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+          const allDeps = {
+            ...pkg.dependencies,
+            ...pkg.devDependencies,
+          };
+
+          for (const dep of signature.packageDeps) {
+            if (allDeps[dep]) {
+              if (!result.frameworks.includes(framework)) {
+                result.frameworks.push(framework);
+              }
+              break;
+            }
+          }
+        } catch {
+          // Ignore JSON parse errors
+        }
+      }
+    }
+
+    // Check for signature files
+    if (signature.files) {
+      for (const sigFile of signature.files) {
+        if (fs.existsSync(path.join(projectRoot, sigFile))) {
+          if (!result.frameworks.includes(framework)) {
+            result.frameworks.push(framework);
+          }
+          break;
+        }
+      }
+    }
+
+    // Check for patterns in source files (sample)
+    if (signature.patterns && result.languages.includes(signature.language)) {
+      // Sample a few source files
+      const ext = TECH_SIGNATURES.languages[signature.language]?.extensions?.[0];
+      if (ext) {
+        try {
+          const sampleFiles = await glob(`**/*${ext}`, {
+            cwd: projectRoot,
+            ignore: ['node_modules/**', 'vendor/**', '.git/**'],
+            nodir: true,
+          });
+
+          // Check first 5 files
+          for (const file of sampleFiles.slice(0, 5)) {
+            try {
+              const content = fs.readFileSync(path.join(projectRoot, file), 'utf8');
+
+              for (const pattern of signature.patterns) {
+                if (content.includes(pattern)) {
+                  if (!result.frameworks.includes(framework)) {
+                    result.frameworks.push(framework);
+                  }
+                  break;
+                }
+              }
+            } catch {
+              // Ignore file read errors
+            }
+          }
+        } catch {
+          // Ignore glob errors
+        }
+      }
+    }
+  }
+
+  // Detect databases
+  for (const [db, signature] of Object.entries(TECH_SIGNATURES.databases)) {
+    // Check environment files
+    const envFiles = ['.env', '.env.example', '.env.local'];
+    for (const envFile of envFiles) {
+      const envPath = path.join(projectRoot, envFile);
+      if (fs.existsSync(envPath)) {
+        try {
+          const content = fs.readFileSync(envPath, 'utf8');
+
+          if (signature.envVars) {
+            for (const envVar of signature.envVars) {
+              if (content.includes(envVar)) {
+                if (!result.databases.includes(db)) {
+                  result.databases.push(db);
+                }
+                break;
+              }
+            }
+          }
+        } catch {
+          // Ignore read errors
+        }
+      }
+    }
+
+    // Check for patterns in config files
+    if (signature.patterns) {
+      const configFiles = ['package.json', 'requirements.txt', 'pyproject.toml', 'Cargo.toml'];
+      for (const configFile of configFiles) {
+        const configPath = path.join(projectRoot, configFile);
+        if (fs.existsSync(configPath)) {
+          try {
+            const content = fs.readFileSync(configPath, 'utf8').toLowerCase();
+
+            for (const pattern of signature.patterns) {
+              if (content.includes(pattern.toLowerCase())) {
+                if (!result.databases.includes(db)) {
+                  result.databases.push(db);
+                }
+                break;
+              }
+            }
+          } catch {
+            // Ignore read errors
+          }
+        }
+      }
+    }
+  }
+
+  // Detect entry points for discovered frameworks
+  result.entryPoints = await detectEntryPoints(projectRoot, result.frameworks);
+
+  // Build stack string
+  const stackParts = [];
+  if (result.languages.length > 0) {
+    stackParts.push(result.languages.map(l => capitalize(l)).join(', '));
+  }
+  if (result.frameworks.length > 0) {
+    stackParts.push(result.frameworks.map(f => capitalize(f)).join(', '));
+  }
+  if (result.databases.length > 0) {
+    stackParts.push(result.databases.map(d => capitalize(d)).join(', '));
+  }
+
+  result.stack = stackParts.join(' + ') || 'Unknown';
+  result.summary = result.stack;
+
+  return result;
+}
+
+/**
+ * Capitalize first letter
+ */
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+module.exports = {
+  detectTechStack,
+  detectEntryPoints,
+  TECH_SIGNATURES,
+  ENTRY_POINT_PATTERNS,
+};