playwright-intelligence-engine 0.0.0-stage → 2.0.0

package/src/gate/index.ts

@@ -0,0 +1,43 @@
+import { SafetyGate, SafetyGateInput, SafetyGateResult } from './safety.js';
+import { QualityGate, CodeQualityGateInput, QualityGateResult } from './quality.js';
+import { OracleGate, OracleGateInput, OracleGateResult } from './oracle.js';
+
+export * from './safety.js';
+export { QualityGate, type QualityGateResult, type CodeQualityGateInput };
+export * from './oracle.js';
+
+export interface GateInput {
+  safety: SafetyGateInput;
+  quality?: CodeQualityGateInput | undefined;
+  oracle?: OracleGateInput | undefined;
+}
+
+export interface GateEvaluationResult {
+  passed: boolean;
+  verdict: 'APPROVED' | 'REJECTED';
+  safety: SafetyGateResult;
+  quality: QualityGateResult;
+  oracle: OracleGateResult;
+  violations: string[];
+}
+
+export function runGate(input: GateInput): GateEvaluationResult {
+  const safety = SafetyGate.evaluate(input.safety);
+  const quality = QualityGate.evaluate(input.quality ?? {});
+  const oracle = OracleGate.evaluate(input.oracle ?? {});
+
+  const violations = [...safety.violations, ...quality.violations];
+  if (!oracle.passed) {
+    violations.push(`Oracle gate contradicted: ${oracle.reasons.join(', ')}`);
+  }
+
+  const passed = safety.passed && quality.passed && oracle.passed;
+  return {
+    passed,
+    verdict: passed ? 'APPROVED' : 'REJECTED',
+    safety,
+    quality,
+    oracle,
+    violations,
+  };
+}

package/src/gate/oracle.ts

@@ -0,0 +1,69 @@
+import { BusinessOracleStatus } from '../core/types/repair-evidence.js';
+import { evaluateBuiltInBusinessOracles, BusinessIntent } from '../intelligence/business-intent.js';
+
+export interface OracleGateInput {
+  intent?: BusinessIntent | undefined;
+  oracles?: Array<{ id: string; name: string; verified: boolean; required?: boolean }> | undefined;
+  originalSourceText?: string | undefined;
+  currentSourceText?: string | undefined;
+  originalAssertions?: string[] | undefined;
+  currentAssertions?: string[] | undefined;
+  observedStates?: Record<string, unknown> | undefined;
+  executionPassed?: boolean | undefined;
+}
+
+export interface OracleGateResult {
+  passed: boolean;
+  status: BusinessOracleStatus;
+  reasons: string[];
+}
+
+export class OracleGate {
+  public static evaluate(input: OracleGateInput): OracleGateResult {
+    // 1. Explicit business oracles
+    if (input.oracles && input.oracles.length > 0) {
+      const reasons: string[] = [];
+      let allPassed = true;
+      let hasUnavailable = false;
+
+      for (const o of input.oracles) {
+        if (!o.verified) {
+          if (o.required !== false) {
+            allPassed = false;
+            hasUnavailable = true;
+            reasons.push(`Required business oracle '${o.name}' is unverified.`);
+          }
+        }
+      }
+
+      return {
+        passed: allPassed,
+        status: allPassed ? 'verified' : (hasUnavailable ? 'unavailable' : 'contradicted'),
+        reasons,
+      };
+    }
+
+    if (!input.intent) {
+      // Missing business intent evidence is NEVER marked verified
+      return {
+        passed: true,
+        status: 'unavailable',
+        reasons: ['No explicit business intent provided for oracle evaluation.'],
+      };
+    }
+
+    const evaluation = evaluateBuiltInBusinessOracles({
+      intent: input.intent,
+      originalSourceText: input.originalSourceText ?? (input.originalAssertions ? input.originalAssertions.join('\n') : undefined),
+      currentSourceText: input.currentSourceText ?? (input.currentAssertions ? input.currentAssertions.join('\n') : undefined),
+      executionPassed: input.executionPassed ?? true,
+    });
+
+    const passed = evaluation.status !== 'contradicted';
+    return {
+      passed,
+      status: evaluation.status,
+      reasons: evaluation.results.map((r) => `${r.name}: ${r.status} (${r.reason})`),
+    };
+  }
+}

