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

package/dist/chunk-3VDDPPGG.js

@@ -0,0 +1,927 @@
+// src/signature.ts
+import { createHash } from "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 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
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+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 = path.isAbsolute(failure.file) ? failure.file : path.resolve(options.workspaceRoot || process.cwd(), failure.file);
+  if (!existsSync(filePath)) return void 0;
+  const lines = 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/stores/sqlite.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path2 from "path";
+import initSqlJs from "sql.js";
+var sqlModule;
+function sql() {
+  sqlModule || (sqlModule = initSqlJs());
+  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 || path2.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 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 mkdir(path2.dirname(this.filePath), { recursive: true });
+    await writeFile(this.filePath, Buffer.from(this.db.export()));
+  }
+};
+
+// 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/report.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+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 mkdir2(outputDir, { recursive: true });
+  const portable = normalizedReport(report);
+  await writeFile2(path3.join(outputDir, "ai-analysis-report.json"), `${JSON.stringify(portable, null, 2)}
+`, "utf8");
+  await writeFile2(path3.join(outputDir, "ai-analysis-report.md"), markdownReport(portable), "utf8");
+  await writeFile2(path3.join(outputDir, "ai-analysis-report.html"), htmlReport(portable), "utf8");
+}
+
+export {
+  failureSignature,
+  classifyFailure,
+  DeterministicAnalyzer,
+  analyzeFailures,
+  evaluatePatchPolicy,
+  generatePatchSuggestions,
+  SQLiteStore,
+  FailureGrouper,
+  markdownReport,
+  htmlReport,
+  mcpSummary,
+  writePortableReport
+};