No magic.Just math.

// Extracts schema delta from a merged PR diff. The output feeds the
// Upstream Producer Graph (UPG). Diff content is processed in-memory
// and discarded after extraction — never written to durable storage.

import { DiffHunk, SchemaDelta, UPGNode } from '../types/sde.types';
import { parseTypeAnnotations, extractFieldDeclarations } from '../ast/utils';

export class ASTParser {
  /** Entry point for ingest pipeline. Called once per merged PR. */
  static async parse(prDiff: string, prMeta: { prId: string; mergedAt: Date; authorId: string }): Promise<UPGNode> {

    // Step 1 · Split diff into typed hunks.
    const hunks: DiffHunk[] = await this.splitIntoHunks(prDiff);

    // Step 2 · For each hunk, extract field-level schema delta.
    const delta: SchemaDelta = {
      fieldsAdded: [],
      fieldsRemoved: [],     // Removal is the primary attribution signal.
      fieldsModified: [],
      typesChanged: [],
    };

    for (const hunk of hunks) {
      const declarations = extractFieldDeclarations(hunk.context);
      delta.fieldsModified.push(...declarations);

      // REQ-12 INFERRED: field name absent, infer from type annotation change.
      const inferredFields = parseTypeAnnotations(hunk.context, hunk.delta);
      delta.fieldsModified.push(...inferredFields);
    }

    // Step 3 · Build and return UPG node — stored against prId.
    return {
      prId: prMeta.prId,
      mergedAt: prMeta.mergedAt,
      authorId: prMeta.authorId,
      schemaDelta: delta,                       // queried by CCSMathEngine at error time
      graphEdges: await this.resolveUpstreamEdges(delta),
    };
  }

  private static async resolveUpstreamEdges(delta: SchemaDelta): Promise<string[]> {
    /* ... omitted: walks consumer registry to find downstream services ... */
    return [];
  }
}

// CCS Math Engine — computes the Causal Confidence Score from eight independent
// factors. Output is fully decomposable: every classification carries its
// per-factor scores so attribution is auditable end-to-end.

import { SchemaDelta, Fingerprint, PRMeta, ScoreResult } from '../types/sde.types';

const WEIGHTS = {
  w1_fieldOverlap:        0.30,   // dominant signal: missing field ↔ removed field
  w2_temporal:            0.17,   // exp(−λ · hoursElapsed), λ = ln(2)/24 (24h half-life)
  w3_blastRadius:         0.13,   // saturating avg: downstream services + queues + schema files
  w4_errorTypeMatch:      0.13,   // error taxonomy overlap
  w5_authorHistory:       0.08,   // PR author's prior break-rate (from VCS history)
  w6_zoneBoundary:        0.07,   // service zone alignment
  w7_producerDistance:    0.07,   // BFS hops through Upstream Producer Graph (max 2)
  w8_schemaStability:     0.05,   // min(1.0, hoursSinceLastMutation / 720) — 30-day saturation
} as const;

// Σ = 1.00. Pure function — no Date.now(), no Math.random(), no I/O.
// All inputs injected by the caller. Same inputs → same score, every time.

export class CCSMathEngine {
  static computeCCS(input: {
    delta: SchemaDelta;
    fp: Fingerprint;
    prMeta: PRMeta;
    inferredCeiling?: number;     // caps inferred-extraction paths (default 0.65)
  }): ScoreResult {
    const factors = {
      w1: this.scoreFieldOverlap(input.fp, input.delta),
      w2: this.scoreTemporalProximity(input.fp, input.prMeta),
      w3: this.scoreBlastRadius(input.delta),
      w4: this.scoreErrorTypeMatch(input.fp),
      w5: this.scoreAuthorHistory(input.prMeta),
      w6: this.scoreZoneBoundary(input.fp, input.delta),
      w7: this.scoreProducerDistance(input.delta),    // 0.5 (neutral) if no graph data
      w8: this.scoreSchemaStability(input.fp),       // 0.5 (neutral) if no mutation data
    };

    let ccs =
      factors.w1 * WEIGHTS.w1_fieldOverlap +
      factors.w2 * WEIGHTS.w2_temporal +
      factors.w3 * WEIGHTS.w3_blastRadius +
      factors.w4 * WEIGHTS.w4_errorTypeMatch +
      factors.w5 * WEIGHTS.w5_authorHistory +
      factors.w6 * WEIGHTS.w6_zoneBoundary +
      factors.w7 * WEIGHTS.w7_producerDistance +
      factors.w8 * WEIGHTS.w8_schemaStability;

    // Inferred extraction paths are capped — they cannot cross the attribution threshold.
    if (input.delta.fieldExtractionMethod === 'inferred') {
      const cap = input.inferredCeiling ?? 0.65;
      ccs = Math.min(ccs, cap);
    }

    // Two thresholds: attribution and high-confidence. Below 0.80 → no receipt.
    const classification =
      ccs >= 0.90 ? 'HIGH_CONFIDENCE' :
      ccs >= 0.80 ? 'ATTRIBUTED' :
                     'BELOW_THRESHOLD';

    return { ccs, classification, factors, spec: 'DSR/1.0' };
  }

  /* ... per-factor scoring methods — pure functions, fully unit-tested ... */
}

// Resolution gate evaluation. All five gates run; all five scores are recorded.
// allPassed = true when every gate score ≥ threshold. The Resolution Receipt
// is issued regardless of allPassed — it captures what was evaluated, signed.

import { FileGate, RateGate, InfraGate, FeatureGate, DurationGate } from './gates';
import { ResolutionContext, GateEvaluation } from '../types/sde.types';

export async function evaluateGates(
  ctx: ResolutionContext,
  threshold: number,        // injected per-vault from VaultPolicy
): Promise<GateEvaluation> {
  // All five gates evaluated. Missing signals score neutral, not failure.
  const scores = {
    file:     await FileGate.score(ctx),         // file-change baseline alignment
    rate:     await RateGate.score(ctx),         // error-rate post-fix recovery
    infra:    await InfraGate.score(ctx),        // CPU / memory / latency normalization
    feature:  await FeatureGate.score(ctx),      // flag-rollout stability
    duration: await DurationGate.score(ctx),     // resolution observation window
  };

  const allPassed = Object.values(scores).every(s => s >= threshold);

  // Resolution Receipt issued regardless of allPassed.
  // It is a signed evidence record of the resolution attempt, not a success certification.
  return { scores, allPassed, threshold, evaluatedAt: ctx.now };
}