package/src/gate/quality.ts

@@ -0,0 +1,101 @@
+import { NamingLinter, NamingLintReport } from '../authoring/naming/naming-linter.js';
+import type { NamePlan } from '../authoring/naming/name-plan.js';
+
+export interface CodeQualityGateInput {
+  symbols?: NamePlan | undefined;
+  files?: Array<{ relativePath: string; content: string }> | undefined;
+  diff?: string | undefined;
+  originalSource?: string | undefined;
+  patchedSource?: string | undefined;
+  locatorPolicy?: string | undefined;
+}
+
+export type QualityGateInput = CodeQualityGateInput;
+
+export interface QualityGateResult {
+  passed: boolean;
+  namingReport?: NamingLintReport | undefined;
+  duplicateSelectors: string[];
+  locatorPolicyViolations: string[];
+  assertionStrengthPassed: boolean;
+  changedLines: number;
+  violations: string[];
+}
+
+export class QualityGate {
+  public static evaluate(input: QualityGateInput): QualityGateResult {
+    const violations: string[] = [];
+
+    // 1. Naming Conformance
+    let namingReport: NamingLintReport | undefined;
+    if (input.symbols && input.symbols.symbols.length > 0) {
+      namingReport = NamingLinter.lint(input.symbols);
+      if (!namingReport.passed) {
+        for (const v of namingReport.violations) {
+          violations.push(`Naming quality violation [${v.kind}]: ${v.message}`);
+        }
+      }
+    }
+
+    // 2. Duplicate Selectors Check
+    const duplicateSelectors: string[] = [];
+    if (input.files) {
+      for (const file of input.files) {
+        if (file.relativePath.endsWith('Page.ts')) {
+          const locatorMatches = [...file.content.matchAll(/this\.page\.(?:getByRole|getByText|getByTestId|locator)\s*\(([^)]+)\)/g)];
+          const seen = new Set<string>();
+          for (const match of locatorMatches) {
+            const locStr = match[1]!.trim();
+            if (seen.has(locStr)) {
+              duplicateSelectors.push(locStr);
+              violations.push(`Duplicate selector in '${file.relativePath}': ${locStr}`);
+            }
+            seen.add(locStr);
+          }
+        }
+      }
+    }
+
+    // 3. Locator Policy Conformance (e.g. Reject raw CSS when ARIA is required)
+    const locatorPolicyViolations: string[] = [];
+    if (input.files && input.locatorPolicy === 'prefer-role-over-css') {
+      for (const file of input.files) {
+        const rawCssMatches = [...file.content.matchAll(/this\.page\.locator\s*\(\s*['"]([#.]|div|button|input)[^'"]*['"]\s*\)/g)];
+        for (const match of rawCssMatches) {
+          locatorPolicyViolations.push(match[0]);
+          violations.push(`Locator policy violation in '${file.relativePath}': raw CSS used instead of role-based locator: ${match[0]}`);
+        }
+      }
+    }
+
+    // 4. Assertion Strength Non-Downgrade Check
+    let assertionStrengthPassed = true;
+    if (input.originalSource && input.patchedSource) {
+      const origHasExactText = /\b(toHaveText|toHaveValue|toContainText)\b/.test(input.originalSource);
+      const patchHasExactText = /\b(toHaveText|toHaveValue|toContainText)\b/.test(input.patchedSource);
+      const patchDowngradedToVisible = /\btoBeVisible\b/.test(input.patchedSource) && !/\btoBeVisible\b/.test(input.originalSource);
+
+      if (origHasExactText && !patchHasExactText && patchDowngradedToVisible) {
+        assertionStrengthPassed = false;
+        violations.push('Assertion strength regression: exact text assertion was downgraded to toBeVisible');
+      }
+    }
+
+    // 5. Diff Minimality (Count changed lines)
+    let changedLines = 0;
+    if (input.diff) {
+      const diffLines = input.diff.split(/\r?\n/);
+      changedLines = diffLines.filter((l) => (l.startsWith('+') || l.startsWith('-')) && !l.startsWith('+++') && !l.startsWith('---')).length;
+    }
+
+    return {
+      passed: violations.length === 0,
+      namingReport,
+      duplicateSelectors,
+      locatorPolicyViolations,
+      assertionStrengthPassed,
+      changedLines,
+      violations,
+    };
+  }
+}

