@howlil/ez-agents 3.5.0 → 4.0.0

package/ez-agents/bin/lib/finops/finops-analyzer.cjs

@@ -0,0 +1,112 @@
+/**
+ * FinOps Analyzer — Cloud resource cost analysis and rightsizing recommendations
+ * Analyzes resource usage and provides cost optimization recommendations
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class FinopsAnalyzer {
+  constructor(cwd) {
+    this.cwd = cwd || process.cwd();
+    this.costsPath = path.join(this.cwd, '.planning', 'finops', 'costs.json');
+    this.ensureFile();
+  }
+
+  /**
+   * Analyze cloud resource costs
+   * @param {Object} resources - Resource usage data
+   * @returns {Object} Cost analysis with recommendations
+   */
+  analyzeCosts(resources = {}) {
+    const analysis = {
+      timestamp: new Date().toISOString(),
+      totalCost: 0,
+      byResource: {},
+      byCategory: {},
+      recommendations: []
+    };
+
+    // Analyze each resource
+    for (const [name, resource] of Object.entries(resources)) {
+      const cost = resource.cost || 0;
+      const category = resource.category || 'other';
+
+      analysis.totalCost += cost;
+      analysis.byResource[name] = cost;
+
+      if (!analysis.byCategory[category]) {
+        analysis.byCategory[category] = 0;
+      }
+      analysis.byCategory[category] += cost;
+
+      // Generate rightsizing recommendations
+      if (resource.utilization < 30) {
+        analysis.recommendations.push({
+          resource: name,
+          type: 'rightsize',
+          reason: `Low utilization (${resource.utilization}%)`,
+          suggestion: 'Downsize instance or consolidate workloads',
+          potentialSavings: Math.round(cost * 0.4)
+        });
+      }
+    }
+
+    return analysis;
+  }
+
+  /**
+   * Get cost trend over time
+   * @returns {Array} Cost trend data
+   */
+  getTrend() {
+    if (!fs.existsSync(this.costsPath)) return [];
+    const costs = JSON.parse(fs.readFileSync(this.costsPath, 'utf8'));
+    return costs.trend || [];
+  }
+
+  /**
+   * Save cost data
+   * @param {Object} costData - Cost data to save
+   */
+  saveCostData(costData) {
+    const data = {
+      timestamp: new Date().toISOString(),
+      ...costData
+    };
+
+    let existing = { trend: [] };
+    if (fs.existsSync(this.costsPath)) {
+      existing = JSON.parse(fs.readFileSync(this.costsPath, 'utf8'));
+    }
+
+    existing.trend.push(data);
+    fs.writeFileSync(this.costsPath, JSON.stringify(existing, null, 2), 'utf8');
+  }
+
+  /**
+   * Ensure costs file exists
+   */
+  ensureFile() {
+    const dir = path.dirname(this.costsPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    if (!fs.existsSync(this.costsPath)) {
+      fs.writeFileSync(this.costsPath, '{"trend":[]}', 'utf8');
+    }
+  }
+}
+
+/**
+ * Analyze cloud resource costs
+ * @param {Object} resources - Resource usage data
+ * @param {string} cwd - Working directory
+ * @returns {Object} Cost analysis
+ */
+function analyzeCosts(resources = {}, cwd) {
+  const analyzer = new FinopsAnalyzer(cwd);
+  return analyzer.analyzeCosts(resources);
+}
+
+module.exports = { FinopsAnalyzer, analyzeCosts };

package/ez-agents/bin/lib/finops/spot-manager.cjs

