@itz4blitz/agentful 0.4.0 → 1.0.0

package/lib/core/detectors/framework.js

@@ -0,0 +1,276 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Framework Detector
+ *
+ * Detects frameworks and libraries used in the project based on:
+ * - package.json dependencies
+ * - Import statements
+ * - Configuration files
+ * - File structure patterns
+ */
+
+/**
+ * Framework detection rules
+ * Maps package names to frameworks
+ */
+const FRAMEWORK_PACKAGES = {
+  // JavaScript/TypeScript frameworks
+  'next': { name: 'Next.js', type: 'framework', category: 'web' },
+  'react': { name: 'React', type: 'library', category: 'ui' },
+  'vue': { name: 'Vue', type: 'framework', category: 'web' },
+  'nuxt': { name: 'Nuxt', type: 'framework', category: 'web' },
+  'angular': { name: 'Angular', type: 'framework', category: 'web' },
+  'svelte': { name: 'Svelte', type: 'framework', category: 'ui' },
+  'express': { name: 'Express', type: 'framework', category: 'backend' },
+  'fastify': { name: 'Fastify', type: 'framework', category: 'backend' },
+  'nestjs': { name: 'NestJS', type: 'framework', category: 'backend' },
+  'koa': { name: 'Koa', type: 'framework', category: 'backend' },
+  'hapi': { name: 'Hapi', type: 'framework', category: 'backend' },
+
+  // Testing frameworks
+  'vitest': { name: 'Vitest', type: 'framework', category: 'testing' },
+  'jest': { name: 'Jest', type: 'framework', category: 'testing' },
+  'mocha': { name: 'Mocha', type: 'framework', category: 'testing' },
+  'jasmine': { name: 'Jasmine', type: 'framework', category: 'testing' },
+  'cypress': { name: 'Cypress', type: 'framework', category: 'testing' },
+  'playwright': { name: 'Playwright', type: 'framework', category: 'testing' },
+
+  // Build tools
+  'vite': { name: 'Vite', type: 'tool', category: 'build' },
+  'webpack': { name: 'Webpack', type: 'tool', category: 'build' },
+  'rollup': { name: 'Rollup', type: 'tool', category: 'build' },
+  'esbuild': { name: 'esbuild', type: 'tool', category: 'build' },
+  'parcel': { name: 'Parcel', type: 'tool', category: 'build' },
+
+  // Database/ORM
+  'prisma': { name: 'Prisma', type: 'library', category: 'database' },
+  'typeorm': { name: 'TypeORM', type: 'library', category: 'database' },
+  'sequelize': { name: 'Sequelize', type: 'library', category: 'database' },
+  'mongoose': { name: 'Mongoose', type: 'library', category: 'database' },
+  'drizzle-orm': { name: 'Drizzle', type: 'library', category: 'database' },
+
+  // Styling
+  'tailwindcss': { name: 'Tailwind CSS', type: 'library', category: 'styling' },
+  'styled-components': { name: 'Styled Components', type: 'library', category: 'styling' },
+  '@emotion/react': { name: 'Emotion', type: 'library', category: 'styling' },
+  'sass': { name: 'Sass', type: 'tool', category: 'styling' }
+};
+
+/**
+ * Configuration files that indicate specific frameworks
+ */
+const CONFIG_FILES = {
+  'next.config.js': 'Next.js',
+  'next.config.mjs': 'Next.js',
+  'next.config.ts': 'Next.js',
+  'nuxt.config.js': 'Nuxt',
+  'nuxt.config.ts': 'Nuxt',
+  'vue.config.js': 'Vue',
+  'angular.json': 'Angular',
+  'svelte.config.js': 'Svelte',
+  'vite.config.js': 'Vite',
+  'vite.config.ts': 'Vite',
+  'vitest.config.js': 'Vitest',
+  'vitest.config.ts': 'Vitest',
+  'jest.config.js': 'Jest',
+  'jest.config.ts': 'Jest',
+  'playwright.config.js': 'Playwright',
+  'playwright.config.ts': 'Playwright',
+  'tailwind.config.js': 'Tailwind CSS',
+  'tailwind.config.ts': 'Tailwind CSS'
+};
+
+/**
+ * File structure patterns that indicate frameworks
+ */
+const STRUCTURE_PATTERNS = {
+  'Next.js': ['pages/', 'app/', 'public/'],
+  'Nuxt': ['pages/', 'layouts/', 'nuxt.config'],
+  'Angular': ['src/app/', 'angular.json'],
+  'Vue': ['src/components/', 'src/views/'],
+  'Express': ['routes/', 'middleware/'],
+  'NestJS': ['src/modules/', 'src/controllers/']
+};
+
+/**
+ * Detect frameworks from package.json
+ *
+ * @param {string} projectRoot - Absolute path to project root
+ * @returns {Promise<Object[]>} Array of detected frameworks
+ */
+export async function detectFromPackageJson(projectRoot) {
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  const frameworks = [];
+
+  try {
+    const content = await fs.readFile(packageJsonPath, 'utf-8');
+    const packageJson = JSON.parse(content);
+
+    const allDeps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+
+    for (const [pkg, version] of Object.entries(allDeps)) {
+      const framework = FRAMEWORK_PACKAGES[pkg];
+      if (framework) {
+        frameworks.push({
+          name: framework.name,
+          version: version.replace(/[\^~]/g, ''),
+          type: framework.type,
+          category: framework.category,
+          confidence: 95,
+          source: 'package.json'
+        });
+      }
+    }
+  } catch (error) {
+    // package.json not found or invalid - not an error, just no data
+  }
+
+  return frameworks;
+}
+
+/**
+ * Detect frameworks from config files
+ *
+ * @param {string[]} files - Array of file paths
+ * @returns {Object[]} Array of detected frameworks
+ */
+export function detectFromConfigFiles(files) {
+  const frameworks = [];
+  const seen = new Set();
+
+  for (const file of files) {
+    const basename = path.basename(file);
+    const frameworkName = CONFIG_FILES[basename];
+
+    if (frameworkName && !seen.has(frameworkName)) {
+      seen.add(frameworkName);
+      frameworks.push({
+        name: frameworkName,
+        confidence: 90,
+        source: 'config file',
+        configFile: basename
+      });
+    }
+  }
+
+  return frameworks;
+}
+
+/**
+ * Detect frameworks from file structure
+ *
+ * @param {string[]} files - Array of file paths
+ * @returns {Object[]} Array of detected frameworks
+ */
+export function detectFromStructure(files) {
+  const frameworks = [];
+
+  for (const [frameworkName, patterns] of Object.entries(STRUCTURE_PATTERNS)) {
+    let matchCount = 0;
+
+    for (const pattern of patterns) {
+      const hasPattern = files.some(file =>
+        file.startsWith(pattern) || file.includes(`/${pattern}`)
+      );
+      if (hasPattern) matchCount++;
+    }
+
+    if (matchCount > 0) {
+      const confidence = Math.min(85, 50 + (matchCount / patterns.length) * 35);
+      frameworks.push({
+        name: frameworkName,
+        confidence: Math.round(confidence),
+        source: 'file structure',
+        patternsMatched: matchCount,
+        patternsTotal: patterns.length
+      });
+    }
+  }
+
+  return frameworks;
+}
+
+/**
+ * Detect frameworks from import statements
+ *
+ * @param {string} content - File content to analyze
+ * @returns {string[]} Array of imported framework names
+ */
+export function detectFromImports(content) {
+  const imports = new Set();
+  const importRegex = /(?:import|require)\s*\(?['"]([^'"]+)['"]\)?/g;
+
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    const importPath = match[1];
+    const packageName = importPath.startsWith('@')
+      ? importPath.split('/').slice(0, 2).join('/')
+      : importPath.split('/')[0];
+
+    if (FRAMEWORK_PACKAGES[packageName]) {
+      imports.add(FRAMEWORK_PACKAGES[packageName].name);
+    }
+  }
+
+  return Array.from(imports);
+}
+
+/**
+ * Merge and deduplicate framework detections
+ *
+ * @param {Object[][]} detectionResults - Multiple arrays of detected frameworks
+ * @returns {Object[]} Merged and deduplicated frameworks with highest confidence
+ */
+export function mergeFrameworks(...detectionResults) {
+  const frameworkMap = new Map();
+
+  for (const results of detectionResults) {
+    for (const framework of results) {
+      const existing = frameworkMap.get(framework.name);
+
+      if (!existing || framework.confidence > existing.confidence) {
+        frameworkMap.set(framework.name, framework);
+      } else if (existing) {
+        // Merge sources
+        existing.sources = existing.sources || [existing.source];
+        if (!existing.sources.includes(framework.source)) {
+          existing.sources.push(framework.source);
+        }
+        // Boost confidence if detected from multiple sources
+        existing.confidence = Math.min(98, existing.confidence + 5);
+      }
+    }
+  }
+
+  return Array.from(frameworkMap.values())
+    .sort((a, b) => b.confidence - a.confidence);
+}
+
+/**
+ * Detect all frameworks in project
+ *
+ * @param {string[]} files - Array of file paths
+ * @param {string} projectRoot - Absolute path to project root
+ * @returns {Promise<Object[]>} Array of detected frameworks
+ */
+export async function detectFrameworks(files, projectRoot) {
+  const fromPackage = await detectFromPackageJson(projectRoot);
+  const fromConfig = detectFromConfigFiles(files);
+  const fromStructure = detectFromStructure(files);
+
+  return mergeFrameworks(fromPackage, fromConfig, fromStructure);
+}
+
+export default {
+  detectFrameworks,
+  detectFromPackageJson,
+  detectFromConfigFiles,
+  detectFromStructure,
+  detectFromImports,
+  mergeFrameworks
+};

