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

package/dist/chunk-GSXFV7YQ.js

@@ -0,0 +1,544 @@
+import {
+  classifyFailure,
+  failureSignature,
+  generatePatchSuggestions
+} from "./chunk-3VDDPPGG.js";
+
+// 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
+import { mkdir, writeFile } from "fs/promises";
+import path from "path";
+import { chromium } from "@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 = path.join(outputDir, source);
+  const filePath = path.join(caseDir, `${caseKey}.spec.ts`);
+  const reportPath = path.join(caseDir, `${caseKey}.generation-report.json`);
+  const screenshotPath = path.join(caseDir, `${caseKey}.png`);
+  await mkdir(caseDir, { recursive: true });
+  const browser = await 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 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 writeFile(filePath, `${generated.code.trimEnd()}
+`, "utf8");
+      await writeFile(reportPath, `${JSON.stringify(report, null, 2)}
+`, "utf8");
+      return draft;
+    } finally {
+      await context.close();
+    }
+  } finally {
+    await browser.close();
+  }
+}
+
+// src/normalize.ts
+function walkSuites(suites, visitor) {
+  for (const suite of suites || []) {
+    for (const spec of suite.specs || []) {
+      visitor(spec, suite);
+    }
+    walkSuites(suite.suites || [], visitor);
+  }
+}
+function resultError(result) {
+  return result?.error?.message || result?.error?.stack || result?.errors?.[0]?.message || result?.errors?.[0]?.stack || "Unknown error";
+}
+function normalizeSteps(result) {
+  const collected = [];
+  const visit = (step, insideUserStep) => {
+    if (!step) return;
+    const category = step.category;
+    const isUserStep = category === "test.step";
+    const isExpect = category === "expect";
+    if ((isUserStep || isExpect) && !insideUserStep && step.title) {
+      collected.push(String(step.title));
+    }
+    for (const child of step.steps || []) {
+      visit(child, insideUserStep || isUserStep);
+    }
+  };
+  for (const step of result?.steps || []) {
+    visit(step, false);
+  }
+  return collected;
+}
+function attachmentType(contentType, name) {
+  if (contentType?.startsWith("image/")) return "screenshot";
+  if (contentType?.includes("zip")) return "trace";
+  if (contentType?.includes("video")) return "video";
+  if (name?.toLowerCase().includes("trace")) return "trace";
+  return name || "artifact";
+}
+function normalizeArtifacts(result) {
+  return (result?.attachments || []).filter((attachment) => attachment?.path).map((attachment) => ({
+    type: attachmentType(attachment.contentType, attachment.name),
+    path: String(attachment.path),
+    contentType: attachment.contentType
+  }));
+}
+function normalizePlaywrightJsonReport(report, options = {}) {
+  const failures = [];
+  const run = options.runId ? { id: options.runId } : void 0;
+  walkSuites(report?.suites || [], (spec) => {
+    for (const testCase of spec.tests || []) {
+      for (const result of testCase.results || []) {
+        if (!["failed", "timedOut", "interrupted"].includes(result.status)) {
+          continue;
+        }
+        failures.push({
+          title: String(spec.title || testCase.title || "unnamed test"),
+          file: String(spec.file || testCase.location?.file || "unknown"),
+          line: spec.line || testCase.location?.line,
+          project: testCase.projectName,
+          status: result.status,
+          retry: result.retry || 0,
+          durationMs: result.duration || 0,
+          error: resultError(result),
+          steps: normalizeSteps(result),
+          artifacts: normalizeArtifacts(result),
+          annotations: (testCase.annotations || []).map((annotation) => ({
+            type: String(annotation.type),
+            description: annotation.description
+          })),
+          run
+        });
+      }
+    }
+  });
+  return failures;
+}
+
+// src/providers/openai.ts
+var analysisSchema = {
+  type: "object",
+  properties: {
+    side: { type: "string", enum: ["app_bug", "test_bug", "flaky_test", "env_issue", "unknown"] },
+    rootCause: { type: "string" },
+    evidence: { type: "array", items: { type: "string" } },
+    reproductionSteps: { type: "array", items: { type: "string" } },
+    suspects: {
+      type: "object",
+      properties: {
+        selectors: { type: "array", items: { type: "string" } },
+        pages: { type: "array", items: { type: "string" } },
+        endpoints: { type: "array", items: { type: "string" } }
+      },
+      required: ["selectors", "pages", "endpoints"],
+      additionalProperties: false
+    },
+    fixSuggestions: { type: "array", items: { type: "string" } },
+    confidence: { type: "number", minimum: 0, maximum: 100 },
+    category: {
+      type: "string",
+      enum: ["selector", "timing", "runtime", "test_data", "visual", "interaction", "environment", "unknown"]
+    },
+    risk: { type: "string", enum: ["low", "medium", "high"] },
+    evidenceRefs: { type: "array", items: { type: "string" } },
+    confidenceReasons: { type: "array", items: { type: "string" } },
+    needsHumanReview: { type: "boolean" }
+  },
+  required: [
+    "side",
+    "rootCause",
+    "evidence",
+    "reproductionSteps",
+    "suspects",
+    "fixSuggestions",
+    "confidence",
+    "category",
+    "risk",
+    "evidenceRefs",
+    "confidenceReasons",
+    "needsHumanReview"
+  ],
+  additionalProperties: false
+};
+var generationSchema = {
+  type: "object",
+  properties: {
+    code: { type: "string" },
+    locators: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          stepIndex: { type: "number" },
+          selector: { type: "string" },
+          reason: { type: "string" }
+        },
+        required: ["selector", "reason"],
+        additionalProperties: false
+      }
+    },
+    coverage: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          stepIndex: { type: "number" },
+          status: { type: "string", enum: ["covered", "partial", "missing"] },
+          notes: { type: "string" }
+        },
+        required: ["status", "notes"],
+        additionalProperties: false
+      }
+    },
+    warnings: { type: "array", items: { type: "string" } }
+  },
+  required: ["code", "locators", "coverage", "warnings"],
+  additionalProperties: false
+};
+function normalizeAnalysis(data, usage) {
+  return {
+    side: data.side || "unknown",
+    rootCause: data.rootCause || data.root_cause || "No root cause returned",
+    evidence: data.evidence || [],
+    reproductionSteps: data.reproductionSteps || data.reproduction_steps || [],
+    suspects: data.suspects || { selectors: [], pages: [], endpoints: [] },
+    fixSuggestions: data.fixSuggestions || data.fix || [],
+    confidence: Number(data.confidence ?? 0),
+    category: data.category || "unknown",
+    risk: data.risk || "high",
+    evidenceRefs: data.evidenceRefs || [],
+    confidenceReasons: data.confidenceReasons || [],
+    needsHumanReview: data.needsHumanReview ?? true,
+    source: "ai",
+    tokenUsage: usage ? {
+      inputTokens: usage.input_tokens || usage.inputTokens || 0,
+      outputTokens: usage.output_tokens || usage.outputTokens || 0,
+      totalTokens: usage.total_tokens || usage.totalTokens || 0
+    } : void 0
+  };
+}
+function normalizeGeneratedTest(data) {
+  return {
+    code: String(data.code || ""),
+    locators: Array.isArray(data.locators) ? data.locators : [],
+    coverage: Array.isArray(data.coverage) ? data.coverage : [],
+    warnings: Array.isArray(data.warnings) ? data.warnings : []
+  };
+}
+function outputText(response) {
+  if (response.output_text) return response.output_text;
+  for (const item of response.output || []) {
+    for (const content of item.content || []) {
+      if (content.text) return content.text;
+    }
+  }
+  return "";
+}
+function compactFailure(failure) {
+  return {
+    title: failure.title,
+    file: failure.file,
+    line: failure.line,
+    project: failure.project,
+    status: failure.status,
+    retry: failure.retry,
+    durationMs: failure.durationMs,
+    error: failure.error,
+    steps: failure.steps || [],
+    artifacts: failure.artifacts || [],
+    annotations: failure.annotations || [],
+    browserContext: failure.browserContext,
+    page: failure.page,
+    consoleErrors: failure.consoleErrors || [],
+    networkFailures: failure.networkFailures || [],
+    lastActions: failure.lastActions || [],
+    artifactRefs: failure.artifactRefs || failure.artifacts || []
+  };
+}
+var OpenAIResponsesProvider = class {
+  constructor(options = {}) {
+    this.apiKey = options.apiKey ?? process.env.OPENAI_API_KEY ?? "";
+    this.model = options.model ?? process.env.PW_AI_MODEL ?? process.env.AI_MODEL ?? "gpt-4.1-mini";
+    this.baseUrl = options.baseUrl ?? "https://api.openai.com/v1/responses";
+    this.transport = options.transport ?? ((url, init) => fetch(url, init));
+  }
+  async analyzeFailure(request) {
+    if (!this.apiKey) {
+      throw new Error("OPENAI_API_KEY is required for OpenAIResponsesProvider");
+    }
+    const payload = {
+      model: this.model,
+      instructions: `You are a generic Playwright failure analyzer. Return concise ${request.outputLanguage} JSON only. Use only the supplied test failure, trace evidence, steps, artifacts, and similar analyses. Every conclusion must point to supplied evidenceRefs.`,
+      input: JSON.stringify({
+        failure: compactFailure(request.failure),
+        similarAnalyses: request.similarAnalyses || []
+      }),
+      text: {
+        format: {
+          type: "json_schema",
+          name: "playwright_failure_analysis",
+          strict: true,
+          schema: analysisSchema
+        }
+      }
+    };
+    const response = await this.transport(this.baseUrl, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.apiKey}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`OpenAI Responses request failed with status ${response.status}`);
+    }
+    const body = await response.json();
+    const rawText = outputText(body);
+    if (!rawText) {
+      throw new Error("OpenAI Responses payload did not contain output text");
+    }
+    return normalizeAnalysis(JSON.parse(rawText), body.usage);
+  }
+  async generateTest(request) {
+    if (!this.apiKey) {
+      throw new Error("OPENAI_API_KEY is required for OpenAIResponsesProvider");
+    }
+    const browser = {
+      requestedUrl: request.browser.requestedUrl,
+      currentUrl: request.browser.currentUrl,
+      title: request.browser.title,
+      domSummary: request.browser.domSummary,
+      htmlSnippet: request.browser.htmlSnippet
+    };
+    const content = [
+      {
+        type: "input_text",
+        text: JSON.stringify({
+          manualCase: request.manualCase,
+          url: request.url,
+          browser
+        })
+      }
+    ];
+    if (request.browser.screenshotBase64) {
+      content.push({
+        type: "input_image",
+        image_url: `data:image/png;base64,${request.browser.screenshotBase64}`
+      });
+    }
+    const payload = {
+      model: this.model,
+      instructions: `You generate review-only Playwright tests from manual test cases. Return concise ${request.outputLanguage || "ru"} JSON only. Use only the supplied manual steps, browser DOM evidence, URL, and screenshot. Prefer user-facing locators and data-testid selectors when the evidence supports them. Do not weaken assertions, do not invent credentials, and include warnings for any uncertain step.`,
+      input: [{ role: "user", content }],
+      text: {
+        format: {
+          type: "json_schema",
+          name: "playwright_test_generation",
+          strict: true,
+          schema: generationSchema
+        }
+      }
+    };
+    const response = await this.transport(this.baseUrl, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.apiKey}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`OpenAI Responses request failed with status ${response.status}`);
+    }
+    const body = await response.json();
+    const rawText = outputText(body);
+    if (!rawText) {
+      throw new Error("OpenAI Responses payload did not contain output text");
+    }
+    return normalizeGeneratedTest(JSON.parse(rawText));
+  }
+};
+
+export {
+  benchmarkFailures,
+  isDestructiveManualCase,
+  assertBrowserGenerationAllowed,
+  TemplateTestGenerationProvider,
+  generatePlaywrightTestDraft,
+  normalizePlaywrightJsonReport,
+  OpenAIResponsesProvider
+};