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

package/dist/reporter.d.cts

@@ -0,0 +1,22 @@
+import { Reporter, FullConfig, Suite, TestCase, TestResult, FullResult } from '@playwright/test/reporter';
+import { j as AnalysisStore } from './types-B55GjfW7.cjs';
+
+interface PlaywrightAiReporterOptions {
+    outputDir?: string;
+    databasePath?: string;
+    store?: AnalysisStore;
+    outputLanguage?: string;
+}
+declare class PlaywrightAiReporter implements Reporter {
+    private readonly outputDir;
+    private readonly store;
+    private readonly outputLanguage?;
+    private run;
+    private failures;
+    constructor(options?: PlaywrightAiReporterOptions);
+    onBegin(_config: FullConfig, suite: Suite): Promise<void>;
+    onTestEnd(test: TestCase, result: TestResult): Promise<void>;
+    onEnd(_result: FullResult): Promise<void>;
+}
+
+export { PlaywrightAiReporter, type PlaywrightAiReporterOptions, PlaywrightAiReporter as default };

package/dist/reporter.d.ts

@@ -0,0 +1,22 @@
+import { Reporter, FullConfig, Suite, TestCase, TestResult, FullResult } from '@playwright/test/reporter';
+import { j as AnalysisStore } from './types-B55GjfW7.js';
+
+interface PlaywrightAiReporterOptions {
+    outputDir?: string;
+    databasePath?: string;
+    store?: AnalysisStore;
+    outputLanguage?: string;
+}
+declare class PlaywrightAiReporter implements Reporter {
+    private readonly outputDir;
+    private readonly store;
+    private readonly outputLanguage?;
+    private run;
+    private failures;
+    constructor(options?: PlaywrightAiReporterOptions);
+    onBegin(_config: FullConfig, suite: Suite): Promise<void>;
+    onTestEnd(test: TestCase, result: TestResult): Promise<void>;
+    onEnd(_result: FullResult): Promise<void>;
+}
+
+export { PlaywrightAiReporter, type PlaywrightAiReporterOptions, PlaywrightAiReporter as default };

package/dist/reporter.js

