@mitre/hdf-diff 3.4.4 → 3.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -11,6 +11,7 @@ Compares HDF documents (results, baselines, or system documents) and produces a
11
11
  - **System drift** (`diffSystems`) — compare two HDF system documents for component, data flow, and configuration changes
12
12
  - **SBOM comparison** (`diffSboms`) — CycloneDX/SPDX package-level diffs (added, removed, updated)
13
13
  - **Amendment operations** (Go only, `amend` subpackage) — merge overrides into results, verify amendment chains, compute effectiveStatus/effectiveImpact/disposition
14
+ - **Requirement change events** (`changeEventFromPrevious`, `applyChangeEvents`, `foldChangeEventsIntoComparison`) — the continuous-monitoring kernel (ADR-0005): derive a per-requirement change-event stream between two scans, fold a batch of events into a comparison, and replay events onto a seed to reassemble a reconciled results document (parity law: `applyChangeEvents(A, derive(A→B)) ≡ B` at requirement level). Dual Go + TS; wrapped by the `hdf events` CLI command group.
14
15
 
15
16
  Additional capabilities:
16
17
  - Multiple comparison modes: temporal, baseline, fleet, multi-source
@@ -65,10 +66,11 @@ hdf-diff supports multiple strategies for matching requirements across evaluatio
65
66
  - **Fuzzy title** — Jaccard similarity on tokenized titles
66
67
 
67
68
  ```typescript
68
- import { diffHdf, createFuzzyTitleStrategy } from '@mitre/hdf-diff';
69
+ import { diffHdf } from '@mitre/hdf-diff';
69
70
 
70
71
  const comparison = diffHdf(oldResults, newResults, {
71
- matchStrategy: createFuzzyTitleStrategy(0.8), // 80% similarity threshold
72
+ matchStrategy: 'fuzzyTitle',
73
+ minConfidence: 0.8, // 80% similarity threshold
72
74
  });
73
75
  ```
74
76
 
@@ -95,7 +97,7 @@ hdf diff old-system.json new-system.json
95
97
  # SBOM comparison
96
98
  hdf diff --sbom old.cdx.json new.cdx.json
97
99
 
98
- # Encode the security outcome in the exit code (10=fixes, 11=regressions, 12=mixed, 13=baseline change)
100
+ # Encode the security outcome in the exit code (10=fixes, 11=regressions, 12=mixed, 13=baseline change, 14=metadata drift only)
99
101
  hdf diff old-results.json new-results.json --detailed-exitcode
