@oalacea/daemon 0.5.1 → 0.6.0

package/agents/perf-analyzer.js

@@ -1,294 +0,0 @@
-/**
- * Daemon - Performance Analyzer Agent
- *
- * Analyzes application performance including:
- * - API response times
- * - Database query efficiency
- * - Bundle size
- * - Web Vitals
- */
-
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-const CONFIG = {
-  container: 'daemon-tools',
-  docker: 'docker exec',
-};
-
-/**
- * Run k6 performance test
- */
-function runK6Test(testFile, options = {}) {
-  const stages = options.stages || [
-    { duration: '30s', target: 20 },
-    { duration: '1m', target: 20 },
-    { duration: '30s', target: 0 },
-  ];
-
-  const thresholds = options.thresholds || [
-    'http_req_duration[p(95)]<200',
-    'http_req_failed<0.01',
-  ];
-
-  // Create temp k6 script
-  const script = generateK6Script(options.target || 'http://host.docker.internal:3000', stages, thresholds);
-
-  return runDockerCommand(`k6 run -`, { input: script });
-}
-
-/**
- * Generate k6 test script
- */
-function generateK6Script(target, stages, thresholds) {
-  return `
-import http from 'k6/http';
-import { check, sleep } from 'k6';
-
-export const options = {
-  stages: ${JSON.stringify(stages)},
-  thresholds: {
-    ${thresholds.map(t => `'${t}': true`).join(',\n    ')}
-  },
-};
-
-const BASE_URL = '${target}';
-
-export default function () {
-  let res = http.get(\`\${BASE_URL}/\`);
-  check(res, {
-    'homepage OK': r => r.status === 200,
-  });
-
-  sleep(1);
-
-  res = http.get(\`\${BASE_URL}/api/users\`);
-  check(res, {
-    'users API OK': r => r.status === 200,
-    'response time < 200ms': r => r.timings.duration < 200,
-  });
-
-  sleep(1);
-}
-`;
-}
-
-/**
- * Analyze bundle size
- */
-function analyzeBundleSize(projectDir) {
-  const buildDir = path.join(projectDir, '.next', 'static', 'chunks');
-  const distDir = path.join(projectDir, 'dist', 'assets');
-
-  let chunksDir;
-  if (fs.existsSync(buildDir)) chunksDir = buildDir;
-  else if (fs.existsSync(distDir)) chunksDir = distDir;
-  else return null;
-
-  const chunks = [];
-  let totalSize = 0;
-
-  function analyzeDir(dir) {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-
-      if (entry.isDirectory()) {
-        analyzeDir(fullPath);
-      } else if (entry.isFile() && (entry.name.endsWith('.js') || entry.name.endsWith('.css'))) {
-        const stats = fs.statSync(fullPath);
-        const size = stats.size;
-        totalSize += size;
-
-        chunks.push({
-          name: entry.name,
-          size: size,
-          sizeKB: (size / 1024).toFixed(2),
-          path: path.relative(projectDir, fullPath),
-        });
-      }
-    }
-  }
-
-  analyzeDir(chunksDir);
-
-  return {
-    totalSize,
-    totalSizeKB: (totalSize / 1024).toFixed(2),
-    totalSizeMB: (totalSize / 1024 / 1024).toFixed(2),
-    chunks: chunks.sort((a, b) => b.size - a.size).slice(0, 20), // Top 20
-  };
-}
-
-/**
- * Analyze database queries (Prisma)
- */
-function analyzeDbQueries(projectDir) {
-  const prismaDir = path.join(projectDir, 'prisma');
-  if (!fs.existsSync(prismaDir)) {
-    return null;
-  }
-
-  const schemaPath = path.join(prismaDir, 'schema.prisma');
-  if (!fs.existsSync(schemaPath)) {
-    return null;
-  }
-
-  const schema = fs.readFileSync(schemaPath, 'utf-8');
-
-  const models = [];
-  const modelMatches = schema.matchAll(/model\s+(\w+)\s*{([^}]+)}/g);
-
-  for (const match of modelMatches) {
-    const modelName = match[1];
-    const body = match[2];
-
-    const fields = [];
-    const fieldMatches = body.matchAll(/(\w+)\s+(\w+)(?:\s+@([^{\s]+[^}]*))?/g);
-
-    for (const fieldMatch of fieldMatches) {
-      const fieldName = fieldMatch[1];
-      const fieldType = fieldMatch[2];
-      const attributes = fieldMatch[3] || '';
-
-      fields.push({
-        name: fieldName,
-        type: fieldType,
-        attributes: attributes,
-        isIndexed: attributes.includes('index') || attributes.includes('unique') || attributes.includes('id'),
-      });
-    }
-
-    models.push({
-      name: modelName,
-      fields: fields,
-    });
-  }
-
-  return {
-    models,
-    recommendations: generateDbRecommendations(models),
-  };
-}
-
-/**
- * Generate database recommendations
- */
-function generateDbRecommendations(models) {
-  const recommendations = [];
-
-  for (const model of models) {
-    // Check for common filter fields without indexes
-    const filterFields = ['email', 'username', 'slug', 'status', 'published', 'createdAt'];
-
-    for (const field of model.fields) {
-      if (filterFields.includes(field.name) && !field.isIndexed) {
-        recommendations.push({
-          type: 'index',
-          model: model.name,
-          field: field.name,
-          message: `Consider adding index on ${model.name}.${field.name}`,
-          priority: field.name === 'email' ? 'high' : 'medium',
-        });
-      }
-    }
-  }
-
-  return recommendations;
-}
-
-/**
- * Analyze Web Vitals (Lighthouse)
- */
-function analyzeWebVitals(target) {
-  // This would run Playwright with metrics
-  return runDockerCommand(`npx playwright test --reporter=json`, {
-    cwd: path.join(process.cwd(), 'tests', 'e2e'),
-  });
-}
-
-/**
- * Run command in Docker container
- */
-function runDockerCommand(command, options = {}) {
-  const dockerCmd = `${CONFIG.docker} ${CONFIG.container} ${command}`;
-
-  try {
-    return {
-      success: true,
-      output: execSync(dockerCmd, {
-        encoding: 'utf-8',
-        stdio: options.silent ? 'pipe' : 'inherit',
-        input: options.input,
-      }),
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error.message,
-    };
-  }
-}
-
-/**
- * Generate performance report
- */
-function generateReport(analysis) {
-  const report = {
-    summary: {},
-    recommendations: [],
-  };
-
-  // Bundle analysis
-  if (analysis.bundle) {
-    report.summary.bundle = {
-      totalSize: analysis.bundle.totalSizeMB + ' MB',
-      largestChunks: analysis.bundle.chunks.slice(0, 5),
-    };
-
-    // Check for large bundles
-    analysis.bundle.chunks.forEach((chunk) => {
-      if (chunk.size > 200 * 1024) { // > 200KB
-        report.recommendations.push({
-          type: 'bundle',
-          message: `Large chunk: ${chunk.name} (${chunk.sizeKB} KB)`,
-          priority: 'medium',
-        });
-      }
-    });
-  }
-
-  // DB analysis
-  if (analysis.db) {
-    report.summary.database = {
-      models: analysis.db.models.length,
-      recommendations: analysis.db.recommendations,
-    };
-    report.recommendations.push(...analysis.db.recommendations);
-  }
-
-  return report;
-}
-
-/**
- * Full performance analysis
- */
-function analyze(projectDir) {
-  const analysis = {
-    bundle: analyzeBundleSize(projectDir),
-    db: analyzeDbQueries(projectDir),
-  };
-
-  return generateReport(analysis);
-}
-
-module.exports = {
-  runK6Test,
-  analyzeBundleSize,
-  analyzeDbQueries,
-  analyzeWebVitals,
-  generateReport,
-  analyze,
-};

