@howlil/ez-agents 3.4.2 → 4.0.0

package/ez-agents/bin/lib/stack-detector.cjs

@@ -0,0 +1,399 @@
+/**
+ * Stack Detector — Automated technology stack detection from package manifests and config files
+ * 
+ * Provides:
+ * - detect(rootPath): Returns languages, runtime, packageManager, frameworks, databases, infrastructure
+ * - detectPackageManifests(rootPath): Finds and parses manifest files
+ * - detectPackageManager(rootPath): Delegates to PackageManagerDetector
+ * - detectFrameworks(dependencies): Maps package names to framework names
+ * - detectDatabases(dependencies): Maps ORM/db packages to database names
+ * - detectInfrastructure(dependencies): Maps cloud/monitoring/testing packages
+ */
+
+const fs = require('fs');
+const path = require('path');
+const PackageManagerDetector = require('./package-manager-detector.cjs');
+
+class StackDetector {
+  constructor(rootPath) {
+    this.rootPath = rootPath;
+    this.pmDetector = new PackageManagerDetector(rootPath);
+  }
+
+  /**
+   * Detect technology stack from root path
+   * @param {string} rootPath - Root directory to analyze
+   * @returns {object} Stack object with language, runtime, packageManager, frameworks, databases, infrastructure
+   */
+  detect(rootPath = this.rootPath) {
+    const manifests = this.detectPackageManifests(rootPath);
+    const packageManager = this.detectPackageManager(rootPath);
+
+    let result = {
+      language: 'unknown',
+      runtime: 'unknown',
+      packageManager,
+      frameworks: [],
+      databases: [],
+      infrastructure: [],
+      manifests
+    };
+
+    // Parse package.json if exists
+    if (manifests.node) {
+      const pkgPath = path.join(rootPath, manifests.node);
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        const dependencies = {
+          ...pkg.dependencies,
+          ...pkg.devDependencies,
+          ...pkg.peerDependencies
+        };
+
+        result.language = 'javascript';
+        result.runtime = 'node';
+        result.runtimeVersion = pkg.engines?.node || '>=16.0.0';
+        result.frameworks = this.detectFrameworks(dependencies);
+        result.databases = this.detectDatabases(dependencies);
+        result.infrastructure = this.detectInfrastructure(dependencies);
+      } catch (err) {
+        // Ignore parse errors
+      }
+    }
+
+    // Check for other languages
+    if (manifests.python) {
+      result.language = 'python';
+      result.runtime = 'python';
+    }
+    if (manifests.ruby) {
+      result.language = 'ruby';
+      result.runtime = 'ruby';
+    }
+    if (manifests.php) {
+      result.language = 'php';
+      result.runtime = 'php';
+    }
+    if (manifests.java) {
+      result.language = 'java';
+      result.runtime = 'jvm';
+    }
+    if (manifests.go) {
+      result.language = 'go';
+      result.runtime = 'go';
+    }
+    if (manifests.rust) {
+      result.language = 'rust';
+      result.runtime = 'rust';
+    }
+
+    return result;
+  }
+
+  /**
+   * Detect package manifests in root path
+   * @param {string} rootPath - Root directory to analyze
+   * @returns {object} Object with found manifest files
+   */
+  detectPackageManifests(rootPath = this.rootPath) {
+    const manifests = {};
+
+    const manifestMap = {
+      node: ['package.json'],
+      python: ['requirements.txt', 'pyproject.toml', 'setup.py', 'Pipfile'],
+      ruby: ['Gemfile'],
+      php: ['composer.json'],
+      java: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
+      go: ['go.mod'],
+      rust: ['Cargo.toml']
+    };
+
+    for (const [lang, files] of Object.entries(manifestMap)) {
+      for (const file of files) {
+        const fullPath = path.join(rootPath, file);
+        if (fs.existsSync(fullPath)) {
+          manifests[lang] = file;
+          break;
+        }
+      }
+    }
+
+    return manifests;
+  }
+
+  /**
+   * Detect package manager
+   * @param {string} rootPath - Root directory to analyze
+   * @returns {string} Package manager name (npm, yarn, pnpm)
+   */
+  detectPackageManager(rootPath = this.rootPath) {
+    const result = this.pmDetector.detect();
+    if (result && typeof result === 'object' && result.manager) {
+      return result.manager;
+    }
+    return result || 'npm';
+  }
+
+  /**
+   * Detect frameworks from dependencies
+   * @param {object} dependencies - Dependencies object from package.json
+   * @returns {Array} Array of framework names
+   */
+  detectFrameworks(dependencies = {}) {
+    const frameworkMap = {
+      // Frontend
+      'react': 'React',
+      'next': 'Next.js',
+      'vue': 'Vue.js',
+      'nuxt': 'Nuxt.js',
+      '@angular/core': 'Angular',
+      'svelte': 'Svelte',
+      'solid-js': 'SolidJS',
+      // Backend
+      'express': 'Express',
+      'fastify': 'Fastify',
+      '@nestjs/core': 'NestJS',
+      'nest': 'NestJS',
+      'koa': 'Koa',
+      'hapi': 'Hapi',
+      '@hapi/hapi': 'Hapi',
+      // Full-stack
+      'remix': 'Remix',
+      // Mobile
+      'react-native': 'React Native',
+      // Python
+      'django': 'Django',
+      'flask': 'Flask',
+      'fastapi': 'FastAPI',
+      // Ruby
+      'rails': 'Ruby on Rails',
+      'sinatra': 'Sinatra',
+      // PHP
+      'laravel/framework': 'Laravel',
+      'symfony': 'Symfony',
+      // Java
+      'spring-boot': 'Spring Boot',
+      'quarkus': 'Quarkus',
+      // Build/Dev
+      'vite': 'Vite',
+      'webpack': 'Webpack',
+      'rollup': 'Rollup',
+      'parcel': 'Parcel',
+      // CSS
+      'tailwindcss': 'Tailwind CSS',
+      'bootstrap': 'Bootstrap',
+      '@mui/material': 'Material-UI',
+      '@chakra-ui/react': 'Chakra UI',
+      'antd': 'Ant Design'
+    };
+
+    const detected = [];
+    for (const [pkg, name] of Object.entries(frameworkMap)) {
+      if (dependencies[pkg]) {
+        detected.push(name);
+      }
+    }
+
+    return detected;
+  }
+
+  /**
+   * Detect databases from dependencies
+   * @param {object} dependencies - Dependencies object from package.json
+   * @returns {Array} Array of database names
+   */
+  detectDatabases(dependencies = {}) {
+    const dbMap = {
+      'pg': 'PostgreSQL',
+      'postgres': 'PostgreSQL',
+      'mysql2': 'MySQL',
+      'mysql': 'MySQL',
+      'sqlite3': 'SQLite',
+      'better-sqlite3': 'SQLite',
+      'mssql': 'SQL Server',
+      'tedious': 'SQL Server',
+      'oracledb': 'Oracle',
+      'mongoose': 'MongoDB',
+      'mongodb': 'MongoDB',
+      'redis': 'Redis',
+      'ioredis': 'Redis',
+      'prisma': 'Prisma (ORM)',
+      '@prisma/client': 'Prisma',
+      'typeorm': 'TypeORM',
+      'sequelize': 'Sequelize',
+      'knex': 'Knex.js',
+      'drizzle-orm': 'Drizzle ORM',
+      'objection': 'Objection.js',
+      'bookshelf': 'Bookshelf',
+      'waterline': 'Waterline',
+      'rethinkdb': 'RethinkDB',
+      'cassandra-driver': 'Cassandra',
+      'neo4j-driver': 'Neo4j'
+    };
+
+    const detected = [];
+    for (const [pkg, name] of Object.entries(dbMap)) {
+      if (dependencies[pkg]) {
+        detected.push(name);
+      }
+    }
+
+    return detected;
+  }
+
+  /**
+   * Detect infrastructure from dependencies
+   * @param {object} dependencies - Dependencies object from package.json
+   * @returns {Array} Array of infrastructure names
+   */
+  detectInfrastructure(dependencies = {}) {
+    const infraMap = {
+      // Cloud
+      '@aws-sdk/*': 'AWS SDK',
+      '@aws-sdk': 'AWS SDK',
+      'aws-sdk': 'AWS SDK v2',
+      '@azure/*': 'Azure SDK',
+      '@azure': 'Azure SDK',
+      '@google-cloud/*': 'Google Cloud SDK',
+      // Serverless
+      'serverless': 'Serverless Framework',
+      // Containers
+      'dockerode': 'Docker',
+      '@docker/cli': 'Docker',
+      // Monitoring/Logging
+      'winston': 'Winston (logging)',
+      'pino': 'Pino (logging)',
+      'bunyan': 'Bunyan (logging)',
+      '@sentry/node': 'Sentry',
+      '@sentry/*': 'Sentry',
+      'datadog-metrics': 'Datadog',
+      'newrelic': 'New Relic',
+      // Testing
+      'jest': 'Jest',
+      'vitest': 'Vitest',
+      'mocha': 'Mocha',
+      'chai': 'Chai',
+      'cypress': 'Cypress',
+      'playwright': 'Playwright',
+      '@testing-library/*': 'Testing Library',
+      '@testing-library': 'Testing Library',
+      'puppeteer': 'Puppeteer',
+      // CI/CD
+      'semantic-release': 'Semantic Release',
+      // Auth
+      'next-auth': 'NextAuth.js',
+      '@auth/core': 'Auth.js',
+      'passport': 'Passport',
+      'jsonwebtoken': 'JWT',
+      'bcrypt': 'bcrypt',
+      'argon2': 'Argon2'
+    };
+
+    const detected = [];
+    for (const [pkg, name] of Object.entries(infraMap)) {
+      const pattern = pkg.replace('*', '.*');
+      const regex = new RegExp(`^${pattern}$`);
+      if (Object.keys(dependencies).some(k => regex.test(k) || k.startsWith(pkg.replace('/*', '')))) {
+        if (!detected.includes(name)) {
+          detected.push(name);
+        }
+      }
+    }
+
+    return detected;
+  }
+
+  /**
+   * Detect languages from file structure
+   * @param {object} structure - Structure object from CodebaseAnalyzer
+   * @returns {object} Object with language counts
+   */
+  detectLanguages(structure) {
+    const languageDetectors = {
+      '.ts': 'typescript',
+      '.tsx': 'typescript',
+      '.js': 'javascript',
+      '.jsx': 'javascript',
+      '.py': 'python',
+      '.rb': 'ruby',
+      '.go': 'go',
+      '.java': 'java',
+      '.php': 'php',
+      '.rs': 'rust',
+      '.cs': 'csharp',
+      '.swift': 'swift',
+      '.kt': 'kotlin',
+      '.scala': 'scala',
+      '.clj': 'clojure',
+      '.ex': 'elixir',
+      '.exs': 'elixir',
+      '.erl': 'erlang',
+      '.hs': 'haskell',
+      '.ml': 'ocaml',
+      '.r': 'r',
+      '.R': 'r',
+      '.sql': 'sql',
+      '.sh': 'shell',
+      '.bash': 'shell'
+    };
+
+    const languages = {};
+    const files = structure?.files || [];
+
+    for (const file of files) {
+      const ext = path.extname(file);
+      const lang = languageDetectors[ext] || 'unknown';
+      languages[lang] = (languages[lang] || 0) + 1;
+    }
+
+    return languages;
+  }
+
+  /**
+   * Detect config files in root path
+   * @param {string} rootPath - Root directory to analyze
+   * @returns {object} Object with found config files
+   */
+  detectConfigFiles(rootPath = this.rootPath) {
+    const configPatterns = {
+      typescript: 'tsconfig.json',
+      jsconfig: 'jsconfig.json',
+      vite: 'vite.config.js',
+      webpack: 'webpack.config.js',
+      rollup: 'rollup.config.js',
+      eslint: '.eslintrc.js',
+      prettier: '.prettierrc',
+      next: 'next.config.js',
+      nuxt: 'nuxt.config.js',
+      remix: 'remix.config.js',
+      prisma: 'prisma/schema.prisma',
+      jest: 'jest.config.js',
+      vitest: 'vitest.config.js',
+      cypress: 'cypress.config.js',
+      docker: 'Dockerfile',
+      dockerCompose: 'docker-compose.yml',
+      serverless: 'serverless.yml',
+      vercel: 'vercel.json',
+      netlify: 'netlify.toml',
+      heroku: 'Procfile',
+      github: '.github/workflows',
+      gitlab: '.gitlab-ci.yml',
+      circle: '.circleci/config.yml'
+    };
+
+    const configs = {};
+    for (const [key, pattern] of Object.entries(configPatterns)) {
+      const fullPath = path.join(rootPath, pattern);
+      if (fs.existsSync(fullPath)) {
+        configs[key] = {
+          path: fullPath,
+          exists: true
+        };
+      }
+    }
+
+    return configs;
+  }
+}
+
+module.exports = { StackDetector };

