playwright-intelligence-engine 0.0.0-stage → 2.0.1

package/src/collectors/collector-interface.ts

@@ -0,0 +1,8 @@
+import { UnifiedEvidenceRecord, EvidenceSource } from '../evidence/evidence-model.js';
+
+export interface EvidenceCollector<TInput = any> {
+  readonly name: string;
+  readonly source: EvidenceSource;
+  collect(input: TInput): Promise<UnifiedEvidenceRecord[]>;
+}
+

package/src/collectors/environment-collector.ts

@@ -0,0 +1,103 @@
+import * as os from 'os';
+import * as fs from 'fs';
+import * as path from 'path';
+import { EvidenceCollector } from './collector-interface.js';
+import { UnifiedEvidenceRecord } from '../evidence/evidence-model.js';
+
+export interface EnvironmentInput {
+  workspaceRoot?: string;
+  executionId?: string;
+}
+
+export class EnvironmentCollector implements EvidenceCollector<EnvironmentInput> {
+  public readonly name = 'EnvironmentCollector';
+  public readonly source = 'environment' as const;
+
+  public async collect(input: EnvironmentInput = {}): Promise<UnifiedEvidenceRecord[]> {
+    const executionId = input.executionId ?? `exec-${Date.now()}`;
+    const timestamp = Date.now();
+
+    // 1. Playwright version detection
+    let playwrightVersion = 'unknown';
+    if (input.workspaceRoot) {
+      try {
+        const pwPkgPath = path.join(
+          input.workspaceRoot,
+          'node_modules',
+          '@playwright',
+          'test',
+          'package.json'
+        );
+        if (fs.existsSync(pwPkgPath)) {
+          const pkg = JSON.parse(fs.readFileSync(pwPkgPath, 'utf-8'));
+          playwrightVersion = pkg.version || 'unknown';
+        } else {
+          // Check root package.json
+          const rootPkgPath = path.join(input.workspaceRoot, 'package.json');
+          if (fs.existsSync(rootPkgPath)) {
+            const rootPkg = JSON.parse(fs.readFileSync(rootPkgPath, 'utf-8'));
+            playwrightVersion =
+              rootPkg.devDependencies?.['@playwright/test'] ||
+              rootPkg.dependencies?.['@playwright/test'] ||
+              'unknown';
+          }
+        }
+      } catch {
+        // Safe fallback
+      }
+    }
+
+    // 2. Identify CI Provider safely (zero secret leakage)
+    let ciProvider: string | null = null;
+    let ciRunId: string | null = null;
+    if (process.env.GITHUB_ACTIONS) {
+      ciProvider = 'GitHub Actions';
+      ciRunId = process.env.GITHUB_RUN_ID ?? null;
+    } else if (process.env.GITLAB_CI) {
+      ciProvider = 'GitLab CI';
+      ciRunId = process.env.CI_PIPELINE_ID ?? null;
+    } else if (process.env.JENKINS_URL) {
+      ciProvider = 'Jenkins';
+      ciRunId = process.env.BUILD_NUMBER ?? null;
+    } else if (process.env.CIRCLECI) {
+      ciProvider = 'CircleCI';
+      ciRunId = process.env.CIRCLE_BUILD_NUM ?? null;
+    } else if (process.env.TF_BUILD) {
+      ciProvider = 'Azure DevOps Pipelines';
+      ciRunId = process.env.BUILD_BUILDID ?? null;
+    }
+
+    const payload = {
+      nodeVersion: process.version,
+      platform: os.platform(),
+      arch: os.arch(),
+      osRelease: os.release(),
+      cpuCount: os.cpus().length,
+      totalMemoryMb: Math.round(os.totalmem() / (1024 * 1024)),
+      freeMemoryMb: Math.round(os.freemem() / (1024 * 1024)),
+      playwrightVersion,
+      ciProvider,
+      ciRunId,
+      isCI: Boolean(process.env.CI),
+    };
+
+    return [
+      {
+        evidenceId: `env-${timestamp}-${Math.random().toString(36).slice(2, 8)}`,
+        executionId,
+        source: 'environment',
+        timestamp,
+        evidenceType: 'environment-metadata',
+        payload,
+        reliability: 'HIGH',
+        provenance: {
+          collector: this.name,
+          collectedAt: timestamp,
+          captureMethod: 'os-process-inspection',
+        },
+        redactionStatus: { isRedacted: false },
+      },
+    ];
+  }
+}
+

package/src/collectors/error-collector.ts