@@ -0,0 +1,118 @@
+/**
+ * Spot Manager — Spot/preemptible instance management recommendations
+ * Analyzes workload patterns and recommends spot vs on-demand instances
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class SpotManager {
+  constructor(cwd) {
+    this.cwd = cwd || process.cwd();
+    this.recommendationsPath = path.join(this.cwd, '.planning', 'finops', 'spot-recommendations.json');
+  }
+
+  /**
+   * Analyze workload for spot instance suitability
+   * @param {Object} workload - Workload characteristics
+   * @returns {Object} Spot recommendations
+   */
+  analyzeWorkload(workload = {}) {
+    const recommendations = {
+      timestamp: new Date().toISOString(),
+      workloads: [],
+      totalPotentialSavings: 0
+    };
+
+    for (const [name, characteristics] of Object.entries(workload)) {
+      const suitability = this.calculateSpotSuitability(characteristics);
+      const savings = this.calculateSavings(characteristics.cost, suitability);
+
+      recommendations.workloads.push({
+        name,
+        spotSuitable: suitability.score >= 70,
+        suitabilityScore: suitability.score,
+        reasons: suitability.reasons,
+        currentCost: characteristics.cost,
+        potentialSavings: savings,
+        recommendation: suitability.score >= 70 ? 'Use spot instances' : 'Use on-demand'
+      });
+
+      recommendations.totalPotentialSavings += savings;
+    }
+
+    return recommendations;
+  }
+
+  /**
+   * Calculate spot suitability score
+   * @param {Object} characteristics - Workload characteristics
+   * @returns {Object} Suitability analysis
+   */
+  calculateSpotSuitability(characteristics) {
+    let score = 50; // Base score
+    const reasons = [];
+
+    // Fault tolerant workloads are good for spot
+    if (characteristics.faultTolerant) {
+      score += 30;
+      reasons.push('Fault tolerant workload');
+    }
+
+    // Batch processing is good for spot
+    if (characteristics.batchProcessing) {
+      score += 20;
+      reasons.push('Batch processing workload');
+    }
+
+    // Stateful workloads are bad for spot
+    if (characteristics.stateful) {
+      score -= 20;
+      reasons.push('Stateful workload (checkpointing recommended)');
+    }
+
+    // Time-sensitive workloads are bad for spot
+    if (characteristics.timeSensitive) {
+      score -= 30;
+      reasons.push('Time-sensitive workload');
+    }
+
+    return {
+      score: Math.min(100, Math.max(0, score)),
+      reasons
+    };
+  }
+
+  /**
+   * Calculate potential savings from spot
+   * @param {number} currentCost - Current on-demand cost
+   * @param {number} suitability - Suitability score
+   * @returns {number} Potential savings
+   */
+  calculateSavings(currentCost, suitability) {
+    // Spot instances typically 60-90% cheaper
+    const savingsRate = 0.7;
+    return Math.round(currentCost * savingsRate * (suitability / 100));
+  }
+
+  /**
+   * Save recommendations
+   * @param {Object} recommendations - Recommendations to save
+   */
+  saveRecommendations(recommendations) {
+    fs.writeFileSync(this.recommendationsPath, JSON.stringify(recommendations, null, 2), 'utf8');
+  }
+}
+
+/**
+ * Analyze workload for spot suitability
+ * @param {Object} workload - Workload characteristics
+ * @param {string} cwd - Working directory
+ * @returns {Object} Spot recommendations
+ */
+function analyzeWorkload(workload = {}, cwd) {
+  const manager = new SpotManager(cwd);
+  return manager.analyzeWorkload(workload);
+}
+
+module.exports = { SpotManager, analyzeWorkload };

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

