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

package/dist/types-B55GjfW7.d.ts

@@ -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 };

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@continuum8032/playwright-ai-tools",
+  "version": "0.2.0-oidc-bootstrap.0",
+  "description": "Local-first AI triage and repair-suggestion tools for Playwright test projects.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Continuum8032/codex-playwright-tools.git",
+    "directory": "typescript"
+  },
+  "homepage": "https://github.com/Continuum8032/codex-playwright-tools#readme",
+  "bugs": {
+    "url": "https://github.com/Continuum8032/codex-playwright-tools/issues"
+  },
+  "keywords": [
+    "playwright",
+    "testing",
+    "ai",
+    "triage",
+    "trace",
+    "automation"
+  ],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "playwright-ai-tools": "./dist/cli.cjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./reporter": {
+      "types": "./dist/reporter.d.ts",
+      "import": "./dist/reporter.js",
+      "require": "./dist/reporter.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts src/reporter.ts --format esm,cjs --dts --clean",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "@playwright/test": ">=1.40.0"
+  },
+  "dependencies": {
+    "@types/sql.js": "^1.4.11",
+    "sql.js": "^1.14.1"
+  }
+}