package/src/gate/safety.ts

@@ -0,0 +1,94 @@
+import { DiffAllowlistValidator } from '../repair/diff-allowlist.js';
+
+export interface SafetyGateInput {
+  targetFilePath?: string | undefined;
+  originalSource?: string | undefined;
+  patchedSource?: string | undefined;
+  targetClassName?: string | undefined;
+  targetMemberName?: string | undefined;
+  diff?: string | undefined;
+  compilationPassed?: boolean | undefined;
+  testsPassed?: boolean | undefined;
+  isolatedExecution?: boolean | undefined;
+  assertionsPreserved?: boolean | undefined;
+  diffMinimal?: boolean | undefined;
+  executionPassed?: boolean | undefined;
+  executionProof?: unknown | undefined;
+}
+
+export interface SafetyGateResult {
+  passed: boolean;
+  assertionsIntact: boolean;
+  diffAllowlistPassed: boolean;
+  targetIdentityPreserved: boolean;
+  executionPassed: boolean;
+  isolatedExecutionPassed: boolean;
+  violations: string[];
+}
+
+export class SafetyGate {
+  public static evaluate(input: SafetyGateInput): SafetyGateResult {
+    const violations: string[] = [];
+
+    // 1. Assertion Integrity (Zero Assertion Weakening: V = A ^ T ^ F ^ I ^ D ^ E)
+    let assertionsIntact = true;
+    if (input.assertionsPreserved !== undefined) {
+      assertionsIntact = input.assertionsPreserved;
+    } else if (input.originalSource && input.patchedSource) {
+      const origAssertions = [...input.originalSource.matchAll(/expect(?:\.soft|\.poll)?\([^\n]+/g)].map((m) => m[0]!.trim());
+      const patchedAssertions = [...input.patchedSource.matchAll(/expect(?:\.soft|\.poll)?\([^\n]+/g)].map((m) => m[0]!.trim());
+      assertionsIntact = origAssertions.every((a) => patchedAssertions.includes(a));
+    }
+    if (!assertionsIntact) {
+      violations.push('Assertion integrity violation: assertions were weakened, mutated, or deleted.');
+    }
+
+    // 2. Diff Allowlist (Only target member modified)
+    let diffAllowlistPassed = true;
+    if (input.diffMinimal !== undefined) {
+      diffAllowlistPassed = input.diffMinimal;
+    } else if (input.originalSource && input.patchedSource && input.targetClassName && input.targetMemberName) {
+      const diffCheck = DiffAllowlistValidator.validate({
+        originalSource: input.originalSource,
+        patchedSource: input.patchedSource,
+        targetClassName: input.targetClassName,
+        targetMemberName: input.targetMemberName,
+      });
+      diffAllowlistPassed = diffCheck.isAllowed;
+      if (!diffCheck.isAllowed) {
+        violations.push(`Diff allowlist violation: ${diffCheck.reason ?? 'unauthorized AST modification'}`);
+      }
+    }
+    if (!diffAllowlistPassed && !violations.some((v) => v.includes('Diff allowlist'))) {
+      violations.push('Diff allowlist violation: modified statements outside authorized target member.');
+    }
+
+    // 3. Compilation Integrity
+    if (input.compilationPassed === false) {
+      violations.push('Compilation failure: candidate changes do not compile with TypeScript.');
+    }
+
+    // 4. Sandboxed Worktree Isolation
+    const isolatedExecutionPassed = input.isolatedExecution ?? true;
+    if (!isolatedExecutionPassed) {
+      violations.push('Sandbox violation: execution proof was not run in an isolated Git worktree.');
+    }
+
+    // 5. Real Playwright Execution
+    const executionPassed = (input.testsPassed ?? input.executionPassed) ?? true;
+    if (!executionPassed) {
+      violations.push('Execution gate failed: real Playwright test execution exited with non-zero code.');
+    }
+
+    const passed = violations.length === 0;
+    return {
+      passed,
+      assertionsIntact,
+      diffAllowlistPassed,
+      targetIdentityPreserved: true,
+      executionPassed,
+      isolatedExecutionPassed,
+      violations,
+    };
+  }
+}