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

package/dist/index.d.cts

@@ -0,0 +1,218 @@
+import { A as AiProvider, F as FailureRecord, a as AnalysisResult, b as AnalyzeFailuresOptions, c as FailureCategory, P as PatchSuggestion, d as FailureGroup, T as TestGenerationProvider, M as ManualTestCase, e as TestGenerationProviderResult, f as TestGenerationRequest, G as GeneratedTestDraft, g as AiProviderRequest, h as TestGenerationProviderRequest, R as RunRecord, i as TraceSummary, j as AnalysisStore, k as MemoryRecord, l as FeedbackRecord, m as MemoryRecordInput, S as SearchMemoryInput, n as FeedbackRecordInput, o as FeedbackDecision, p as FailureHistoryQuery } from './types-B55GjfW7.cjs';
+export { q as ArtifactProvider, r as ArtifactRecord, s as ArtifactResolver, B as BrowserEvidence, C as ConsoleEvent, t as FeedbackStore, u as GeneratedLocator, v as GeneratedStepCoverage, I as IssueReporter, w as ManualTestArtifact, x as ManualTestCaseQuery, y as ManualTestProvider, z as ManualTestStep, N as NetworkEvent, D as PatchPolicyDecision, E as PatchSuggestionPublisher, H as PrivacyPolicy, J as ProjectContext, K as ReportPublisher, L as RiskLevel, O as TestManagementProvider } from './types-B55GjfW7.cjs';
+
+interface DeterministicAnalyzerOptions {
+    provider?: AiProvider;
+    outputLanguage?: string;
+}
+declare class DeterministicAnalyzer {
+    private readonly provider?;
+    private readonly outputLanguage;
+    constructor(options?: DeterministicAnalyzerOptions);
+    analyzeFailure(failure: FailureRecord, similarAnalyses?: AnalysisResult[]): Promise<AnalysisResult>;
+    analyzeFailures(failures: FailureRecord[]): Promise<AnalysisResult[]>;
+}
+declare function analyzeFailures(failures: FailureRecord[], options?: AnalyzeFailuresOptions): Promise<AnalysisResult[]>;
+
+interface BenchmarkFailureInput extends FailureRecord {
+    expectedCategory?: FailureCategory;
+}
+interface BenchmarkFailureResult {
+    title: string;
+    file: string;
+    expectedCategory: FailureCategory;
+    actualCategory: FailureCategory;
+    correct: boolean;
+    signature: string;
+    cacheHit: boolean;
+    analysis: AnalysisResult;
+    suggestions: PatchSuggestion[];
+}
+interface BenchmarkReport {
+    metrics: {
+        total: number;
+        correct: number;
+        accuracy: number;
+        unknown: number;
+        unknownRate: number;
+        cacheHits: number;
+        cacheHitRate: number;
+        suggestions: {
+            blocked: number;
+            review: number;
+        };
+    };
+    failures: BenchmarkFailureResult[];
+}
+declare function benchmarkFailures(fixtures: BenchmarkFailureInput[]): BenchmarkReport;
+
+interface EnrichFailureOptions {
+    artifactRoot?: string;
+}
+declare function enrichFailureWithArtifacts(failure: FailureRecord, options?: EnrichFailureOptions): Promise<FailureRecord>;
+
+declare class FailureGrouper {
+    group(failures: FailureRecord[]): FailureGroup[];
+}
+
+declare function isDestructiveManualCase(manualCase: ManualTestCase): boolean;
+declare function assertBrowserGenerationAllowed(request: Pick<TestGenerationRequest, 'manualCase' | 'url' | 'confirmBrowserRun' | 'allowDestructiveActions'>): void;
+declare class TemplateTestGenerationProvider implements TestGenerationProvider {
+    generateTest(request: {
+        manualCase: ManualTestCase;
+        url: string;
+    }): Promise<TestGenerationProviderResult>;
+}
+declare function generatePlaywrightTestDraft(request: TestGenerationRequest): Promise<GeneratedTestDraft>;
+
+interface NormalizeOptions {
+    runId?: string;
+    baseDir?: string;
+}
+declare function normalizePlaywrightJsonReport(report: any, options?: NormalizeOptions): FailureRecord[];
+
+type Transport = (url: string, init: RequestInit) => Promise<{
+    ok: boolean;
+    status: number;
+    json(): Promise<any>;
+}>;
+interface OpenAIResponsesProviderOptions {
+    apiKey?: string;
+    model?: string;
+    baseUrl?: string;
+    transport?: Transport;
+}
+declare class OpenAIResponsesProvider implements AiProvider, TestGenerationProvider {
+    private readonly apiKey;
+    private readonly model;
+    private readonly baseUrl;
+    private readonly transport;
+    constructor(options?: OpenAIResponsesProviderOptions);
+    analyzeFailure(request: AiProviderRequest): Promise<AnalysisResult>;
+    generateTest(request: TestGenerationProviderRequest): Promise<TestGenerationProviderResult>;
+}
+
+interface PortableReport {
+    run: RunRecord;
+    failures: FailureRecord[];
+    analyses: AnalysisResult[];
+    suggestions?: PatchSuggestion[][];
+}
+declare function markdownReport(report: PortableReport): string;
+declare function htmlReport(report: PortableReport): string;
+declare function mcpSummary(report: PortableReport): string;
+declare function writePortableReport(outputDir: string, report: PortableReport): Promise<void>;
+
+interface GeneratePatchSuggestionOptions {
+    workspaceRoot?: string;
+}
+declare function evaluatePatchPolicy(suggestion: PatchSuggestion): PatchSuggestion;
+declare function generatePatchSuggestions(failure: FailureRecord, analysis: AnalysisResult, options?: GeneratePatchSuggestionOptions): PatchSuggestion[];
+
+declare function classifyFailure(failure: FailureRecord): AnalysisResult;
+
+declare function parseTraceArtifact(filePath: string): Promise<TraceSummary>;
+
+declare class MemoryStore implements AnalysisStore {
+    protected runs: Map<string, RunRecord>;
+    protected failures: FailureRecord[];
+    protected analyses: Map<string, AnalysisResult>;
+    protected memory: Map<string, MemoryRecord>;
+    protected feedback: FeedbackRecord[];
+    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(input: 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 SQLiteStoreOptions {
+    path?: string;
+}
+declare class SQLiteStore {
+    private readonly filePath;
+    private db?;
+    private loaded;
+    private readonly inMemory;
+    constructor(options?: SQLiteStoreOptions);
+    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>;
+    private load;
+    private importSnapshot;
+    private all;
+    private persist;
+}
+
+interface QueryExecutor {
+    query(sql: string, params?: unknown[]): Promise<{
+        rows: any[];
+        rowCount?: number | null;
+    }>;
+    close?(): Promise<void>;
+}
+declare class PostgresStore extends MemoryStore {
+    private readonly executor?;
+    constructor(executor?: QueryExecutor | undefined);
+    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(record: FeedbackRecordInput): Promise<void>;
+    searchFeedback(input: {
+        signature?: string;
+        decision?: FeedbackDecision;
+        query?: string;
+        limit?: number;
+    }): Promise<FeedbackRecord[]>;
+    findFailures(input: FailureHistoryQuery): Promise<FailureRecord[]>;
+    close(): Promise<void>;
+}
+
+interface ImportLegacyRowsInput {
+    testResults?: any[];
+    analysisCache?: any[];
+    artifacts?: any[];
+}
+interface LegacyAnalysisImport {
+    signature: string;
+    analysis: AnalysisResult;
+}
+interface LegacyImportResult {
+    failures: FailureRecord[];
+    analyses: LegacyAnalysisImport[];
+}
+declare function importLegacyRows(input: ImportLegacyRowsInput): LegacyImportResult;
+
+export { AiProvider, AiProviderRequest, AnalysisResult, AnalysisStore, type BenchmarkFailureInput, type BenchmarkFailureResult, type BenchmarkReport, DeterministicAnalyzer, FailureCategory, FailureGroup, FailureGrouper, FailureHistoryQuery, FailureRecord, FeedbackDecision, FeedbackRecord, FeedbackRecordInput, GeneratedTestDraft, type ImportLegacyRowsInput, type LegacyImportResult, ManualTestCase, MemoryRecord, MemoryRecordInput, MemoryStore, OpenAIResponsesProvider, PatchSuggestion, type PortableReport, PostgresStore, type QueryExecutor, RunRecord, SQLiteStore, SearchMemoryInput, TemplateTestGenerationProvider, TestGenerationProvider, TestGenerationProviderRequest, TestGenerationProviderResult, TestGenerationRequest, TraceSummary, analyzeFailures, assertBrowserGenerationAllowed, benchmarkFailures, classifyFailure, enrichFailureWithArtifacts, evaluatePatchPolicy, generatePatchSuggestions, generatePlaywrightTestDraft, htmlReport, importLegacyRows, isDestructiveManualCase, markdownReport, mcpSummary, normalizePlaywrightJsonReport, parseTraceArtifact, writePortableReport };

package/dist/index.d.ts

@@ -0,0 +1,218 @@
+import { A as AiProvider, F as FailureRecord, a as AnalysisResult, b as AnalyzeFailuresOptions, c as FailureCategory, P as PatchSuggestion, d as FailureGroup, T as TestGenerationProvider, M as ManualTestCase, e as TestGenerationProviderResult, f as TestGenerationRequest, G as GeneratedTestDraft, g as AiProviderRequest, h as TestGenerationProviderRequest, R as RunRecord, i as TraceSummary, j as AnalysisStore, k as MemoryRecord, l as FeedbackRecord, m as MemoryRecordInput, S as SearchMemoryInput, n as FeedbackRecordInput, o as FeedbackDecision, p as FailureHistoryQuery } from './types-B55GjfW7.js';
+export { q as ArtifactProvider, r as ArtifactRecord, s as ArtifactResolver, B as BrowserEvidence, C as ConsoleEvent, t as FeedbackStore, u as GeneratedLocator, v as GeneratedStepCoverage, I as IssueReporter, w as ManualTestArtifact, x as ManualTestCaseQuery, y as ManualTestProvider, z as ManualTestStep, N as NetworkEvent, D as PatchPolicyDecision, E as PatchSuggestionPublisher, H as PrivacyPolicy, J as ProjectContext, K as ReportPublisher, L as RiskLevel, O as TestManagementProvider } from './types-B55GjfW7.js';
+
+interface DeterministicAnalyzerOptions {
+    provider?: AiProvider;
+    outputLanguage?: string;
+}
+declare class DeterministicAnalyzer {
+    private readonly provider?;
+    private readonly outputLanguage;
+    constructor(options?: DeterministicAnalyzerOptions);
+    analyzeFailure(failure: FailureRecord, similarAnalyses?: AnalysisResult[]): Promise<AnalysisResult>;
+    analyzeFailures(failures: FailureRecord[]): Promise<AnalysisResult[]>;
+}
+declare function analyzeFailures(failures: FailureRecord[], options?: AnalyzeFailuresOptions): Promise<AnalysisResult[]>;
+
+interface BenchmarkFailureInput extends FailureRecord {
+    expectedCategory?: FailureCategory;
+}
+interface BenchmarkFailureResult {
+    title: string;
+    file: string;
+    expectedCategory: FailureCategory;
+    actualCategory: FailureCategory;
+    correct: boolean;
+    signature: string;
+    cacheHit: boolean;
+    analysis: AnalysisResult;
+    suggestions: PatchSuggestion[];
+}
+interface BenchmarkReport {
+    metrics: {
+        total: number;
+        correct: number;
+        accuracy: number;
+        unknown: number;
+        unknownRate: number;
+        cacheHits: number;
+        cacheHitRate: number;
+        suggestions: {
+            blocked: number;
+            review: number;
+        };
+    };
+    failures: BenchmarkFailureResult[];
+}
+declare function benchmarkFailures(fixtures: BenchmarkFailureInput[]): BenchmarkReport;
+
+interface EnrichFailureOptions {
+    artifactRoot?: string;
+}
+declare function enrichFailureWithArtifacts(failure: FailureRecord, options?: EnrichFailureOptions): Promise<FailureRecord>;
+
+declare class FailureGrouper {
+    group(failures: FailureRecord[]): FailureGroup[];
+}
+
+declare function isDestructiveManualCase(manualCase: ManualTestCase): boolean;
+declare function assertBrowserGenerationAllowed(request: Pick<TestGenerationRequest, 'manualCase' | 'url' | 'confirmBrowserRun' | 'allowDestructiveActions'>): void;
+declare class TemplateTestGenerationProvider implements TestGenerationProvider {
+    generateTest(request: {
+        manualCase: ManualTestCase;
+        url: string;
+    }): Promise<TestGenerationProviderResult>;
+}
+declare function generatePlaywrightTestDraft(request: TestGenerationRequest): Promise<GeneratedTestDraft>;
+
+interface NormalizeOptions {
+    runId?: string;
+    baseDir?: string;
+}
+declare function normalizePlaywrightJsonReport(report: any, options?: NormalizeOptions): FailureRecord[];
+
+type Transport = (url: string, init: RequestInit) => Promise<{
+    ok: boolean;
+    status: number;
+    json(): Promise<any>;
+}>;
+interface OpenAIResponsesProviderOptions {
+    apiKey?: string;
+    model?: string;
+    baseUrl?: string;
+    transport?: Transport;
+}
+declare class OpenAIResponsesProvider implements AiProvider, TestGenerationProvider {
+    private readonly apiKey;
+    private readonly model;
+    private readonly baseUrl;
+    private readonly transport;
+    constructor(options?: OpenAIResponsesProviderOptions);
+    analyzeFailure(request: AiProviderRequest): Promise<AnalysisResult>;
+    generateTest(request: TestGenerationProviderRequest): Promise<TestGenerationProviderResult>;
+}
+
+interface PortableReport {
+    run: RunRecord;
+    failures: FailureRecord[];
+    analyses: AnalysisResult[];
+    suggestions?: PatchSuggestion[][];
+}
+declare function markdownReport(report: PortableReport): string;
+declare function htmlReport(report: PortableReport): string;
+declare function mcpSummary(report: PortableReport): string;
+declare function writePortableReport(outputDir: string, report: PortableReport): Promise<void>;
+
+interface GeneratePatchSuggestionOptions {
+    workspaceRoot?: string;
+}
+declare function evaluatePatchPolicy(suggestion: PatchSuggestion): PatchSuggestion;
+declare function generatePatchSuggestions(failure: FailureRecord, analysis: AnalysisResult, options?: GeneratePatchSuggestionOptions): PatchSuggestion[];
+
+declare function classifyFailure(failure: FailureRecord): AnalysisResult;
+
+declare function parseTraceArtifact(filePath: string): Promise<TraceSummary>;
+
+declare class MemoryStore implements AnalysisStore {
+    protected runs: Map<string, RunRecord>;
+    protected failures: FailureRecord[];
+    protected analyses: Map<string, AnalysisResult>;
+    protected memory: Map<string, MemoryRecord>;
+    protected feedback: FeedbackRecord[];
+    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(input: 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 SQLiteStoreOptions {
+    path?: string;
+}
+declare class SQLiteStore {
+    private readonly filePath;
+    private db?;
+    private loaded;
+    private readonly inMemory;
+    constructor(options?: SQLiteStoreOptions);
+    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>;
+    private load;
+    private importSnapshot;
+    private all;
+    private persist;
+}
+
+interface QueryExecutor {
+    query(sql: string, params?: unknown[]): Promise<{
+        rows: any[];
+        rowCount?: number | null;
+    }>;
+    close?(): Promise<void>;
+}
+declare class PostgresStore extends MemoryStore {
+    private readonly executor?;
+    constructor(executor?: QueryExecutor | undefined);
+    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(record: FeedbackRecordInput): Promise<void>;
+    searchFeedback(input: {
+        signature?: string;
+        decision?: FeedbackDecision;
+        query?: string;
+        limit?: number;
+    }): Promise<FeedbackRecord[]>;
+    findFailures(input: FailureHistoryQuery): Promise<FailureRecord[]>;
+    close(): Promise<void>;
+}
+
+interface ImportLegacyRowsInput {
+    testResults?: any[];
+    analysisCache?: any[];
+    artifacts?: any[];
+}
+interface LegacyAnalysisImport {
+    signature: string;
+    analysis: AnalysisResult;
+}
+interface LegacyImportResult {
+    failures: FailureRecord[];
+    analyses: LegacyAnalysisImport[];
+}
+declare function importLegacyRows(input: ImportLegacyRowsInput): LegacyImportResult;
+
+export { AiProvider, AiProviderRequest, AnalysisResult, AnalysisStore, type BenchmarkFailureInput, type BenchmarkFailureResult, type BenchmarkReport, DeterministicAnalyzer, FailureCategory, FailureGroup, FailureGrouper, FailureHistoryQuery, FailureRecord, FeedbackDecision, FeedbackRecord, FeedbackRecordInput, GeneratedTestDraft, type ImportLegacyRowsInput, type LegacyImportResult, ManualTestCase, MemoryRecord, MemoryRecordInput, MemoryStore, OpenAIResponsesProvider, PatchSuggestion, type PortableReport, PostgresStore, type QueryExecutor, RunRecord, SQLiteStore, SearchMemoryInput, TemplateTestGenerationProvider, TestGenerationProvider, TestGenerationProviderRequest, TestGenerationProviderResult, TestGenerationRequest, TraceSummary, analyzeFailures, assertBrowserGenerationAllowed, benchmarkFailures, classifyFailure, enrichFailureWithArtifacts, evaluatePatchPolicy, generatePatchSuggestions, generatePlaywrightTestDraft, htmlReport, importLegacyRows, isDestructiveManualCase, markdownReport, mcpSummary, normalizePlaywrightJsonReport, parseTraceArtifact, writePortableReport };