package/ez-agents/bin/lib/tech-debt-analyzer.cjs

@@ -0,0 +1,309 @@
+/**
+ * Tech Debt Analyzer — Automated tech debt hotspot identification
+ * 
+ * Provides:
+ * - detectDebtMarkers(rootPath): Finds TODO/FIXME/HACK/XXX/BUG/DEPRECATED comments with severity scores
+ * - analyzeDependencyRisk(rootPath): npm audit parsing for vulnerabilities
+ * - aggregateFindings(debtMarkers, complexityIssues, largeFiles, duplicates): Combines all findings with severity scores
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+class TechDebtAnalyzer {
+  constructor(rootPath) {
+    this.rootPath = rootPath;
+    this.patterns = [
+      { marker: 'TODO', severity: 'Low', weight: 1 },
+      { marker: 'FIXME', severity: 'Medium', weight: 2 },
+      { marker: 'HACK', severity: 'Medium', weight: 2 },
+      { marker: 'XXX', severity: 'High', weight: 3 },
+      { marker: 'BUG', severity: 'High', weight: 3 },
+      { marker: 'DEPRECATED', severity: 'Critical', weight: 4 },
+      { marker: 'OPTIMIZE', severity: 'Low', weight: 1 },
+      { marker: 'REFACTOR', severity: 'Medium', weight: 2 }
+    ];
+  }
+
+  /**
+   * Detect debt markers in codebase
+   * @param {string} rootPath - Root directory to analyze
+   * @returns {Array} Array of debt marker objects with file, line, marker, severity, weight, content
+   */
+  detectDebtMarkers(rootPath = this.rootPath) {
+    const results = [];
+    const srcDirs = ['src', 'app', 'lib', 'commands', 'bin', 'agents', 'hooks'];
+
+    // Try grep first (Unix-like systems), fallback to pure JS for Windows
+    for (const pattern of this.patterns) {
+      for (const srcDir of srcDirs) {
+        const searchPath = path.join(rootPath, srcDir);
+        if (!fs.existsSync(searchPath)) continue;
+
+        // Try grep on Unix-like systems
+        try {
+          const output = execSync(
+            `grep -rn "${pattern.marker}" "${searchPath}" --include="*.ts" --include="*.tsx" --include="*.js" --include="*.cjs" --include="*.mjs" 2>nul`,
+            { cwd: rootPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }
+          );
+
+          const lines = output.trim().split('\n');
+          for (const line of lines) {
+            if (!line.trim()) continue;
+
+            const parts = line.split(':');
+            if (parts.length < 3) continue;
+
+            const filePath = parts[0];
+            const lineNum = parseInt(parts[1], 10);
+            const content = parts.slice(2).join(':').trim();
+
+            results.push({
+              file: filePath,
+              line: lineNum,
+              marker: pattern.marker,
+              severity: pattern.severity,
+              weight: pattern.weight,
+              content: content.substring(0, 200),
+              age: null
+            });
+          }
+        } catch (err) {
+          // grep not available or no matches, use fallback
+          if (err.code === 'ENOENT' || err.status === 1) {
+            // Use pure JavaScript fallback
+            const fallbackResults = this._detectDebtMarkersJS(searchPath, pattern);
+            results.push(...fallbackResults);
+          }
+          // Other errors are ignored (grep returns non-zero if no matches)
+        }
+      }
+    }
+
+    // Sort by severity (Critical first)
+    results.sort((a, b) => b.weight - a.weight || a.file.localeCompare(b.file));
+
+    return results;
+  }
+
+  /**
+   * Pure JavaScript fallback for debt marker detection (Windows compatibility)
+   * @private
+   */
+  _detectDebtMarkersJS(dir, pattern) {
+    const results = [];
+    const fileExtensions = ['.ts', '.tsx', '.js', '.cjs', '.mjs'];
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          // Recurse into subdirectory
+          results.push(...this._detectDebtMarkersJS(fullPath, pattern));
+        } else if (entry.isFile() && fileExtensions.includes(path.extname(entry.name))) {
+          try {
+            const content = fs.readFileSync(fullPath, 'utf8');
+            const lines = content.split('\n');
+
+            for (let i = 0; i < lines.length; i++) {
+              const line = lines[i];
+              if (line.includes(pattern.marker)) {
+                results.push({
+                  file: fullPath,
+                  line: i + 1,
+                  marker: pattern.marker,
+                  severity: pattern.severity,
+                  weight: pattern.weight,
+                  content: line.trim().substring(0, 200),
+                  age: null
+                });
+              }
+            }
+          } catch (err) {
+            // Ignore read errors
+          }
+        }
+      }
+    } catch (err) {
+      // Ignore directory read errors
+    }
+
+    return results;
+  }
+
+  /**
+   * Analyze dependency risk from npm audit
+   * @param {string} rootPath - Root directory to analyze
+   * @returns {Array} Array of vulnerability objects with type, package, severity, message, score
+   */
+  analyzeDependencyRisk(rootPath = this.rootPath) {
+    const risks = [];
+
+    try {
+      const auditOutput = execSync('npm audit --json', {
+        cwd: rootPath,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'ignore']
+      });
+
+      const audit = JSON.parse(auditOutput);
+      const vulnerabilities = audit.vulnerabilities || {};
+
+      for (const [pkgName, vuln] of Object.entries(vulnerabilities)) {
+        const severity = vuln.severity || 'medium';
+        const score = severity === 'critical' ? 4 : severity === 'high' ? 3 : severity === 'medium' ? 2 : 1;
+
+        risks.push({
+          type: 'security',
+          package: pkgName,
+          severity: severity.charAt(0).toUpperCase() + severity.slice(1),
+          message: `${pkgName}@${vuln.vulnerable_versions || 'unknown'} has ${severity} vulnerability`,
+          score,
+          via: vuln.via || [],
+          recommendation: vuln.recommendation || 'Update to latest version'
+        });
+      }
+    } catch (err) {
+      // npm audit may fail or return no vulnerabilities
+      if (err.status !== 1) {
+        console.warn(`Warning: npm audit failed: ${err.message}`);
+      }
+    }
+
+    // Sort by severity
+    risks.sort((a, b) => b.score - a.score);
+
+    return risks;
+  }
+
+  /**
+   * Aggregate all findings into a single report
+   * @param {Array} debtMarkers - Debt markers from detectDebtMarkers
+   * @param {Array} complexityIssues - Complexity issues from CodeComplexityAnalyzer
+   * @param {Array} largeFiles - Large files from CodeComplexityAnalyzer
+   * @param {Array} duplicates - Duplicate code from CodeComplexityAnalyzer
+   * @param {Array} dependencyRisks - Dependency risks from analyzeDependencyRisk
+   * @returns {Array} Aggregated findings sorted by score
+   */
+  aggregateFindings(debtMarkers = [], complexityIssues = [], largeFiles = [], duplicates = [], dependencyRisks = []) {
+    const allFindings = [];
+
+    // Add debt markers
+    for (const marker of debtMarkers) {
+      allFindings.push({
+        ...marker,
+        type: 'debt_marker',
+        score: marker.weight,
+        description: `${marker.marker}: ${marker.content}`
+      });
+    }
+
+    // Add complexity issues
+    for (const issue of complexityIssues) {
+      allFindings.push({
+        ...issue,
+        type: 'complexity',
+        description: issue.message
+      });
+    }
+
+    // Add large files
+    for (const file of largeFiles) {
+      allFindings.push({
+        ...file,
+        type: 'large_file',
+        description: `Large file: ${file.lines} lines, ${file.sizeKB}KB`
+      });
+    }
+
+    // Add duplicates
+    for (const dup of duplicates) {
+      allFindings.push({
+        ...dup,
+        type: 'duplicate',
+        description: `Duplicate code in ${dup.fileCount} files`
+      });
+    }
+
+    // Add dependency risks
+    for (const risk of dependencyRisks) {
+      allFindings.push({
+        ...risk,
+        type: 'dependency',
+        description: risk.message
+      });
+    }
+
+    // Sort by score descending
+    allFindings.sort((a, b) => b.score - a.score || a.file?.localeCompare(b.file) || 0);
+
+    return allFindings;
+  }
+
+  /**
+   * Get summary of tech debt
+   * @param {Array} findings - Aggregated findings
+   * @returns {object} Summary object
+   */
+  getSummary(findings = []) {
+    const summary = {
+      total: findings.length,
+      byType: {},
+      bySeverity: {
+        Critical: 0,
+        High: 0,
+        Medium: 0,
+        Low: 0
+      },
+      topIssues: []
+    };
+
+    for (const finding of findings) {
+      // Count by type
+      summary.byType[finding.type] = (summary.byType[finding.type] || 0) + 1;
+
+      // Count by severity
+      const severity = finding.severity || 'Medium';
+      if (summary.bySeverity[severity] !== undefined) {
+        summary.bySeverity[severity]++;
+      }
+    }
+
+    // Get top 10 issues
+    summary.topIssues = findings.slice(0, 10);
+
+    return summary;
+  }
+
+  /**
+   * Get tech debt by file
+   * @param {Array} findings - Aggregated findings
+   * @returns {object} Object mapping file paths to their issues
+   */
+  getByFile(findings = []) {
+    const byFile = {};
+
+    for (const finding of findings) {
+      if (!finding.file) continue;
+
+      if (!byFile[finding.file]) {
+        byFile[finding.file] = {
+          file: finding.file,
+          issues: [],
+          totalScore: 0
+        };
+      }
+
+      byFile[finding.file].issues.push(finding);
+      byFile[finding.file].totalScore += finding.score || 0;
+    }
+
+    // Sort by total score
+    return Object.values(byFile).sort((a, b) => b.totalScore - a.totalScore);
+  }
+}
+
+module.exports = { TechDebtAnalyzer };