Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

2.8 KB
Raw Blame
import type { Evidence } from "../domain/evidence.js";
import type { ReconstructionObligation } from "../domain/reconstructionObligationLedgerSchemas.js";
import { evidenceSupportsOriginalAuthority } from "./ReconstructionObligationAuthority.js";
import type { ReconstructionObligationCandidate } from "./ReconstructionObligationCandidates.js";
import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";

type Binding = NonNullable<ReconstructionObligation["binding"]>;
type Diagnostic = ReconstructionObligation["diagnostics"][number];

/** Merge generated and manifest-supplied original observations canonically. */
export const originalCasesFor = (
  candidate: ReconstructionObligationCandidate,
  binding: Binding | null,
): ReconstructionObligation["observed_cases"] =>
  [
    ...new Map(
      [...candidate.observed_cases, ...(binding?.original_cases ?? [])].map(
        (observed) => [
          `${observed.kind}:${observed.evidence_id}:${observed.location}`,
          observed,
        ],
      ),
    ).values(),
  ].sort((left, right) =>
    compareUnicodeCodePoints(
      `${left.kind}:${left.evidence_id}:${left.location}`,
      `${right.kind}:${right.evidence_id}:${right.location}`,
    ),
  );

/** Report original cases that are absent or lack comparable Evidence authority. */
export const originalCaseDiagnostics = (
  candidate: ReconstructionObligationCandidate,
  binding: Binding | null,
  evidenceById: ReadonlyMap<string, Evidence>,
): Diagnostic[] => {
  const diagnostics: Diagnostic[] = [];
  const originalCases = originalCasesFor(candidate, binding);
  for (const caseKind of candidate.required_case_kinds) {
    const cases = originalCases.filter(({ kind }) => kind === caseKind);
    if (cases.length === 0) {
      diagnostics.push({
        code: "missing-original-case",
        detail: `Original ${caseKind} behavior has not been observed.`,
      });
      continue;
    }
    // A valid entry for this case kind does not resolve another entry's
    // reference; every referenced Evidence ID must be in the bundle.
    for (const { evidence_id: evidenceId } of cases)
      if (!evidenceById.has(evidenceId))
        diagnostics.push({
          code: "missing-original-case",
          detail: `Original ${caseKind} case references Evidence ${evidenceId}, which is absent from the bundle.`,
        });
    if (
      !cases.some(({ evidence_id: evidenceId }) => {
        const evidence = evidenceById.get(evidenceId);
        return (
          evidence !== undefined &&
          evidenceSupportsOriginalAuthority(
            evidence,
            candidate.required_original_authority,
          )
        );
      })
    )
      diagnostics.push({
        code: "weak-original-case-authority",
        detail: `Original ${caseKind} behavior lacks ${candidate.required_original_authority} Evidence.`,
      });
  }
  return diagnostics;
};