@oalacea/demon 1.0.0

package/agents/fix-engine.js

@@ -0,0 +1,305 @@
+/**
+ * Demon - Fix Engine
+ *
+ * Analyzes test failures and applies fixes.
+ * Handles common test issues automatically.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Analyze test failure and categorize
+ */
+function categorizeFailure(errorOutput, testPath) {
+  if (!errorOutput) return { category: 'unknown' };
+
+  if (errorOutput.includes('Cannot find module')) {
+    return { category: 'import', message: 'Module import issue' };
+  }
+
+  if (errorOutput.includes('is not defined') || errorOutput.includes('is not a function')) {
+    return { category: 'mock', message: 'Missing mock' };
+  }
+
+  if (errorOutput.includes('timeout')) {
+    return { category: 'timeout', message: 'Test timeout' };
+  }
+
+  if (errorOutput.includes('Expected') && errorOutput.includes('Received')) {
+    return { category: 'assertion', message: 'Assertion failed' };
+  }
+
+  if (errorOutput.includes('Cannot read property')) {
+    return { category: 'null', message: 'Null/undefined access' };
+  }
+
+  if (errorOutput.includes('ECONNREFUSED') || errorOutput.includes('connect')) {
+    return { category: 'connection', message: 'Connection refused' };
+  }
+
+  return { category: 'unknown', message: 'Unknown error' };
+}
+
+/**
+ * Fix import issues
+ */
+function fixImportIssue(testPath, error) {
+  const content = fs.readFileSync(testPath, 'utf-8');
+  const missingModule = error.match(/Cannot find module ['"](.+)['"]/)?.[1];
+
+  if (!missingModule) return false;
+
+  // Check if it's a relative import issue
+  if (missingModule.startsWith('@/')) {
+    // Check if vitest.config.ts has the alias
+    const vitestConfig = path.join(process.cwd(), 'vitest.config.ts');
+    if (fs.existsSync(vitestConfig)) {
+      const config = fs.readFileSync(vitestConfig, 'utf-8');
+      if (!config.includes('resolve:') || !config.includes('alias:')) {
+        return {
+          fixType: 'config',
+          message: 'Add path alias to vitest.config.ts',
+          configFix: `
+export default defineConfig({
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+    },
+  },
+});`,
+        };
+      }
+    }
+  }
+
+  return {
+    fixType: 'import',
+    message: `Create or update import for ${missingModule}`,
+  };
+}
+
+/**
+ * Fix mock issues
+ */
+function fixMockIssue(testPath, error) {
+  const content = fs.readFileSync(testPath, 'utf-8');
+  const missingVar = error.match(/(.+) is not defined/)?.[1];
+
+  if (!missingVar) return false;
+
+  // Check if it's a hook/function that needs mocking
+  if (missingVar.startsWith('use')) {
+    return {
+      fixType: 'mock',
+      message: `Add mock for ${missingVar}`,
+      mock: `vi.mock('@/hooks/${missingVar}', () => ({
+      ${missingVar}: vi.fn(() => ({/* default return */})),
+    }));`,
+    };
+  }
+
+  return {
+    fixType: 'mock',
+    message: `Add mock for ${missingVar}`,
+  };
+}
+
+/**
+ * Fix assertion issues
+ */
+function fixAssertionIssue(testPath, error) {
+  const content = fs.readFileSync(testPath, 'utf-8');
+
+  // Check for common issues
+  if (error.includes('querySelector returned null')) {
+    return {
+      fixType: 'selector',
+      message: 'Element not found - use queryBy or add waitFor',
+      suggestion: 'Replace getBy with queryBy for optional elements, or add waitFor',
+    };
+  }
+
+  if (error.includes('received null') || error.includes('received undefined')) {
+    return {
+      fixType: 'assertion',
+      message: 'Element/property is null/undefined',
+      suggestion: 'Check if component renders with required props',
+    };
+  }
+
+  return {
+    fixType: 'manual',
+    message: 'Manual fix required',
+    error,
+  };
+}
+
+/**
+ * Fix timeout issues
+ */
+function fixTimeoutIssue(testPath, error) {
+  return {
+    fixType: 'timeout',
+    message: 'Increase test timeout or fix async operation',
+    suggestion: `Add timeout to test: it('test name', async () => { ... }, { timeout: 10000 })`,
+  };
+}
+
+/**
+ * Fix connection issues
+ */
+function fixConnectionIssue(testPath, error) {
+  return {
+    fixType: 'mock',
+    message: 'Mock external API calls',
+    suggestion: 'Use vi.mock or MSW to mock fetch/axios calls',
+  };
+}
+
+/**
+ * Generate fix for a failing test
+ */
+function generateFix(testPath, error) {
+  const failure = categorizeFailure(error, testPath);
+
+  switch (failure.category) {
+    case 'import':
+      return fixImportIssue(testPath, error);
+    case 'mock':
+      return fixMockIssue(testPath, error);
+    case 'timeout':
+      return fixTimeoutIssue(testPath, error);
+    case 'assertion':
+      return fixAssertionIssue(testPath, error);
+    case 'connection':
+      return fixConnectionIssue(testPath, error);
+    default:
+      return {
+        fixType: 'manual',
+        message: 'Manual analysis required',
+        error,
+      };
+  }
+}
+
+/**
+ * Apply fix to file
+ */
+function applyFix(testPath, fix) {
+  if (!fix) return false;
+
+  const content = fs.readFileSync(testPath, 'utf-8');
+  let newContent = content;
+
+  switch (fix.fixType) {
+    case 'mock':
+      // Add mock at top of file after imports
+      const importsEnd = content.indexOf(');', content.indexOf('import '));
+      if (importsEnd > -1) {
+        newContent = content.slice(0, importsEnd + 2) +
+          '\n\n' + fix.mock +
+          content.slice(importsEnd + 2);
+      }
+      break;
+
+    case 'timeout':
+      // Add timeout option to it() call
+      newContent = content.replace(
+        /it\('([^']+)',\s*(async\s*)?\(([^)]*)\)\s*=>/g,
+        "it('$1', async ($2) => { ... }, { timeout: 10000 })"
+      );
+      break;
+
+    case 'selector':
+      // Suggest using queryBy instead of getBy
+      newContent = content.replace(
+        /getBy\(([^)]+)\)/g,
+        'queryBy($1) || getBy($1)'
+      );
+      break;
+
+    default:
+      return false;
+  }
+
+  if (newContent !== content) {
+    fs.writeFileSync(testPath, newContent);
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Fix all failing tests
+ */
+function fixFailures(testResults) {
+  const fixes = [];
+
+  for (const result of testResults) {
+    if (result.status === 'failed') {
+      const fix = generateFix(result.file, result.error);
+      fixes.push({
+        file: result.file,
+        error: result.error,
+        fix,
+      });
+    }
+  }
+
+  return fixes;
+}
+
+/**
+ * Create fix summary
+ */
+function createFixSummary(fixes) {
+  const summary = {
+    total: fixes.length,
+    applied: 0,
+    manual: 0,
+    failed: 0,
+    details: [],
+  };
+
+  for (const fix of fixes) {
+    const detail = {
+      file: fix.file,
+      type: fix.fix?.fixType || 'unknown',
+      message: fix.fix?.message || 'No fix available',
+      applied: false,
+    };
+
+    if (fix.fix?.fixType === 'manual') {
+      summary.manual++;
+      detail.applied = false;
+    } else if (fix.fix) {
+      // Try to apply fix
+      // const applied = applyFix(fix.file, fix.fix);
+      // if (applied) summary.applied++;
+      // else summary.failed++;
+      summary.manual++; // For safety, mark as manual
+      detail.applied = false;
+    } else {
+      summary.failed++;
+    }
+
+    summary.details.push(detail);
+  }
+
+  return summary;
+}
+
+module.exports = {
+  categorizeFailure,
+  fixImportIssue,
+  fixMockIssue,
+  fixAssertionIssue,
+  fixTimeoutIssue,
+  fixConnectionIssue,
+  generateFix,
+  applyFix,
+  fixFailures,
+  createFixSummary,
+};

package/agents/perf-analyzer.js

@@ -0,0 +1,294 @@
+/**
+ * Demon - 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: 'demon-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,
+};