package/agents/perf-front-analyzer.js

@@ -1,229 +0,0 @@
-/**
- * Daemon - Frontend Performance Analyzer
- *
- * Analyzes frontend performance using Lighthouse:
- * - Core Web Vitals (LCP, FID, CLS)
- * - Performance score
- * - Accessibility
- * - Best Practices
- * - SEO
- */
-
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-const CONFIG = {
-  container: 'daemon-tools',
-  docker: 'docker exec',
-};
-
-/**
- * Run Lighthouse audit
- */
-function runLighthouse(url, options = {}) {
-  const outputPath = options.output || path.join(process.cwd(), 'lighthouse-report.json');
-  const htmlOutput = outputPath.replace('.json', '.html');
-
-  const cmd = [
-    `docker exec ${CONFIG.container} npx lighthouse`,
-    url,
-    `--output=json --output=html`,
-    `--chrome-flags="--headless --no-sandbox --disable-gpu"`,
-    `--quiet`,
-    options.onlyCategories ? `--only-categories=${options.onlyCategories}` : '',
-    options.formFactor ? `--form-factor=${options.formFactor}` : '--throttling-method=devtools',
-    options.screenEmulation ? `--screen-emulation=${options.screenEmulation}` : '',
-  ].filter(Boolean).join(' ');
-
-  try {
-    execSync(cmd, { encoding: 'utf-8', stdio: 'pipe', timeout: 120000 });
-
-    // Read the JSON report (container writes to /app)
-    const reportPath = path.join(process.cwd(), 'lighthouse-report.json');
-    if (fs.existsSync(reportPath)) {
-      const report = JSON.parse(fs.readFileSync(reportPath, 'utf-8'));
-      return { success: true, report, htmlOutput };
-    }
-  } catch (error) {
-    return {
-      success: false,
-      error: error.message,
-    };
-  }
-}
-
-/**
- * Analyze Lighthouse results
- */
-function analyzeResults(report) {
-  const categories = report.categories || {};
-  const audits = report.audits || {};
-
-  return {
-    scores: {
-      performance: categories.performance?.score || 0,
-      accessibility: categories.accessibility?.score || 0,
-      bestPractices: categories['best-practices']?.score || 0,
-      seo: categories.seo?.score || 0,
-      pwa: categories.pwa?.score || 0,
-    },
-    coreWebVitals: {
-      lcp: audits['largest-contentful-paint']?.displayValue || 'N/A',
-      fid: audits['max-potential-fid']?.displayValue || 'N/A',
-      cls: audits['cumulative-layout-shift']?.displayValue || 'N/A',
-      ttfb: audits['time-to-first-byte']?.displayValue || 'N/A',
-      fcp: audits['first-contentful-paint']?.displayValue || 'N/A',
-      tti: audits['interactive']?.displayValue || 'N/A',
-      si: audits['speed-index']?.displayValue || 'N/A',
-    },
-    opportunities: (opportunities || []).map(item => ({
-      id: item.id,
-      title: item.title,
-      description: item.description,
-      score: item.score,
-      displayValue: item.displayValue,
-    })),
-    diagnostics: Object.values(audits)
-      .filter(audit => audit.details && audit.details.type === 'table')
-      .map(audit => ({
-        id: audit.id,
-        title: audit.title,
-        description: audit.description,
-        items: audit.details?.items || [],
-      })),
-  };
-}
-
-/**
- * Get performance opportunities
- */
-function getOpportunities(report) {
-  const opportunities = [];
-
-  if (!report.audits) return opportunities;
-
-  const opportunityAudits = [
-    'render-blocking-resources',
-    'unminified-css',
-    'unminified-javascript',
-    'unused-css-rules',
-    'unused-javascript',
-    'modern-image-formats',
-    'offscreen-images',
-    'scaled-images',
-    'efficient-animated-content',
-    'text-compression',
-    'uses-long-cache-ttl',
-    'total-byte-weight',
-    'uses-optimized-images',
-  ];
-
-  for (const id of opportunityAudits) {
-    const audit = report.audits[id];
-    if (audit && audit.score !== null && audit.score < 1) {
-      opportunities.push({
-        id,
-        title: audit.title,
-        description: audit.description,
-        score: audit.score,
-        displayValue: audit.displayValue,
-        severity: audit.score < 0.5 ? 'high' : 'medium',
-      });
-    }
-  }
-
-  return opportunities.sort((a, b) => a.score - b.score);
-}
-
-/**
- * Generate performance recommendations
- */
-function generateRecommendations(results) {
-  const recommendations = [];
-  const { scores, coreWebVitals, opportunities } = results;
-
-  // Performance score recommendations
-  if (scores.performance < 0.5) {
-    recommendations.push({
-      type: 'critical',
-      message: `Performance score is ${(scores.performance * 100).toFixed(0)}/100. Immediate optimization required.`,
-    });
-  } else if (scores.performance < 0.8) {
-    recommendations.push({
-      type: 'warning',
-      message: `Performance score is ${(scores.performance * 100).toFixed(0)}/100. Optimization recommended.`,
-    });
-  }
-
-  // Core Web Vitals recommendations
-  if (coreWebVitals.lcp) {
-    const lcpValue = parseFloat(coreWebVitals.lcp);
-    if (lcpValue > 4000) {
-      recommendations.push({
-        type: 'critical',
-        metric: 'LCP',
-        message: `LCP is ${coreWebVitals.lcp} (target: <2.5s). Consider lazy loading, code splitting, or optimizing images.`,
-      });
-    }
-  }
-
-  if (coreWebVitals.cls) {
-    const clsValue = parseFloat(coreWebVitals.cls);
-    if (clsValue > 0.25) {
-      recommendations.push({
-        type: 'critical',
-        metric: 'CLS',
-        message: `CLS is ${coreWebVitals.cls} (target: <0.1). Reserve space for dynamic content.`,
-      });
-    }
-  }
-
-  // Opportunity-based recommendations
-  for (const opp of opportunities.slice(0, 5)) {
-    recommendations.push({
-      type: opp.severity === 'high' ? 'warning' : 'info',
-      message: `${opp.title}: ${opp.displayValue || 'Needs improvement'}`,
-    });
-  }
-
-  return recommendations;
-}
-
-/**
- * Run mobile audit
- */
-function runMobileAudit(url) {
-  return runLighthouse(url, {
-    formFactor: 'mobile',
-    screenEmulation: 'mobile',
-  });
-}
-
-/**
- * Run desktop audit
- */
-function runDesktopAudit(url) {
-  return runLighthouse(url, {
-    formFactor: 'desktop',
-  });
-}
-
-/**
- * Run performance-only audit (faster)
- */
-function runPerformanceOnlyAudit(url) {
-  return runLighthouse(url, {
-    onlyCategories: 'performance',
-  });
-}
-
-module.exports = {
-  runLighthouse,
-  analyzeResults,
-  getOpportunities,
-  generateRecommendations,
-  runMobileAudit,
-  runDesktopAudit,
-  runPerformanceOnlyAudit,
-};