package/lib/core/detectors/index.js

@@ -0,0 +1,15 @@
+/**
+ * Detector Module Exports
+ *
+ * Centralized exports for all detector modules
+ */
+
+export * from './language.js';
+export * from './framework.js';
+export * from './patterns.js';
+export * from './conventions.js';
+
+export { default as languageDetector } from './language.js';
+export { default as frameworkDetector } from './framework.js';
+export { default as patternDetector } from './patterns.js';
+export { default as conventionDetector } from './conventions.js';

package/lib/core/detectors/language.js

@@ -0,0 +1,199 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Language Detector
+ *
+ * Detects programming languages used in the project based on:
+ * - File extensions
+ * - File content analysis
+ * - Configuration files
+ */
+
+/**
+ * Language detection rules
+ * Maps file extensions to languages
+ */
+const LANGUAGE_EXTENSIONS = {
+  '.js': 'JavaScript',
+  '.mjs': 'JavaScript',
+  '.cjs': 'JavaScript',
+  '.jsx': 'JavaScript',
+  '.ts': 'TypeScript',
+  '.tsx': 'TypeScript',
+  '.py': 'Python',
+  '.java': 'Java',
+  '.go': 'Go',
+  '.rs': 'Rust',
+  '.rb': 'Ruby',
+  '.php': 'PHP',
+  '.cs': 'C#',
+  '.cpp': 'C++',
+  '.c': 'C',
+  '.h': 'C',
+  '.hpp': 'C++',
+  '.swift': 'Swift',
+  '.kt': 'Kotlin',
+  '.scala': 'Scala',
+  '.r': 'R',
+  '.jl': 'Julia',
+  '.lua': 'Lua',
+  '.sh': 'Shell',
+  '.bash': 'Shell',
+  '.zsh': 'Shell'
+};
+
+/**
+ * Language detection from config files
+ */
+const CONFIG_FILES = {
+  'tsconfig.json': 'TypeScript',
+  'jsconfig.json': 'JavaScript',
+  'package.json': 'JavaScript',
+  'requirements.txt': 'Python',
+  'setup.py': 'Python',
+  'Pipfile': 'Python',
+  'pyproject.toml': 'Python',
+  'go.mod': 'Go',
+  'Cargo.toml': 'Rust',
+  'pom.xml': 'Java',
+  'build.gradle': 'Java',
+  'Gemfile': 'Ruby',
+  'composer.json': 'PHP'
+};
+
+/**
+ * Detect languages from file list
+ *
+ * @param {string[]} files - Array of file paths relative to project root
+ * @param {string} projectRoot - Absolute path to project root
+ * @returns {Promise<Object[]>} Array of detected languages with confidence scores
+ */
+export async function detectLanguages(files, projectRoot) {
+  const languageCounts = {};
+  const configEvidence = {};
+
+  // Count files by extension
+  for (const file of files) {
+    const ext = path.extname(file).toLowerCase();
+    const language = LANGUAGE_EXTENSIONS[ext];
+
+    if (language) {
+      if (!languageCounts[language]) {
+        languageCounts[language] = { files: 0, extensions: new Set() };
+      }
+      languageCounts[language].files++;
+      languageCounts[language].extensions.add(ext);
+    }
+
+    // Check for config files
+    const basename = path.basename(file);
+    const configLang = CONFIG_FILES[basename];
+    if (configLang) {
+      configEvidence[configLang] = (configEvidence[configLang] || 0) + 1;
+    }
+  }
+
+  // Calculate confidence scores
+  const totalFiles = files.length;
+  const languages = [];
+
+  for (const [language, data] of Object.entries(languageCounts)) {
+    const filePercentage = (data.files / totalFiles) * 100;
+    const configBonus = configEvidence[language] ? 10 : 0;
+    const extensionDiversity = data.extensions.size > 1 ? 5 : 0;
+
+    let confidence = Math.min(95, Math.round(filePercentage * 0.8 + configBonus + extensionDiversity));
+
+    // TypeScript bonus: if tsconfig.json exists
+    if (language === 'TypeScript' && configEvidence['TypeScript']) {
+      confidence = Math.min(95, confidence + 10);
+    }
+
+    languages.push({
+      name: language,
+      confidence,
+      files: data.files,
+      percentage: Math.round(filePercentage * 10) / 10,
+      extensions: Array.from(data.extensions)
+    });
+  }
+
+  // Sort by file count descending
+  languages.sort((a, b) => b.files - a.files);
+
+  return languages;
+}
+
+/**
+ * Detect primary language (highest confidence)
+ *
+ * @param {Object[]} languages - Array of detected languages
+ * @returns {Object|null} Primary language or null if none detected
+ */
+export function getPrimaryLanguage(languages) {
+  if (languages.length === 0) return null;
+
+  // Return language with highest confidence
+  return languages.reduce((prev, current) =>
+    current.confidence > prev.confidence ? current : prev
+  );
+}
+
+/**
+ * Analyze language-specific patterns in content
+ *
+ * @param {string} content - File content to analyze
+ * @param {string} language - Language to check for
+ * @returns {Object} Pattern detection result
+ */
+export function analyzeLanguagePatterns(content, language) {
+  const patterns = {
+    TypeScript: {
+      features: [
+        { name: 'interfaces', regex: /interface\s+\w+/g },
+        { name: 'types', regex: /type\s+\w+\s*=/g },
+        { name: 'generics', regex: /<[A-Z]\w*>/g },
+        { name: 'decorators', regex: /@\w+/g }
+      ]
+    },
+    JavaScript: {
+      features: [
+        { name: 'async/await', regex: /async\s+function|await\s+/g },
+        { name: 'arrow functions', regex: /=>\s*{|=>\s*\w+/g },
+        { name: 'destructuring', regex: /const\s*{[^}]+}\s*=/g },
+        { name: 'template literals', regex: /`[^`]*\${[^}]*}[^`]*`/g }
+      ]
+    },
+    Python: {
+      features: [
+        { name: 'classes', regex: /class\s+\w+:/g },
+        { name: 'decorators', regex: /@\w+/g },
+        { name: 'list comprehensions', regex: /\[[^\]]+for\s+\w+\s+in\s+[^\]]+\]/g },
+        { name: 'type hints', regex: /:\s*\w+\s*(?:=|\))/g }
+      ]
+    }
+  };
+
+  const langPatterns = patterns[language];
+  if (!langPatterns) {
+    return { detected: false };
+  }
+
+  const detected = {};
+  for (const { name, regex } of langPatterns.features) {
+    const matches = content.match(regex);
+    detected[name] = matches ? matches.length : 0;
+  }
+
+  return {
+    detected: true,
+    features: detected
+  };
+}
+
+export default {
+  detectLanguages,
+  getPrimaryLanguage,
+  analyzeLanguagePatterns
+};