@@ -0,0 +1,133 @@
+import {
+  enrichFailureWithArtifacts
+} from "./chunk-QL3XW2UN.js";
+import {
+  SQLiteStore,
+  analyzeFailures,
+  writePortableReport
+} from "./chunk-3VDDPPGG.js";
+
+// src/reporter.ts
+function isFailure(status) {
+  return ["failed", "timedOut", "interrupted"].includes(status);
+}
+function extractError(result) {
+  return result.error?.message || result.error?.stack || result.errors?.[0]?.message || "Unknown error";
+}
+function extractSteps(result) {
+  const steps = result.steps || [];
+  return steps.filter((step) => step.category === "test.step" || step.category === "expect").map((step) => String(step.title)).filter(Boolean);
+}
+function extractArtifacts(result) {
+  return (result.attachments || []).filter((attachment) => attachment.path).map((attachment) => ({
+    type: attachment.contentType?.startsWith("image/") ? "screenshot" : attachment.name,
+    path: String(attachment.path),
+    contentType: attachment.contentType
+  }));
+}
+function ciMetadata() {
+  if (process.env.GITHUB_RUN_ID && process.env.GITHUB_REPOSITORY) {
+    const server = process.env.GITHUB_SERVER_URL || "https://github.com";
+    return {
+      provider: "github",
+      runId: process.env.GITHUB_RUN_ID,
+      repository: process.env.GITHUB_REPOSITORY,
+      commit: process.env.GITHUB_SHA,
+      branch: process.env.GITHUB_REF_NAME,
+      url: `${server}/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`
+    };
+  }
+  if (process.env.CI) {
+    return {
+      provider: "generic",
+      commit: process.env.GIT_COMMIT || process.env.CI_COMMIT_SHA,
+      branch: process.env.GIT_BRANCH || process.env.CI_COMMIT_REF_NAME,
+      url: process.env.BUILD_URL || process.env.CI_JOB_URL
+    };
+  }
+  return void 0;
+}
+function projectMetadata(config) {
+  return {
+    rootDir: config.rootDir,
+    projects: (config.projects || []).map((project) => ({
+      name: project.name,
+      browserName: project.use?.browserName,
+      viewport: project.use?.viewport,
+      locale: project.use?.locale
+    }))
+  };
+}
+var PlaywrightAiReporter = class {
+  constructor(options = {}) {
+    this.run = { id: `local-${Date.now()}`, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    this.failures = [];
+    this.outputDir = options.outputDir || "playwright-ai-report";
+    this.store = options.store || new SQLiteStore({ path: options.databasePath });
+    this.outputLanguage = options.outputLanguage;
+  }
+  async onBegin(_config, suite) {
+    this.failures = [];
+    this.run = {
+      id: process.env.PW_AI_RUN_ID || `local-${Date.now()}`,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      total: suite.allTests().length,
+      metadata: {
+        ...projectMetadata(_config),
+        ci: ciMetadata()
+      }
+    };
+    await this.store.migrate();
+    await this.store.saveRun(this.run);
+  }
+  async onTestEnd(test, result) {
+    if (!isFailure(result.status)) {
+      return;
+    }
+    const failure = {
+      title: String(test.title),
+      file: test.location.file,
+      line: test.location.line,
+      project: test.parent?.project()?.name,
+      workerIndex: result.workerIndex,
+      status: result.status,
+      retry: result.retry,
+      durationMs: result.duration,
+      error: extractError(result),
+      steps: extractSteps(result),
+      artifacts: extractArtifacts(result),
+      annotations: test.annotations.map((annotation) => ({
+        type: annotation.type,
+        description: annotation.description
+      })),
+      run: { id: this.run.id, ci: ciMetadata() },
+      metadata: {
+        testId: test.id,
+        parallelIndex: result.parallelIndex
+      }
+    };
+    const enriched = await enrichFailureWithArtifacts(failure);
+    this.failures.push(enriched);
+    await this.store.saveFailure(enriched);
+  }
+  async onEnd(_result) {
+    this.run.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.run.failed = this.failures.length;
+    const analyses = await analyzeFailures(this.failures, {
+      store: this.store,
+      outputLanguage: this.outputLanguage
+    });
+    await writePortableReport(this.outputDir, {
+      run: this.run,
+      failures: this.failures,
+      analyses
+    });
+    await this.store.saveRun(this.run);
+    await this.store.close();
+  }
+};
+var reporter_default = PlaywrightAiReporter;
+export {
+  PlaywrightAiReporter,
+  reporter_default as default
+};

package/dist/types-B55GjfW7.d.cts

@@ -0,0 +1,355 @@
+type FailureStatus = 'failed' | 'timedOut' | 'interrupted' | 'skipped' | 'passed' | string;
+interface ArtifactRecord {
+    type: string;
+    path: string;
+    contentType?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ManualTestArtifact {
+    type: string;
+    path?: string;
+    url?: string;
+    contentType?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ManualTestStep {
+    index?: number;
+    action: string;
+    expected?: string;
+    data?: Record<string, unknown>;
+    artifacts?: ManualTestArtifact[];
+}
+interface ManualTestCase {
+    id: string;
+    key?: string;
+    title: string;
+    description?: string;
+    preconditions?: string;
+    steps: ManualTestStep[];
+    artifacts?: ManualTestArtifact[];
+    labels?: string[];
+    source?: {
+        provider?: string;
+        project?: string;
+        url?: string;
+    };
+    metadata?: Record<string, unknown>;
+}
+interface ManualTestCaseQuery {
+    project: string;
+    query?: string;
+    limit?: number;
+}
+interface ManualTestProvider {
+    listCases(input: ManualTestCaseQuery): Promise<ManualTestCase[]>;
+}
+type FailureCategory = 'selector' | 'timing' | 'runtime' | 'test_data' | 'visual' | 'interaction' | 'environment' | 'unknown';
+type RiskLevel = 'low' | 'medium' | 'high';
+interface ConsoleEvent {
+    level: string;
+    text: string;
+    url?: string;
+    lineNumber?: number;
+    columnNumber?: number;
+    timestamp?: number;
+}
+interface NetworkEvent {
+    url: string;
+    method?: string;
+    status?: number;
+    statusText?: string;
+    errorText?: string;
+    timestamp?: number;
+}
+interface ActionEvent {
+    name: string;
+    selector?: string;
+    url?: string;
+    timestamp?: number;
+    pageId?: string;
+}
+interface TraceSummary {
+    browserContext?: Record<string, unknown>;
+    page?: {
+        url?: string;
+        title?: string;
+        snapshot?: string;
+    };
+    pageSnapshot?: string;
+    consoleErrors: ConsoleEvent[];
+    networkFailures: NetworkEvent[];
+    lastActions: ActionEvent[];
+    artifactRefs: ArtifactRecord[];
+}
+interface FailureRecord {
+    title: string;
+    file: string;
+    line?: number;
+    project?: string;
+    workerIndex?: number;
+    status: FailureStatus;
+    retry?: number;
+    durationMs?: number;
+    error: string;
+    steps?: string[];
+    artifacts?: ArtifactRecord[];
+    artifactRefs?: ArtifactRecord[];
+    annotations?: Array<{
+        type: string;
+        description?: string;
+    }>;
+    browserContext?: Record<string, unknown>;
+    page?: {
+        url?: string;
+        title?: string;
+        snapshot?: string;
+    };
+    pageSnapshot?: string;
+    consoleErrors?: ConsoleEvent[];
+    networkFailures?: NetworkEvent[];
+    lastActions?: ActionEvent[];
+    trace?: TraceSummary;
+    run?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+interface AnalysisResult {
+    side: 'app_bug' | 'test_bug' | 'flaky_test' | 'env_issue' | 'unknown';
+    rootCause: string;
+    evidence: string[];
+    reproductionSteps: string[];
+    suspects: {
+        selectors: string[];
+        pages: string[];
+        endpoints: string[];
+    };
+    fixSuggestions: string[];
+    confidence: number;
+    category: FailureCategory;
+    risk: RiskLevel;
+    evidenceRefs: string[];
+    confidenceReasons: string[];
+    needsHumanReview: boolean;
+    suggestedFixes?: PatchSuggestion[];
+    source: 'deterministic' | 'ai' | 'cache' | 'unknown';
+    tokenUsage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+}
+type PatchPolicyDecision = 'review' | 'blocked';
+interface PatchSuggestion {
+    filePath: string;
+    line?: number;
+    oldSnippet: string;
+    newSnippet: string;
+    explanation: string;
+    evidence: string[];
+    risk: RiskLevel;
+    policyDecision: PatchPolicyDecision;
+    reviewReason: string;
+}
+interface FailureGroup {
+    signature: string;
+    pattern: string;
+    failures: FailureRecord[];
+}
+interface RunRecord {
+    id: string;
+    startedAt?: string;
+    finishedAt?: string;
+    total?: number;
+    passed?: number;
+    failed?: number;
+    skipped?: number;
+    metadata?: Record<string, unknown>;
+}
+interface MemoryRecordInput {
+    namespace: string;
+    kind: string;
+    key: string;
+    value: Record<string, unknown>;
+    tags?: string[];
+    confidence?: number;
+    source: string;
+}
+interface MemoryRecord extends Required<MemoryRecordInput> {
+    supersededBy: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SearchMemoryInput {
+    namespace?: string;
+    kind?: string;
+    query?: string;
+    tags?: string[];
+    limit?: number;
+}
+type FeedbackDecision = 'approved' | 'rejected' | 'needs_work' | 'mark_flaky';
+interface FeedbackRecordInput {
+    signature: string;
+    decision: FeedbackDecision;
+    reason?: string;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackRecord extends Required<FeedbackRecordInput> {
+    createdAt: string;
+}
+interface FailureHistoryQuery {
+    signature?: string;
+    query?: string;
+    file?: string;
+    limit?: number;
+}
+interface ProjectContext {
+    namespace?: string;
+    repository?: string;
+    commit?: string;
+    branch?: string;
+    ci?: Record<string, unknown>;
+}
+interface PrivacyPolicy {
+    redactSecrets?: boolean;
+}
+interface AnalysisStore {
+    migrate(): Promise<void>;
+    saveRun(run: RunRecord): Promise<void>;
+    saveFailure(failure: FailureRecord): Promise<void>;
+    saveAnalysis(signature: string, analysis: AnalysisResult): Promise<void>;
+    getCachedAnalysis(signature: string): Promise<AnalysisResult | null>;
+    upsertMemory(record: MemoryRecordInput): Promise<void>;
+    searchMemory(input: SearchMemoryInput): Promise<MemoryRecord[]>;
+    recordFeedback(input: FeedbackRecordInput): Promise<void>;
+    searchFeedback(input: {
+        signature?: string;
+        decision?: FeedbackDecision;
+        query?: string;
+        limit?: number;
+    }): Promise<FeedbackRecord[]>;
+    findFailures(input: FailureHistoryQuery): Promise<FailureRecord[]>;
+    getRun?(id: string): Promise<RunRecord | null>;
+    stats?(): Promise<Record<string, number>>;
+    close(): Promise<void>;
+}
+interface AiProviderRequest {
+    failure: FailureRecord;
+    outputLanguage: string;
+    similarAnalyses?: AnalysisResult[];
+}
+interface AiProvider {
+    analyzeFailure(request: AiProviderRequest): Promise<AnalysisResult>;
+}
+interface IssueReporter {
+    publishAnalysis(report: {
+        failure: FailureRecord;
+        analysis: AnalysisResult;
+        markdown: string;
+    }): Promise<{
+        url?: string;
+        id?: string;
+    } | void>;
+}
+interface ArtifactProvider {
+    resolveArtifacts(failure: FailureRecord): Promise<ArtifactRecord[]>;
+}
+interface TestManagementProvider {
+    resolveCase(failure: FailureRecord): Promise<Record<string, unknown> | null>;
+}
+interface BrowserEvidence {
+    requestedUrl: string;
+    currentUrl: string;
+    title: string;
+    domSummary: string;
+    htmlSnippet: string;
+    screenshotBase64: string;
+}
+interface GeneratedLocator {
+    stepIndex?: number;
+    selector: string;
+    reason: string;
+}
+interface GeneratedStepCoverage {
+    stepIndex?: number;
+    status: 'covered' | 'partial' | 'missing';
+    notes: string;
+}
+interface TestGenerationProviderRequest {
+    manualCase: ManualTestCase;
+    url: string;
+    browser: BrowserEvidence;
+    outputLanguage?: string;
+}
+interface TestGenerationProviderResult {
+    code: string;
+    locators: GeneratedLocator[];
+    coverage: GeneratedStepCoverage[];
+    warnings: string[];
+}
+interface TestGenerationProvider {
+    generateTest(request: TestGenerationProviderRequest): Promise<TestGenerationProviderResult>;
+}
+interface TestGenerationRequest {
+    manualCase: ManualTestCase;
+    url: string;
+    outputDir?: string;
+    provider: TestGenerationProvider;
+    confirmBrowserRun?: boolean;
+    allowDestructiveActions?: boolean;
+    storageState?: string;
+    sourceName?: string;
+    outputLanguage?: string;
+}
+interface GeneratedTestDraft extends TestGenerationProviderResult {
+    manualCase: ManualTestCase;
+    filePath: string;
+    reportPath: string;
+    screenshotPath: string;
+    browser: Omit<BrowserEvidence, 'screenshotBase64'>;
+    needsHumanReview: boolean;
+}
+interface ReportPublisher {
+    publishReport(report: {
+        run: RunRecord;
+        failures: FailureRecord[];
+        analyses: AnalysisResult[];
+        markdown: string;
+        html?: string;
+    }): Promise<{
+        url?: string;
+        id?: string;
+    } | void>;
+}
+interface PatchSuggestionPublisher {
+    publishSuggestions(report: {
+        failure: FailureRecord;
+        analysis: AnalysisResult;
+        suggestions: PatchSuggestion[];
+        markdown: string;
+    }): Promise<{
+        url?: string;
+        id?: string;
+    } | void>;
+}
+interface ArtifactResolver {
+    resolveArtifact(artifact: ArtifactRecord): Promise<string | Buffer | null>;
+}
+interface FeedbackStore {
+    recordFeedback(input: {
+        signature: string;
+        decision: FeedbackDecision;
+        reason?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+}
+interface AnalyzeFailuresOptions {
+    store?: AnalysisStore;
+    provider?: AiProvider;
+    outputLanguage?: string;
+    projectContext?: ProjectContext;
+    knowledgeSources?: string[];
+    ciMetadata?: Record<string, unknown>;
+    privacyPolicy?: PrivacyPolicy;
+    similarityLimit?: number;
+}
+
+export type { AiProvider as A, BrowserEvidence as B, ConsoleEvent as C, PatchPolicyDecision as D, PatchSuggestionPublisher as E, FailureRecord as F, GeneratedTestDraft as G, PrivacyPolicy as H, IssueReporter as I, ProjectContext as J, ReportPublisher as K, RiskLevel as L, ManualTestCase as M, NetworkEvent as N, TestManagementProvider as O, PatchSuggestion as P, RunRecord as R, SearchMemoryInput as S, TestGenerationProvider as T, AnalysisResult as a, AnalyzeFailuresOptions as b, FailureCategory as c, FailureGroup as d, TestGenerationProviderResult as e, TestGenerationRequest as f, AiProviderRequest as g, TestGenerationProviderRequest as h, TraceSummary as i, AnalysisStore as j, MemoryRecord as k, FeedbackRecord as l, MemoryRecordInput as m, FeedbackRecordInput as n, FeedbackDecision as o, FailureHistoryQuery as p, ArtifactProvider as q, ArtifactRecord as r, ArtifactResolver as s, FeedbackStore as t, GeneratedLocator as u, GeneratedStepCoverage as v, ManualTestArtifact as w, ManualTestCaseQuery as x, ManualTestProvider as y, ManualTestStep as z };