@triscope/mcp 0.4.0

package/src/targets.ts

@@ -0,0 +1,163 @@
+// Declarative "definition of done": evaluate per-camera convergence constraints
+// from .claude/element-targets.json against captured stats, so an agent gets a
+// machine-readable pass/fail instead of eyeballing screenshots. Pure + tested.
+
+export interface Constraints {
+  /** Minimum SSIM vs the stored reference (needs a reference; else skipped). */
+  ssim?: number;
+  /** Maximum meanAbsDiff vs the stored reference (needs a reference; else skipped). */
+  meanAbsDiff?: number;
+  /** Allowed mean-luminance band (from the GPU probe — always available). */
+  luminance?: { min?: number; max?: number };
+  /** Allowed dynamic-range band (from the GPU probe). */
+  dynamicRange?: { min?: number; max?: number };
+}
+
+export interface CapturedStats {
+  ssim?: number;
+  meanAbsDiff?: number;
+  luminance?: number;
+  dynamicRange?: number;
+}
+
+export interface TargetResult {
+  camera: string;
+  constraint: string;
+  op: '>=' | '<=' | 'range' | 'present';
+  expected: unknown;
+  actual: unknown;
+  pass: boolean;
+  skipped?: boolean;
+  reason?: string;
+}
+
+export interface TargetReport {
+  checked: number;
+  passed: number;
+  allPassed: boolean;
+  results: TargetResult[];
+}
+
+export function evaluateTargets(
+  targetsByCamera: Record<string, Constraints>,
+  capturedByCamera: Record<string, CapturedStats>,
+): TargetReport {
+  const results: TargetResult[] = [];
+
+  for (const [camera, c] of Object.entries(targetsByCamera ?? {})) {
+    const cap = capturedByCamera?.[camera];
+    if (!cap) {
+      results.push({
+        camera,
+        constraint: 'capture',
+        op: 'present',
+        expected: 'captured view',
+        actual: undefined,
+        pass: false,
+        skipped: true,
+        reason: 'camera not captured',
+      });
+      continue;
+    }
+    if (typeof c.ssim === 'number') {
+      if (typeof cap.ssim === 'number') {
+        results.push({
+          camera,
+          constraint: 'ssim',
+          op: '>=',
+          expected: c.ssim,
+          actual: cap.ssim,
+          pass: cap.ssim >= c.ssim,
+        });
+      } else {
+        results.push({
+          camera,
+          constraint: 'ssim',
+          op: '>=',
+          expected: c.ssim,
+          actual: undefined,
+          pass: true,
+          skipped: true,
+          reason: 'no reference image — set_reference to enable',
+        });
+      }
+    }
+    if (typeof c.meanAbsDiff === 'number') {
+      if (typeof cap.meanAbsDiff === 'number') {
+        results.push({
+          camera,
+          constraint: 'meanAbsDiff',
+          op: '<=',
+          expected: c.meanAbsDiff,
+          actual: cap.meanAbsDiff,
+          pass: cap.meanAbsDiff <= c.meanAbsDiff,
+        });
+      } else {
+        results.push({
+          camera,
+          constraint: 'meanAbsDiff',
+          op: '<=',
+          expected: c.meanAbsDiff,
+          actual: undefined,
+          pass: true,
+          skipped: true,
+          reason: 'no reference image — set_reference to enable',
+        });
+      }
+    }
+    pushBand(results, camera, 'luminance', c.luminance, cap.luminance);
+    pushBand(results, camera, 'dynamicRange', c.dynamicRange, cap.dynamicRange);
+  }
+
+  const evaluated = results.filter((r) => !r.skipped);
+  const passed = evaluated.filter((r) => r.pass).length;
+  return {
+    checked: evaluated.length,
+    passed,
+    allPassed: evaluated.every((r) => r.pass),
+    results,
+  };
+}
+
+function pushBand(
+  out: TargetResult[],
+  camera: string,
+  constraint: string,
+  band: { min?: number; max?: number } | undefined,
+  actual: number | undefined,
+): void {
+  if (!band) return;
+  if (typeof actual !== 'number') {
+    out.push({
+      camera,
+      constraint,
+      op: 'range',
+      expected: band,
+      actual: undefined,
+      pass: true,
+      skipped: true,
+      reason: 'probe unavailable',
+    });
+    return;
+  }
+  if (typeof band.min === 'number') {
+    out.push({
+      camera,
+      constraint: `${constraint}.min`,
+      op: '>=',
+      expected: band.min,
+      actual,
+      pass: actual >= band.min,
+    });
+  }
+  if (typeof band.max === 'number') {
+    out.push({
+      camera,
+      constraint: `${constraint}.max`,
+      op: '<=',
+      expected: band.max,
+      actual,
+      pass: actual <= band.max,
+    });
+  }
+}