@ai-qa/workflow 2.0.10 → 2.0.13

package/scripts/context-manager.js

@@ -0,0 +1,226 @@
+const path = require('path');
+const fs = require('fs');
+
+const ROOT = path.resolve(__dirname, '..');
+const CONTEXT_DIR = path.join(ROOT, '.qa-context');
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function readJSON(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch { return null; }
+}
+
+function writeJSON(filePath, data) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+}
+
+function pipelinePath() { return path.join(CONTEXT_DIR, 'pipeline.json'); }
+function selectorsPath() { return path.join(CONTEXT_DIR, 'selectors.json'); }
+function healHistoryPath() { return path.join(CONTEXT_DIR, 'heal-history.json'); }
+function traceabilityPath() { return path.join(CONTEXT_DIR, 'traceability.json'); }
+
+const context = {
+
+  // ── Pipeline State ──
+
+  getPipeline() {
+    return readJSON(pipelinePath()) || {
+      project_path: '',
+      phases: { plan: { completed: [], in_progress: null }, generate: { completed: [], in_progress: null }, execute: { completed: [], in_progress: null }, heal: { completed: [], in_progress: null }, report: { completed: [], in_progress: null } },
+      current_story: null,
+      last_run_id: null,
+      updated_at: '',
+    };
+  },
+
+  setPipeline(updates) {
+    const data = this.getPipeline();
+    Object.assign(data, updates);
+    data.updated_at = new Date().toISOString();
+    writeJSON(pipelinePath(), data);
+  },
+
+  phaseComplete(phase, item) {
+    const data = this.getPipeline();
+    if (!data.phases[phase]) data.phases[phase] = { completed: [], in_progress: null };
+    if (!data.phases[phase].completed.includes(item)) {
+      data.phases[phase].completed.push(item);
+    }
+    data.phases[phase].in_progress = null;
+    data.updated_at = new Date().toISOString();
+    writeJSON(pipelinePath(), data);
+  },
+
+  phaseInProgress(phase, item) {
+    const data = this.getPipeline();
+    if (!data.phases[phase]) data.phases[phase] = { completed: [], in_progress: null };
+    data.phases[phase].in_progress = item;
+    data.updated_at = new Date().toISOString();
+    writeJSON(pipelinePath(), data);
+  },
+
+  setCurrentStory(story) {
+    this.setPipeline({ current_story: story });
+  },
+
+  setLastRun(runId) {
+    this.setPipeline({ last_run_id: runId });
+  },
+
+  // ── Selectors Memory ──
+
+  getSelectors() {
+    return readJSON(selectorsPath()) || [];
+  },
+
+  addSelector(page, element, selectorValue, options = {}) {
+    const selectors = this.getSelectors();
+    let entry = selectors.find(s => s.page === page && s.element === element);
+    if (!entry) {
+      entry = { page, element, selectors: [], recommended: selectorValue };
+      selectors.push(entry);
+    }
+    const existing = entry.selectors.find(s => s.value === selectorValue);
+    if (existing) {
+      existing.last_used = new Date().toISOString();
+      if (options.reliability !== undefined) existing.reliability = options.reliability;
+      if (options.healed) existing.healed = true;
+      if (options.original) existing.original = options.original;
+    } else {
+      entry.selectors.push({
+        value: selectorValue,
+        type: options.type || 'css',
+        reliability: options.reliability || 0.5,
+        healed: options.healed || false,
+        original: options.original || null,
+        strategy: options.strategy || null,
+        healed_at: options.healed_at || null,
+        run_id: options.run_id || null,
+        first_seen: new Date().toISOString(),
+        last_used: new Date().toISOString(),
+      });
+    }
+    entry.selectors.sort((a, b) => b.reliability - a.reliability);
+    entry.recommended = entry.selectors[0].value;
+    writeJSON(selectorsPath(), selectors);
+  },
+
+  getRecommendedSelector(page, element) {
+    const selectors = this.getSelectors();
+    const entry = selectors.find(s => s.page === page && s.element === element);
+    return entry ? entry.recommended : null;
+  },
+
+  updateSelectorReliability(page, element, selectorValue, succeeded) {
+    const selectors = this.getSelectors();
+    const entry = selectors.find(s => s.page === page && s.element === element);
+    if (!entry) return;
+    const sel = entry.selectors.find(s => s.value === selectorValue);
+    if (!sel) return;
+    sel.reliability = succeeded
+      ? Math.min(1, sel.reliability + 0.1)
+      : Math.max(0, sel.reliability - 0.2);
+    sel.last_used = new Date().toISOString();
+    entry.selectors.sort((a, b) => b.reliability - a.reliability);
+    entry.recommended = entry.selectors[0].value;
+    writeJSON(selectorsPath(), selectors);
+  },
+
+  // ── Healing History ──
+
+  getHealHistory() {
+    return readJSON(healHistoryPath()) || [];
+  },
+
+  addHealAttempt(runId, story, test, element, attempts, success) {
+    const history = this.getHealHistory();
+    history.push({
+      run_id: runId,
+      story,
+      test,
+      element,
+      original_selector: attempts[0] && attempts[0].original ? attempts[0].original : null,
+      failure_reason: attempts[0] && attempts[0].error || null,
+      attempts: attempts.map(a => ({
+        selector: a.selector,
+        strategy: a.strategy || 'retry',
+        success: a.success,
+        duration_ms: a.duration_ms || 0,
+      })),
+      success,
+      duration_ms: attempts.reduce((s, a) => s + (a.duration_ms || 0), 0),
+      timestamp: new Date().toISOString(),
+    });
+    writeJSON(healHistoryPath(), history);
+    return history;
+  },
+
+  getHealHistoryForStory(story) {
+    return this.getHealHistory().filter(h => h.story === story);
+  },
+
+  // ── Traceability ──
+
+  getTraceability() {
+    return readJSON(traceabilityPath()) || { stories: {} };
+  },
+
+  addRunId(story, runId, success, testName) {
+    const data = this.getTraceability();
+    if (!data.stories[story]) {
+      data.stories[story] = { plan: null, spec: null, runs: [], latest_heal: null, status: 'pending' };
+    }
+    data.stories[story].runs.push({ run_id: runId, success, test: testName || null, timestamp: new Date().toISOString() });
+    data.stories[story].status = success ? 'stable' : 'unstable';
+    writeJSON(traceabilityPath(), data);
+  },
+
+  addPlan(story, planFile) {
+    const data = this.getTraceability();
+    if (!data.stories[story]) data.stories[story] = { plan: null, spec: null, runs: [], latest_heal: null, status: 'pending' };
+    data.stories[story].plan = planFile;
+    writeJSON(traceabilityPath(), data);
+  },
+
+  addSpec(story, specFile) {
+    const data = this.getTraceability();
+    if (!data.stories[story]) data.stories[story] = { plan: null, spec: null, runs: [], latest_heal: null, status: 'pending' };
+    data.stories[story].spec = specFile;
+    writeJSON(traceabilityPath(), data);
+  },
+
+  setHealed(story, runId) {
+    const data = this.getTraceability();
+    if (!data.stories[story]) data.stories[story] = { plan: null, spec: null, runs: [], latest_heal: null, status: 'pending' };
+    data.stories[story].latest_heal = runId;
+    writeJSON(traceabilityPath(), data);
+  },
+
+  // ── Init ──
+
+  init() {
+    ensureDir(CONTEXT_DIR);
+    for (const file of ['pipeline.json', 'selectors.json', 'heal-history.json', 'traceability.json']) {
+      const fp = path.join(CONTEXT_DIR, file);
+      if (!fs.existsSync(fp)) {
+        const defaults = {
+          'pipeline.json': { project_path: '', phases: { plan: { completed: [], in_progress: null }, generate: { completed: [], in_progress: null }, execute: { completed: [], in_progress: null }, heal: { completed: [], in_progress: null }, report: { completed: [], in_progress: null } }, current_story: null, last_run_id: null, updated_at: '' },
+          'selectors.json': [],
+          'heal-history.json': [],
+          'traceability.json': { stories: {} },
+        };
+        writeJSON(fp, defaults[file]);
+      }
+    }
+  },
+
+  contextDir: CONTEXT_DIR,
+};
+
+module.exports = context;

