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

package/dist/cli.cjs

@@ -0,0 +1,1750 @@
+#!/usr/bin/env node
+"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/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(cli_exports);
+var import_promises4 = require("fs/promises");
+var import_node_path5 = __toESM(require("path"), 1);
+
+// 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/generation.ts
+var import_promises = require("fs/promises");
+var import_node_path2 = __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_path2.default.join(outputDir, source);
+  const filePath = import_node_path2.default.join(caseDir, `${caseKey}.spec.ts`);
+  const reportPath = import_node_path2.default.join(caseDir, `${caseKey}.generation-report.json`);
+  const screenshotPath = import_node_path2.default.join(caseDir, `${caseKey}.png`);
+  await (0, import_promises.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_promises.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_promises.writeFile)(filePath, `${generated.code.trimEnd()}
+`, "utf8");
+      await (0, import_promises.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/privacy.ts
+var SECRET_PATTERNS = [
+  [/\b(authorization\s*:\s*bearer)\s+[A-Za-z0-9._~+/-]+=*/gi, "$1 [REDACTED]"],
+  [/\b(cookie\s*:\s*)[^\n\r]+/gi, "$1[REDACTED]"],
+  [/\b(password|passwd|token|api[_-]?key|secret)=([^&\s]+)/gi, "$1=[REDACTED]"],
+  [/\b(password|passwd|token|api[_-]?key|secret)\s*:\s*["']?[^"',\s}]+/gi, "$1: [REDACTED]"]
+];
+function redactSensitiveText(text) {
+  return SECRET_PATTERNS.reduce((value, [pattern, replacement]) => value.replace(pattern, replacement), text);
+}
+
+// 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/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_path4 = __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/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>
+`;
+}
+
+// src/cli.ts
+function argValue(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : void 0;
+}
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+async function commandInit() {
+  await (0, import_promises4.mkdir)(".playwright-ai-tools", { recursive: true });
+  await (0, import_promises4.writeFile)(
+    ".playwright-ai-tools/config.json",
+    `${JSON.stringify({ outputLanguage: process.env.PW_AI_OUTPUT_LANGUAGE || "ru", privacy: { redactSecrets: true } }, null, 2)}
+`,
+    "utf8"
+  );
+  await (0, import_promises4.writeFile)(
+    ".playwright-ai-tools/knowledge.md",
+    "# Project testing knowledge\n\nAdd selectors policy, test data rules, known flaky areas, and ownership notes here.\n",
+    "utf8"
+  );
+  console.log("Created .playwright-ai-tools/config.json");
+}
+async function writeJson(output, payload) {
+  const text = `${JSON.stringify(payload, null, 2)}
+`;
+  if (!output) {
+    console.log(text.trimEnd());
+    return;
+  }
+  await (0, import_promises4.mkdir)(import_node_path5.default.dirname(output), { recursive: true });
+  await (0, import_promises4.writeFile)(output, text, "utf8");
+}
+async function commandDoctor(args) {
+  const configPath = argValue(args, "--config") || "playwright.config.ts";
+  const output = argValue(args, "--output");
+  let config = "";
+  let configExists = true;
+  try {
+    config = await (0, import_promises4.readFile)(configPath, "utf8");
+  } catch {
+    configExists = false;
+  }
+  const checks = [
+    {
+      id: "playwright-config",
+      status: configExists ? "pass" : "fail",
+      message: configExists ? `Found ${configPath}` : `Missing ${configPath}`
+    },
+    {
+      id: "trace",
+      status: /trace\s*:\s*['"](?:on|on-first-retry|retain-on-failure)['"]/.test(config) ? "pass" : "warn",
+      message: "Enable trace on retry or failure for useful evidence."
+    },
+    {
+      id: "screenshot",
+      status: /screenshot\s*:\s*['"](?:on|only-on-failure)['"]/.test(config) ? "pass" : "warn",
+      message: "Enable screenshots on failure for visual evidence."
+    },
+    {
+      id: "video",
+      status: /video\s*:\s*['"](?:on|retain-on-failure|on-first-retry)['"]/.test(config) ? "pass" : "warn",
+      message: "Enable video on failure when debugging interactions matters."
+    },
+    {
+      id: "privacy",
+      status: "pass",
+      message: "Text knowledge imports and generated summaries redact common secrets by default."
+    }
+  ];
+  await writeJson(output, {
+    status: checks.some((check) => check.status === "fail") ? "fail" : "pass",
+    checks
+  });
+}
+async function commandKnowledgeImport(args) {
+  const source = argValue(args, "--source");
+  if (!source) throw new Error("Missing --source <path>");
+  const database = argValue(args, "--database") || import_node_path5.default.join(".playwright-ai-tools", "ai-tools.sqlite");
+  const namespace = argValue(args, "--namespace") || "default";
+  const store = new SQLiteStore({ path: database });
+  await store.migrate();
+  const raw = await (0, import_promises4.readFile)(source, "utf8");
+  const text = redactSensitiveText(raw);
+  await store.upsertMemory({
+    namespace,
+    kind: "knowledge",
+    key: import_node_path5.default.basename(source),
+    value: { source, text },
+    tags: ["knowledge", ...import_node_path5.default.basename(source).replace(/\.[^.]+$/, "").split(/[-_\s]+/).filter(Boolean)],
+    confidence: 1,
+    source: "knowledge-import"
+  });
+  await store.close();
+  console.log(`Imported knowledge from ${source}`);
+}
+async function commandFeedbackRecord(args) {
+  const signature = argValue(args, "--signature");
+  const decision = argValue(args, "--decision");
+  if (!signature) throw new Error("Missing --signature <signature>");
+  if (!decision) throw new Error("Missing --decision <approved|rejected|needs_work|mark_flaky>");
+  const database = argValue(args, "--database") || import_node_path5.default.join(".playwright-ai-tools", "ai-tools.sqlite");
+  const reason = argValue(args, "--reason");
+  const store = new SQLiteStore({ path: database });
+  await store.migrate();
+  await store.recordFeedback({ signature, decision, reason, metadata: {} });
+  await store.close();
+  console.log(`Recorded ${decision} feedback for ${signature}`);
+}
+async function commandHistoryFind(args) {
+  const database = argValue(args, "--database") || import_node_path5.default.join(".playwright-ai-tools", "ai-tools.sqlite");
+  const query = argValue(args, "--query") || "";
+  const output = argValue(args, "--output");
+  const limit = Number(argValue(args, "--limit") || 20);
+  const store = new SQLiteStore({ path: database });
+  await store.migrate();
+  const payload = {
+    failures: await store.findFailures({ query, limit }),
+    memory: await store.searchMemory({ query, limit }),
+    feedback: await store.searchFeedback({ query, limit })
+  };
+  await store.close();
+  await writeJson(output, payload);
+}
+async function commandGithubSummary(args) {
+  const reportPath = argValue(args, "--report");
+  if (!reportPath) throw new Error("Missing --report <path>");
+  const output = argValue(args, "--output");
+  if (!output) throw new Error("Missing --output <path>");
+  const artifactBaseUrl = argValue(args, "--artifact-base-url")?.replace(/\/$/, "");
+  const report = JSON.parse(await (0, import_promises4.readFile)(reportPath, "utf8"));
+  const lines = [
+    "# Playwright AI Tools Summary",
+    "",
+    `Run: ${report.run.id}`,
+    `Failures: ${report.failures.length}`,
+    ""
+  ];
+  if (artifactBaseUrl) {
+    lines.push(`[Open HTML report](${artifactBaseUrl}/ai-analysis-report.html)`, "");
+  }
+  report.failures.forEach((failure, index) => {
+    const analysis = report.analyses[index];
+    lines.push(
+      `- **${failure.title}**: ${analysis?.category || "unknown"} / ${analysis?.risk || "high"} / confidence ${analysis?.confidence ?? 0}`
+    );
+  });
+  await (0, import_promises4.mkdir)(import_node_path5.default.dirname(output), { recursive: true });
+  await (0, import_promises4.writeFile)(output, `${lines.join("\n")}
+`, "utf8");
+  console.log(`Wrote GitHub summary to ${output}`);
+}
+async function commandAnalyze(args) {
+  const input = argValue(args, "--playwright-json");
+  if (!input) {
+    throw new Error("Missing --playwright-json <path>");
+  }
+  const output = argValue(args, "--output") || "ai-analysis-report.json";
+  const database = argValue(args, "--database") || import_node_path5.default.join(".playwright-ai-tools", "ai-tools.sqlite");
+  const report = JSON.parse(await (0, import_promises4.readFile)(input, "utf8"));
+  const failures = normalizePlaywrightJsonReport(report, { runId: `cli-${Date.now()}` });
+  const store = new SQLiteStore({ path: database });
+  await store.migrate();
+  const analyses = await analyzeFailures(failures, { store });
+  const portableReport = {
+    run: { id: failures[0]?.run?.id || `cli-${Date.now()}`, total: failures.length, failed: failures.length },
+    failures,
+    analyses
+  };
+  await (0, import_promises4.mkdir)(import_node_path5.default.dirname(output), { recursive: true });
+  await (0, import_promises4.writeFile)(output, `${JSON.stringify(portableReport, null, 2)}
+`, "utf8");
+  await (0, import_promises4.writeFile)(output.replace(/\.json$/i, ".md"), markdownReport(portableReport), "utf8");
+  await (0, import_promises4.writeFile)(output.replace(/\.json$/i, ".html"), htmlReport(portableReport), "utf8");
+  await store.close();
+  console.log(`Analyzed ${failures.length} failure${failures.length === 1 ? "" : "s"}`);
+}
+async function commandSuggestFix(args) {
+  const input = argValue(args, "--report");
+  if (!input) {
+    throw new Error("Missing --report <path>");
+  }
+  const output = argValue(args, "--output") || "ai-fix-suggestions.json";
+  const report = JSON.parse(await (0, import_promises4.readFile)(input, "utf8"));
+  const suggestions = report.suggestions || report.failures.map(
+    (failure, index) => report.analyses[index] ? generatePatchSuggestions(failure, report.analyses[index]) : []
+  );
+  await (0, import_promises4.mkdir)(import_node_path5.default.dirname(output), { recursive: true });
+  await (0, import_promises4.writeFile)(output, `${JSON.stringify({ suggestions }, null, 2)}
+`, "utf8");
+  console.log(`Wrote suggestions for ${suggestions.length} failure${suggestions.length === 1 ? "" : "s"}`);
+}
+async function commandBenchmark(args) {
+  const input = argValue(args, "--fixtures");
+  if (!input) {
+    throw new Error("Missing --fixtures <path>");
+  }
+  const output = argValue(args, "--output");
+  const payload = JSON.parse(await (0, import_promises4.readFile)(input, "utf8"));
+  const fixtures = Array.isArray(payload) ? payload : payload.failures || [];
+  const benchmark = benchmarkFailures(fixtures);
+  if (output) {
+    await (0, import_promises4.mkdir)(import_node_path5.default.dirname(output), { recursive: true });
+    await (0, import_promises4.writeFile)(output, `${JSON.stringify(benchmark, null, 2)}
+`, "utf8");
+  }
+  console.log(
+    `Benchmarked ${benchmark.metrics.total} failure${benchmark.metrics.total === 1 ? "" : "s"}: accuracy=${benchmark.metrics.accuracy}, unknownRate=${benchmark.metrics.unknownRate}`
+  );
+}
+function generationProvider() {
+  return process.env.OPENAI_API_KEY ? new OpenAIResponsesProvider() : new TemplateTestGenerationProvider();
+}
+async function commandGenerateTest(args) {
+  const manualCasePath = argValue(args, "--manual-case");
+  const url = argValue(args, "--url");
+  if (!manualCasePath) throw new Error("Missing --manual-case <json>");
+  if (!url) throw new Error("Missing --url <url>");
+  const outputDir = argValue(args, "--output-dir") || "generated-tests";
+  const manualCase = JSON.parse(await (0, import_promises4.readFile)(manualCasePath, "utf8"));
+  const draft = await generatePlaywrightTestDraft({
+    manualCase,
+    url,
+    outputDir,
+    provider: generationProvider(),
+    confirmBrowserRun: hasFlag(args, "--confirm-browser-run"),
+    allowDestructiveActions: hasFlag(args, "--allow-destructive-actions"),
+    storageState: argValue(args, "--storage-state"),
+    sourceName: argValue(args, "--source-name"),
+    outputLanguage: argValue(args, "--output-language") || process.env.PW_AI_OUTPUT_LANGUAGE || "ru"
+  });
+  console.log(`Wrote generated test draft to ${draft.filePath}`);
+  console.log(`Wrote generation report to ${draft.reportPath}`);
+}
+async function commandMigrate(args) {
+  const database = argValue(args, "--database") || import_node_path5.default.join(".playwright-ai-tools", "ai-tools.sqlite");
+  const store = new SQLiteStore({ path: database });
+  await store.migrate();
+  await store.close();
+  console.log(`Migrated store at ${database}`);
+}
+async function commandStats(args) {
+  const database = argValue(args, "--database") || import_node_path5.default.join(".playwright-ai-tools", "ai-tools.sqlite");
+  const store = new SQLiteStore({ path: database });
+  await store.migrate();
+  console.log(JSON.stringify(await store.stats?.(), null, 2));
+  await store.close();
+}
+async function main(argv = process.argv.slice(2)) {
+  const [command, subcommand, ...rest] = argv;
+  if (command === "init") return commandInit();
+  if (command === "doctor") return commandDoctor([subcommand, ...rest].filter(Boolean));
+  if (command === "analyze") return commandAnalyze([subcommand, ...rest].filter(Boolean));
+  if (command === "generate-test") return commandGenerateTest([subcommand, ...rest].filter(Boolean));
+  if (command === "suggest-fix") return commandSuggestFix([subcommand, ...rest].filter(Boolean));
+  if (command === "benchmark") return commandBenchmark([subcommand, ...rest].filter(Boolean));
+  if (command === "migrate") return commandMigrate([subcommand, ...rest].filter(Boolean));
+  if (command === "db" && subcommand === "stats") return commandStats(rest);
+  if (command === "knowledge" && subcommand === "import") return commandKnowledgeImport(rest);
+  if (command === "feedback" && subcommand === "record") return commandFeedbackRecord(rest);
+  if (command === "history" && subcommand === "find") return commandHistoryFind(rest);
+  if (command === "ci" && subcommand === "github-summary") return commandGithubSummary(rest);
+  if (hasFlag(argv, "--help")) {
+    console.log("Usage: playwright-ai-tools <init|doctor|analyze|generate-test|suggest-fix|benchmark|migrate|db stats|knowledge import|feedback record|history find|ci github-summary>");
+    return;
+  }
+  throw new Error("Usage: playwright-ai-tools <init|doctor|analyze|generate-test|suggest-fix|benchmark|migrate|db stats|knowledge import|feedback record|history find|ci github-summary>");
+}
+if (process.argv[1] && /(?:playwright-ai-tools|cli\.(?:cjs|js|ts))$/.test(import_node_path5.default.basename(process.argv[1]))) {
+  main().catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});