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

package/dist/cli.d.cts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+declare function main(argv?: string[]): Promise<void>;
+
+export { main };

package/dist/cli.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+declare function main(argv?: string[]): Promise<void>;
+
+export { main };

package/dist/cli.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+import {
+  OpenAIResponsesProvider,
+  TemplateTestGenerationProvider,
+  benchmarkFailures,
+  generatePlaywrightTestDraft,
+  normalizePlaywrightJsonReport
+} from "./chunk-GSXFV7YQ.js";
+import {
+  SQLiteStore,
+  analyzeFailures,
+  generatePatchSuggestions,
+  htmlReport,
+  markdownReport
+} from "./chunk-3VDDPPGG.js";
+
+// src/cli.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import path from "path";
+
+// 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/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 mkdir(".playwright-ai-tools", { recursive: true });
+  await writeFile(
+    ".playwright-ai-tools/config.json",
+    `${JSON.stringify({ outputLanguage: process.env.PW_AI_OUTPUT_LANGUAGE || "ru", privacy: { redactSecrets: true } }, null, 2)}
+`,
+    "utf8"
+  );
+  await 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 mkdir(path.dirname(output), { recursive: true });
+  await 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 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") || path.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 readFile(source, "utf8");
+  const text = redactSensitiveText(raw);
+  await store.upsertMemory({
+    namespace,
+    kind: "knowledge",
+    key: path.basename(source),
+    value: { source, text },
+    tags: ["knowledge", ...path.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") || path.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") || path.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 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 mkdir(path.dirname(output), { recursive: true });
+  await 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") || path.join(".playwright-ai-tools", "ai-tools.sqlite");
+  const report = JSON.parse(await 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 mkdir(path.dirname(output), { recursive: true });
+  await writeFile(output, `${JSON.stringify(portableReport, null, 2)}
+`, "utf8");
+  await writeFile(output.replace(/\.json$/i, ".md"), markdownReport(portableReport), "utf8");
+  await 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 readFile(input, "utf8"));
+  const suggestions = report.suggestions || report.failures.map(
+    (failure, index) => report.analyses[index] ? generatePatchSuggestions(failure, report.analyses[index]) : []
+  );
+  await mkdir(path.dirname(output), { recursive: true });
+  await 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 readFile(input, "utf8"));
+  const fixtures = Array.isArray(payload) ? payload : payload.failures || [];
+  const benchmark = benchmarkFailures(fixtures);
+  if (output) {
+    await mkdir(path.dirname(output), { recursive: true });
+    await 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 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") || path.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") || path.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(path.basename(process.argv[1]))) {
+  main().catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+}
+export {
+  main
+};