package/scripts/executor.js

@@ -1,4 +1,5 @@
 const { DIRS, CONFIG, ensureDir, timestamp, log, writeMarkdown } = require('./utils');
+const context = require('./context-manager');
 const path = require('path');
 const fs = require('fs');
 const { execSync, spawn } = require('child_process');
@@ -10,15 +11,18 @@ function executeTests(testName, options = {}) {
     timeout = testCfg.timeout || 120000,
     retries = testCfg.retries || 0,
     workers = testCfg.workers || 1,
-    screenshots = 'off',
+    //screenshots = 'off',
   } = options;
 
   const runId = `run-${timestamp()}`;
   const runDir = path.join(DIRS.testResults, runId);
   ensureDir(runDir);
 
+  const storyName = testName ? testName.replace(/\.spec\.ts$/, '').split(/[\/\\]/).pop() : null;
+
   log('EXECUTOR', `Run ID: ${runId}`);
   log('EXECUTOR', `Test: ${testName || 'all tests'}`);
+  if (storyName) log('EXECUTOR', `Story: ${storyName}`);
 
   const args = ['playwright', 'test'];
 
@@ -37,12 +41,7 @@ function executeTests(testName, options = {}) {
   if (retries > 0) args.push('--retries', retries.toString());
   if (workers) args.push('--workers', workers.toString());
   if (timeout) args.push('--timeout', timeout.toString());
-  if (screenshots === 'off') {
-    args.push('--screenshot', 'off');
-  }
-  if (screenshots === 'only-on-failure') {
-    args.push('--screenshot', 'only-on-failure');
-  }
+  // Screenshots configured in playwright.config.ts — not a valid CLI arg
 
   const outputPath = path.join(runDir, 'execution-output.json');
   const resultPath = path.join(runDir, 'execution-result.json');
@@ -64,6 +63,7 @@ function executeTests(testName, options = {}) {
 
     const result = {
       runId,
+      story: storyName,
       test: testName || 'all',
       success: true,
       exitCode: 0,
@@ -75,6 +75,11 @@ function executeTests(testName, options = {}) {
     };
 
     writeMarkdown(resultPath, JSON.stringify(result, null, 2));
+    context.setLastRun(runId);
+    if (storyName) {
+      context.addRunId(storyName, runId, true, testName);
+      context.phaseComplete('execute', storyName);
+    }
     log('EXECUTOR', `Tests passed (${result.duration}ms)`);
 
     return result;
@@ -89,6 +94,7 @@ function executeTests(testName, options = {}) {
 
     const result = {
       runId,
+      story: storyName,
       test: testName || 'all',
       success: false,
       exitCode: err.status || 1,
@@ -100,6 +106,11 @@ function executeTests(testName, options = {}) {
     };
 
     writeMarkdown(resultPath, JSON.stringify(result, null, 2));
+    context.setLastRun(runId);
+    if (storyName) {
+      context.addRunId(storyName, runId, false, testName);
+      context.phaseComplete('execute', storyName);
+    }
     log('EXECUTOR', `Tests failed (${result.duration}ms) - ${failedTests.length} failure(s)`);
 
     return result;

package/scripts/generator.js

@@ -1,130 +1,24 @@
-const { DIRS, CONFIG, readMarkdown, writeMarkdown, slugify, log } = require('./utils');
-const path = require('path');
-const fs = require('fs');
-
-function generateTestSpec(planName) {
-  const planPath = path.join(DIRS.specs, planName);
-  if (!fs.existsSync(planPath)) {
-    console.error(`Test plan not found: ${planPath}`);
-    console.log(`Available plans: ${require('./utils').listTestPlans().join(', ')}`);
-    process.exit(1);
-  }
-
-  const content = readMarkdown(planPath);
-  const specName = planName.replace('-test-plan.md', '');
-  const specPath = path.join(DIRS.tests, `${specName}.spec.ts`);
-
-  log('GENERATOR', `Generating test spec from: ${planName}`);
-
-  const spec = generateSpecContent(content, specName, planName);
-
-  writeMarkdown(specPath, spec);
-  log('GENERATOR', `Test spec saved: tests/${specName}.spec.ts`);
-
-  return { specName, specPath };
-}
-
-function generateSpecContent(planContent, specName, planFileName) {
-  const featureMatch = planContent.match(/\*\*Feature\*\*:\s*(.+)/);
-  const feature = featureMatch ? featureMatch[1].trim() : specName;
-
-  const scenarios = extractScenarios(planContent);
-
-  const browserType = CONFIG.browser.type || 'chromium';
-  const cdpPort = CONFIG.browser.cdpPort || 9222;
-  const cdpImport = browserType === 'edge' ? "import { startEdgeCDP } from '../cdpSession';" : `import { chromium } from '@playwright/test';`;
-
-  let setupBlock;
-  if (browserType === 'edge') {
-    setupBlock = `    // const { page } = await startEdgeCDP();\n    // global.page = page;`;
-  } else {
-    setupBlock = `    // const browser = await chromium.launch({ headless: !process.env.HEADED });\n    // const page = await browser.newPage();\n    // global.page = page;`;
-  }
-
-  let spec = `import { test, expect } from '@playwright/test';
-${cdpImport}
-
-test.describe('${feature.replace(/'/g, "\\'")}', () => {
-
-  test.beforeEach(async () => {
-${setupBlock}
-  });
-
-  test.afterEach(async () => {
-    // Cleanup if needed
-  });
-
-`;
-
-  scenarios.forEach((scenario, idx) => {
-    const safeTitle = scenario.title.replace(/['"]/g, "'");
-    spec += `  test('${safeTitle}', async () => {\n`;
-    spec += `    // TODO: Implement test steps from plan\n`;
-    spec += `    // Reference: specs/${planFileName} (Scenario ${idx + 3}.1)\n`;
-    spec += `    // \n`;
-
-    scenario.steps.forEach((step, si) => {
-      const truncated = step.length > 100 ? step.substring(0, 97) + '...' : step;
-      spec += `    // Step ${si + 1}: ${truncated}\n`;
-    });
-
-    spec += `    // \n`;
-    spec += `    // Expected: ${scenario.expected || 'Workflow completes successfully'}\n`;
-    spec += `    \n`;
-    spec += `  });\n\n`;
-  });
-
-  spec += `});\n`;
-
-  return spec;
-}
-
-function extractScenarios(content) {
-  const scenarios = [];
-  const lines = content.split('\n');
-  let current = null;
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-
-    const scenarioMatch = line.match(/###\s+\d+\.\d+\s+Scenario:\s*(.+)/i);
-    if (scenarioMatch) {
-      if (current) scenarios.push(current);
-      current = { title: scenarioMatch[1].trim(), steps: [], expected: '' };
-      continue;
-    }
-
-    if (current) {
-      const stepMatch = line.match(/^\d+\.\s+(.+)/);
-      if (stepMatch && !line.match(/^\d+\.\s+\*\*/)) {
-        current.steps.push(stepMatch[1].trim());
-      }
-
-      const expectedMatch = line.match(/Expected Results?[:\]]\s*(.+)/i);
-      if (expectedMatch) {
-        current.expected = expectedMatch[1].trim();
-      }
-
-      if (line.match(/---/) && current.steps.length > 0) {
-        scenarios.push(current);
-        current = null;
-      }
-    }
-  }
-
-  if (current) scenarios.push(current);
-
-  return scenarios;
+function generateTestSpec() {
+  console.log('');
+  console.log('╔══════════════════════════════════════════════════════════╗');
+  console.log('║  TEST GENERATION is handled by the AI agent            ║');
+  console.log('║                                                         ║');
+  console.log('║  The AI reads playwright-test-generator.agent.md,       ║');
+  console.log('║  uses Playwright MCP to capture real selectors, and     ║');
+  console.log('║  writes complete Playwright tests directly to tests/.   ║');
+  console.log('║                                                         ║');
+  console.log('║  The AI will STOP and ask for your approval before      ║');
+  console.log('║  proceeding to execution.                               ║');
+  console.log('║                                                         ║');
+  console.log('║  Tell your AI agent:                                    ║');
+  console.log('║  "Generate tests for the plan in specs/"                ║');
+  console.log('╚══════════════════════════════════════════════════════════╝');
+  console.log('');
+  process.exit(0);
 }
 
 if (require.main === module) {
-  const planName = process.argv[2];
-  if (!planName) {
-    console.log('Usage: node scripts/generator.js <test-plan-file.md>');
-    console.log(`Available: ${require('./utils').listTestPlans().join(', ')}`);
-    process.exit(1);
-  }
-  generateTestSpec(planName);
+  generateTestSpec();
 }
 
 module.exports = { generateTestSpec };