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

package/dist/reporter.cjs

@@ -0,0 +1,1265 @@
+"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/reporter.ts
+var reporter_exports = {};
+__export(reporter_exports, {
+  PlaywrightAiReporter: () => PlaywrightAiReporter,
+  default: () => reporter_default
+});
+module.exports = __toCommonJS(reporter_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/evidence.ts
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/trace.ts
+var import_promises = require("fs/promises");
+var import_node_zlib = require("zlib");
+var import_node_path = __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_path.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_path2.default.isAbsolute(artifactPath)) return artifactPath;
+  return import_node_path2.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/stores/sqlite.ts
+var import_promises2 = require("fs/promises");
+var import_node_path3 = __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 now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeTags(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_path3.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: normalizeTags(record.tags),
+      confidence: record.confidence ?? 1,
+      source: record.source,
+      supersededBy: previous?.supersededBy ?? null,
+      createdAt: previous?.createdAt ?? now(),
+      updatedAt: now()
+    };
+    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: now()
+    };
+    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_promises2.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_promises2.mkdir)(import_node_path3.default.dirname(this.filePath), { recursive: true });
+    await (0, import_promises2.writeFile)(this.filePath, Buffer.from(this.db.export()));
+  }
+};
+
+// src/report.ts
+var import_promises3 = require("fs/promises");
+var import_node_path5 = __toESM(require("path"), 1);
+
+// 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/suggestions.ts
+var import_node_fs = require("fs");
+var import_node_path4 = __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_path4.default.isAbsolute(failure.file) ? failure.file : import_node_path4.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/report.ts
+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>
+`;
+}
+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/reporter.ts
+function isFailure(status) {
+  return ["failed", "timedOut", "interrupted"].includes(status);
+}
+function extractError(result) {
+  return result.error?.message || result.error?.stack || result.errors?.[0]?.message || "Unknown error";
+}
+function extractSteps(result) {
+  const steps = result.steps || [];
+  return steps.filter((step) => step.category === "test.step" || step.category === "expect").map((step) => String(step.title)).filter(Boolean);
+}
+function extractArtifacts(result) {
+  return (result.attachments || []).filter((attachment) => attachment.path).map((attachment) => ({
+    type: attachment.contentType?.startsWith("image/") ? "screenshot" : attachment.name,
+    path: String(attachment.path),
+    contentType: attachment.contentType
+  }));
+}
+function ciMetadata() {
+  if (process.env.GITHUB_RUN_ID && process.env.GITHUB_REPOSITORY) {
+    const server = process.env.GITHUB_SERVER_URL || "https://github.com";
+    return {
+      provider: "github",
+      runId: process.env.GITHUB_RUN_ID,
+      repository: process.env.GITHUB_REPOSITORY,
+      commit: process.env.GITHUB_SHA,
+      branch: process.env.GITHUB_REF_NAME,
+      url: `${server}/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`
+    };
+  }
+  if (process.env.CI) {
+    return {
+      provider: "generic",
+      commit: process.env.GIT_COMMIT || process.env.CI_COMMIT_SHA,
+      branch: process.env.GIT_BRANCH || process.env.CI_COMMIT_REF_NAME,
+      url: process.env.BUILD_URL || process.env.CI_JOB_URL
+    };
+  }
+  return void 0;
+}
+function projectMetadata(config) {
+  return {
+    rootDir: config.rootDir,
+    projects: (config.projects || []).map((project) => ({
+      name: project.name,
+      browserName: project.use?.browserName,
+      viewport: project.use?.viewport,
+      locale: project.use?.locale
+    }))
+  };
+}
+var PlaywrightAiReporter = class {
+  constructor(options = {}) {
+    this.run = { id: `local-${Date.now()}`, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    this.failures = [];
+    this.outputDir = options.outputDir || "playwright-ai-report";
+    this.store = options.store || new SQLiteStore({ path: options.databasePath });
+    this.outputLanguage = options.outputLanguage;
+  }
+  async onBegin(_config, suite) {
+    this.failures = [];
+    this.run = {
+      id: process.env.PW_AI_RUN_ID || `local-${Date.now()}`,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      total: suite.allTests().length,
+      metadata: {
+        ...projectMetadata(_config),
+        ci: ciMetadata()
+      }
+    };
+    await this.store.migrate();
+    await this.store.saveRun(this.run);
+  }
+  async onTestEnd(test, result) {
+    if (!isFailure(result.status)) {
+      return;
+    }
+    const failure = {
+      title: String(test.title),
+      file: test.location.file,
+      line: test.location.line,
+      project: test.parent?.project()?.name,
+      workerIndex: result.workerIndex,
+      status: result.status,
+      retry: result.retry,
+      durationMs: result.duration,
+      error: extractError(result),
+      steps: extractSteps(result),
+      artifacts: extractArtifacts(result),
+      annotations: test.annotations.map((annotation) => ({
+        type: annotation.type,
+        description: annotation.description
+      })),
+      run: { id: this.run.id, ci: ciMetadata() },
+      metadata: {
+        testId: test.id,
+        parallelIndex: result.parallelIndex
+      }
+    };
+    const enriched = await enrichFailureWithArtifacts(failure);
+    this.failures.push(enriched);
+    await this.store.saveFailure(enriched);
+  }
+  async onEnd(_result) {
+    this.run.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.run.failed = this.failures.length;
+    const analyses = await analyzeFailures(this.failures, {
+      store: this.store,
+      outputLanguage: this.outputLanguage
+    });
+    await writePortableReport(this.outputDir, {
+      run: this.run,
+      failures: this.failures,
+      analyses
+    });
+    await this.store.saveRun(this.run);
+    await this.store.close();
+  }
+};
+var reporter_default = PlaywrightAiReporter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PlaywrightAiReporter
+});