@@ -0,0 +1,177 @@
+import { EvidenceCollector } from './collector-interface.js';
+import { UnifiedEvidenceRecord } from '../evidence/evidence-model.js';
+import { EvidenceRedactor } from '../evidence/evidence-redactor.js';
+
+export interface PlaywrightErrorInput {
+  errorMessage: string;
+  errorStack?: string;
+  testTitle?: string;
+  testFile?: string;
+  line?: number;
+  column?: number;
+  executionId?: string;
+}
+
+export class ErrorCollector implements EvidenceCollector<PlaywrightErrorInput> {
+  public readonly name = 'ErrorCollector';
+  public readonly source = 'error' as const;
+
+  public async collect(input: PlaywrightErrorInput): Promise<UnifiedEvidenceRecord[]> {
+    const executionId = input.executionId ?? `exec-${Date.now()}`;
+    const timestamp = Date.now();
+
+    const {
+      errorType,
+      action,
+      selector,
+      sourceFile,
+      line,
+      column,
+      isStrictModeViolation,
+      isTimeout,
+      isAssertion,
+    } = this.parseError(input);
+
+    const { redactedText: cleanMessage } = EvidenceRedactor.redactText(input.errorMessage);
+    const { redactedText: cleanStack } = EvidenceRedactor.redactText(input.errorStack ?? '');
+
+    const record: UnifiedEvidenceRecord = {
+      evidenceId: `err-${timestamp}-${Math.random().toString(36).slice(2, 8)}`,
+      executionId,
+      source: 'error',
+      timestamp,
+      evidenceType: 'playwright-error',
+      payload: {
+        errorType,
+        action,
+        selector,
+        sourceFile,
+        line,
+        column,
+        errorMessage: cleanMessage,
+        errorStack: cleanStack,
+        isStrictModeViolation,
+        isTimeout,
+        isAssertion,
+        testTitle: input.testTitle,
+      },
+      reliability: 'HIGH',
+      provenance: {
+        collector: this.name,
+        collectedAt: timestamp,
+        captureMethod: 'playwright-error-parser',
+        sourceUri: sourceFile,
+      },
+      redactionStatus: {
+        isRedacted: false,
+      },
+    };
+
+    return [record];
+  }
+
+  private parseError(input: PlaywrightErrorInput) {
+    const rawMsg = input.errorMessage || '';
+    const rawStack = input.errorStack || '';
+
+    let errorType = 'Error';
+    let isStrictModeViolation = false;
+    let isTimeout = false;
+    let isAssertion = false;
+    let action = 'action';
+    let selector: string | undefined;
+
+    const lower = rawMsg.toLowerCase();
+
+    // Strict mode
+    if (lower.includes('strict mode violation') || lower.includes('resolved to') && lower.includes('elements')) {
+      errorType = 'StrictModeViolation';
+      isStrictModeViolation = true;
+    } else if (lower.includes('timeout') || lower.includes('timed out')) {
+      errorType = 'TimeoutError';
+      isTimeout = true;
+    } else if (
+      lower.includes('expect(') ||
+      lower.includes('received:') ||
+      lower.includes('to have text') ||
+      lower.includes('to be visible')
+    ) {
+      errorType = 'AssertionError';
+      isAssertion = true;
+      action = 'expect';
+    }
+
+    // Action extraction
+    const actionMatch = rawMsg.match(
+      /(?:page\.|locator\([^)]+\)\.)(click|fill|press|type|check|uncheck|hover|selectOption|waitFor|dblclick)\b/i
+    );
+    if (actionMatch && actionMatch[1]) {
+      action = actionMatch[1].toLowerCase();
+    } else if (lower.includes('click')) {
+      action = 'click';
+    } else if (lower.includes('fill')) {
+      action = 'fill';
+    } else if (lower.includes('select')) {
+      action = 'selectOption';
+    }
+
+    // Selector extraction patterns
+    // 1. waiting for locator('...') or locator("...")
+    const locatorMatch = rawMsg.match(/waiting for (?:locator|getByRole|getByText|getByTestId|getByLabel)\((['"`].+?['"`])\)/);
+    if (locatorMatch && locatorMatch[1]) {
+      selector = locatorMatch[1].slice(1, -1);
+    } else {
+      // 2. waiting for selector "..."
+      const selectorMatch = rawMsg.match(/waiting for selector ["'](.+?)["']/);
+      if (selectorMatch && selectorMatch[1]) {
+        selector = selectorMatch[1];
+      } else {
+        // 3. locator('...') in message
+        const directLocator = rawMsg.match(/locator\((['"`].+?['"`])\)/);
+        if (directLocator && directLocator[1]) {
+          selector = directLocator[1].slice(1, -1);
+        } else {
+          // 4. Strict mode violation: locator('...') resolved to N elements
+          const strictMatch = rawMsg.match(/strict mode violation:\s*(.+?)\s+resolved to/i);
+          if (strictMatch && strictMatch[1]) {
+            selector = strictMatch[1];
+          }
+        }
+      }
+    }
+
+    // Source location parsing
+    let sourceFile = input.testFile;
+    let line = input.line;
+    let column = input.column;
+
+    if (!sourceFile && rawStack) {
+      // Find stack line pointing to a spec or page file
+      const lines = rawStack.split('\n');
+      for (const l of lines) {
+        const stackMatch = l.match(/at\s+(?:.*?\s+)?\(?(.*?):(\d+):(\d+)\)?$/);
+        if (stackMatch && stackMatch[1]) {
+          const file = stackMatch[1];
+          if (!file.includes('node_modules') && (file.endsWith('.ts') || file.endsWith('.js'))) {
+            sourceFile = file;
+            if (stackMatch[2]) line = parseInt(stackMatch[2], 10);
+            if (stackMatch[3]) column = parseInt(stackMatch[3], 10);
+            break;
+          }
+        }
+      }
+    }
+
+    return {
+      errorType,
+      action,
+      selector,
+      sourceFile,
+      line,
+      column,
+      isStrictModeViolation,
+      isTimeout,
+      isAssertion,
+    };
+  }
+}

package/src/collectors/git-diff-collector.ts

@@ -0,0 +1,190 @@
+import { execFileSync } from 'child_process';
+import { EvidenceCollector } from './collector-interface.js';
+import { UnifiedEvidenceRecord } from '../evidence/evidence-model.js';
+import { EvidenceRedactor } from '../evidence/evidence-redactor.js';
+
+export interface GitDiffInput {
+  workspaceRoot: string;
+  sinceRef?: string;
+  executionId?: string;
+}
+
+export class GitDiffCollector implements EvidenceCollector<GitDiffInput> {
+  public readonly name = 'GitDiffCollector';
+  public readonly source = 'git-diff' as const;
+
+  public async collect(input: GitDiffInput): Promise<UnifiedEvidenceRecord[]> {
+    const executionId = input.executionId ?? `exec-${Date.now()}`;
+    const timestamp = Date.now();
+    const ref = input.sinceRef ?? 'HEAD~1';
+
+    try {
+      // 1. Get recent commits
+      const logOutput = execFileSync(
+        'git',
+        ['log', '-n', '5', '--pretty=format:%h|%an|%s'],
+        { cwd: input.workspaceRoot, encoding: 'utf-8', timeout: 5000 }
+      );
+
+      const recentCommits = logOutput
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => {
+          const [hash, author, subject] = line.split('|');
+          return { hash, author, subject };
+        });
+
+      // 2. Get changed files
+      let changedFiles: string[] = [];
+      try {
+        const filesOutput = execFileSync('git', ['diff', '--name-only', ref, 'HEAD'], {
+          cwd: input.workspaceRoot,
+          encoding: 'utf-8',
+          timeout: 5000,
+        });
+        changedFiles = filesOutput.split('\n').filter(Boolean);
+      } catch {
+        // If ref doesn't exist, diff working tree
+        const uncommitted = execFileSync('git', ['diff', '--name-only'], {
+          cwd: input.workspaceRoot,
+          encoding: 'utf-8',
+          timeout: 5000,
+        });
+        changedFiles = uncommitted.split('\n').filter(Boolean);
+      }
+
+      // 3. Get diff summary with line changes
+      let rawDiff = '';
+      try {
+        rawDiff = execFileSync('git', ['diff', '-U2', ref, 'HEAD'], {
+          cwd: input.workspaceRoot,
+          encoding: 'utf-8',
+          timeout: 5000,
+          maxBuffer: 4 * 1024 * 1024,
+        });
+      } catch {
+        rawDiff = execFileSync('git', ['diff', '-U2'], {
+          cwd: input.workspaceRoot,
+          encoding: 'utf-8',
+          timeout: 5000,
+          maxBuffer: 4 * 1024 * 1024,
+        });
+      }
+
+      const { redactedText: cleanDiff } = EvidenceRedactor.redactText(rawDiff);
+
+      // Extract modified selectors or identifiers in diff
+      const modifiedAttributes: string[] = [];
+      const attrMatches = cleanDiff.matchAll(/[+-]\s*.*?(id|data-testid|class|name|role|aria-label|placeholder)=["']([^"']+)["']/g);
+      for (const m of attrMatches) {
+        modifiedAttributes.push(`${m[1]}="${m[2]}"`);
+      }
+
+      const diffHints = GitDiffCollector.extractDiffHints(cleanDiff, changedFiles);
+
+      return [
+        {
+          evidenceId: `git-${timestamp}-${Math.random().toString(36).slice(2, 8)}`,
+          executionId,
+          source: 'git-diff',
+          timestamp,
+          evidenceType: 'git-diff',
+          payload: {
+            sinceRef: ref,
+            recentCommits,
+            changedFiles,
+            modifiedAttributes: Array.from(new Set(modifiedAttributes)),
+            diffHints,
+            diffSnippet: cleanDiff.slice(0, 10000),
+          },
+          reliability: 'HIGH',
+          provenance: {
+            collector: this.name,
+            collectedAt: timestamp,
+            captureMethod: 'git-cli-diff',
+            sourceUri: input.workspaceRoot,
+          },
+          redactionStatus: { isRedacted: false },
+        },
+      ];
+    } catch (err: any) {
+      return [
+        {
+          evidenceId: `git-${timestamp}-${Math.random().toString(36).slice(2, 8)}`,
+          executionId,
+          source: 'git-diff',
+          timestamp,
+          evidenceType: 'git-diff',
+          payload: {
+            error: err?.message || 'Failed to collect git diff',
+            changedFiles: [],
+            recentCommits: [],
+          },
+          reliability: 'LOW',
+          provenance: {
+            collector: this.name,
+            collectedAt: timestamp,
+            captureMethod: 'git-cli-diff',
+            sourceUri: input.workspaceRoot,
+          },
+          redactionStatus: { isRedacted: false },
+        },
+      ];
+    }
+  }
+
+  public static extractDiffHints(cleanDiff: string, changedFiles: string[]): {
+    changedRoutes: string[];
+    changedSymbols: string[];
+    apiEndpoints: string[];
+    validationHints: string[];
+    existingTestsChanged: string[];
+  } {
+    const addedOrChangedLines = cleanDiff
+      .split(/\r?\n/)
+      .filter((line) => (line.startsWith('+') || line.startsWith('-')) && !line.startsWith('+++') && !line.startsWith('---'))
+      .join('\n');
+
+    const changedRoutes = new Set<string>();
+    for (const file of changedFiles) {
+      const appMatch = file.match(/(?:^|\/)(?:src\/)?app\/(.+?)\/page\.[tj]sx?$/i);
+      if (appMatch?.[1]) changedRoutes.add(`/${appMatch[1]}`);
+      const pagesMatch = file.match(/(?:^|\/)(?:src\/)?pages\/(.+?)\.[tj]sx?$/i);
+      if (pagesMatch?.[1] && !pagesMatch[1].startsWith('api/')) {
+        changedRoutes.add(pagesMatch[1] === 'index' ? '/' : `/${pagesMatch[1].replace(/\/index$/, '')}`);
+      }
+    }
+    for (const m of addedOrChangedLines.matchAll(/path\s*[:=]\s*['"](\/[^'"]*)['"]/g)) {
+      if (m[1]) changedRoutes.add(m[1]);
+    }
+
+    const changedSymbols = new Set<string>();
+    for (const m of addedOrChangedLines.matchAll(/(?:function|class|const|export\s+(?:async\s+)?function)\s+([A-Za-z_][A-Za-z0-9_]*)/g)) {
+      if (m[1]) changedSymbols.add(m[1]);
+    }
+
+    const apiEndpoints = new Set<string>();
+    for (const m of addedOrChangedLines.matchAll(/['"`](\/api\/[A-Za-z0-9_/?=&{}:-]+)['"`]/g)) {
+      if (m[1]) apiEndpoints.add(m[1]);
+    }
+
+    const validationHints = new Set<string>();
+    for (const m of addedOrChangedLines.matchAll(/\.(min|max|email|regex|required)\s*\(([^)]*)\)/g)) {
+      validationHints.add(`${m[1]}(${(m[2] ?? '').trim()})`);
+    }
+    for (const m of addedOrChangedLines.matchAll(/required(?:\s*=\s*\{?true\}?|\b)/g)) {
+      validationHints.add(m[0].trim());
+    }
+
+    const existingTestsChanged = changedFiles.filter((f) => /\.(?:spec|test)\.[tj]sx?$/i.test(f));
+
+    return {
+      changedRoutes: [...changedRoutes],
+      changedSymbols: [...changedSymbols].slice(0, 30),
+      apiEndpoints: [...apiEndpoints].slice(0, 20),
+      validationHints: [...validationHints].slice(0, 20),
+      existingTestsChanged,
+    };
+  }
+}
+