@ai-qa/workflow 2.0.0

package/scripts/reporter.js

@@ -0,0 +1,190 @@
+const { DIRS, ensureDir, readMarkdown, writeMarkdown, log } = require('./utils');
+const path = require('path');
+const fs = require('fs');
+
+function generateReport(runId) {
+  const runDir = runId
+    ? path.join(DIRS.testResults, runId)
+    : findLatestRunDir();
+
+  if (!runDir || !fs.existsSync(runDir)) {
+    log('REPORTER', 'No execution results found');
+    return null;
+  }
+
+  log('REPORTER', `Generating report from: test-results/${path.basename(runDir)}`);
+
+  const report = {
+    runId: path.basename(runDir),
+    generatedAt: new Date().toISOString(),
+    execution: null,
+    healing: null,
+    testFiles: [],
+    stats: { total: 0, passed: 0, failed: 0, healed: 0 },
+  };
+
+  const resultPath = path.join(runDir, 'execution-result.json');
+  if (fs.existsSync(resultPath)) {
+    report.execution = JSON.parse(fs.readFileSync(resultPath, 'utf-8'));
+  }
+
+  const healingPath = path.join(runDir, 'healing-report.json');
+  if (fs.existsSync(healingPath)) {
+    report.healing = JSON.parse(fs.readFileSync(healingPath, 'utf-8'));
+  }
+
+  report.testFiles = listTestFilesWithStatus();
+
+  if (report.execution) {
+    report.stats.total = (report.execution.failedTests || []).length + (report.execution.passedTests || []).length;
+    if (report.execution.success) {
+      report.stats.passed = report.stats.total;
+    } else {
+      report.stats.failed = (report.execution.failedTests || []).length;
+    }
+  }
+
+  if (report.healing) {
+    report.stats.healed = report.healing.totalHealed || 0;
+    report.stats.failed = Math.max(0, report.stats.failed - report.stats.healed);
+    report.stats.passed += report.stats.healed;
+  }
+
+  const md = generateMarkdownReport(report);
+  const reportPath = path.join(runDir, 'final-test-report.md');
+  writeMarkdown(reportPath, md);
+
+  log('REPORTER', `Report saved: test-results/${path.basename(runDir)}/final-test-report.md`);
+
+  return {
+    reportPath,
+    stats: report.stats,
+    report,
+  };
+}
+
+function listTestFilesWithStatus() {
+  const testsDir = DIRS.tests;
+  if (!fs.existsSync(testsDir)) return [];
+
+  return fs.readdirSync(testsDir)
+    .filter(f => f.endsWith('.spec.ts'))
+    .map(f => {
+      const content = fs.readFileSync(path.join(testsDir, f), 'utf-8');
+      const testCount = (content.match(/test\(/g) || []).length;
+      return { file: f, tests: testCount };
+    });
+}
+
+function generateMarkdownReport(report) {
+  const { runId, stats, execution, healing, testFiles } = report;
+
+  let md = `# AI QA Execution Report
+
+**Run ID**: ${runId}
+**Generated**: ${report.generatedAt}
+**Status**: ${stats.failed === 0 ? '✅ PASSED' : '❌ FAILED'}
+
+---
+
+## Executive Summary
+
+| Metric | Value |
+|--------|-------|
+| Total Test Cases | ${stats.total || 'N/A'} |
+| Passed | ${stats.passed} |
+| Failed | ${stats.failed} |
+| Healed (Self-Healing) | ${stats.healed} |
+| Pass Rate | ${stats.total > 0 ? Math.round((stats.passed / stats.total) * 100) : 'N/A'}% |
+| Duration | ${execution ? `${(execution.duration / 1000).toFixed(1)}s` : 'N/A'} |
+
+---
+
+## Test Coverage
+
+| Test File | Scenarios |
+|-----------|-----------|
+`;
+
+  testFiles.forEach(tf => {
+    md += `| ${tf.file} | ${tf.tests} |\n`;
+  });
+
+  if (execution && !execution.success && execution.failedTests && execution.failedTests.length > 0) {
+    md += `\n## Failed Tests (Before Healing)\n\n`;
+    md += `| # | Test | Error |\n`;
+    md += `|---|------|-------|\n`;
+    execution.failedTests.forEach((ft, i) => {
+      const error = ft.error ? ft.error.substring(0, 100) : 'N/A';
+      md += `| ${i + 1} | ${ft.test || ft.file} | ${error} |\n`;
+    });
+  }
+
+  if (healing) {
+    md += `\n## Self-Healing Activity\n\n`;
+
+    if (healing.healingAttempts && healing.healingAttempts.length > 0) {
+      md += `| Attempt | Healed | Remaining |\n`;
+      md += `|---------|--------|-----------|\n`;
+      healing.healingAttempts.forEach(a => {
+        md += `| ${a.attempt} | ${a.healed.length} | ${a.stillFailing.length} |\n`;
+      });
+    }
+
+    if (healing.totalHealed > 0) {
+      md += `\n**Healed Tests:**\n\n`;
+      healing.healingAttempts.forEach(a => {
+        a.healed.forEach(h => {
+          md += `- \`${h.test || h.file}\` → Healed via "${h.strategy}" (attempt ${h.healedOnAttempt})\n`;
+        });
+      });
+    }
+
+    if (healing.totalRemaining > 0) {
+      md += `\n**Still Failing (requires AI investigation):**\n\n`;
+      md += `These tests could not be auto-healed and need manual inspection:\n\n`;
+      (healing.healingAttempts[healing.healingAttempts.length - 1]?.stillFailing || []).forEach(ft => {
+        md += `- \`${ft.test || ft.file}\`\n`;
+      });
+    }
+  }
+
+  md += `\n## Artifacts\n\n`;
+  md += `- **Execution Log**: \`test-results/${runId}/execution-output.json\`\n`;
+  md += `- **Execution Result**: \`test-results/${runId}/execution-result.json\`\n`;
+
+  if (healing) {
+    md += `- **Healing Report**: \`test-results/${runId}/healing-report.json\`\n`;
+  }
+
+  md += `- **Allure Results**: \`allure-results/\`\n`;
+  md += `- **Screenshots**: \`test-results/\`\n`;
+
+  md += `\n---\n\n`;
+  md += `> **Next Step**: If failures remain, use the Playwright Test Healer agent to investigate.\n`;
+  md += `> Run: \`node ai-qa-workflow.js heal ${runId}\`\n`;
+
+  return md;
+}
+
+function findLatestRunDir() {
+  if (!fs.existsSync(DIRS.testResults)) return null;
+
+  const dirs = fs.readdirSync(DIRS.testResults)
+    .map(d => ({ name: d, path: path.join(DIRS.testResults, d) }))
+    .filter(d => fs.statSync(d.path).isDirectory())
+    .sort((a, b) => fs.statSync(b.path).mtimeMs - fs.statSync(a.path).mtimeMs);
+
+  return dirs.length > 0 ? dirs[0].path : null;
+}
+
+if (require.main === module) {
+  const runId = process.argv[2];
+  const result = generateReport(runId);
+  if (result) {
+    console.log(`\n  Report: ${result.reportPath}`);
+    console.log(`  Passed: ${result.stats.passed} | Failed: ${result.stats.failed} | Healed: ${result.stats.healed}`);
+  }
+}
+
+module.exports = { generateReport };

package/scripts/utils.js

@@ -0,0 +1,244 @@
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..');
+
+const CONFIG_PATH = path.join(ROOT, '.qa-workflow.json');
+
+function extractUrl(script) {
+  if (!script) return null;
+  const portMatch = script.match(/--port\s+(\d+)/) || script.match(/-p\s+(\d+)/) || script.match(/PORT=(\d+)/);
+  if (portMatch) return `http://localhost:${portMatch[1]}`;
+  const urlMatch = script.match(/https?:\/\/[^\s"'`]+/);
+  return urlMatch ? urlMatch[0] : null;
+}
+
+function autoDetectConfig() {
+  const detected = {
+    project: { name: '', description: '', url: '', environment: '' },
+    browser: { type: 'chromium', cdpPort: 9222, headed: false },
+    test: { timeout: 120000, retries: 0, workers: 1 },
+    auth: { user: '', credentials: {} },
+  };
+
+  // Detect from package.json
+  const pkgPath = path.join(ROOT, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      detected.project.name = pkg.name || path.basename(ROOT);
+      detected.project.description = pkg.description || '';
+      if (pkg.scripts) {
+        const devScript = pkg.scripts.dev || pkg.scripts.start || pkg.scripts.serve || '';
+        detected.project.url = extractUrl(devScript) || 'http://localhost:3000';
+      }
+    } catch {}
+  } else {
+    detected.project.name = path.basename(ROOT);
+  }
+
+  // Detect from docker-compose (first exposed port)
+  const composePaths = ['docker-compose.yml', 'docker-compose.yaml', 'compose.yml', 'compose.yaml'];
+  for (const cp of composePaths) {
+    const cpPath = path.join(ROOT, cp);
+    if (fs.existsSync(cpPath)) {
+      try {
+        const content = fs.readFileSync(cpPath, 'utf-8');
+        const portMatch = content.match(/"(\d+):\d+"/) || content.match(/'(\d+):\d+'/);
+        if (portMatch) detected.project.url = `http://localhost:${portMatch[1]}`;
+        const envMatch = content.match(/COMPOSE_PROJECT_NAME[=:]\s*["']?([^"'\s]+)/);
+        if (envMatch && !detected.project.name) detected.project.name = envMatch[1];
+      } catch {}
+    }
+  }
+
+  // Detect environment from .env
+  const envPath = path.join(ROOT, '.env');
+  if (fs.existsSync(envPath)) {
+    try {
+      const envContent = fs.readFileSync(envPath, 'utf-8');
+      const appUrl = envContent.match(/APP_URL\s*=\s*(.+)/);
+      if (appUrl) detected.project.url = appUrl[1].trim();
+      const appEnv = envContent.match(/APP_ENV\s*=\s*(.+)/) || envContent.match(/NODE_ENV\s*=\s*(.+)/);
+      if (appEnv) detected.project.environment = appEnv[1].trim();
+    } catch {}
+  }
+
+  // Detect from README
+  for (const readme of ['README.md', 'README.rst', 'README.txt']) {
+    const rp = path.join(ROOT, readme);
+    if (fs.existsSync(rp)) {
+      try {
+        const content = fs.readFileSync(rp, 'utf-8');
+        const titleMatch = content.match(/^#\s+(.+)/m);
+        if (titleMatch && !detected.project.name) detected.project.name = titleMatch[1].trim();
+        const urlMatch = content.match(/https?:\/\/[^\s"')\]>]+/);
+        if (urlMatch) detected.project.url = urlMatch[0].replace(/[.)]>]$/g, '');
+        const descLine = content.split('\n').slice(1, 3).join(' ').replace(/^>?\s*/, '').substring(0, 300);
+        if (descLine && !detected.project.description) detected.project.description = descLine;
+      } catch {}
+    }
+  }
+
+  // Detect browser type from playwright config
+  const pwPaths = ['playwright.config.ts', 'playwright.config.js'];
+  for (const pw of pwPaths) {
+    const pwPath = path.join(ROOT, pw);
+    if (fs.existsSync(pwPath)) {
+      try {
+        const content = fs.readFileSync(pwPath, 'utf-8');
+        if (/\bedge\b/i.test(content) || /\bmsedge\b/i.test(content)) detected.browser.type = 'edge';
+        if (/webkit/i.test(content)) detected.browser.type = 'webkit';
+      } catch {}
+    }
+  }
+
+  // Detect project type from directory patterns
+  if (fs.existsSync(path.join(ROOT, 'src', 'app')) || fs.existsSync(path.join(ROOT, 'angular.json'))) {
+    detected.project.environment = detected.project.environment || 'Angular App';
+  } else if (fs.existsSync(path.join(ROOT, 'src', 'pages')) && fs.existsSync(path.join(ROOT, 'next.config.js'))) {
+    detected.project.environment = detected.project.environment || 'Next.js App';
+  } else if (fs.existsSync(path.join(ROOT, 'src')) && !detected.project.environment) {
+    detected.project.environment = 'Web Application';
+  } else if (fs.existsSync(path.join(ROOT, 'app.py')) || fs.existsSync(path.join(ROOT, 'manage.py'))) {
+    detected.project.environment = 'Python Web App';
+  }
+
+  return detected;
+}
+
+function loadConfig() {
+  const defaults = {
+    project: { name: 'my-project', description: '', url: 'http://localhost:3000', environment: 'Development' },
+    browser: { type: 'chromium', cdpPort: 9222, headed: false },
+    test: { timeout: 120000, retries: 0, workers: 1 },
+    auth: { user: '', credentials: {} },
+  };
+
+  let base = { ...defaults };
+  if (fs.existsSync(CONFIG_PATH)) {
+    try {
+      const userConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+      deepMerge(base, userConfig);
+      return base;
+    } catch (e) {
+      console.warn(`  ⚠  Failed to parse .qa-workflow.json: ${e.message}`);
+    }
+  }
+
+  // No config file — auto-detect from project, then fill gaps with defaults
+  const detected = autoDetectConfig();
+  deepMerge(base, detected);
+  return base;
+}
+
+function deepMerge(target, source) {
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      if (!target[key]) target[key] = {};
+      deepMerge(target[key], source[key]);
+    } else {
+      target[key] = source[key];
+    }
+  }
+}
+
+let CONFIG = loadConfig();
+
+function reloadConfig() {
+  CONFIG = loadConfig();
+  return CONFIG;
+}
+
+const DIRS = {
+  userStory: path.join(ROOT, 'user-story'),
+  specs: path.join(ROOT, 'specs'),
+  tests: path.join(ROOT, 'tests'),
+  testResults: path.join(ROOT, 'test-results'),
+  allureResults: path.join(ROOT, 'allure-results'),
+  scratch: path.join(ROOT, 'scratch'),
+  docs: path.join(ROOT, 'docs'),
+  scripts: path.join(ROOT, 'scripts'),
+};
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function listFiles(dir, ext) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir)
+    .filter(f => f.endsWith(ext))
+    .sort();
+}
+
+function listUserStories() {
+  return listFiles(DIRS.userStory, '.md');
+}
+
+function listTestPlans() {
+  return listFiles(DIRS.specs, '.md');
+}
+
+function listTestSpecs() {
+  return listFiles(DIRS.tests, '.spec.ts');
+}
+
+function readMarkdown(filePath) {
+  return fs.readFileSync(filePath, 'utf-8');
+}
+
+function writeMarkdown(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, content, 'utf-8');
+}
+
+function parseUserStory(filePath) {
+  const content = readMarkdown(filePath);
+  const story = { content, metadata: {} };
+
+  const idMatch = content.match(/\*\*Story ID\*\*:\s*(\S+)/);
+  if (idMatch) story.id = idMatch[1];
+
+  const titleMatch = content.match(/^#\s+(.+)$/m);
+  if (titleMatch) story.title = titleMatch[1].trim();
+
+  const titleMetaMatch = content.match(/\*\*Title\*\*:\s*(.+)/);
+  if (titleMetaMatch) story.metaTitle = titleMetaMatch[1].trim();
+
+  const descMatch = content.match(/## Description\s*\n(.+?)(?=\n## |\n---|$)/s);
+  if (descMatch) story.description = descMatch[1].trim();
+
+  const precondMatch = content.match(/## Preconditions\s*\n(.+?)(?=\n## |\n---|$)/s);
+  if (precondMatch) {
+    story.preconditions = precondMatch[1]
+      .split('\n')
+      .filter(l => l.trim().startsWith('-'))
+      .map(l => l.replace(/^- /, '').trim());
+  }
+
+  const acMatch = content.match(/## Acceptance Criteria\s*\n(.+?)(?=\n## |\n---|$)/s);
+  if (acMatch) {
+    story.acceptanceCriteria = acMatch[1].trim();
+  }
+
+  return story;
+}
+
+function slugify(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+function timestamp() {
+  return new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+}
+
+function log(step, msg) {
+  const ts = new Date().toLocaleTimeString();
+  console.log(`  [${ts}] [${step}] ${msg}`);
+}
+
+module.exports = { ROOT, DIRS, CONFIG, CONFIG_PATH, loadConfig, reloadConfig, autoDetectConfig, ensureDir, listFiles, listUserStories, listTestPlans, listTestSpecs, readMarkdown, writeMarkdown, parseUserStory, slugify, timestamp, log, extractUrl };