@@ -0,0 +1,396 @@
+/**
+ * Framework Detector — Detailed framework detection from config files and imports
+ * 
+ * Provides:
+ * - detectFromConfig(rootPath): Analyzes config files for framework confirmation
+ * - detectFromImports(sourceFiles): Analyzes import statements for framework usage
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class FrameworkDetector {
+  constructor(rootPath) {
+    this.rootPath = rootPath;
+  }
+
+  /**
+   * Detect frameworks from config files
+   * @param {string} rootPath - Root directory to analyze
+   * @returns {object} Object with detected frameworks from configs
+   */
+  detectFromConfig(rootPath = this.rootPath) {
+    const configPatterns = {
+      typescript: ['tsconfig.json'],
+      vite: ['vite.config.js', 'vite.config.ts', 'vite.config.mjs'],
+      webpack: ['webpack.config.js', 'webpack.config.ts'],
+      rollup: ['rollup.config.js', 'rollup.config.ts'],
+      eslint: ['.eslintrc.js', '.eslintrc.json', '.eslintrc', '.eslintrc.cjs', 'eslint.config.js'],
+      prettier: ['.prettierrc', '.prettierrc.js', '.prettierrc.json', 'prettier.config.js'],
+      next: ['next.config.js', 'next.config.mjs', 'next.config.ts'],
+      nuxt: ['nuxt.config.js', 'nuxt.config.ts'],
+      remix: ['remix.config.js'],
+      prisma: ['prisma/schema.prisma'],
+      jest: ['jest.config.js', 'jest.config.ts', 'jest.config.cjs'],
+      vitest: ['vitest.config.js', 'vitest.config.ts'],
+      cypress: ['cypress.config.js', 'cypress.config.ts'],
+      playwright: ['playwright.config.js', 'playwright.config.ts'],
+      tailwind: ['tailwind.config.js', 'tailwind.config.ts'],
+      postcss: ['postcss.config.js', 'postcss.config.cjs'],
+      babel: ['babel.config.js', '.babelrc', '.babelrc.js'],
+      docker: ['Dockerfile'],
+      dockerCompose: ['docker-compose.yml', 'docker-compose.yaml'],
+      serverless: ['serverless.yml', 'serverless.yaml'],
+      vercel: ['vercel.json'],
+      netlify: ['netlify.toml'],
+      heroku: ['Procfile'],
+      terraform: ['main.tf', 'terraform.tfvars'],
+      kubernetes: ['k8s/', 'kubernetes/', 'helm/']
+    };
+
+    const detected = {};
+
+    for (const [framework, patterns] of Object.entries(configPatterns)) {
+      for (const pattern of patterns) {
+        const fullPath = path.join(rootPath, pattern);
+        if (fs.existsSync(fullPath)) {
+          detected[framework] = {
+            config: pattern,
+            path: fullPath,
+            confidence: 'high'
+          };
+          break;
+        }
+        // Check for directory patterns
+        if (pattern.endsWith('/')) {
+          const dirPath = path.join(rootPath, pattern);
+          if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+            detected[framework] = {
+              config: pattern,
+              path: dirPath,
+              confidence: 'medium'
+            };
+            break;
+          }
+        }
+      }
+    }
+
+    return detected;
+  }
+
+  /**
+   * Detect frameworks from import statements in source files
+   * @param {Array} sourceFiles - Array of source file paths
+   * @returns {object} Object with detected frameworks from imports
+   */
+  detectFromImports(sourceFiles = []) {
+    const frameworkImports = {
+      'React': {
+        patterns: ['import React', 'import {', 'from \'react\'', 'from "react"'],
+        name: 'React'
+      },
+      'Next.js': {
+        patterns: ['from \'next\'', 'from "next"', 'import {', 'next/server', 'next/router'],
+        name: 'Next.js'
+      },
+      'Vue.js': {
+        patterns: ['import Vue', 'from \'vue\'', 'from "vue"', 'createApp'],
+        name: 'Vue.js'
+      },
+      'Nuxt.js': {
+        patterns: ['from \'#app\'', 'from "#app"', 'useNuxtApp', 'defineNuxtComponent'],
+        name: 'Nuxt.js'
+      },
+      'Angular': {
+        patterns: ['from \'@angular/core\'', 'from "@angular/core"', '@Component', '@Injectable'],
+        name: 'Angular'
+      },
+      'Svelte': {
+        patterns: ['from \'svelte\'', 'from "svelte"', 'import { onMount', 'import { writable'],
+        name: 'Svelte'
+      },
+      'SolidJS': {
+        patterns: ['from \'solid-js\'', 'from "solid-js"', 'createSignal', 'createEffect'],
+        name: 'SolidJS'
+      },
+      'Express': {
+        patterns: ['import express', 'from \'express\'', 'from "express"', 'require(\'express\')'],
+        name: 'Express'
+      },
+      'Fastify': {
+        patterns: ['import fastify', 'from \'fastify\'', 'from "fastify"'],
+        name: 'Fastify'
+      },
+      'NestJS': {
+        patterns: ['from \'@nestjs/core\'', 'from "@nestjs/core"', '@Module', '@Controller'],
+        name: 'NestJS'
+      },
+      'Koa': {
+        patterns: ['import Koa', 'from \'koa\'', 'from "koa"'],
+        name: 'Koa'
+      },
+      'Remix': {
+        patterns: ['from \'@remix-run\'', 'from "@remix-run"', 'useLoaderData', 'ActionFunction'],
+        name: 'Remix'
+      },
+      'Django': {
+        patterns: ['from django.', 'import django', 'django.conf'],
+        name: 'Django'
+      },
+      'Flask': {
+        patterns: ['from flask', 'import Flask', 'flask.'],
+        name: 'Flask'
+      },
+      'FastAPI': {
+        patterns: ['from fastapi', 'import FastAPI', 'FastAPI()'],
+        name: 'FastAPI'
+      }
+    };
+
+    const detected = {};
+
+    for (const file of sourceFiles) {
+      try {
+        const content = fs.readFileSync(file, 'utf8');
+        
+        for (const [key, config] of Object.entries(frameworkImports)) {
+          for (const pattern of config.patterns) {
+            if (content.includes(pattern)) {
+              if (!detected[key]) {
+                detected[key] = {
+                  name: config.name,
+                  files: [],
+                  evidence: []
+                };
+              }
+              if (!detected[key].files.includes(file)) {
+                detected[key].files.push(file);
+              }
+              detected[key].evidence.push({
+                file,
+                pattern
+              });
+              break;
+            }
+          }
+        }
+      } catch (err) {
+        // Ignore read errors
+      }
+    }
+
+    return detected;
+  }
+
+  /**
+   * Detect framework-specific patterns in source files
+   * @param {Array} sourceFiles - Array of source file paths
+   * @returns {object} Object with detected framework patterns
+   */
+  detectFrameworkPatterns(sourceFiles = []) {
+    const patterns = {
+      'React': {
+        components: /function\s+\w+Component\s*\(/,
+        hooks: /use\w+\(/,
+        jsx: /<\w+\s*[^>]*>/,
+        context: /createContext|useContext/
+      },
+      'Next.js': {
+        pages: /pages\//,
+        api: /pages\/api\//,
+        getServerSideProps: /getServerSideProps|getStaticProps|getStaticPaths/,
+        image: /<Image\s/,
+        link: /<Link\s/
+      },
+      'Vue.js': {
+        component: /export\s+default\s*{/,
+        template: /<template>/,
+        setup: /setup\s*\(\)/,
+        directives: /v-if|v-for|v-model/
+      },
+      'Angular': {
+        decorator: /@\w+\(/,
+        module: /@NgModule/,
+        component: /@Component/,
+        service: /@Injectable/,
+        dependency: /constructor\s*\([^)]*private\s+\w+:\s+\w+/
+      },
+      'Express': {
+        router: /express\.Router/,
+        middleware: /app\.use\(|router\.use\(/,
+        route: /app\.(get|post|put|delete|patch)\(/,
+        request: /req\.|request\./
+      },
+      'NestJS': {
+        module: /@Module\(/,
+        controller: /@Controller\(/,
+        service: /@Injectable\(/,
+        guard: /@UseGuards\(/,
+        interceptor: /@UseInterceptors\(/
+      }
+    };
+
+    const results = {};
+
+    for (const [framework, patternSet] of Object.entries(patterns)) {
+      const matches = {
+        total: 0,
+        files: {},
+        patterns: {}
+      };
+
+      for (const file of sourceFiles) {
+        try {
+          const content = fs.readFileSync(file, 'utf8');
+          const fileMatches = {};
+
+          for (const [patternName, regex] of Object.entries(patternSet)) {
+            const matchCount = (content.match(regex) || []).length;
+            if (matchCount > 0) {
+              fileMatches[patternName] = matchCount;
+              matches.patterns[patternName] = (matches.patterns[patternName] || 0) + matchCount;
+              matches.total += matchCount;
+            }
+          }
+
+          if (Object.keys(fileMatches).length > 0) {
+            matches.files[file] = fileMatches;
+          }
+        } catch (err) {
+          // Ignore read errors
+        }
+      }
+
+      if (matches.total > 0) {
+        results[framework] = matches;
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Get comprehensive framework analysis
+   * @param {string} rootPath - Root directory to analyze
+   * @returns {object} Comprehensive framework analysis
+   */
+  analyze(rootPath = this.rootPath) {
+    const configDetection = this.detectFromConfig(rootPath);
+    
+    // Get source files
+    const sourceFiles = this._getSourceFiles(rootPath);
+    const importDetection = this.detectFromImports(sourceFiles);
+    const patternDetection = this.detectFrameworkPatterns(sourceFiles);
+
+    // Merge results
+    const frameworks = {};
+
+    // Add config-based detections
+    for (const [framework, config] of Object.entries(configDetection)) {
+      frameworks[framework] = {
+        detected: true,
+        confidence: config.confidence,
+        source: 'config',
+        config: config.config,
+        importEvidence: null,
+        patternEvidence: null
+      };
+    }
+
+    // Add import-based detections
+    for (const [framework, evidence] of Object.entries(importDetection)) {
+      if (frameworks[framework]) {
+        frameworks[framework].importEvidence = evidence;
+        frameworks[framework].confidence = 'high';
+      } else {
+        frameworks[framework] = {
+          detected: true,
+          confidence: 'medium',
+          source: 'imports',
+          config: null,
+          importEvidence: evidence,
+          patternEvidence: null
+        };
+      }
+    }
+
+    // Add pattern-based detections
+    for (const [framework, patterns] of Object.entries(patternDetection)) {
+      if (frameworks[framework]) {
+        frameworks[framework].patternEvidence = patterns;
+      } else {
+        frameworks[framework] = {
+          detected: true,
+          confidence: 'low',
+          source: 'patterns',
+          config: null,
+          importEvidence: null,
+          patternEvidence: patterns
+        };
+      }
+    }
+
+    return {
+      frameworks,
+      summary: {
+        total: Object.keys(frameworks).length,
+        byConfidence: {
+          high: Object.values(frameworks).filter(f => f.confidence === 'high').length,
+          medium: Object.values(frameworks).filter(f => f.confidence === 'medium').length,
+          low: Object.values(frameworks).filter(f => f.confidence === 'low').length
+        }
+      }
+    };
+  }
+
+  /**
+   * Get source files from root path
+   * @private
+   */
+  _getSourceFiles(rootPath) {
+    const files = [];
+    const srcDir = path.join(rootPath, 'src');
+    const appDir = path.join(rootPath, 'app');
+    const libDir = path.join(rootPath, 'lib');
+    const pagesDir = path.join(rootPath, 'pages');
+    const componentsDir = path.join(rootPath, 'components');
+
+    const dirsToSearch = [rootPath];
+    if (fs.existsSync(srcDir)) dirsToSearch.push(srcDir);
+    if (fs.existsSync(appDir)) dirsToSearch.push(appDir);
+    if (fs.existsSync(libDir)) dirsToSearch.push(libDir);
+    if (fs.existsSync(pagesDir)) dirsToSearch.push(pagesDir);
+    if (fs.existsSync(componentsDir)) dirsToSearch.push(componentsDir);
+
+    for (const dir of dirsToSearch) {
+      this._collectSourceFiles(dir, files);
+    }
+
+    return files.slice(0, 100); // Limit to 100 files
+  }
+
+  /**
+   * Collect source files from directory
+   * @private
+   */
+  _collectSourceFiles(dir, files, depth = 0) {
+    if (depth > 5 || dir.includes('node_modules')) return;
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          this._collectSourceFiles(fullPath, files, depth + 1);
+        } else if (entry.isFile() && /\.(ts|tsx|js|jsx)$/.test(entry.name)) {
+          files.push(fullPath);
+        }
+      }
+    } catch (err) {
+      // Ignore errors
+    }
+  }
+}
+
+module.exports = { FrameworkDetector };

package/ez-agents/bin/lib/frontmatter.cjs

@@ -10,7 +10,9 @@ const { safeReadFile, output, error } = require('./core.cjs');
 
 function extractFrontmatter(content) {
   const frontmatter = {};
-  const match = content.match(/^---\n([\s\S]+?)\n---/);
+  // Normalize CRLF to LF so regex works on Windows-converted files
+  const normalized = content.replace(/\r\n/g, '\n');
+  const match = normalized.match(/^---\n([\s\S]+?)\n---/);
   if (!match) return frontmatter;
 
   const yaml = match[1];