@continuum8032/playwright-ai-tools 0.2.0-oidc-bootstrap.0

package/dist/index.cjs

@@ -0,0 +1,2030 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DeterministicAnalyzer: () => DeterministicAnalyzer,
+  FailureGrouper: () => FailureGrouper,
+  MemoryStore: () => MemoryStore,
+  OpenAIResponsesProvider: () => OpenAIResponsesProvider,
+  PostgresStore: () => PostgresStore,
+  SQLiteStore: () => SQLiteStore,
+  TemplateTestGenerationProvider: () => TemplateTestGenerationProvider,
+  analyzeFailures: () => analyzeFailures,
+  assertBrowserGenerationAllowed: () => assertBrowserGenerationAllowed,
+  benchmarkFailures: () => benchmarkFailures,
+  classifyFailure: () => classifyFailure,
+  enrichFailureWithArtifacts: () => enrichFailureWithArtifacts,
+  evaluatePatchPolicy: () => evaluatePatchPolicy,
+  generatePatchSuggestions: () => generatePatchSuggestions,
+  generatePlaywrightTestDraft: () => generatePlaywrightTestDraft,
+  htmlReport: () => htmlReport,
+  importLegacyRows: () => importLegacyRows,
+  isDestructiveManualCase: () => isDestructiveManualCase,
+  markdownReport: () => markdownReport,
+  mcpSummary: () => mcpSummary,
+  normalizePlaywrightJsonReport: () => normalizePlaywrightJsonReport,
+  parseTraceArtifact: () => parseTraceArtifact,
+  writePortableReport: () => writePortableReport
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/signature.ts
+var import_node_crypto = require("crypto");
+function normalizeErrorForSignature(error) {
+  return error.replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, "UUID").replace(/\d+/g, "N").replace(/(['"])(.*?)\1/g, (_match, quote, value) => {
+    const normalizedValue = value.replace(/\d+/g, "N");
+    return `${quote}${normalizedValue}${quote}`;
+  }).replace(/\/[\w./-]+/g, "PATH").slice(0, 500);
+}
+function failureSignature(failure) {
+  return (0, import_node_crypto.createHash)("sha256").update(normalizeErrorForSignature(failure.error)).digest("hex");
+}
+function readablePattern(error) {
+  const firstLine2 = error.split("\n")[0] || "Unknown failure";
+  return firstLine2.length > 120 ? `${firstLine2.slice(0, 117)}...` : firstLine2;
+}
+function extractSelectors(error) {
+  const selectors = /* @__PURE__ */ new Set();
+  const patterns = [
+    /locator\((['"`])(.+?)\1\)/g,
+    /selector\s+(['"`])(.+?)\1/g,
+    /(?:getByTestId|data-testid)[^\n'"`]*(['"`])(.+?)\1/g
+  ];
+  for (const pattern of patterns) {
+    for (const match of error.matchAll(pattern)) {
+      const value = match[2]?.trim();
+      if (value) {
+        selectors.add(value);
+      }
+    }
+  }
+  return [...selectors];
+}
+function extractUrls(error) {
+  const urls = /* @__PURE__ */ new Set();
+  for (const match of error.matchAll(/https?:\/\/[^\s)'"]+|\/api\/[^\s)'"]+/g)) {
+    urls.add(match[0]);
+  }
+  return [...urls];
+}
+
+// src/taxonomy.ts
+function firstLine(text) {
+  return text.split("\n")[0] || text;
+}
+function evidence(failure) {
+  const items = [firstLine(failure.error)];
+  for (const item of failure.consoleErrors || []) {
+    items.push(`console:${item.level}:${item.text}`);
+  }
+  for (const item of failure.networkFailures || []) {
+    items.push(`network:${item.method || "GET"}:${item.status || item.errorText}:${item.url}`);
+  }
+  for (const item of failure.lastActions || []) {
+    items.push(`action:${item.name}${item.selector ? `:${item.selector}` : ""}`);
+  }
+  return items.filter(Boolean);
+}
+function evidenceRefs(failure) {
+  const refs = ["error"];
+  if (failure.consoleErrors?.length) refs.push("consoleErrors[0]");
+  if (failure.networkFailures?.length) refs.push("networkFailures[0]");
+  if (failure.lastActions?.length) refs.push("lastActions[-1]");
+  if (failure.pageSnapshot) refs.push("pageSnapshot");
+  if (failure.artifactRefs?.length || failure.artifacts?.length) refs.push("artifactRefs");
+  return refs;
+}
+function matchFailure(failure) {
+  const text = [
+    failure.error,
+    ...(failure.consoleErrors || []).map((item) => item.text),
+    ...(failure.networkFailures || []).map((item) => `${item.status || ""} ${item.errorText || ""} ${item.url}`)
+  ].join("\n").toLowerCase();
+  if (/strict mode violation|resolved to \d+ elements|locator\(.+\) resolved/.test(text)) {
+    return {
+      category: "selector",
+      risk: "medium",
+      side: "test_bug",
+      rootCause: "A locator is ambiguous or no longer points to the intended element.",
+      suggestions: ["Make the locator specific to the intended role, label, text, or test id."],
+      confidence: 94,
+      humanReview: false,
+      reason: "Playwright reported strict locator matching evidence."
+    };
+  }
+  if (/not receiving pointer events|intercepts pointer events|element is covered|element is detached|not enabled|not editable/.test(text)) {
+    return {
+      category: "interaction",
+      risk: "medium",
+      side: "test_bug",
+      rootCause: "The page changed the interaction state before Playwright could complete the action.",
+      suggestions: ["Wait for the actionable UI state and inspect overlays, disabled states, or animations."],
+      confidence: 88,
+      humanReview: true,
+      reason: "The failure describes an element actionability or interaction problem."
+    };
+  }
+  if (/screenshot|snapshot|pixel|visual|image comparison|tohavescreenshot/.test(text)) {
+    return {
+      category: "visual",
+      risk: "medium",
+      side: "unknown",
+      rootCause: "A visual assertion differs from the stored baseline or expected snapshot.",
+      suggestions: ["Inspect the screenshot diff and update the baseline only if the product change is intended."],
+      confidence: 86,
+      humanReview: true,
+      reason: "The error contains visual comparison evidence."
+    };
+  }
+  if (/no test data|fixture|seed|factory|test data|not found for .*user|missing data/.test(text)) {
+    return {
+      category: "test_data",
+      risk: "medium",
+      side: "test_bug",
+      rootCause: "The test appears to depend on missing or inconsistent data setup.",
+      suggestions: ["Make the data fixture explicit and validate setup before the user journey starts."],
+      confidence: 84,
+      humanReview: false,
+      reason: "The failure references missing seeded data or fixture setup."
+    };
+  }
+  if (/net::err_|econnrefused|enotfound|timed out connecting|500|502|503|504|internal server error|service unavailable|fetch failed/.test(text)) {
+    return {
+      category: "environment",
+      risk: "high",
+      side: "env_issue",
+      rootCause: "A backend, network, or environment dependency failed during the test.",
+      suggestions: ["Check dependency health, request logs, and CI environment configuration for the failing endpoint."],
+      confidence: 86,
+      humanReview: true,
+      reason: "Network or server failure evidence was found."
+    };
+  }
+  if (/typeerror|referenceerror|cannot read properties|is not defined|uncaught|unhandled/.test(text)) {
+    return {
+      category: "runtime",
+      risk: "high",
+      side: "app_bug",
+      rootCause: "The application or test runtime threw an exception during the scenario.",
+      suggestions: ["Inspect the console stack, failing page state, and recent runtime changes."],
+      confidence: 88,
+      humanReview: true,
+      reason: "Runtime exception evidence was found in the error or console output."
+    };
+  }
+  if (/timeout|waiting for locator|waiting for selector|tobevisible|to be visible|waiting for .*state/.test(text)) {
+    return {
+      category: "timing",
+      risk: "medium",
+      side: "test_bug",
+      rootCause: "A Playwright wait timed out before the expected element or state appeared.",
+      suggestions: [
+        "Verify the expected UI state is still correct.",
+        "Wait for the user-visible state with an assertion before acting.",
+        "Check whether navigation or data setup leaves the element hidden."
+      ],
+      confidence: 90,
+      humanReview: false,
+      reason: "Playwright reported a timeout while waiting for an expected state."
+    };
+  }
+  return {
+    category: "unknown",
+    risk: "high",
+    side: "unknown",
+    rootCause: "No deterministic taxonomy rule matched this failure.",
+    suggestions: ["Review trace, screenshot, console output, network output, and recent changes."],
+    confidence: 30,
+    humanReview: true,
+    reason: "No deterministic classifier matched the available evidence."
+  };
+}
+function analysisWithDefaults(analysis, failure, source = analysis.source || "unknown") {
+  const classified = matchFailure(failure);
+  const urls = extractUrls(failure.error);
+  return {
+    side: analysis.side || classified.side,
+    rootCause: analysis.rootCause || classified.rootCause,
+    evidence: analysis.evidence?.length ? analysis.evidence : evidence(failure),
+    reproductionSteps: analysis.reproductionSteps?.length ? analysis.reproductionSteps : failure.steps?.length ? failure.steps : ["Run the failing Playwright test."],
+    suspects: analysis.suspects || {
+      selectors: extractSelectors(failure.error),
+      pages: urls.filter((url) => !url.startsWith("/api/")),
+      endpoints: [
+        ...urls.filter((url) => url.startsWith("/api/")),
+        ...(failure.networkFailures || []).map((item) => item.url)
+      ]
+    },
+    fixSuggestions: analysis.fixSuggestions?.length ? analysis.fixSuggestions : classified.suggestions,
+    confidence: Number(analysis.confidence ?? classified.confidence),
+    category: analysis.category || classified.category,
+    risk: analysis.risk || classified.risk,
+    evidenceRefs: analysis.evidenceRefs?.length ? analysis.evidenceRefs : evidenceRefs(failure),
+    confidenceReasons: analysis.confidenceReasons?.length ? analysis.confidenceReasons : [classified.reason],
+    needsHumanReview: analysis.needsHumanReview ?? classified.humanReview,
+    suggestedFixes: analysis.suggestedFixes,
+    source,
+    tokenUsage: analysis.tokenUsage
+  };
+}
+function classifyFailure(failure) {
+  const matched = matchFailure(failure);
+  return analysisWithDefaults(
+    {
+      side: matched.side,
+      rootCause: matched.rootCause,
+      fixSuggestions: matched.suggestions,
+      confidence: matched.confidence,
+      category: matched.category,
+      risk: matched.risk,
+      needsHumanReview: matched.humanReview,
+      source: matched.category === "unknown" ? "unknown" : "deterministic"
+    },
+    failure,
+    matched.category === "unknown" ? "unknown" : "deterministic"
+  );
+}
+
+// src/analyzer.ts
+function deterministicAnalysis(failure) {
+  const classified = classifyFailure(failure);
+  return classified.category === "unknown" ? null : classified;
+}
+function unknownAnalysis(failure) {
+  return analysisWithDefaults(
+    {
+      rootCause: "No deterministic pattern matched and no AI provider was configured.",
+      source: "unknown"
+    },
+    failure,
+    "unknown"
+  );
+}
+function contextQuery(failure) {
+  return [
+    failure.title,
+    failure.file,
+    ...extractSelectors(failure.error),
+    ...failure.steps || [],
+    failure.error.split("\n")[0]
+  ].filter(Boolean).join(" ").slice(0, 500);
+}
+function queryTokens(query) {
+  return [
+    ...new Set(
+      query.toLowerCase().split(/[^a-z0-9_-]+/i).map((item) => item.trim()).filter((item) => item.length > 2)
+    )
+  ];
+}
+function matchesAnyToken(value, tokens) {
+  const text = JSON.stringify(value).toLowerCase();
+  return tokens.some((token) => text.includes(token));
+}
+function memorySuggestion(record) {
+  const value = record.value || {};
+  const summary = typeof value.summary === "string" ? value.summary : typeof value.text === "string" ? value.text : JSON.stringify(value);
+  return summary.length > 240 ? `${summary.slice(0, 237)}...` : summary;
+}
+async function contextForFailure(store, failure, options) {
+  if (!store) {
+    return { memories: [], feedbackReasons: [], similarFailures: [], similarAnalyses: [] };
+  }
+  const query = contextQuery(failure);
+  const tokens = queryTokens(query);
+  const namespace = options.projectContext?.namespace || "default";
+  const limit = options.similarityLimit ?? 5;
+  const memories = [
+    ...await store.searchMemory({ namespace, limit: 100 }),
+    ...namespace === "default" ? [] : await store.searchMemory({ namespace: "default", limit: 100 })
+  ].filter((record) => matchesAnyToken(record, tokens)).slice(0, limit);
+  const feedback = (await store.searchFeedback({ limit: 100 })).filter((record) => matchesAnyToken(record, tokens)).slice(0, limit);
+  const similarFailures = (await store.findFailures({ limit: 100 })).filter((record) => matchesAnyToken(record, tokens)).slice(0, limit);
+  const similarAnalyses = (await Promise.all(similarFailures.map((item) => store.getCachedAnalysis(failureSignature(item))))).filter((item) => Boolean(item));
+  return {
+    memories,
+    feedbackReasons: feedback.map((record) => `feedback:${record.decision}${record.reason ? `:${record.reason}` : ""}`),
+    similarFailures,
+    similarAnalyses
+  };
+}
+function applyContext(analysis, context) {
+  const knownFixes = context.memories.filter((record) => ["known_fix", "knowledge", "known_issue", "owner"].includes(record.kind));
+  const suggestions = knownFixes.map(memorySuggestion).filter(Boolean);
+  const confidenceReasons = [
+    ...analysis.confidenceReasons,
+    ...knownFixes.map((record) => `memory:${record.kind}:${record.key}`),
+    ...context.feedbackReasons
+  ];
+  if (context.similarFailures.length > 0) {
+    confidenceReasons.push(
+      `history:${context.similarFailures.length} similar failure${context.similarFailures.length === 1 ? "" : "s"}`
+    );
+  }
+  const flakyFeedback = context.feedbackReasons.some((reason) => reason.startsWith("feedback:mark_flaky"));
+  return {
+    ...analysis,
+    side: flakyFeedback && analysis.side === "unknown" ? "flaky_test" : analysis.side,
+    fixSuggestions: [...analysis.fixSuggestions, ...suggestions],
+    evidence: analysis.evidence,
+    evidenceRefs: analysis.evidenceRefs,
+    confidenceReasons: [...new Set(confidenceReasons)],
+    needsHumanReview: analysis.needsHumanReview || flakyFeedback || knownFixes.some((record) => record.kind === "known_issue")
+  };
+}
+var DeterministicAnalyzer = class {
+  constructor(options = {}) {
+    this.provider = options.provider;
+    this.outputLanguage = options.outputLanguage || process.env.PW_AI_OUTPUT_LANGUAGE || "ru";
+  }
+  async analyzeFailure(failure, similarAnalyses = []) {
+    const deterministic = deterministicAnalysis(failure);
+    if (deterministic) {
+      return deterministic;
+    }
+    if (this.provider) {
+      const ai = await this.provider.analyzeFailure({
+        failure,
+        outputLanguage: this.outputLanguage,
+        similarAnalyses
+      });
+      return analysisWithDefaults(ai, failure, "ai");
+    }
+    return unknownAnalysis(failure);
+  }
+  async analyzeFailures(failures) {
+    return Promise.all(failures.map((failure) => this.analyzeFailure(failure)));
+  }
+};
+async function analyzeFailures(failures, options = {}) {
+  const outputLanguage = options.outputLanguage || process.env.PW_AI_OUTPUT_LANGUAGE || "ru";
+  const analyzer = new DeterministicAnalyzer({ provider: options.provider, outputLanguage });
+  const results = [];
+  for (const failure of failures) {
+    const signature = failureSignature(failure);
+    const cached = options.store ? await options.store.getCachedAnalysis(signature) : null;
+    if (cached) {
+      results.push(cached);
+      continue;
+    }
+    const context = await contextForFailure(options.store, failure, options);
+    const rawAnalysis = await analyzer.analyzeFailure(failure, context.similarAnalyses);
+    let analysis = applyContext(rawAnalysis, context);
+    if (options.store) {
+      await options.store.saveAnalysis(signature, analysis);
+    }
+    results.push(analysis);
+  }
+  return results;
+}
+
+// src/suggestions.ts
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"), 1);
+function assertionCount(text) {
+  return (text.match(/\bexpect\s*\(/g) || []).length;
+}
+function onlyTimeoutChanged(oldSnippet, newSnippet) {
+  const oldNormalized = oldSnippet.replace(/\d+/g, "#").replace(/\s+/g, " ").trim();
+  const newNormalized = newSnippet.replace(/\d+/g, "#").replace(/\s+/g, " ").trim();
+  return oldNormalized === newNormalized && /timeout/i.test(`${oldSnippet}
+${newSnippet}`);
+}
+function testIdLocator(selector) {
+  const match = selector.match(/\[data-testid=['"]?([^'"\]]+)['"]?\]/i);
+  if (match) return `page.getByTestId("${match[1]}")`;
+  return `page.locator(${JSON.stringify(selector)})`;
+}
+function firstSelector(failure) {
+  return extractSelectors(failure.error)[0] || failure.lastActions?.find((action) => action.selector)?.selector;
+}
+function sourceLine(failure, options) {
+  if (!failure.line) return void 0;
+  const filePath = import_node_path.default.isAbsolute(failure.file) ? failure.file : import_node_path.default.resolve(options.workspaceRoot || process.cwd(), failure.file);
+  if (!(0, import_node_fs.existsSync)(filePath)) return void 0;
+  const lines = (0, import_node_fs.readFileSync)(filePath, "utf8").split(/\r?\n/);
+  return lines[failure.line - 1];
+}
+function evaluatePatchPolicy(suggestion) {
+  const oldAssertions = assertionCount(suggestion.oldSnippet);
+  const newAssertions = assertionCount(suggestion.newSnippet);
+  if (oldAssertions > 0 && newAssertions < oldAssertions) {
+    return {
+      ...suggestion,
+      policyDecision: "blocked",
+      reviewReason: "Blocked: patch weakens or removes an assertion."
+    };
+  }
+  if (/assertion removed|delete assertion|remove assertion/i.test(suggestion.newSnippet)) {
+    return {
+      ...suggestion,
+      policyDecision: "blocked",
+      reviewReason: "Blocked: patch appears to remove an assertion."
+    };
+  }
+  if (onlyTimeoutChanged(suggestion.oldSnippet, suggestion.newSnippet) && suggestion.evidence.length === 0) {
+    return {
+      ...suggestion,
+      policyDecision: "blocked",
+      reviewReason: "Blocked: timeout-only changes require supporting evidence."
+    };
+  }
+  if (/\btest\.skip\b|\breturn;\s*$|TODO:\s*remove check/i.test(suggestion.newSnippet)) {
+    return {
+      ...suggestion,
+      policyDecision: "blocked",
+      reviewReason: "Blocked: patch changes test intent instead of explaining the failure."
+    };
+  }
+  return {
+    ...suggestion,
+    policyDecision: "review",
+    reviewReason: suggestion.reviewReason || "Requires human approval; core never applies patches automatically."
+  };
+}
+function generatePatchSuggestions(failure, analysis, options = {}) {
+  const evidence2 = [...analysis.evidence || [], ...analysis.evidenceRefs || []].filter(Boolean);
+  const selector = firstSelector(failure);
+  const locator = selector ? testIdLocator(selector) : 'page.locator("<target>")';
+  const lastAction = failure.lastActions?.slice(-1)[0];
+  const oldSourceLine = sourceLine(failure, options);
+  let suggestion;
+  if (analysis.category === "selector") {
+    suggestion = {
+      filePath: failure.file,
+      oldSnippet: `await ${locator}.click();`,
+      newSnippet: `await ${locator}.filter({ hasText: "<expected text>" }).click();`,
+      explanation: "Narrow the locator to the intended element instead of relying on an ambiguous match.",
+      evidence: evidence2,
+      risk: analysis.risk,
+      policyDecision: "review",
+      reviewReason: ""
+    };
+  } else if (analysis.category === "environment") {
+    suggestion = {
+      filePath: failure.file,
+      oldSnippet: 'await page.goto("<page>");',
+      newSnippet: 'const response = await page.goto("<page>");\nawait expect(response, "page request should succeed").toBeOK();',
+      explanation: "Expose the failing backend or environment dependency before continuing with UI assertions.",
+      evidence: evidence2,
+      risk: analysis.risk,
+      policyDecision: "review",
+      reviewReason: ""
+    };
+  } else if (analysis.category === "runtime") {
+    suggestion = {
+      filePath: failure.file,
+      oldSnippet: 'await page.goto("<page>");',
+      newSnippet: 'const consoleErrors: string[] = [];\npage.on("console", (message) => message.type() === "error" && consoleErrors.push(message.text()));\nawait page.goto("<page>");',
+      explanation: "Capture runtime console evidence so the owner can fix the thrown exception with context.",
+      evidence: evidence2,
+      risk: analysis.risk,
+      policyDecision: "review",
+      reviewReason: ""
+    };
+  } else {
+    const actionLocator = lastAction?.selector ? testIdLocator(lastAction.selector) : locator;
+    suggestion = {
+      filePath: failure.file,
+      line: failure.line,
+      oldSnippet: oldSourceLine || `await ${actionLocator}.click();`,
+      newSnippet: oldSourceLine ? `${oldSourceLine.match(/^\s*/)?.[0] || ""}await expect(${actionLocator}).toBeVisible();
+${oldSourceLine}` : `await expect(${actionLocator}).toBeVisible();
+await ${actionLocator}.click();`,
+      explanation: "Wait for the user-visible state before the action; do not increase timeouts without evidence.",
+      evidence: evidence2,
+      risk: analysis.risk,
+      policyDecision: "review",
+      reviewReason: ""
+    };
+  }
+  return [evaluatePatchPolicy(suggestion)];
+}
+
+// src/benchmark.ts
+function roundMetric(value) {
+  return Number(value.toFixed(4));
+}
+function benchmarkFailures(fixtures) {
+  const seenSignatures = /* @__PURE__ */ new Set();
+  const failures = fixtures.map((fixture) => {
+    const analysis = classifyFailure(fixture);
+    const suggestions = generatePatchSuggestions(fixture, analysis);
+    const signature = failureSignature(fixture);
+    const cacheHit = seenSignatures.has(signature);
+    seenSignatures.add(signature);
+    const expectedCategory = fixture.expectedCategory || "unknown";
+    return {
+      title: fixture.title,
+      file: fixture.file,
+      expectedCategory,
+      actualCategory: analysis.category,
+      correct: expectedCategory === analysis.category,
+      signature,
+      cacheHit,
+      analysis,
+      suggestions
+    };
+  });
+  const total = failures.length;
+  const correct = failures.filter((failure) => failure.correct).length;
+  const unknown = failures.filter((failure) => failure.actualCategory === "unknown").length;
+  const cacheHits = failures.filter((failure) => failure.cacheHit).length;
+  const blocked = failures.reduce(
+    (count, failure) => count + failure.suggestions.filter((suggestion) => suggestion.policyDecision === "blocked").length,
+    0
+  );
+  const review = failures.reduce(
+    (count, failure) => count + failure.suggestions.filter((suggestion) => suggestion.policyDecision === "review").length,
+    0
+  );
+  return {
+    metrics: {
+      total,
+      correct,
+      accuracy: total ? roundMetric(correct / total) : 0,
+      unknown,
+      unknownRate: total ? roundMetric(unknown / total) : 0,
+      cacheHits,
+      cacheHitRate: total ? roundMetric(cacheHits / total) : 0,
+      suggestions: { blocked, review }
+    },
+    failures
+  };
+}
+
+// src/evidence.ts
+var import_node_path3 = __toESM(require("path"), 1);
+
+// src/trace.ts
+var import_promises = require("fs/promises");
+var import_node_zlib = require("zlib");
+var import_node_path2 = __toESM(require("path"), 1);
+function parseEvents(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return [];
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) return parsed;
+    if (Array.isArray(parsed.events)) return parsed.events;
+    if (Array.isArray(parsed.traceEvents)) return parsed.traceEvents;
+    return [parsed];
+  } catch {
+    return trimmed.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+  }
+}
+function isZip(buffer, filePath) {
+  return import_node_path2.default.extname(filePath).toLowerCase() === ".zip" || buffer.readUInt32LE(0) === 67324752;
+}
+function isTextTraceEntry(name) {
+  const lower = name.toLowerCase();
+  if (lower.startsWith("resources/")) return false;
+  return lower.endsWith(".trace") || lower.endsWith(".network") || lower.endsWith(".json") || lower.endsWith(".jsonl") || lower.includes("trace") || lower.includes("network");
+}
+function findEndOfCentralDirectory(buffer) {
+  for (let index = buffer.length - 22; index >= 0; index -= 1) {
+    if (buffer.readUInt32LE(index) === 101010256) return index;
+  }
+  throw new Error("ZIP central directory not found in trace artifact");
+}
+function extractZipTexts(buffer) {
+  const eocd = findEndOfCentralDirectory(buffer);
+  const totalEntries = buffer.readUInt16LE(eocd + 10);
+  let offset = buffer.readUInt32LE(eocd + 16);
+  const texts = [];
+  for (let entry = 0; entry < totalEntries; entry += 1) {
+    if (buffer.readUInt32LE(offset) !== 33639248) break;
+    const method = buffer.readUInt16LE(offset + 10);
+    const compressedSize = buffer.readUInt32LE(offset + 20);
+    const nameLength = buffer.readUInt16LE(offset + 28);
+    const extraLength = buffer.readUInt16LE(offset + 30);
+    const commentLength = buffer.readUInt16LE(offset + 32);
+    const localOffset = buffer.readUInt32LE(offset + 42);
+    const name = buffer.subarray(offset + 46, offset + 46 + nameLength).toString("utf8");
+    offset += 46 + nameLength + extraLength + commentLength;
+    if (!isTextTraceEntry(name) || buffer.readUInt32LE(localOffset) !== 67324752) continue;
+    const localNameLength = buffer.readUInt16LE(localOffset + 26);
+    const localExtraLength = buffer.readUInt16LE(localOffset + 28);
+    const dataStart = localOffset + 30 + localNameLength + localExtraLength;
+    const compressed = buffer.subarray(dataStart, dataStart + compressedSize);
+    if (method === 0) {
+      texts.push(compressed.toString("utf8"));
+    } else if (method === 8) {
+      texts.push((0, import_node_zlib.inflateRawSync)(compressed).toString("utf8"));
+    }
+  }
+  return texts;
+}
+async function readTraceTexts(filePath) {
+  const buffer = await (0, import_promises.readFile)(filePath);
+  if (isZip(buffer, filePath)) {
+    return extractZipTexts(buffer);
+  }
+  return [buffer.toString("utf8")];
+}
+function timestamp(event) {
+  return event.wallTime || event.timestamp || event.time;
+}
+function actionFromEvent(event) {
+  const name = event.apiName || event.method || event.action;
+  if (!name) return null;
+  return {
+    name: String(name),
+    selector: event.selector || event.params?.selector,
+    url: event.url || event.params?.url,
+    timestamp: timestamp(event),
+    pageId: event.pageId
+  };
+}
+function consoleFromEvent(event) {
+  const level = String(event.level || event.messageType || "").toLowerCase();
+  const text = event.text || event.message || event.args?.join?.(" ");
+  if (!text || !["error", "warning", "warn"].includes(level)) return null;
+  return {
+    level: level === "warn" ? "warning" : level,
+    text: String(text),
+    url: event.location?.url || event.url,
+    lineNumber: event.location?.lineNumber,
+    columnNumber: event.location?.columnNumber,
+    timestamp: timestamp(event)
+  };
+}
+function networkFromEvent(event) {
+  const snapshot = event.snapshot || event;
+  const request = snapshot.request || event.request || {};
+  const response = snapshot.response || event.response || {};
+  const url = request.url || event.url;
+  const status = Number(response.status ?? event.status ?? 0);
+  const errorText = event.errorText || snapshot.errorText || response.errorText;
+  if (!url || status < 400 && !errorText) return null;
+  return {
+    url: String(url),
+    method: request.method || event.method,
+    status: status || void 0,
+    statusText: response.statusText,
+    errorText,
+    timestamp: timestamp(event)
+  };
+}
+function trimLastActions(actions) {
+  return actions.slice(-10);
+}
+async function parseTraceArtifact(filePath) {
+  const texts = await readTraceTexts(filePath);
+  const events = texts.flatMap(parseEvents);
+  const summary = {
+    consoleErrors: [],
+    networkFailures: [],
+    lastActions: [],
+    artifactRefs: [{ type: "trace", path: filePath }]
+  };
+  for (const event of events) {
+    if (!event || typeof event !== "object") continue;
+    if (event.type === "context-options" || event.browserName || event.viewport) {
+      const { type: _type, ...context } = event;
+      summary.browserContext = { ...summary.browserContext || {}, ...context };
+    }
+    if (event.type === "before" || event.type === "action") {
+      const action = actionFromEvent(event);
+      if (action) summary.lastActions = trimLastActions([...summary.lastActions, action]);
+    }
+    if (event.type === "after" && event.result) {
+      summary.page = {
+        ...summary.page || {},
+        url: event.result.url || summary.page?.url,
+        title: event.result.title || summary.page?.title
+      };
+    }
+    const consoleEvent = consoleFromEvent(event);
+    if (consoleEvent) summary.consoleErrors.push(consoleEvent);
+    const networkEvent = networkFromEvent(event);
+    if (networkEvent) summary.networkFailures.push(networkEvent);
+    const snapshot = event.snapshot?.html || event.snapshot?.body || event.html;
+    if (event.type === "page-snapshot" && snapshot) {
+      summary.pageSnapshot = String(snapshot);
+      summary.page = { ...summary.page || {}, snapshot: summary.pageSnapshot };
+    }
+  }
+  return summary;
+}
+
+// src/evidence.ts
+function isTraceArtifact(artifact) {
+  const haystack = `${artifact.type} ${artifact.path} ${artifact.contentType || ""}`.toLowerCase();
+  return haystack.includes("trace") || haystack.includes("jsonl") || haystack.includes("application/zip");
+}
+function resolveArtifactPath(artifactPath, root) {
+  if (import_node_path3.default.isAbsolute(artifactPath)) return artifactPath;
+  return import_node_path3.default.resolve(root || process.cwd(), artifactPath);
+}
+async function enrichFailureWithArtifacts(failure, options = {}) {
+  const artifacts = failure.artifacts || [];
+  const artifactRefs = [...failure.artifactRefs || [], ...artifacts];
+  let enriched = { ...failure, artifactRefs };
+  for (const artifact of artifacts.filter(isTraceArtifact)) {
+    let trace;
+    try {
+      trace = await parseTraceArtifact(resolveArtifactPath(artifact.path, options.artifactRoot));
+    } catch (error) {
+      enriched = {
+        ...enriched,
+        artifactRefs: [
+          ...artifactRefs,
+          {
+            ...artifact,
+            metadata: {
+              ...artifact.metadata || {},
+              parseError: error?.message || String(error)
+            }
+          }
+        ]
+      };
+      continue;
+    }
+    enriched = {
+      ...enriched,
+      trace,
+      browserContext: trace.browserContext || enriched.browserContext,
+      page: trace.page || enriched.page,
+      pageSnapshot: trace.pageSnapshot || enriched.pageSnapshot,
+      consoleErrors: [...enriched.consoleErrors || [], ...trace.consoleErrors],
+      networkFailures: [...enriched.networkFailures || [], ...trace.networkFailures],
+      lastActions: [...enriched.lastActions || [], ...trace.lastActions].slice(-10),
+      artifactRefs: [...artifactRefs, ...trace.artifactRefs]
+    };
+  }
+  return enriched;
+}
+
+// src/grouper.ts
+var FailureGrouper = class {
+  group(failures) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const failure of failures) {
+      const signature = failureSignature(failure);
+      groups.set(signature, [...groups.get(signature) || [], failure]);
+    }
+    return [...groups.entries()].map(([signature, groupedFailures]) => ({
+      signature,
+      pattern: readablePattern(groupedFailures[0]?.error || ""),
+      failures: groupedFailures
+    })).sort((a, b) => b.failures.length - a.failures.length);
+  }
+};
+
+// src/generation.ts
+var import_promises2 = require("fs/promises");
+var import_node_path4 = __toESM(require("path"), 1);
+var import_test = require("@playwright/test");
+var DESTRUCTIVE_PATTERNS = [
+  /\bdelete\b/i,
+  /\bremove\b/i,
+  /\bdestroy\b/i,
+  /\bpay\b/i,
+  /\bpayment\b/i,
+  /\bpurchase\b/i,
+  /\bsubmit\s+order\b/i,
+  /\bplace\s+order\b/i,
+  /\brefund\b/i,
+  /\bcancel\s+subscription\b/i
+];
+function safeSegment(value, fallback) {
+  const normalized = (value || fallback).trim().replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "").slice(0, 100);
+  return normalized || fallback;
+}
+function isLocalUrl(rawUrl) {
+  try {
+    const url = new URL(rawUrl);
+    return ["localhost", "127.0.0.1", "::1"].includes(url.hostname);
+  } catch {
+    return false;
+  }
+}
+function destructiveText(manualCase) {
+  return [
+    manualCase.title,
+    manualCase.description,
+    manualCase.preconditions,
+    ...manualCase.steps.flatMap((step) => [step.action, step.expected])
+  ].filter(Boolean).join("\n");
+}
+function isDestructiveManualCase(manualCase) {
+  const text = destructiveText(manualCase);
+  return DESTRUCTIVE_PATTERNS.some((pattern) => pattern.test(text));
+}
+function assertBrowserGenerationAllowed(request) {
+  if (!isLocalUrl(request.url) && !request.confirmBrowserRun) {
+    throw new Error(`Refusing to open external URL ${request.url}. Pass --confirm-browser-run to allow browser exploration.`);
+  }
+  if (isDestructiveManualCase(request.manualCase) && !request.allowDestructiveActions) {
+    throw new Error("Manual test case appears to contain destructive actions. Pass --allow-destructive-actions to override.");
+  }
+}
+function truncate(value, maxLength) {
+  return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
+}
+function defaultSource(manualCase) {
+  return manualCase.source?.provider || manualCase.source?.project || "manual";
+}
+var TemplateTestGenerationProvider = class {
+  async generateTest(request) {
+    const title = request.manualCase.title.replace(/'/g, "\\'");
+    const steps = request.manualCase.steps.map((step) => `  // Step ${step.index ?? ""}: ${step.action}${step.expected ? ` -> ${step.expected}` : ""}`.trimEnd()).join("\n");
+    return {
+      code: [
+        "import { test, expect } from '@playwright/test';",
+        "",
+        `test('${title}', async ({ page }) => {`,
+        `  await page.goto('${request.url}');`,
+        steps || "  // No manual steps were supplied.",
+        "  await expect(page).toHaveURL(/./);",
+        "});"
+      ].join("\n"),
+      locators: [],
+      coverage: request.manualCase.steps.map((step) => ({
+        stepIndex: step.index,
+        status: "partial",
+        notes: "Template provider preserved the manual step as a draft comment."
+      })),
+      warnings: ["Template provider generated a draft without AI locator reasoning. Review before committing."]
+    };
+  }
+};
+async function generatePlaywrightTestDraft(request) {
+  assertBrowserGenerationAllowed(request);
+  const outputDir = request.outputDir || "generated-tests";
+  const source = safeSegment(request.sourceName || defaultSource(request.manualCase), "manual");
+  const caseKey = safeSegment(request.manualCase.key || request.manualCase.id, "case");
+  const caseDir = import_node_path4.default.join(outputDir, source);
+  const filePath = import_node_path4.default.join(caseDir, `${caseKey}.spec.ts`);
+  const reportPath = import_node_path4.default.join(caseDir, `${caseKey}.generation-report.json`);
+  const screenshotPath = import_node_path4.default.join(caseDir, `${caseKey}.png`);
+  await (0, import_promises2.mkdir)(caseDir, { recursive: true });
+  const browser = await import_test.chromium.launch({ headless: true });
+  try {
+    const context = await browser.newContext(request.storageState ? { storageState: request.storageState } : {});
+    try {
+      const page = await context.newPage();
+      await page.goto(request.url, { waitUntil: "domcontentloaded" });
+      const screenshot = await page.screenshot({ fullPage: true });
+      const [title, html, bodyText] = await Promise.all([
+        page.title(),
+        page.content(),
+        page.locator("body").innerText({ timeout: 2e3 }).catch(() => "")
+      ]);
+      await (0, import_promises2.writeFile)(screenshotPath, screenshot);
+      const browserEvidence = {
+        requestedUrl: request.url,
+        currentUrl: page.url(),
+        title,
+        domSummary: truncate(bodyText, 8e3),
+        htmlSnippet: truncate(html, 12e3),
+        screenshotBase64: screenshot.toString("base64")
+      };
+      const generated = await request.provider.generateTest({
+        manualCase: request.manualCase,
+        url: request.url,
+        browser: browserEvidence,
+        outputLanguage: request.outputLanguage
+      });
+      const draft = {
+        manualCase: request.manualCase,
+        filePath,
+        reportPath,
+        screenshotPath,
+        code: generated.code,
+        locators: generated.locators || [],
+        coverage: generated.coverage || [],
+        warnings: generated.warnings || [],
+        browser: {
+          requestedUrl: browserEvidence.requestedUrl,
+          currentUrl: browserEvidence.currentUrl,
+          title: browserEvidence.title,
+          domSummary: browserEvidence.domSummary,
+          htmlSnippet: browserEvidence.htmlSnippet
+        },
+        needsHumanReview: true
+      };
+      const report = {
+        manualCase: request.manualCase,
+        browser: draft.browser,
+        locators: draft.locators,
+        coverage: draft.coverage,
+        warnings: draft.warnings,
+        needsHumanReview: draft.needsHumanReview,
+        artifacts: { filePath, reportPath, screenshotPath }
+      };
+      await (0, import_promises2.writeFile)(filePath, `${generated.code.trimEnd()}
+`, "utf8");
+      await (0, import_promises2.writeFile)(reportPath, `${JSON.stringify(report, null, 2)}
+`, "utf8");
+      return draft;
+    } finally {
+      await context.close();
+    }
+  } finally {
+    await browser.close();
+  }
+}
+
+// src/normalize.ts
+function walkSuites(suites, visitor) {
+  for (const suite of suites || []) {
+    for (const spec of suite.specs || []) {
+      visitor(spec, suite);
+    }
+    walkSuites(suite.suites || [], visitor);
+  }
+}
+function resultError(result) {
+  return result?.error?.message || result?.error?.stack || result?.errors?.[0]?.message || result?.errors?.[0]?.stack || "Unknown error";
+}
+function normalizeSteps(result) {
+  const collected = [];
+  const visit = (step, insideUserStep) => {
+    if (!step) return;
+    const category = step.category;
+    const isUserStep = category === "test.step";
+    const isExpect = category === "expect";
+    if ((isUserStep || isExpect) && !insideUserStep && step.title) {
+      collected.push(String(step.title));
+    }
+    for (const child of step.steps || []) {
+      visit(child, insideUserStep || isUserStep);
+    }
+  };
+  for (const step of result?.steps || []) {
+    visit(step, false);
+  }
+  return collected;
+}
+function attachmentType(contentType, name) {
+  if (contentType?.startsWith("image/")) return "screenshot";
+  if (contentType?.includes("zip")) return "trace";
+  if (contentType?.includes("video")) return "video";
+  if (name?.toLowerCase().includes("trace")) return "trace";
+  return name || "artifact";
+}
+function normalizeArtifacts(result) {
+  return (result?.attachments || []).filter((attachment) => attachment?.path).map((attachment) => ({
+    type: attachmentType(attachment.contentType, attachment.name),
+    path: String(attachment.path),
+    contentType: attachment.contentType
+  }));
+}
+function normalizePlaywrightJsonReport(report, options = {}) {
+  const failures = [];
+  const run = options.runId ? { id: options.runId } : void 0;
+  walkSuites(report?.suites || [], (spec) => {
+    for (const testCase of spec.tests || []) {
+      for (const result of testCase.results || []) {
+        if (!["failed", "timedOut", "interrupted"].includes(result.status)) {
+          continue;
+        }
+        failures.push({
+          title: String(spec.title || testCase.title || "unnamed test"),
+          file: String(spec.file || testCase.location?.file || "unknown"),
+          line: spec.line || testCase.location?.line,
+          project: testCase.projectName,
+          status: result.status,
+          retry: result.retry || 0,
+          durationMs: result.duration || 0,
+          error: resultError(result),
+          steps: normalizeSteps(result),
+          artifacts: normalizeArtifacts(result),
+          annotations: (testCase.annotations || []).map((annotation) => ({
+            type: String(annotation.type),
+            description: annotation.description
+          })),
+          run
+        });
+      }
+    }
+  });
+  return failures;
+}
+
+// src/providers/openai.ts
+var analysisSchema = {
+  type: "object",
+  properties: {
+    side: { type: "string", enum: ["app_bug", "test_bug", "flaky_test", "env_issue", "unknown"] },
+    rootCause: { type: "string" },
+    evidence: { type: "array", items: { type: "string" } },
+    reproductionSteps: { type: "array", items: { type: "string" } },
+    suspects: {
+      type: "object",
+      properties: {
+        selectors: { type: "array", items: { type: "string" } },
+        pages: { type: "array", items: { type: "string" } },
+        endpoints: { type: "array", items: { type: "string" } }
+      },
+      required: ["selectors", "pages", "endpoints"],
+      additionalProperties: false
+    },
+    fixSuggestions: { type: "array", items: { type: "string" } },
+    confidence: { type: "number", minimum: 0, maximum: 100 },
+    category: {
+      type: "string",
+      enum: ["selector", "timing", "runtime", "test_data", "visual", "interaction", "environment", "unknown"]
+    },
+    risk: { type: "string", enum: ["low", "medium", "high"] },
+    evidenceRefs: { type: "array", items: { type: "string" } },
+    confidenceReasons: { type: "array", items: { type: "string" } },
+    needsHumanReview: { type: "boolean" }
+  },
+  required: [
+    "side",
+    "rootCause",
+    "evidence",
+    "reproductionSteps",
+    "suspects",
+    "fixSuggestions",
+    "confidence",
+    "category",
+    "risk",
+    "evidenceRefs",
+    "confidenceReasons",
+    "needsHumanReview"
+  ],
+  additionalProperties: false
+};
+var generationSchema = {
+  type: "object",
+  properties: {
+    code: { type: "string" },
+    locators: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          stepIndex: { type: "number" },
+          selector: { type: "string" },
+          reason: { type: "string" }
+        },
+        required: ["selector", "reason"],
+        additionalProperties: false
+      }
+    },
+    coverage: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          stepIndex: { type: "number" },
+          status: { type: "string", enum: ["covered", "partial", "missing"] },
+          notes: { type: "string" }
+        },
+        required: ["status", "notes"],
+        additionalProperties: false
+      }
+    },
+    warnings: { type: "array", items: { type: "string" } }
+  },
+  required: ["code", "locators", "coverage", "warnings"],
+  additionalProperties: false
+};
+function normalizeAnalysis(data, usage) {
+  return {
+    side: data.side || "unknown",
+    rootCause: data.rootCause || data.root_cause || "No root cause returned",
+    evidence: data.evidence || [],
+    reproductionSteps: data.reproductionSteps || data.reproduction_steps || [],
+    suspects: data.suspects || { selectors: [], pages: [], endpoints: [] },
+    fixSuggestions: data.fixSuggestions || data.fix || [],
+    confidence: Number(data.confidence ?? 0),
+    category: data.category || "unknown",
+    risk: data.risk || "high",
+    evidenceRefs: data.evidenceRefs || [],
+    confidenceReasons: data.confidenceReasons || [],
+    needsHumanReview: data.needsHumanReview ?? true,
+    source: "ai",
+    tokenUsage: usage ? {
+      inputTokens: usage.input_tokens || usage.inputTokens || 0,
+      outputTokens: usage.output_tokens || usage.outputTokens || 0,
+      totalTokens: usage.total_tokens || usage.totalTokens || 0
+    } : void 0
+  };
+}
+function normalizeGeneratedTest(data) {
+  return {
+    code: String(data.code || ""),
+    locators: Array.isArray(data.locators) ? data.locators : [],
+    coverage: Array.isArray(data.coverage) ? data.coverage : [],
+    warnings: Array.isArray(data.warnings) ? data.warnings : []
+  };
+}
+function outputText(response) {
+  if (response.output_text) return response.output_text;
+  for (const item of response.output || []) {
+    for (const content of item.content || []) {
+      if (content.text) return content.text;
+    }
+  }
+  return "";
+}
+function compactFailure(failure) {
+  return {
+    title: failure.title,
+    file: failure.file,
+    line: failure.line,
+    project: failure.project,
+    status: failure.status,
+    retry: failure.retry,
+    durationMs: failure.durationMs,
+    error: failure.error,
+    steps: failure.steps || [],
+    artifacts: failure.artifacts || [],
+    annotations: failure.annotations || [],
+    browserContext: failure.browserContext,
+    page: failure.page,
+    consoleErrors: failure.consoleErrors || [],
+    networkFailures: failure.networkFailures || [],
+    lastActions: failure.lastActions || [],
+    artifactRefs: failure.artifactRefs || failure.artifacts || []
+  };
+}
+var OpenAIResponsesProvider = class {
+  constructor(options = {}) {
+    this.apiKey = options.apiKey ?? process.env.OPENAI_API_KEY ?? "";
+    this.model = options.model ?? process.env.PW_AI_MODEL ?? process.env.AI_MODEL ?? "gpt-4.1-mini";
+    this.baseUrl = options.baseUrl ?? "https://api.openai.com/v1/responses";
+    this.transport = options.transport ?? ((url, init) => fetch(url, init));
+  }
+  async analyzeFailure(request) {
+    if (!this.apiKey) {
+      throw new Error("OPENAI_API_KEY is required for OpenAIResponsesProvider");
+    }
+    const payload = {
+      model: this.model,
+      instructions: `You are a generic Playwright failure analyzer. Return concise ${request.outputLanguage} JSON only. Use only the supplied test failure, trace evidence, steps, artifacts, and similar analyses. Every conclusion must point to supplied evidenceRefs.`,
+      input: JSON.stringify({
+        failure: compactFailure(request.failure),
+        similarAnalyses: request.similarAnalyses || []
+      }),
+      text: {
+        format: {
+          type: "json_schema",
+          name: "playwright_failure_analysis",
+          strict: true,
+          schema: analysisSchema
+        }
+      }
+    };
+    const response = await this.transport(this.baseUrl, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.apiKey}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`OpenAI Responses request failed with status ${response.status}`);
+    }
+    const body = await response.json();
+    const rawText = outputText(body);
+    if (!rawText) {
+      throw new Error("OpenAI Responses payload did not contain output text");
+    }
+    return normalizeAnalysis(JSON.parse(rawText), body.usage);
+  }
+  async generateTest(request) {
+    if (!this.apiKey) {
+      throw new Error("OPENAI_API_KEY is required for OpenAIResponsesProvider");
+    }
+    const browser = {
+      requestedUrl: request.browser.requestedUrl,
+      currentUrl: request.browser.currentUrl,
+      title: request.browser.title,
+      domSummary: request.browser.domSummary,
+      htmlSnippet: request.browser.htmlSnippet
+    };
+    const content = [
+      {
+        type: "input_text",
+        text: JSON.stringify({
+          manualCase: request.manualCase,
+          url: request.url,
+          browser
+        })
+      }
+    ];
+    if (request.browser.screenshotBase64) {
+      content.push({
+        type: "input_image",
+        image_url: `data:image/png;base64,${request.browser.screenshotBase64}`
+      });
+    }
+    const payload = {
+      model: this.model,
+      instructions: `You generate review-only Playwright tests from manual test cases. Return concise ${request.outputLanguage || "ru"} JSON only. Use only the supplied manual steps, browser DOM evidence, URL, and screenshot. Prefer user-facing locators and data-testid selectors when the evidence supports them. Do not weaken assertions, do not invent credentials, and include warnings for any uncertain step.`,
+      input: [{ role: "user", content }],
+      text: {
+        format: {
+          type: "json_schema",
+          name: "playwright_test_generation",
+          strict: true,
+          schema: generationSchema
+        }
+      }
+    };
+    const response = await this.transport(this.baseUrl, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.apiKey}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`OpenAI Responses request failed with status ${response.status}`);
+    }
+    const body = await response.json();
+    const rawText = outputText(body);
+    if (!rawText) {
+      throw new Error("OpenAI Responses payload did not contain output text");
+    }
+    return normalizeGeneratedTest(JSON.parse(rawText));
+  }
+};
+
+// src/report.ts
+var import_promises3 = require("fs/promises");
+var import_node_path5 = __toESM(require("path"), 1);
+function escapeHtml(value) {
+  return String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function normalizedReport(report) {
+  return {
+    ...report,
+    suggestions: report.suggestions || report.failures.map((failure, index) => {
+      const analysis = report.analyses[index];
+      return analysis ? generatePatchSuggestions(failure, analysis) : [];
+    })
+  };
+}
+function markdownReport(report) {
+  const portable = normalizedReport(report);
+  const lines = [
+    "# Playwright AI Analysis Report",
+    "",
+    `Run: ${portable.run.id}`,
+    `Failures: ${portable.failures.length}`,
+    ""
+  ];
+  portable.failures.forEach((failure, index) => {
+    const analysis = portable.analyses[index];
+    const suggestions = portable.suggestions[index] || [];
+    lines.push(`## ${failure.title}`);
+    lines.push("");
+    lines.push(`- File: ${failure.file}${failure.line ? `:${failure.line}` : ""}`);
+    lines.push(`- Category: ${analysis?.category || "unknown"}`);
+    lines.push(`- Side: ${analysis?.side || "unknown"}`);
+    lines.push(`- Risk: ${analysis?.risk || "high"}`);
+    lines.push(`- Confidence: ${analysis?.confidence ?? 0}`);
+    lines.push(`- Root cause: ${analysis?.rootCause || "n/a"}`);
+    if (analysis?.evidenceRefs?.length) {
+      lines.push(`- Evidence refs: ${analysis.evidenceRefs.join(", ")}`);
+    }
+    if (failure.consoleErrors?.length || failure.networkFailures?.length) {
+      lines.push("- Evidence:");
+      for (const item of failure.consoleErrors || []) lines.push(`  - Console ${item.level}: ${item.text}`);
+      for (const item of failure.networkFailures || []) {
+        lines.push(`  - Network ${item.status || item.errorText}: ${item.method || "GET"} ${item.url}`);
+      }
+    }
+    if (suggestions.length) {
+      lines.push("");
+      lines.push("### Suggested Fixes");
+      for (const suggestion of suggestions) {
+        lines.push(`- ${suggestion.policyDecision}: ${suggestion.explanation} (${suggestion.reviewReason})`);
+      }
+    }
+    lines.push("");
+  });
+  return `${lines.join("\n")}
+`;
+}
+function htmlReport(report) {
+  const portable = normalizedReport(report);
+  const groups = new FailureGrouper().group(portable.failures);
+  const groupSummary = groups.map((group) => `<li><code>${escapeHtml(group.signature)}</code> ${group.failures.length} failure(s)</li>`).join("");
+  const failures = portable.failures.map((failure, index) => {
+    const analysis = portable.analyses[index];
+    const suggestions = portable.suggestions[index] || [];
+    const evidence2 = [
+      ...(failure.consoleErrors || []).map((item) => `Console ${item.level}: ${item.text}`),
+      ...(failure.networkFailures || []).map(
+        (item) => `Network ${item.status || item.errorText}: ${item.method || "GET"} ${item.url}`
+      ),
+      ...(failure.lastActions || []).map((item) => `Action ${item.name}${item.selector ? ` ${item.selector}` : ""}`),
+      ...(failure.artifactRefs || failure.artifacts || []).map((item) => `Artifact ${item.type}: ${item.path}`)
+    ];
+    return `<section class="failure" data-category="${escapeHtml(analysis?.category || "unknown")}">
+  <h2>${escapeHtml(failure.title)}</h2>
+  <p><strong>${escapeHtml(analysis?.category || "unknown")}</strong> ${escapeHtml(analysis?.side || "unknown")} risk=${escapeHtml(analysis?.risk || "high")} confidence=${escapeHtml(analysis?.confidence ?? 0)} humanReview=${escapeHtml(analysis?.needsHumanReview ?? true)}</p>
+  <p>${escapeHtml(analysis?.rootCause || failure.error)}</p>
+  <h3>Evidence</h3>
+  <ul>${evidence2.map((item) => `<li>${escapeHtml(item)}</li>`).join("") || "<li>No extra evidence collected.</li>"}</ul>
+  <h3>Suggested Fixes</h3>
+  <ul>${suggestions.map(
+      (suggestion) => `<li><strong>${escapeHtml(suggestion.policyDecision)}</strong> ${escapeHtml(suggestion.explanation)}<pre>${escapeHtml(suggestion.newSnippet)}</pre><small>${escapeHtml(suggestion.reviewReason)}</small></li>`
+    ).join("") || "<li>No suggestion available.</li>"}</ul>
+</section>`;
+  }).join("\n");
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Playwright AI Analysis Report</title>
+<style>
+body{font-family:system-ui,-apple-system,Segoe UI,sans-serif;margin:0;background:#f7f7f4;color:#171717}
+header,main{max-width:1120px;margin:0 auto;padding:24px}
+header{border-bottom:1px solid #d8d8d2}
+.summary{display:flex;gap:16px;flex-wrap:wrap}
+.pill{border:1px solid #c9c9c1;border-radius:6px;padding:6px 10px;background:white}
+.failure{background:white;border:1px solid #d8d8d2;border-radius:8px;padding:18px;margin:18px 0}
+pre{white-space:pre-wrap;background:#111;color:#f5f5f5;border-radius:6px;padding:12px;overflow:auto}
+code{font-size:.9em}
+</style>
+</head>
+<body>
+<header>
+<h1>Playwright AI Analysis Report</h1>
+<div class="summary"><span class="pill">Run ${escapeHtml(portable.run.id)}</span><span class="pill">Failures ${portable.failures.length}</span><span class="pill">Cache hits ${portable.analyses.filter((analysis) => analysis.source === "cache").length}</span></div>
+</header>
+<main>
+<h2>Groups</h2>
+<ul>${groupSummary}</ul>
+${failures}
+</main>
+</body>
+</html>
+`;
+}
+function mcpSummary(report) {
+  const portable = normalizedReport(report);
+  return portable.failures.map((failure, index) => {
+    const analysis = portable.analyses[index];
+    return [
+      `failure="${failure.title}"`,
+      `file=${failure.file}${failure.line ? `:${failure.line}` : ""}`,
+      `category=${analysis?.category || "unknown"}`,
+      `risk=${analysis?.risk || "high"}`,
+      `source=${analysis?.source || "unknown"}`,
+      `needsHumanReview=${analysis?.needsHumanReview ?? true}`
+    ].join(" ");
+  }).join("\n");
+}
+async function writePortableReport(outputDir, report) {
+  await (0, import_promises3.mkdir)(outputDir, { recursive: true });
+  const portable = normalizedReport(report);
+  await (0, import_promises3.writeFile)(import_node_path5.default.join(outputDir, "ai-analysis-report.json"), `${JSON.stringify(portable, null, 2)}
+`, "utf8");
+  await (0, import_promises3.writeFile)(import_node_path5.default.join(outputDir, "ai-analysis-report.md"), markdownReport(portable), "utf8");
+  await (0, import_promises3.writeFile)(import_node_path5.default.join(outputDir, "ai-analysis-report.html"), htmlReport(portable), "utf8");
+}
+
+// src/stores/memory.ts
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeTags(tags) {
+  return [...new Set(tags || [])].filter(Boolean).sort();
+}
+function recordText(record) {
+  return JSON.stringify([record.key, record.kind, record.source, record.tags, record.value]).toLowerCase();
+}
+var MemoryStore = class {
+  constructor() {
+    this.runs = /* @__PURE__ */ new Map();
+    this.failures = [];
+    this.analyses = /* @__PURE__ */ new Map();
+    this.memory = /* @__PURE__ */ new Map();
+    this.feedback = [];
+  }
+  async migrate() {
+  }
+  async saveRun(run) {
+    this.runs.set(run.id, run);
+  }
+  async saveFailure(failure) {
+    this.failures.push(failure);
+  }
+  async saveAnalysis(signature, analysis) {
+    this.analyses.set(signature, analysis);
+  }
+  async getCachedAnalysis(signature) {
+    const cached = this.analyses.get(signature);
+    return cached ? { ...cached, source: "cache" } : null;
+  }
+  async upsertMemory(input) {
+    const key = `${input.namespace}:${input.kind}:${input.key}`;
+    const existing = this.memory.get(key);
+    this.memory.set(key, {
+      namespace: input.namespace,
+      kind: input.kind,
+      key: input.key,
+      value: input.value,
+      tags: normalizeTags(input.tags),
+      confidence: input.confidence ?? 1,
+      source: input.source,
+      supersededBy: existing?.supersededBy ?? null,
+      createdAt: existing?.createdAt ?? now(),
+      updatedAt: now()
+    });
+  }
+  async searchMemory(input) {
+    const query = input.query?.toLowerCase().trim();
+    const tags = new Set(input.tags || []);
+    const matches = [...this.memory.values()].filter((record) => {
+      if (input.namespace && record.namespace !== input.namespace) return false;
+      if (input.kind && record.kind !== input.kind) return false;
+      if (tags.size > 0 && !record.tags.some((tag) => tags.has(tag))) return false;
+      if (query && !recordText(record).includes(query)) return false;
+      return !record.supersededBy;
+    });
+    return matches.slice(0, input.limit ?? 20);
+  }
+  async recordFeedback(input) {
+    this.feedback.push({
+      signature: input.signature,
+      decision: input.decision,
+      reason: input.reason || "",
+      metadata: input.metadata || {},
+      createdAt: now()
+    });
+  }
+  async searchFeedback(input) {
+    const query = input.query?.toLowerCase().trim();
+    return this.feedback.filter((record) => {
+      if (input.signature && record.signature !== input.signature) return false;
+      if (input.decision && record.decision !== input.decision) return false;
+      if (query && !JSON.stringify(record).toLowerCase().includes(query)) return false;
+      return true;
+    }).slice(0, input.limit ?? 20);
+  }
+  async findFailures(input) {
+    const query = input.query?.toLowerCase().trim();
+    return this.failures.filter((failure) => {
+      if (input.signature && failureSignature(failure) !== input.signature) return false;
+      if (input.file && failure.file !== input.file) return false;
+      if (query && !JSON.stringify(failure).toLowerCase().includes(query)) return false;
+      return true;
+    }).slice(0, input.limit ?? 20);
+  }
+  async getRun(id) {
+    return this.runs.get(id) || null;
+  }
+  async stats() {
+    return {
+      runs: this.runs.size,
+      failures: this.failures.length,
+      analyses: this.analyses.size,
+      memoryRecords: this.memory.size,
+      feedbackRecords: this.feedback.length
+    };
+  }
+  async close() {
+  }
+};
+
+// src/stores/sqlite.ts
+var import_promises4 = require("fs/promises");
+var import_node_path6 = __toESM(require("path"), 1);
+var import_sql = __toESM(require("sql.js"), 1);
+var sqlModule;
+function sql() {
+  sqlModule || (sqlModule = (0, import_sql.default)());
+  return sqlModule;
+}
+function now2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeTags2(tags) {
+  return [...new Set(tags || [])].filter(Boolean).sort();
+}
+function parsePayload(value) {
+  return typeof value === "string" ? JSON.parse(value) : value;
+}
+function hasSQLiteHeader(buffer) {
+  return buffer.subarray(0, 16).toString("utf8") === "SQLite format 3\0";
+}
+var SQLiteStore = class {
+  constructor(options = {}) {
+    this.loaded = false;
+    this.filePath = options.path || import_node_path6.default.join(process.cwd(), ".playwright-ai-tools", "ai-tools.sqlite");
+    this.inMemory = this.filePath === ":memory:";
+  }
+  async migrate() {
+    const db = await this.load();
+    db.run(`
+      CREATE TABLE IF NOT EXISTS runs (
+        id TEXT PRIMARY KEY,
+        payload TEXT NOT NULL,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS failures (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        signature TEXT,
+        file TEXT,
+        title TEXT,
+        run_id TEXT,
+        payload TEXT NOT NULL,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS analyses (
+        signature TEXT PRIMARY KEY,
+        payload TEXT NOT NULL,
+        updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS memory_records (
+        id TEXT PRIMARY KEY,
+        namespace TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        key TEXT NOT NULL,
+        tags TEXT NOT NULL,
+        payload TEXT NOT NULL,
+        updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS feedback_records (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        signature TEXT NOT NULL,
+        decision TEXT NOT NULL,
+        reason TEXT,
+        payload TEXT NOT NULL,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_failures_signature ON failures(signature);
+      CREATE INDEX IF NOT EXISTS idx_failures_file ON failures(file);
+      CREATE INDEX IF NOT EXISTS idx_memory_namespace_kind ON memory_records(namespace, kind);
+      CREATE INDEX IF NOT EXISTS idx_feedback_signature ON feedback_records(signature);
+      CREATE INDEX IF NOT EXISTS idx_feedback_decision ON feedback_records(decision);
+      CREATE INDEX IF NOT EXISTS idx_analyses_category ON analyses(json_extract(payload, '$.category'));
+      CREATE INDEX IF NOT EXISTS idx_analyses_risk ON analyses(json_extract(payload, '$.risk'));
+      CREATE INDEX IF NOT EXISTS idx_failures_error ON failures(json_extract(payload, '$.error'));
+    `);
+    await this.persist();
+  }
+  async saveRun(run) {
+    const db = await this.load();
+    db.run(
+      "INSERT OR REPLACE INTO runs (id, payload) VALUES (?, ?)",
+      [run.id, JSON.stringify(run)]
+    );
+    await this.persist();
+  }
+  async saveFailure(failure) {
+    const db = await this.load();
+    const signature = failureSignature(failure);
+    const runId = typeof failure.run?.id === "string" ? failure.run.id : null;
+    db.run(
+      "INSERT INTO failures (signature, file, title, run_id, payload) VALUES (?, ?, ?, ?, ?)",
+      [signature, failure.file, failure.title, runId, JSON.stringify(failure)]
+    );
+    await this.persist();
+  }
+  async saveAnalysis(signature, analysis) {
+    const db = await this.load();
+    db.run(
+      `
+      INSERT INTO analyses (signature, payload, updated_at)
+      VALUES (?, ?, CURRENT_TIMESTAMP)
+      ON CONFLICT(signature) DO UPDATE SET payload = excluded.payload, updated_at = CURRENT_TIMESTAMP
+      `,
+      [signature, JSON.stringify(analysis)]
+    );
+    await this.persist();
+  }
+  async getCachedAnalysis(signature) {
+    const rows = await this.all("SELECT payload FROM analyses WHERE signature = ? LIMIT 1", [signature]);
+    return rows[0]?.payload ? { ...parsePayload(rows[0].payload), source: "cache" } : null;
+  }
+  async upsertMemory(record) {
+    const db = await this.load();
+    const id = `${record.namespace}:${record.kind}:${record.key}`;
+    const existing = await this.searchMemory({
+      namespace: record.namespace,
+      kind: record.kind,
+      query: record.key,
+      limit: 100
+    });
+    const previous = existing.find((item) => item.key === record.key);
+    const memory = {
+      namespace: record.namespace,
+      kind: record.kind,
+      key: record.key,
+      value: record.value,
+      tags: normalizeTags2(record.tags),
+      confidence: record.confidence ?? 1,
+      source: record.source,
+      supersededBy: previous?.supersededBy ?? null,
+      createdAt: previous?.createdAt ?? now2(),
+      updatedAt: now2()
+    };
+    db.run(
+      `
+      INSERT INTO memory_records (id, namespace, kind, key, tags, payload, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+      ON CONFLICT(id) DO UPDATE SET
+        namespace = excluded.namespace,
+        kind = excluded.kind,
+        key = excluded.key,
+        tags = excluded.tags,
+        payload = excluded.payload,
+        updated_at = CURRENT_TIMESTAMP
+      `,
+      [id, memory.namespace, memory.kind, memory.key, JSON.stringify(memory.tags), JSON.stringify(memory)]
+    );
+    await this.persist();
+  }
+  async searchMemory(input) {
+    const rows = await this.all("SELECT payload FROM memory_records ORDER BY updated_at DESC");
+    const query = input.query?.toLowerCase().trim();
+    const tags = new Set(input.tags || []);
+    return rows.map((row) => parsePayload(row.payload)).filter((record) => {
+      if (input.namespace && record.namespace !== input.namespace) return false;
+      if (input.kind && record.kind !== input.kind) return false;
+      if (tags.size > 0 && !record.tags.some((tag) => tags.has(tag))) return false;
+      if (query && !JSON.stringify([record.key, record.kind, record.source, record.tags, record.value]).toLowerCase().includes(query)) {
+        return false;
+      }
+      return !record.supersededBy;
+    }).slice(0, input.limit ?? 20);
+  }
+  async recordFeedback(input) {
+    const db = await this.load();
+    const feedback = {
+      signature: input.signature,
+      decision: input.decision,
+      reason: input.reason || "",
+      metadata: input.metadata || {},
+      createdAt: now2()
+    };
+    db.run(
+      "INSERT INTO feedback_records (signature, decision, reason, payload) VALUES (?, ?, ?, ?)",
+      [feedback.signature, feedback.decision, feedback.reason, JSON.stringify(feedback)]
+    );
+    await this.persist();
+  }
+  async searchFeedback(input) {
+    const rows = await this.all("SELECT payload FROM feedback_records ORDER BY created_at DESC");
+    const query = input.query?.toLowerCase().trim();
+    return rows.map((row) => parsePayload(row.payload)).filter((record) => {
+      if (input.signature && record.signature !== input.signature) return false;
+      if (input.decision && record.decision !== input.decision) return false;
+      if (query && !JSON.stringify(record).toLowerCase().includes(query)) return false;
+      return true;
+    }).slice(0, input.limit ?? 20);
+  }
+  async findFailures(input) {
+    const rows = await this.all("SELECT payload FROM failures ORDER BY id DESC");
+    const query = input.query?.toLowerCase().trim();
+    return rows.map((row) => parsePayload(row.payload)).filter((failure) => {
+      if (input.signature && failureSignature(failure) !== input.signature) return false;
+      if (input.file && failure.file !== input.file) return false;
+      if (query && !JSON.stringify(failure).toLowerCase().includes(query)) return false;
+      return true;
+    }).slice(0, input.limit ?? 20);
+  }
+  async getRun(id) {
+    const rows = await this.all("SELECT payload FROM runs WHERE id = ? LIMIT 1", [id]);
+    return rows[0]?.payload ? parsePayload(rows[0].payload) : null;
+  }
+  async stats() {
+    const tables = ["runs", "failures", "analyses", "memory_records", "feedback_records"];
+    const stats = {};
+    for (const table of tables) {
+      const rows = await this.all(`SELECT COUNT(*) AS count FROM ${table}`);
+      stats[table === "memory_records" ? "memoryRecords" : table === "feedback_records" ? "feedbackRecords" : table] = Number(rows[0]?.count || 0);
+    }
+    return stats;
+  }
+  async close() {
+    if (!this.db) return;
+    await this.persist();
+    this.db.close();
+    this.db = void 0;
+    this.loaded = false;
+  }
+  async load() {
+    if (this.loaded && this.db) return this.db;
+    this.loaded = true;
+    const SQL = await sql();
+    if (this.inMemory) {
+      this.db = new SQL.Database();
+      await this.migrate();
+      return this.db;
+    }
+    try {
+      const buffer = await (0, import_promises4.readFile)(this.filePath);
+      if (buffer.length === 0) {
+        this.db = new SQL.Database();
+        await this.migrate();
+      } else if (hasSQLiteHeader(buffer)) {
+        this.db = new SQL.Database(buffer);
+      } else {
+        this.db = new SQL.Database();
+        await this.migrate();
+        await this.importSnapshot(JSON.parse(buffer.toString("utf8")));
+      }
+    } catch (error) {
+      if (error?.code !== "ENOENT") {
+        throw error;
+      }
+      this.db = new SQL.Database();
+      await this.migrate();
+    }
+    return this.db;
+  }
+  async importSnapshot(snapshot) {
+    for (const run of snapshot.runs || []) {
+      await this.saveRun(run);
+    }
+    for (const failure of snapshot.failures || []) {
+      await this.saveFailure(failure);
+    }
+    for (const [signature, analysis] of snapshot.analyses || []) {
+      await this.saveAnalysis(signature, analysis);
+    }
+    for (const [, memory] of snapshot.memory || []) {
+      await this.upsertMemory(memory);
+    }
+  }
+  async all(sqlText, params = []) {
+    const db = await this.load();
+    const statement = db.prepare(sqlText, params);
+    const rows = [];
+    try {
+      while (statement.step()) {
+        rows.push(statement.getAsObject());
+      }
+    } finally {
+      statement.free();
+    }
+    return rows;
+  }
+  async persist() {
+    if (!this.db || this.inMemory) return;
+    await (0, import_promises4.mkdir)(import_node_path6.default.dirname(this.filePath), { recursive: true });
+    await (0, import_promises4.writeFile)(this.filePath, Buffer.from(this.db.export()));
+  }
+};
+
+// src/stores/postgres.ts
+var PostgresStore = class extends MemoryStore {
+  constructor(executor) {
+    super();
+    this.executor = executor;
+  }
+  async migrate() {
+    if (!this.executor) return;
+    await this.executor.query(`
+      CREATE TABLE IF NOT EXISTS pw_ai_runs (id text PRIMARY KEY, payload jsonb NOT NULL, created_at timestamptz DEFAULT now());
+      CREATE TABLE IF NOT EXISTS pw_ai_failures (id bigserial PRIMARY KEY, signature text, file text, title text, run_id text, payload jsonb NOT NULL, created_at timestamptz DEFAULT now());
+      CREATE TABLE IF NOT EXISTS pw_ai_analyses (signature text PRIMARY KEY, payload jsonb NOT NULL, updated_at timestamptz DEFAULT now());
+      CREATE TABLE IF NOT EXISTS pw_ai_memory (id text PRIMARY KEY, namespace text NOT NULL, kind text NOT NULL, key text NOT NULL, tags text[] DEFAULT '{}', payload jsonb NOT NULL, updated_at timestamptz DEFAULT now());
+      CREATE TABLE IF NOT EXISTS pw_ai_feedback (id bigserial PRIMARY KEY, signature text NOT NULL, decision text NOT NULL, reason text, payload jsonb NOT NULL, created_at timestamptz DEFAULT now());
+      CREATE INDEX IF NOT EXISTS idx_pw_ai_failures_signature ON pw_ai_failures(signature);
+      CREATE INDEX IF NOT EXISTS idx_pw_ai_memory_namespace_kind ON pw_ai_memory(namespace, kind);
+      CREATE INDEX IF NOT EXISTS idx_pw_ai_feedback_signature ON pw_ai_feedback(signature);
+    `);
+  }
+  async saveRun(run) {
+    if (!this.executor) return super.saveRun(run);
+    await this.executor.query(
+      "INSERT INTO pw_ai_runs (id, payload) VALUES ($1, $2::jsonb) ON CONFLICT (id) DO UPDATE SET payload = EXCLUDED.payload",
+      [run.id, JSON.stringify(run)]
+    );
+  }
+  async saveFailure(failure) {
+    if (!this.executor) return super.saveFailure(failure);
+    await this.executor.query(
+      "INSERT INTO pw_ai_failures (signature, file, title, run_id, payload) VALUES ($1, $2, $3, $4, $5::jsonb)",
+      [failureSignature(failure), failure.file, failure.title, typeof failure.run?.id === "string" ? failure.run.id : null, JSON.stringify(failure)]
+    );
+  }
+  async saveAnalysis(signature, analysis) {
+    if (!this.executor) return super.saveAnalysis(signature, analysis);
+    await this.executor.query(
+      "INSERT INTO pw_ai_analyses (signature, payload) VALUES ($1, $2::jsonb) ON CONFLICT (signature) DO UPDATE SET payload = EXCLUDED.payload",
+      [signature, JSON.stringify(analysis)]
+    );
+  }
+  async getCachedAnalysis(signature) {
+    if (!this.executor) return super.getCachedAnalysis(signature);
+    const result = await this.executor.query("SELECT payload FROM pw_ai_analyses WHERE signature = $1 LIMIT 1", [
+      signature
+    ]);
+    return result.rows[0]?.payload ? { ...result.rows[0].payload, source: "cache" } : null;
+  }
+  async upsertMemory(record) {
+    if (!this.executor) return super.upsertMemory(record);
+    const id = `${record.namespace}:${record.kind}:${record.key}`;
+    const tags = [...new Set(record.tags || [])].filter(Boolean).sort();
+    const payload = {
+      namespace: record.namespace,
+      kind: record.kind,
+      key: record.key,
+      value: record.value,
+      tags,
+      confidence: record.confidence ?? 1,
+      source: record.source,
+      supersededBy: null,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.executor.query(
+      `
+      INSERT INTO pw_ai_memory (id, namespace, kind, key, tags, payload)
+      VALUES ($1, $2, $3, $4, $5, $6::jsonb)
+      ON CONFLICT (id) DO UPDATE SET
+        namespace = EXCLUDED.namespace,
+        kind = EXCLUDED.kind,
+        key = EXCLUDED.key,
+        tags = EXCLUDED.tags,
+        payload = EXCLUDED.payload,
+        updated_at = now()
+      `,
+      [id, payload.namespace, payload.kind, payload.key, payload.tags, JSON.stringify(payload)]
+    );
+  }
+  async searchMemory(input) {
+    if (!this.executor) return super.searchMemory(input);
+    const result = await this.executor.query("SELECT payload FROM pw_ai_memory ORDER BY updated_at DESC LIMIT $1", [
+      input.limit ?? 100
+    ]);
+    const query = input.query?.toLowerCase().trim();
+    const tags = new Set(input.tags || []);
+    return result.rows.map((row) => row.payload).filter((record) => {
+      if (input.namespace && record.namespace !== input.namespace) return false;
+      if (input.kind && record.kind !== input.kind) return false;
+      if (tags.size > 0 && !record.tags.some((tag) => tags.has(tag))) return false;
+      if (query && !JSON.stringify(record).toLowerCase().includes(query)) return false;
+      return !record.supersededBy;
+    }).slice(0, input.limit ?? 20);
+  }
+  async recordFeedback(record) {
+    if (!this.executor) return super.recordFeedback(record);
+    const payload = {
+      signature: record.signature,
+      decision: record.decision,
+      reason: record.reason || "",
+      metadata: record.metadata || {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.executor.query(
+      "INSERT INTO pw_ai_feedback (signature, decision, reason, payload) VALUES ($1, $2, $3, $4::jsonb)",
+      [payload.signature, payload.decision, payload.reason, JSON.stringify(payload)]
+    );
+  }
+  async searchFeedback(input) {
+    if (!this.executor) return super.searchFeedback(input);
+    const result = await this.executor.query("SELECT payload FROM pw_ai_feedback ORDER BY created_at DESC LIMIT $1", [
+      input.limit ?? 100
+    ]);
+    const query = input.query?.toLowerCase().trim();
+    return result.rows.map((row) => row.payload).filter((record) => {
+      if (input.signature && record.signature !== input.signature) return false;
+      if (input.decision && record.decision !== input.decision) return false;
+      if (query && !JSON.stringify(record).toLowerCase().includes(query)) return false;
+      return true;
+    }).slice(0, input.limit ?? 20);
+  }
+  async findFailures(input) {
+    if (!this.executor) return super.findFailures(input);
+    const result = await this.executor.query("SELECT payload FROM pw_ai_failures ORDER BY id DESC LIMIT $1", [
+      input.limit ?? 100
+    ]);
+    const query = input.query?.toLowerCase().trim();
+    return result.rows.map((row) => row.payload).filter((failure) => {
+      if (input.signature && failureSignature(failure) !== input.signature) return false;
+      if (input.file && failure.file !== input.file) return false;
+      if (query && !JSON.stringify(failure).toLowerCase().includes(query)) return false;
+      return true;
+    }).slice(0, input.limit ?? 20);
+  }
+  async close() {
+    await this.executor?.close?.();
+  }
+};
+
+// src/legacy.ts
+function parseJsonLike(value) {
+  if (!value) return {};
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return {};
+    }
+  }
+  return value;
+}
+function normalizeLegacyAnalysis(row) {
+  const analysis = parseJsonLike(row.analysis_result);
+  return {
+    signature: row.error_cache_key,
+    analysis: {
+      side: row.side || analysis.side || "unknown",
+      rootCause: row.root_cause || analysis.rootCause || analysis.root_cause || "No root cause recorded",
+      evidence: analysis.evidence || [],
+      reproductionSteps: analysis.reproductionSteps || analysis.reproduction_steps || [],
+      suspects: analysis.suspects || { selectors: [], pages: [], endpoints: [] },
+      fixSuggestions: row.fix_suggestions || analysis.fixSuggestions || analysis.fix || [],
+      confidence: Number(row.confidence ?? analysis.confidence ?? 0),
+      category: analysis.category || "unknown",
+      risk: analysis.risk || "high",
+      evidenceRefs: analysis.evidenceRefs || [],
+      confidenceReasons: analysis.confidenceReasons || ["Imported cached analysis."],
+      needsHumanReview: analysis.needsHumanReview ?? true,
+      source: "cache"
+    }
+  };
+}
+function importLegacyRows(input) {
+  const artifactsByResultId = /* @__PURE__ */ new Map();
+  for (const artifact of input.artifacts || []) {
+    const id = Number(artifact.test_result_id);
+    artifactsByResultId.set(id, [...artifactsByResultId.get(id) || [], artifact]);
+  }
+  return {
+    failures: (input.testResults || []).map((row) => ({
+      title: row.test_title,
+      file: row.test_file,
+      line: row.test_line,
+      project: row.project_name,
+      status: row.status,
+      retry: row.retry_index || 0,
+      durationMs: row.duration_ms || 0,
+      error: row.error_message || row.error_stack || "Unknown error",
+      artifacts: (artifactsByResultId.get(Number(row.id)) || []).map((artifact) => ({
+        type: artifact.artifact_type || "artifact",
+        path: artifact.file_path,
+        contentType: artifact.mime_type
+      })),
+      run: row.run_id ? { id: row.run_id } : void 0
+    })),
+    analyses: (input.analysisCache || []).filter((row) => row.error_cache_key).map(normalizeLegacyAnalysis)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DeterministicAnalyzer,
+  FailureGrouper,
+  MemoryStore,
+  OpenAIResponsesProvider,
+  PostgresStore,
+  SQLiteStore,
+  TemplateTestGenerationProvider,
+  analyzeFailures,
+  assertBrowserGenerationAllowed,
+  benchmarkFailures,
+  classifyFailure,
+  enrichFailureWithArtifacts,
+  evaluatePatchPolicy,
+  generatePatchSuggestions,
+  generatePlaywrightTestDraft,
+  htmlReport,
+  importLegacyRows,
+  isDestructiveManualCase,
+  markdownReport,
+  mcpSummary,
+  normalizePlaywrightJsonReport,
+  parseTraceArtifact,
+  writePortableReport
+});