@veraxhq/verax 0.3.0 → 0.4.0

package/src/cli/util/findings-writer.js

@@ -1,142 +1,35 @@
 import { atomicWriteJson } from './atomic-write.js';
 import { resolve } from 'path';
 import { findingIdFromExpectationId } from './idgen.js';
-import {
-  enforceContractsOnFindings,
-  FINDING_STATUS,
-  CONFIDENCE_LEVEL,
-  IMPACT,
-  USER_RISK,
-  OWNERSHIP,
-} from '../../verax/core/contracts/index.js';
-import { ARTIFACT_REGISTRY, getArtifactVersions } from '../../verax/core/artifacts/registry.js';
+import { ARTIFACT_REGISTRY } from '../../verax/core/artifacts/registry.js';
 
 /**
- * Write findings.json artifact with deterministic IDs and contract enforcement
+ * Write findings.json artifact with deterministic IDs
  */
 export function writeFindingsJson(runDir, findingsData) {
-  const findingsPath = resolve(runDir, ARTIFACT_REGISTRY.findings.filename);
-  const normalizedFindings = normalizeFindings(findingsData?.findings || []);
-  const enforcement = enforceContractsOnFindings(normalizedFindings);
-
-  const findingsWithIds = enforcement.valid.map((finding) => ({
+  const findingsPath = resolve(runDir, 'findings.json');
+  
+  // Add deterministic finding IDs based on expectation IDs
+  const findingsWithIds = (findingsData.findings || []).map(finding => ({
     ...finding,
-    findingId: findingIdFromExpectationId(finding.id || finding.expectationId || ''),
+    findingId: findingIdFromExpectationId(finding.id),
   }));
-
-  const stats = findingsData?.stats || {};
+  
   const payload = {
-    contractVersion: 1,
-    artifactVersions: getArtifactVersions(),
+    contractVersion: ARTIFACT_REGISTRY.findings.contractVersion,
     findings: findingsWithIds,
-    total: findingsWithIds.length,
+    total: findingsData.stats?.total || 0,
     stats: {
-      total: findingsWithIds.length,
-      silentFailures: stats.silentFailures || 0,
-      observed: stats.observed || 0,
-      coverageGaps: stats.coverageGaps || 0,
-      unproven: stats.unproven || 0,
-      informational: stats.informational || 0,
-    },
-    detectedAt: findingsData?.detectedAt || new Date().toISOString(),
-    enforcement: {
-      droppedCount: enforcement.dropped.length,
-      downgradedCount: enforcement.downgrades.length,
-      downgrades: enforcement.downgrades.map((entry) => ({
-        reason: entry.reason,
-        originalStatus: entry.original?.status,
-        downgradeToStatus: entry.downgraded?.status,
-      })),
-      dropped: enforcement.dropped.map((entry) => ({
-        reason: entry.reason,
-      })),
+      total: findingsData.stats?.total || 0,
+      silentFailures: findingsData.stats?.silentFailures || 0,
+      observed: findingsData.stats?.observed || 0,
+      coverageGaps: findingsData.stats?.coverageGaps || 0,
+      unproven: findingsData.stats?.unproven || 0,
+      informational: findingsData.stats?.informational || 0,
     },
+    detectedAt: findingsData.detectedAt || new Date().toISOString(),
+    enforcement: findingsData.enforcement || null,
   };
-
+  
   atomicWriteJson(findingsPath, payload);
-  return { path: findingsPath, payload };
-}
-
-function normalizeFindings(findings) {
-  return findings.map((finding) => normalizeFinding(finding));
-}
-
-function normalizeFinding(finding) {
-  const status = finding.status || mapClassificationToStatus(finding.classification);
-  const evidence = normalizeEvidence(finding.evidence);
-  const confidence = normalizeConfidence(finding.confidence);
-  const signals = normalizeSignals(finding);
-  const interaction = finding.interaction || {
-    type: finding.type || 'unknown',
-    selector: finding.promise?.selector || finding.promise?.value || finding.source?.file || 'unknown',
-  };
-
-  return {
-    ...finding,
-    status,
-    evidence,
-    confidence,
-    signals,
-    interaction,
-    what_happened: finding.what_happened || finding.reason || 'Expectation was exercised during scan.',
-    what_was_expected: finding.what_was_expected || finding.promise?.value || 'Expectation derived from source code.',
-    what_was_observed: finding.what_was_observed || finding.reason || 'Observation recorded for expectation.',
-    why_it_matters: finding.why_it_matters || 'Potential silent failure identified by expectation vs observation.',
-  };
-}
-
-function mapClassificationToStatus(classification) {
-  if (classification === 'observed') return FINDING_STATUS.CONFIRMED;
-  if (classification === 'silent-failure') return FINDING_STATUS.SUSPECTED;
-  if (classification === 'coverage-gap' || classification === 'unproven') return FINDING_STATUS.SUSPECTED;
-  return FINDING_STATUS.INFORMATIONAL;
-}
-
-function normalizeConfidence(confidence) {
-  if (confidence && typeof confidence === 'object' && confidence.level && confidence.score !== undefined) {
-    return confidence;
-  }
-
-  const numeric = typeof confidence === 'number' ? Math.max(0, Math.min(1, confidence)) : 0;
-  const score = Math.round(numeric * 100);
-  let level = CONFIDENCE_LEVEL.UNPROVEN;
-  if (score >= 80) level = CONFIDENCE_LEVEL.HIGH;
-  else if (score >= 60) level = CONFIDENCE_LEVEL.MEDIUM;
-  else if (score > 0) level = CONFIDENCE_LEVEL.LOW;
-
-  return { level, score };
-}
-
-function normalizeEvidence(evidenceArray) {
-  const items = Array.isArray(evidenceArray) ? evidenceArray : [];
-  const hasNetworkActivity = items.some((item) => item?.type === 'network-log');
-  const hasDomChange = items.some((item) => item?.type === 'screenshot');
-
-  return {
-    type: hasNetworkActivity ? 'network_activity' : undefined,
-    hasDomChange,
-    hasUrlChange: false,
-    hasNetworkActivity,
-    hasStateChange: false,
-    networkRequests: items.filter((item) => item?.type === 'network-log'),
-    before: items.find((item) => item?.type === 'screenshot')?.path,
-    after: undefined,
-  };
-}
-
-function normalizeSignals(finding) {
-  if (finding.signals && typeof finding.signals === 'object') {
-    return finding.signals;
-  }
-
-  const impact = (finding.impact && IMPACT[finding.impact]) ? finding.impact : IMPACT.MEDIUM;
-
-  return {
-    impact,
-    userRisk: USER_RISK.CONFUSES,
-    ownership: OWNERSHIP.FRONTEND,
-    grouping: {
-      expectationType: finding.type || 'unknown',
-    },
-  };
 }