100
102
  ```
101
103
 
package/dist/index.d.ts CHANGED
@@ -321,12 +321,13 @@ declare function diffSystems(oldSystem: Record<string, unknown>, newSystem: Reco
321
321
  //#endregion
322
322
  //#region src/status.d.ts
323
323
  /**
324
- * Determine the effective status of a requirement from its results and overrides.
324
+ * Determine the effective status of a requirement from its results and
325
+ * overrides, delegating to the canonical shared implementation in
326
+ * `@mitre/hdf-utilities` (see status-determination.md):
325
327
  *
326
- * Priority:
327
328
  * 1. impact === 0 → notApplicable (regardless of results)
328
- * 2. effectiveStatus field set (and no statusOverrides) → use it
329
- * 3. Non-expired statusOverrides → use first non-expired
329
+ * 2. the governing (most recent non-expired) status override's status
330
+ * 3. effectiveStatus field set (and no statusOverrides) → use it
330
331
  * 4. Aggregate results using worst-wins
331
332
  * 5. Empty results → notReviewed
332
333
  */
@@ -346,6 +347,156 @@ declare function classifyChangeReasons(oldReq: Record<string, unknown>, newReq:
346
347
  */
347
348
  declare function classifyDiffStatus(oldEffectiveStatus: string, newEffectiveStatus: string): RequirementState;
348
349
  //#endregion
350
+ //#region src/effective-checksum.d.ts
351
+ interface EffectiveChecksum {
352
+ algorithm: 'sha256';
353
+ value: string;
354
+ }
355
+ /**
356
+ * Determine the effective impact of a requirement: the most recently applied
357
+ * non-expired override carrying an impact value wins (the schema's definition
358
+ * of effectiveImpact, selected by the shared governing helper); with no
359
+ * overrides, a stored effectiveImpact field is honored; otherwise the base
360
+ * impact. (Go parity: ComputeEffectiveImpact in hdf-diff/go/effective_checksum.go.)
361
+ */
362
+ declare function computeEffectiveImpact(requirement: Record<string, unknown>, referenceTimestamp?: string): number;
363
+ /**
364
+ * Return the Override_Type of the governing (most recently applied
365
+ * non-expired) override, a stored disposition field when no overrides are
366
+ * present, or null. (Go parity: ComputeDisposition.)
367
+ */
368
+ declare function computeDisposition(requirement: Record<string, unknown>, referenceTimestamp?: string): string | null;
369
+ /**
370
+ * Hash the resolved effective posture of a requirement: sha256 over the
371
+ * canonical JSON {"status":<resolved>,"impact":<resolved>,"disposition":<type|null>}.
372
+ * Flips exactly when the operative status, impact, or disposition changes;
373
+ * stable under all other document churn. Byte-identical with the Go
374
+ * implementation (ComputeEffectiveChecksum) — the key order of the canonical
375
+ * object is part of the contract. Pass the document timestamp as
376
+ * referenceTimestamp for determinism. A missing or unparseable reference
377
+ * falls back to the wall clock inside the shared governing-override helper,
378
+ * so callers that need reproducible output must always supply a valid
379
+ * timestamp.
380
+ */
381
+ declare function computeEffectiveChecksum(requirement: Record<string, unknown>, referenceTimestamp?: string): Promise<EffectiveChecksum>;
382
+ //#endregion
383
+ //#region src/change-event.d.ts
384
+ /**
385
+ * The reconciler's per-key last-value state (ADR-0005 §1): the minimal
386
+ * posture a producer compares against to decide whether a requirement moved.
387
+ * Go parity: KeyState in hdf-diff/go/change_event.go.
388
+ */
389
+ interface KeyState {
390
+ effectiveStatus: string;
391
+ effectiveImpact: number;
392
+ checksum: EffectiveChecksum;
393
+ }
394
+ /**
395
+ * Caller-injected envelope identity for an emitted event. Everything is
396
+ * supplied by the caller — the kernel touches no wall clock and no RNG, so
397
+ * identical inputs always produce identical events. referenceTimestamp
398
+ * anchors override expiry (pass the new document's timestamp); timestamp is
399
+ * the event's occurrence time (RFC 3339, trimmed UTC).
400
+ */
401
+ interface EventInputs {
402
+ eventId: string;
403
+ source: string;
404
+ sequence: number;
405
+ systemRef: string;
406
+ componentId: string;
407
+ requirementId: string;
408
+ timestamp: string;
409
+ referenceTimestamp: string;
410
+ /** Prior observation's timestamp — enables overrideExpired detection across the window. */
411
+ prevReferenceTimestamp?: string;
412
+ schemaRef?: string;
413
+ }
414
+ /**
415
+ * The pure detection kernel (ADR-0005): compare a requirement's resolved
416
+ * posture against the stored last-value state and emit a
417
+ * Requirement_Change_Event when it moved, or null when it did not.
418
+ *
419
+ * - prev null → state "new" (chain start: null before/priorChecksum)
420
+ * - newReq null → state "absent" (after null, thin before preserved)
421
+ * - checksum match → null (no event; the steady-state majority)
422
+ * - otherwise → fixed/regressed/updated per the effective-status
423
+ * transition, with the full after requirement as payload
424
+ *
425
+ * prevReq (optional) is the full prior requirement when the caller's
426
+ * materialized state has it; it enables complete changeReasons
427
+ * classification via the batch classifier, filtered to the event
428
+ * vocabulary. Without it, only reasons provable from the thin state
429
+ * (impactChanged) are emitted. Byte-parity with the Go kernel
430
+ * (ChangeEventFromPrevious) is pinned by shared test vectors.
431
+ */
432
+ declare function changeEventFromPrevious(prev: KeyState | null, newReq: Record<string, unknown> | null, prevReq: Record<string, unknown> | null, inputs: EventInputs): Promise<Record<string, unknown> | null>;
433
+ //#endregion
434
+ //#region src/apply-events.d.ts
435
+ /**
436
+ * Caller-supplied identity for a reassembly run. Everything else in the
437
+ * derivation block is computed from the seed text and the event batch — no
438
+ * wall clock, no RNG. Go parity: ApplyInputs in hdf-diff/go/apply_events.go.
439
+ */
440
+ interface ApplyInputs {
441
+ /** Names the reconciling tool — a reconciled document never masquerades as scanner output. */
442
+ generator: {
443
+ name: string;
444
+ version: string;
445
+ };
446
+ /** Locates the seed snapshot; its checksum is computed from the seed text. */
447
+ seedUri: string;
448
+ /** The event-stream producer context recorded in the derivation block. */
449
+ source: string;
450
+ }
451
+ /**
452
+ * A non-fatal per-key anomaly. Warnings never abort the fold: the key is
453
+ * still applied last-value-wins and the warning marks it unverified
454
+ * (ADR-0005 §4 fold contract).
455
+ */
456
+ interface ApplyWarning {
457
+ requirementId: string;
458
+ /** chainGap | newOnExisting | absentUnknown | multiBaseline */
459
+ kind: string;
460
+ message: string;
461
+ }
462
+ interface ApplyResult {
463
+ results: Record<string, unknown>;
464
+ warnings: ApplyWarning[];
465
+ }
466
+ type Doc$1 = Record<string, unknown>;
467
+ /**
468
+ * Reassemble the current posture from a seed hdf-results document plus a
469
+ * batch of requirement-change events (ADR-0005 §§4-7): keyed last-value-wins
470
+ * by sequence, idempotent via (source, eventId) dedup, tombstone-aware
471
+ * (absent removes), total over the event-state enum. Delivery order and
472
+ * duplicates never change the output. The result carries the caller's
473
+ * generator and a derivation block (seed pinned by content, watermark,
474
+ * count, asOf) so it can never masquerade as scan evidence. Chain gaps and
475
+ * anomalies surface as warnings, never as refusal. Go parity:
476
+ * ApplyChangeEvents.
477
+ */
478
+ declare function applyChangeEvents(seedJson: string, events: Doc$1[], inputs: ApplyInputs): Promise<ApplyResult>;
479
+ //#endregion
480
+ //#region src/fold-events.d.ts
481
+ type Doc = Record<string, unknown>;
482
+ interface FoldResult {
483
+ comparison: Record<string, unknown>;
484
+ warnings: ApplyWarning[];
485
+ }
486
+ /**
487
+ * Materialize a change-event batch into a full systemDrift hdf-comparison
488
+ * against the seed document (ADR-0005 §5): each winning event lifts into the
489
+ * Requirement_Diff shape the batch engine produces — before from the seed,
490
+ * after from the event payload, field changes derived by the batch engine's
491
+ * own computeFieldChanges — under the same fold contract as
492
+ * applyChangeEvents (dedup, last-value-wins by sequence, tombstone-aware,
493
+ * warnings never abort). Deterministic: the comparison timestamp is the
494
+ * latest event occurrence, and seed-side override expiry anchors to the
495
+ * seed's own timestamp (falling back to the event occurrence when the seed
496
+ * has none) — never wall clock. Go parity: FoldChangeEventsIntoComparison.
497
+ */
498
+ declare function foldChangeEventsIntoComparison(seedJson: string, events: Doc[]): Promise<FoldResult>;
499
+ //#endregion
349
500
  //#region src/summary.d.ts
350
501
  /**
351
502
  * Compute summary counts from an array of RequirementDiff entries.
@@ -697,5 +848,5 @@ declare function renderCsv(comparison: HDFComparison, options?: RenderOptions):
697
848
  */
698
849
  declare function render(comparison: HDFComparison, format: 'json' | 'markdown' | 'terminal' | 'csv', options?: RenderOptions): string;
699
850
  //#endregion
700
- export { type Annotation, type BaselineDiff, type ChangeReason, type ComparisonSummary, type ComponentDiff, type DetailLevel, type DiffOptions, type DiffStatus, type DiffSummary, EXIT_DETAILED_BASELINE_CHANGED, EXIT_DETAILED_DRIFT_ONLY, EXIT_DETAILED_ERROR, EXIT_DETAILED_FIXES_ONLY, EXIT_DETAILED_IDENTICAL, EXIT_DETAILED_MIXED, EXIT_DETAILED_REGRESSIONS_ONLY, EXIT_DIFFERENCES, EXIT_ERROR, EXIT_IDENTICAL, type FieldChange, type HDFComparison, type HdfComparison, type HdfDiff, type MatchOptions, type MatchPair, type MatchResult, type MatchStrategy, type MatchingConfig, type PackageDiff, type RenderOptions, type RequirementDiff, type RequirementState, type SbomDiffResult, type Source, type ValidationResult, classifyChangeReasons, classifyDiffStatus, computeDetailedExitCode, computeEffectiveStatus, computeExitCode, computeSummary, createCciMatchStrategy, createExactIdStrategy, createFuzzyTitleStrategy, createMappedIdStrategy, createSrgCciTiebreakStrategy, createSrgDeterministicStrategy, createVendorFuzzyTitleStrategy, diffBaselines, diffHdf, diffSboms, diffSystems, isV1Format, jaccardSimilarity, levenshteinDistance, matchRequirements, normalizeToV2, normalizedLevenshtein, render, renderCsv, renderJson, renderMarkdown, renderTerminal, tokenize, validateComparison };
851
+ export { type Annotation, type ApplyInputs, type ApplyResult, type ApplyWarning, type BaselineDiff, type ChangeReason, type ComparisonSummary, type ComponentDiff, type DetailLevel, type DiffOptions, type DiffStatus, type DiffSummary, EXIT_DETAILED_BASELINE_CHANGED, EXIT_DETAILED_DRIFT_ONLY, EXIT_DETAILED_ERROR, EXIT_DETAILED_FIXES_ONLY, EXIT_DETAILED_IDENTICAL, EXIT_DETAILED_MIXED, EXIT_DETAILED_REGRESSIONS_ONLY, EXIT_DIFFERENCES, EXIT_ERROR, EXIT_IDENTICAL, type EffectiveChecksum, type EventInputs, type FieldChange, type FoldResult, type HDFComparison, type HdfComparison, type HdfDiff, type KeyState, type MatchOptions, type MatchPair, type MatchResult, type MatchStrategy, type MatchingConfig, type PackageDiff, type RenderOptions, type RequirementDiff, type RequirementState, type SbomDiffResult, type Source, type ValidationResult, applyChangeEvents, changeEventFromPrevious, classifyChangeReasons, classifyDiffStatus, computeDetailedExitCode, computeDisposition, computeEffectiveChecksum, computeEffectiveImpact, computeEffectiveStatus, computeExitCode, computeSummary, createCciMatchStrategy, createExactIdStrategy, createFuzzyTitleStrategy, createMappedIdStrategy, createSrgCciTiebreakStrategy, createSrgDeterministicStrategy, createVendorFuzzyTitleStrategy, diffBaselines, diffHdf, diffSboms, diffSystems, foldChangeEventsIntoComparison, isV1Format, jaccardSimilarity, levenshteinDistance, matchRequirements, normalizeToV2, normalizedLevenshtein, render, renderCsv, renderJson, renderMarkdown, renderTerminal, tokenize, validateComparison };
701
852
  //# sourceMappingURL=index.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"index.d.ts","names":[],"sources":["../src/sbom.ts","../src/types.ts","../src/diff.ts","../src/status.ts","../src/summary.ts","../src/normalize.ts","../src/matching/types.ts","../src/matching/exact-id.ts","../src/matching/mapped-id.ts","../src/matching/cci-match.ts","../src/matching/fuzzy-match.ts","../src/matching/srg-deterministic.ts","../src/matching/srg-cci-tiebreak.ts","../src/matching/vendor-fuzzy-title.ts","../src/matching/index.ts","../src/validate.ts","../src/exit-codes.ts","../src/renderers/types.ts","../src/renderers/json.ts","../src/renderers/markdown.ts","../src/renderers/terminal.ts","../src/renderers/csv.ts","../src/renderers/index.ts"],"mappings":"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"}
1
+ {"version":3,"file":"index.d.ts","names":[],"sources":["../src/sbom.ts","../src/types.ts","../src/diff.ts","../src/status.ts","../src/effective-checksum.ts","../src/change-event.ts","../src/apply-events.ts","../src/fold-events.ts","../src/summary.ts","../src/normalize.ts","../src/matching/types.ts","../src/matching/exact-id.ts","../src/matching/mapped-id.ts","../src/matching/cci-match.ts","../src/matching/fuzzy-match.ts","../src/matching/srg-deterministic.ts","../src/matching/srg-cci-tiebreak.ts","../src/matching/vendor-fuzzy-title.ts","../src/matching/index.ts","../src/validate.ts","../src/exit-codes.ts","../src/renderers/types.ts","../src/renderers/json.ts","../src/renderers/markdown.ts","../src/renderers/terminal.ts","../src/renderers/csv.ts","../src/renderers/index.ts"],"mappings":";;;;;;;;;;;;;;UAciB;EACf;EACA;EACA;EACA;EACA;EACA;;;;;UAMe;EACf,cAAc;EACd;EACA;EACA;EACA;;;;;;;;;;;iBAsBc,UAAU,iBAAiB,kBAAkB;;;;;;;;;;;;;;;;;;;;KCpCjD;;;;;;;;;;;;;;;KA8BA;;;;UAcK;;EAEf;;;;;;;;;;EAUA;;EAEA;;EAEA;;;;;;EAMA;;;;;UAwBe;;EAEf;;EAEA,OAAO;;EAEP,eAAe;;EAGf,QAAQ;;EAER,OAAO;;EAGP;;EAEA;;EAEA;;EAEA;;EAEA;;EAGA,cAAc;;EAGd;;EAEA;;EAGA;;;;;UAMe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;UAOe;;EAEf;;EAEA;;EAEA,QAAQ;;EAER,OAAO;;EAEP,cAAc;;;;;UAMC;;EAEf;;EAEA;;EAEA;;EAEA;;;;;UAMe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;;;UAMe;;EAEf;;EAEA;;EAEA;;;;;UAMe;;EAEf;;EAEA;;EAEA;;EAEA,SAAS;;EAET,WAAW;;EAEX,SAAS;;EAET,eAAe;;EAEf,kBAAkB;;;EAGlB,iBAAiB;;;;;EAKjB,eALiB;;EAOjB;;EAEA,QAAQ;;EAER,cAAc,eAAe;;EAE7B,aAAa;;;;;UAME;;EAEf;;EAEA;;;KAOU,aAAa;;KAGb,cAAc;;KAGd,gBAAgB;;KAGhB,UAAU;;;;;;UC9QL;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA,eAAe;;EAEf;;EAEA;;;;;;;;;;;iBAkEc,QACd,YAAY,yBACZ,YAAY,0BAA0B,2BACtC,UAAU,cACT;;;;;;;;;iBA6zBa,cACd,aAAa,yBACb,aAAa,yBACb,UAAU,cACT;;;;;;;;;iBAyKa,YACd,WAAW,yBACX,WAAW,yBACX,UAAU,cACT;;;;;;;;;;;;;;iBCvjCa,uBACd,aAAa,yBACb;;;;;iBAwBc,sBACd,QAAQ,yBACR,QAAQ,yBACR,uBACA,wBACC;;;;;;;;;iBAmFa,mBACd,4BACA,6BACC;;;UCpIc;EACf;EACA;;;;;;;;;iBAgBc,uBACd,aAAa,yBACb;;;;;;iBA6Bc,mBACd,aAAa,yBACb;;;;;;;;;;;;;iBA4BoB,yBACpB,aAAa,yBACb,8BACC,QAAQ;;;;;;;;UCpFM;EACf;EACA;EACA,UAAU;;;;;;;;;UAUK;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;;;;;;;;;;;;;;;;;;;;iBAwDoB,wBACpB,MAAM,iBACN,QAAQ,gCACR,SAAS,gCACT,QAAQ,cACP,QAAQ;;;;;;;;UCtFM;;EAEf;IAAa;IAAc;;;EAE3B;;EAEA;;;;;;;UAQe;EACf;;EAEA;EACA;;UAGe;EACf,SAAS;EACT,UAAU;;KAGP,QAAM;;;;;;;;;;;;iBA4BW,kBACpB,kBACA,QAAQ,SACR,QAAQ,cACP,QAAQ;;;KC9DN,MAAM;UAGM;EACf,YAAY;EACZ,UAAU;;;;;;;;;;;;;;iBAyBU,+BACpB,kBACA,QAAQ,QACP,QAAQ;;;;;;iBCpCK,eAAe,cAAc,oBAAoB;;;;;;;;;;;;;;;;iBCiDjD,WAAW,KAAK;;;;;iBAQhB,cAAc,KAAK,0BAA0B;;;;;;UC3D5C;;EAEf,SAAS;;EAET,cAAc;;EAEd,cAAc;;;;;UAMC;;EAEf,QAAQ;;EAER,QAAQ;;EAER;;EAEA;;EAEA;;;;;UAMe;;EAEf;;EAEA,MAAM,SAAS,2BAA2B,SAAS,4BAA4B;;;;;;;;;;iBC3BjE,yBAAyB;;;;;;;;;;;;;iBCIzB,uBAAuB,SAAS,yBAAyB;;;;;;;;;;;;;;;;;;iBC6FzD,0BAA0B;;;;;;;;;;;iBClF1B,SAAS,eAAe;;;;;iBAexB,kBAAkB,GAAG,aAAa,GAAG;;;;;;;;;;iBAmCrC,yBAAyB,yBAAyB;;;;;;;;;;;;;;;;iBC9ClD,kCAAkC;;;;;;;;;;;;;iBCoFlC,gCAAgC;;;;;;iBClGhC,oBAAoB,WAAW;;;;iBA8B/B,sBAAsB,WAAW;;;;;;;;;;;;;iBAiFjC,+BAA+B,2BAA2B;;;;;;UCtGzD;;EAEf;;EAEA;;EAEA,eAAe;;EAEf;;;;;;;;;;;;;;;;;iBAoDc,kBACd,SAAS,2BACT,SAAS,2BACT,UAAU,eACT;;;;;;UChFc;;EAEf;;EAEA;;;;;;;;;;;iBAYc,mBAAmB,eAAe;;;;cCnBrC;cACA;cACA;;cAGA;cACA;cACA;cACA;cACA;cACA;cACA;;;;;;;;;;;iBAYG,gBAAgB,SAAS;;;;;;;;;;;;;;;;;iBAuBzB,wBAAwB,SAAS;;;KCjDrC;UAEK;;EAEf,SAAS;;EAET;;EAEA;;EAEA;;;;;;;;;;;;;iBCec,WACd,YAAY,eACZ,UAAU;;;;;;;;;;;;iBCmGI,eACd,YAAY,eACZ,UAAU;;;;;;;;;;;;;iBCmDI,eACd,YAAY,eACZ,UAAU;;;;;;;;;;;;;;iBC1II,UACd,YAAY,eACZ,UAAU;;;;;;;;;;;iBCxBI,OACd,YAAY,eACZ,kDACA,UAAU"}