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

package/dist/index.js

@@ -0,0 +1,354 @@
+import {
+  OpenAIResponsesProvider,
+  TemplateTestGenerationProvider,
+  assertBrowserGenerationAllowed,
+  benchmarkFailures,
+  generatePlaywrightTestDraft,
+  isDestructiveManualCase,
+  normalizePlaywrightJsonReport
+} from "./chunk-GSXFV7YQ.js";
+import {
+  enrichFailureWithArtifacts,
+  parseTraceArtifact
+} from "./chunk-QL3XW2UN.js";
+import {
+  DeterministicAnalyzer,
+  FailureGrouper,
+  SQLiteStore,
+  analyzeFailures,
+  classifyFailure,
+  evaluatePatchPolicy,
+  failureSignature,
+  generatePatchSuggestions,
+  htmlReport,
+  markdownReport,
+  mcpSummary,
+  writePortableReport
+} from "./chunk-3VDDPPGG.js";
+
+// src/stores/memory.ts
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeTags(tags) {
+  return [...new Set(tags || [])].filter(Boolean).sort();
+}
+function recordText(record) {
+  return JSON.stringify([record.key, record.kind, record.source, record.tags, record.value]).toLowerCase();
+}
+var MemoryStore = class {
+  constructor() {
+    this.runs = /* @__PURE__ */ new Map();
+    this.failures = [];
+    this.analyses = /* @__PURE__ */ new Map();
+    this.memory = /* @__PURE__ */ new Map();
+    this.feedback = [];
+  }
+  async migrate() {
+  }
+  async saveRun(run) {
+    this.runs.set(run.id, run);
+  }
+  async saveFailure(failure) {
+    this.failures.push(failure);
+  }
+  async saveAnalysis(signature, analysis) {
+    this.analyses.set(signature, analysis);
+  }
+  async getCachedAnalysis(signature) {
+    const cached = this.analyses.get(signature);
+    return cached ? { ...cached, source: "cache" } : null;
+  }
+  async upsertMemory(input) {
+    const key = `${input.namespace}:${input.kind}:${input.key}`;
+    const existing = this.memory.get(key);
+    this.memory.set(key, {
+      namespace: input.namespace,
+      kind: input.kind,
+      key: input.key,
+      value: input.value,
+      tags: normalizeTags(input.tags),
+      confidence: input.confidence ?? 1,
+      source: input.source,
+      supersededBy: existing?.supersededBy ?? null,
+      createdAt: existing?.createdAt ?? now(),
+      updatedAt: now()
+    });
+  }
+  async searchMemory(input) {
+    const query = input.query?.toLowerCase().trim();
+    const tags = new Set(input.tags || []);
+    const matches = [...this.memory.values()].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 && !recordText(record).includes(query)) return false;
+      return !record.supersededBy;
+    });
+    return matches.slice(0, input.limit ?? 20);
+  }
+  async recordFeedback(input) {
+    this.feedback.push({
+      signature: input.signature,
+      decision: input.decision,
+      reason: input.reason || "",
+      metadata: input.metadata || {},
+      createdAt: now()
+    });
+  }
+  async searchFeedback(input) {
+    const query = input.query?.toLowerCase().trim();
+    return this.feedback.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 query = input.query?.toLowerCase().trim();
+    return this.failures.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) {
+    return this.runs.get(id) || null;
+  }
+  async stats() {
+    return {
+      runs: this.runs.size,
+      failures: this.failures.length,
+      analyses: this.analyses.size,
+      memoryRecords: this.memory.size,
+      feedbackRecords: this.feedback.length
+    };
+  }
+  async close() {
+  }
+};
+
+// src/stores/postgres.ts
+var PostgresStore = class extends MemoryStore {
+  constructor(executor) {
+    super();
+    this.executor = executor;
+  }
+  async migrate() {
+    if (!this.executor) return;
+    await this.executor.query(`
+      CREATE TABLE IF NOT EXISTS pw_ai_runs (id text PRIMARY KEY, payload jsonb NOT NULL, created_at timestamptz DEFAULT now());
+      CREATE TABLE IF NOT EXISTS pw_ai_failures (id bigserial PRIMARY KEY, signature text, file text, title text, run_id text, payload jsonb NOT NULL, created_at timestamptz DEFAULT now());
+      CREATE TABLE IF NOT EXISTS pw_ai_analyses (signature text PRIMARY KEY, payload jsonb NOT NULL, updated_at timestamptz DEFAULT now());
+      CREATE TABLE IF NOT EXISTS pw_ai_memory (id text PRIMARY KEY, namespace text NOT NULL, kind text NOT NULL, key text NOT NULL, tags text[] DEFAULT '{}', payload jsonb NOT NULL, updated_at timestamptz DEFAULT now());
+      CREATE TABLE IF NOT EXISTS pw_ai_feedback (id bigserial PRIMARY KEY, signature text NOT NULL, decision text NOT NULL, reason text, payload jsonb NOT NULL, created_at timestamptz DEFAULT now());
+      CREATE INDEX IF NOT EXISTS idx_pw_ai_failures_signature ON pw_ai_failures(signature);
+      CREATE INDEX IF NOT EXISTS idx_pw_ai_memory_namespace_kind ON pw_ai_memory(namespace, kind);
+      CREATE INDEX IF NOT EXISTS idx_pw_ai_feedback_signature ON pw_ai_feedback(signature);
+    `);
+  }
+  async saveRun(run) {
+    if (!this.executor) return super.saveRun(run);
+    await this.executor.query(
+      "INSERT INTO pw_ai_runs (id, payload) VALUES ($1, $2::jsonb) ON CONFLICT (id) DO UPDATE SET payload = EXCLUDED.payload",
+      [run.id, JSON.stringify(run)]
+    );
+  }
+  async saveFailure(failure) {
+    if (!this.executor) return super.saveFailure(failure);
+    await this.executor.query(
+      "INSERT INTO pw_ai_failures (signature, file, title, run_id, payload) VALUES ($1, $2, $3, $4, $5::jsonb)",
+      [failureSignature(failure), failure.file, failure.title, typeof failure.run?.id === "string" ? failure.run.id : null, JSON.stringify(failure)]
+    );
+  }
+  async saveAnalysis(signature, analysis) {
+    if (!this.executor) return super.saveAnalysis(signature, analysis);
+    await this.executor.query(
+      "INSERT INTO pw_ai_analyses (signature, payload) VALUES ($1, $2::jsonb) ON CONFLICT (signature) DO UPDATE SET payload = EXCLUDED.payload",
+      [signature, JSON.stringify(analysis)]
+    );
+  }
+  async getCachedAnalysis(signature) {
+    if (!this.executor) return super.getCachedAnalysis(signature);
+    const result = await this.executor.query("SELECT payload FROM pw_ai_analyses WHERE signature = $1 LIMIT 1", [
+      signature
+    ]);
+    return result.rows[0]?.payload ? { ...result.rows[0].payload, source: "cache" } : null;
+  }
+  async upsertMemory(record) {
+    if (!this.executor) return super.upsertMemory(record);
+    const id = `${record.namespace}:${record.kind}:${record.key}`;
+    const tags = [...new Set(record.tags || [])].filter(Boolean).sort();
+    const payload = {
+      namespace: record.namespace,
+      kind: record.kind,
+      key: record.key,
+      value: record.value,
+      tags,
+      confidence: record.confidence ?? 1,
+      source: record.source,
+      supersededBy: null,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.executor.query(
+      `
+      INSERT INTO pw_ai_memory (id, namespace, kind, key, tags, payload)
+      VALUES ($1, $2, $3, $4, $5, $6::jsonb)
+      ON CONFLICT (id) DO UPDATE SET
+        namespace = EXCLUDED.namespace,
+        kind = EXCLUDED.kind,
+        key = EXCLUDED.key,
+        tags = EXCLUDED.tags,
+        payload = EXCLUDED.payload,
+        updated_at = now()
+      `,
+      [id, payload.namespace, payload.kind, payload.key, payload.tags, JSON.stringify(payload)]
+    );
+  }
+  async searchMemory(input) {
+    if (!this.executor) return super.searchMemory(input);
+    const result = await this.executor.query("SELECT payload FROM pw_ai_memory ORDER BY updated_at DESC LIMIT $1", [
+      input.limit ?? 100
+    ]);
+    const query = input.query?.toLowerCase().trim();
+    const tags = new Set(input.tags || []);
+    return result.rows.map((row) => 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).toLowerCase().includes(query)) return false;
+      return !record.supersededBy;
+    }).slice(0, input.limit ?? 20);
+  }
+  async recordFeedback(record) {
+    if (!this.executor) return super.recordFeedback(record);
+    const payload = {
+      signature: record.signature,
+      decision: record.decision,
+      reason: record.reason || "",
+      metadata: record.metadata || {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.executor.query(
+      "INSERT INTO pw_ai_feedback (signature, decision, reason, payload) VALUES ($1, $2, $3, $4::jsonb)",
+      [payload.signature, payload.decision, payload.reason, JSON.stringify(payload)]
+    );
+  }
+  async searchFeedback(input) {
+    if (!this.executor) return super.searchFeedback(input);
+    const result = await this.executor.query("SELECT payload FROM pw_ai_feedback ORDER BY created_at DESC LIMIT $1", [
+      input.limit ?? 100
+    ]);
+    const query = input.query?.toLowerCase().trim();
+    return result.rows.map((row) => 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) {
+    if (!this.executor) return super.findFailures(input);
+    const result = await this.executor.query("SELECT payload FROM pw_ai_failures ORDER BY id DESC LIMIT $1", [
+      input.limit ?? 100
+    ]);
+    const query = input.query?.toLowerCase().trim();
+    return result.rows.map((row) => 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 close() {
+    await this.executor?.close?.();
+  }
+};
+
+// src/legacy.ts
+function parseJsonLike(value) {
+  if (!value) return {};
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return {};
+    }
+  }
+  return value;
+}
+function normalizeLegacyAnalysis(row) {
+  const analysis = parseJsonLike(row.analysis_result);
+  return {
+    signature: row.error_cache_key,
+    analysis: {
+      side: row.side || analysis.side || "unknown",
+      rootCause: row.root_cause || analysis.rootCause || analysis.root_cause || "No root cause recorded",
+      evidence: analysis.evidence || [],
+      reproductionSteps: analysis.reproductionSteps || analysis.reproduction_steps || [],
+      suspects: analysis.suspects || { selectors: [], pages: [], endpoints: [] },
+      fixSuggestions: row.fix_suggestions || analysis.fixSuggestions || analysis.fix || [],
+      confidence: Number(row.confidence ?? analysis.confidence ?? 0),
+      category: analysis.category || "unknown",
+      risk: analysis.risk || "high",
+      evidenceRefs: analysis.evidenceRefs || [],
+      confidenceReasons: analysis.confidenceReasons || ["Imported cached analysis."],
+      needsHumanReview: analysis.needsHumanReview ?? true,
+      source: "cache"
+    }
+  };
+}
+function importLegacyRows(input) {
+  const artifactsByResultId = /* @__PURE__ */ new Map();
+  for (const artifact of input.artifacts || []) {
+    const id = Number(artifact.test_result_id);
+    artifactsByResultId.set(id, [...artifactsByResultId.get(id) || [], artifact]);
+  }
+  return {
+    failures: (input.testResults || []).map((row) => ({
+      title: row.test_title,
+      file: row.test_file,
+      line: row.test_line,
+      project: row.project_name,
+      status: row.status,
+      retry: row.retry_index || 0,
+      durationMs: row.duration_ms || 0,
+      error: row.error_message || row.error_stack || "Unknown error",
+      artifacts: (artifactsByResultId.get(Number(row.id)) || []).map((artifact) => ({
+        type: artifact.artifact_type || "artifact",
+        path: artifact.file_path,
+        contentType: artifact.mime_type
+      })),
+      run: row.run_id ? { id: row.run_id } : void 0
+    })),
+    analyses: (input.analysisCache || []).filter((row) => row.error_cache_key).map(normalizeLegacyAnalysis)
+  };
+}
+export {
+  DeterministicAnalyzer,
+  FailureGrouper,
+  MemoryStore,
+  OpenAIResponsesProvider,
+  PostgresStore,
+  SQLiteStore,
+  TemplateTestGenerationProvider,
+  analyzeFailures,
+  assertBrowserGenerationAllowed,
+  benchmarkFailures,
+  classifyFailure,
+  enrichFailureWithArtifacts,
+  evaluatePatchPolicy,
+  generatePatchSuggestions,
+  generatePlaywrightTestDraft,
+  htmlReport,
+  importLegacyRows,
+  isDestructiveManualCase,
+  markdownReport,
+  mcpSummary,
+  normalizePlaywrightJsonReport,
+  parseTraceArtifact,
+  writePortableReport
+};