@itz4blitz/agentful 1.2.0 → 1.3.0

package/lib/core/detectors/conventions.js

@@ -1,342 +0,0 @@
-import path from 'path';
-import fs from 'fs/promises';
-
-/**
- * Convention Detector
- *
- * Extracts coding conventions and style guidelines:
- * - Naming conventions (camelCase, PascalCase, snake_case, kebab-case)
- * - File structure organization (feature-based, layer-based, domain-driven)
- * - Code style (indentation, quotes, semicolons)
- * - Import style (named, default, relative vs absolute)
- */
-
-/**
- * Detect naming conventions from files
- *
- * @param {string[]} files - Array of file paths
- * @returns {Object} Naming convention analysis
- */
-export function detectNamingConventions(files) {
-  const patterns = {
-    camelCase: 0,
-    PascalCase: 0,
-    'snake_case': 0,
-    'kebab-case': 0
-  };
-
-  for (const file of files) {
-    const basename = path.basename(file, path.extname(file));
-
-    if (/^[a-z][a-zA-Z0-9]*$/.test(basename)) {
-      patterns.camelCase++;
-    } else if (/^[A-Z][a-zA-Z0-9]*$/.test(basename)) {
-      patterns.PascalCase++;
-    } else if (/^[a-z][a-z0-9_]*$/.test(basename)) {
-      patterns['snake_case']++;
-    } else if (/^[a-z][a-z0-9-]*$/.test(basename)) {
-      patterns['kebab-case']++;
-    }
-  }
-
-  // Determine dominant pattern
-  const sortedPatterns = Object.entries(patterns)
-    .sort(([, a], [, b]) => b - a);
-
-  const totalFiles = files.length;
-  const [dominant, count] = sortedPatterns[0];
-  const confidence = totalFiles > 0 ? Math.round((count / totalFiles) * 100) : 0;
-
-  return {
-    dominant,
-    confidence,
-    distribution: patterns
-  };
-}
-
-/**
- * Detect file structure organization
- *
- * @param {string[]} files - Array of file paths
- * @returns {Object} File structure analysis
- */
-export function detectFileStructure(files) {
-  const indicators = {
-    'feature-based': 0,
-    'layer-based': 0,
-    'domain-driven': 0,
-    'atomic': 0
-  };
-
-  // Feature-based indicators
-  const hasFeatureDirs = files.some(file =>
-    file.includes('/features/') || file.match(/\/[a-z]+-feature\//)
-  );
-  if (hasFeatureDirs) indicators['feature-based'] += 3;
-
-  // Layer-based indicators (controllers, models, views pattern)
-  const layers = ['controllers', 'models', 'views', 'services', 'repositories'];
-  const layerCount = layers.filter(layer =>
-    files.some(file => file.includes(`/${layer}/`))
-  ).length;
-  indicators['layer-based'] = layerCount;
-
-  // Domain-driven indicators
-  const hasDomains = files.some(file =>
-    file.includes('/domains/') || file.includes('/domain/')
-  );
-  const hasAggregates = files.some(file =>
-    file.includes('/aggregates/') || file.includes('/entities/')
-  );
-  if (hasDomains || hasAggregates) {
-    indicators['domain-driven'] += 2;
-  }
-
-  // Atomic design indicators
-  const hasAtoms = files.some(file =>
-    file.includes('/atoms/') || file.includes('/molecules/') || file.includes('/organisms/')
-  );
-  if (hasAtoms) indicators['atomic'] += 3;
-
-  // Determine dominant structure
-  const sortedIndicators = Object.entries(indicators)
-    .sort(([, a], [, b]) => b - a);
-
-  const [structure, score] = sortedIndicators[0];
-
-  return {
-    structure: score > 0 ? structure : 'mixed',
-    confidence: Math.min(90, score * 20),
-    indicators
-  };
-}
-
-/**
- * Detect code style conventions from file content
- *
- * @param {string} content - File content to analyze
- * @returns {Object} Code style analysis
- */
-export function detectCodeStyle(content) {
-  const style = {
-    indentation: 'unknown',
-    quotes: 'unknown',
-    semicolons: 'unknown',
-    trailingCommas: 'unknown'
-  };
-
-  // Detect indentation
-  const lines = content.split('\n');
-  let twoSpaces = 0;
-  let fourSpaces = 0;
-  let tabs = 0;
-
-  for (const line of lines) {
-    const match = line.match(/^(\s+)/);
-    if (match) {
-      const indent = match[1];
-      if (indent === '  ') twoSpaces++;
-      else if (indent === '    ') fourSpaces++;
-      else if (indent.includes('\t')) tabs++;
-    }
-  }
-
-  if (twoSpaces > fourSpaces && twoSpaces > tabs) {
-    style.indentation = '2 spaces';
-  } else if (fourSpaces > twoSpaces && fourSpaces > tabs) {
-    style.indentation = '4 spaces';
-  } else if (tabs > twoSpaces && tabs > fourSpaces) {
-    style.indentation = 'tabs';
-  }
-
-  // Detect quotes
-  const singleQuotes = (content.match(/'\w+'/g) || []).length;
-  const doubleQuotes = (content.match(/"\w+"/g) || []).length;
-  const backticks = (content.match(/`[^`]+`/g) || []).length;
-
-  if (singleQuotes > doubleQuotes && singleQuotes > backticks) {
-    style.quotes = 'single';
-  } else if (doubleQuotes > singleQuotes && doubleQuotes > backticks) {
-    style.quotes = 'double';
-  } else if (backticks > 0) {
-    style.quotes = 'template literals preferred';
-  }
-
-  // Detect semicolons
-  const withSemicolon = (content.match(/;$/gm) || []).length;
-  const withoutSemicolon = (content.match(/[^;{}\s]$/gm) || []).length;
-
-  style.semicolons = withSemicolon > withoutSemicolon ? 'required' : 'omitted';
-
-  // Detect trailing commas
-  const trailingCommas = (content.match(/,\s*[\]}]/g) || []).length;
-  style.trailingCommas = trailingCommas > 5 ? 'preferred' : 'avoided';
-
-  return style;
-}
-
-/**
- * Detect import style conventions
- *
- * @param {string} content - File content to analyze
- * @returns {Object} Import style analysis
- */
-export function detectImportStyle(content) {
-  const style = {
-    namedImports: 0,
-    defaultImports: 0,
-    namespaceImports: 0,
-    relativeImports: 0,
-    absoluteImports: 0,
-    aliasedImports: 0
-  };
-
-  const importRegex = /import\s+(?:{[^}]+}|[\w]+|\*\s+as\s+[\w]+)\s+from\s+['"]([^'"]+)['"]/g;
-  let match;
-
-  while ((match = importRegex.exec(content)) !== null) {
-    const importStatement = match[0];
-    const importPath = match[1];
-
-    // Count import types
-    if (importStatement.includes('{')) {
-      style.namedImports++;
-    } else if (importStatement.includes('* as')) {
-      style.namespaceImports++;
-    } else {
-      style.defaultImports++;
-    }
-
-    // Count path types
-    if (importPath.startsWith('.')) {
-      style.relativeImports++;
-    } else if (importPath.startsWith('@/') || importPath.startsWith('~/')) {
-      style.aliasedImports++;
-    } else {
-      style.absoluteImports++;
-    }
-  }
-
-  // Determine preferences
-  const total = style.namedImports + style.defaultImports + style.namespaceImports;
-  const preference = total > 0 ? {
-    importType: style.namedImports > style.defaultImports ? 'named' : 'default',
-    pathStyle: style.aliasedImports > style.relativeImports ? 'aliased' :
-               style.relativeImports > 0 ? 'relative' : 'absolute'
-  } : null;
-
-  return {
-    ...style,
-    preference
-  };
-}
-
-/**
- * Detect ESLint/Prettier configuration
- *
- * @param {string[]} files - Array of file paths
- * @param {string} projectRoot - Absolute path to project root
- * @returns {Promise<Object>} Linting configuration
- */
-export async function detectLintingConfig(files, projectRoot) {
-  const config = {
-    eslint: false,
-    prettier: false,
-    styleGuide: null
-  };
-
-  // Check for config files
-  const hasEslint = files.some(file =>
-    file.endsWith('.eslintrc') ||
-    file.endsWith('.eslintrc.js') ||
-    file.endsWith('.eslintrc.json') ||
-    file.endsWith('eslint.config.js')
-  );
-
-  const hasPrettier = files.some(file =>
-    file.endsWith('.prettierrc') ||
-    file.endsWith('.prettierrc.js') ||
-    file.endsWith('.prettierrc.json') ||
-    file.endsWith('prettier.config.js')
-  );
-
-  config.eslint = hasEslint;
-  config.prettier = hasPrettier;
-
-  // Try to detect style guide from package.json
-  try {
-    const packageJsonPath = path.join(projectRoot, 'package.json');
-    const content = await fs.readFile(packageJsonPath, 'utf-8');
-    const packageJson = JSON.parse(content);
-
-    const allDeps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-
-    if (allDeps['eslint-config-airbnb']) {
-      config.styleGuide = 'airbnb';
-    } else if (allDeps['eslint-config-standard']) {
-      config.styleGuide = 'standard';
-    } else if (allDeps['eslint-config-google']) {
-      config.styleGuide = 'google';
-    } else if (allDeps['@typescript-eslint/eslint-plugin']) {
-      config.styleGuide = 'typescript';
-    }
-  } catch (error) {
-    // Can't read package.json, skip style guide detection
-  }
-
-  return config;
-}
-
-/**
- * Detect all conventions in project
- *
- * @param {string[]} files - Array of file paths
- * @param {string} projectRoot - Absolute path to project root
- * @returns {Promise<Object>} All detected conventions
- */
-export async function detectConventions(files, projectRoot) {
-  const naming = detectNamingConventions(files);
-  const fileStructure = detectFileStructure(files);
-  const linting = await detectLintingConfig(files, projectRoot);
-
-  // Sample a few files for code style analysis
-  let codeStyle = null;
-  let importStyle = null;
-
-  const sampleFiles = files
-    .filter(file => /\.(js|ts|jsx|tsx)$/.test(file))
-    .slice(0, 3);
-
-  if (sampleFiles.length > 0) {
-    try {
-      const samplePath = path.join(projectRoot, sampleFiles[0]);
-      const content = await fs.readFile(samplePath, 'utf-8');
-      codeStyle = detectCodeStyle(content);
-      importStyle = detectImportStyle(content);
-    } catch (error) {
-      // Can't read sample file, skip style detection
-    }
-  }
-
-  return {
-    naming: naming.dominant,
-    namingConfidence: naming.confidence,
-    fileStructure: fileStructure.structure,
-    structureConfidence: fileStructure.confidence,
-    codeStyle,
-    importStyle,
-    linting
-  };
-}
-
-export default {
-  detectConventions,
-  detectNamingConventions,
-  detectFileStructure,
-  detectCodeStyle,
-  detectImportStyle,
-  detectLintingConfig
-};

package/lib/core/detectors/framework.js

@@ -1,276 +0,0 @@
-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

@@ -1,15 +0,0 @@
-/**
- * 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';