@contractspec/module.workspace 0.0.0-canary-20260113162409

package/dist/analysis/impact/rules.js

@@ -0,0 +1,154 @@
+//#region src/analysis/impact/rules.ts
+/**
+* Default breaking change rules.
+*/
+const BREAKING_RULES = [
+	{
+		id: "endpoint-removed",
+		description: "Endpoint/operation was removed",
+		severity: "breaking",
+		matches: (delta) => delta.path.includes("spec.") && delta.type === "removed"
+	},
+	{
+		id: "field-removed",
+		description: "Field was removed from response",
+		severity: "breaking",
+		matches: (delta) => delta.path.includes(".output.") && delta.description.includes("removed")
+	},
+	{
+		id: "field-type-changed",
+		description: "Field type was changed",
+		severity: "breaking",
+		matches: (delta) => delta.path.includes(".type") && delta.description.includes("type changed")
+	},
+	{
+		id: "field-made-required",
+		description: "Optional field became required",
+		severity: "breaking",
+		matches: (delta) => delta.path.includes(".required") && delta.description.includes("optional to required")
+	},
+	{
+		id: "enum-value-removed",
+		description: "Enum value was removed",
+		severity: "breaking",
+		matches: (delta) => delta.path.includes(".enumValues") && delta.description.includes("removed")
+	},
+	{
+		id: "nullable-removed",
+		description: "Field is no longer nullable",
+		severity: "breaking",
+		matches: (delta) => delta.path.includes(".nullable") && delta.description.includes("no longer nullable")
+	},
+	{
+		id: "method-changed",
+		description: "HTTP method was changed",
+		severity: "breaking",
+		matches: (delta) => delta.path.includes(".http.method") || delta.path.includes(".method")
+	},
+	{
+		id: "path-changed",
+		description: "HTTP path was changed",
+		severity: "breaking",
+		matches: (delta) => delta.path.includes(".http.path") || delta.path.includes(".path")
+	},
+	{
+		id: "required-field-added-to-input",
+		description: "Required field was added to input",
+		severity: "breaking",
+		matches: (delta) => delta.path.includes(".input.") && delta.description.includes("Required field")
+	},
+	{
+		id: "event-payload-field-removed",
+		description: "Event payload field was removed",
+		severity: "breaking",
+		matches: (delta) => delta.path.includes(".payload.") && delta.description.includes("removed")
+	}
+];
+/**
+* Non-breaking change rules.
+*/
+const NON_BREAKING_RULES = [
+	{
+		id: "optional-field-added",
+		description: "Optional field was added",
+		severity: "non_breaking",
+		matches: (delta) => delta.description.includes("Optional field") && delta.description.includes("added")
+	},
+	{
+		id: "endpoint-added",
+		description: "New endpoint/operation was added",
+		severity: "non_breaking",
+		matches: (delta) => delta.path.includes("spec.") && delta.type === "added"
+	},
+	{
+		id: "enum-value-added",
+		description: "Enum value was added",
+		severity: "non_breaking",
+		matches: (delta) => delta.path.includes(".enumValues") && delta.description.includes("added")
+	},
+	{
+		id: "field-made-optional",
+		description: "Required field became optional",
+		severity: "non_breaking",
+		matches: (delta) => delta.path.includes(".required") && delta.description.includes("required to optional")
+	},
+	{
+		id: "nullable-added",
+		description: "Field is now nullable",
+		severity: "non_breaking",
+		matches: (delta) => delta.path.includes(".nullable") && delta.description.includes("now nullable")
+	}
+];
+/**
+* Info-level change rules.
+*/
+const INFO_RULES = [
+	{
+		id: "stability-changed",
+		description: "Stability level was changed",
+		severity: "info",
+		matches: (delta) => delta.path.includes(".stability")
+	},
+	{
+		id: "description-changed",
+		description: "Description was changed",
+		severity: "info",
+		matches: (delta) => delta.path.includes(".description")
+	},
+	{
+		id: "owners-changed",
+		description: "Owners were changed",
+		severity: "info",
+		matches: (delta) => delta.path.includes(".owners")
+	},
+	{
+		id: "tags-changed",
+		description: "Tags were changed",
+		severity: "info",
+		matches: (delta) => delta.path.includes(".tags")
+	}
+];
+/**
+* All default rules in priority order (breaking > non_breaking > info).
+*/
+const DEFAULT_RULES = [
+	...BREAKING_RULES,
+	...NON_BREAKING_RULES,
+	...INFO_RULES
+];
+/**
+* Get rules by severity.
+*/
+function getRulesBySeverity(severity) {
+	return DEFAULT_RULES.filter((rule) => rule.severity === severity);
+}
+/**
+* Find matching rule for a delta.
+*/
+function findMatchingRule(delta, rules = DEFAULT_RULES) {
+	return rules.find((rule) => rule.matches(delta));
+}
+
+//#endregion
+export { BREAKING_RULES, DEFAULT_RULES, INFO_RULES, NON_BREAKING_RULES, findMatchingRule, getRulesBySeverity };
+//# sourceMappingURL=rules.js.map

package/dist/analysis/impact/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","names":[],"sources":["../../../src/analysis/impact/rules.ts"],"sourcesContent":["/**\n * Impact classification rules.\n *\n * Defines rules for classifying changes as breaking or non-breaking.\n */\n\nimport type { ImpactRule, ImpactSeverity } from './types';\n\n/**\n * Default breaking change rules.\n */\nexport const BREAKING_RULES: ImpactRule[] = [\n  {\n    id: 'endpoint-removed',\n    description: 'Endpoint/operation was removed',\n    severity: 'breaking',\n    matches: (delta) =>\n      delta.path.includes('spec.') && delta.type === 'removed',\n  },\n  {\n    id: 'field-removed',\n    description: 'Field was removed from response',\n    severity: 'breaking',\n    matches: (delta) =>\n      delta.path.includes('.output.') && delta.description.includes('removed'),\n  },\n  {\n    id: 'field-type-changed',\n    description: 'Field type was changed',\n    severity: 'breaking',\n    matches: (delta) =>\n      delta.path.includes('.type') &&\n      delta.description.includes('type changed'),\n  },\n  {\n    id: 'field-made-required',\n    description: 'Optional field became required',\n    severity: 'breaking',\n    matches: (delta) =>\n      delta.path.includes('.required') &&\n      delta.description.includes('optional to required'),\n  },\n  {\n    id: 'enum-value-removed',\n    description: 'Enum value was removed',\n    severity: 'breaking',\n    matches: (delta) =>\n      delta.path.includes('.enumValues') &&\n      delta.description.includes('removed'),\n  },\n  {\n    id: 'nullable-removed',\n    description: 'Field is no longer nullable',\n    severity: 'breaking',\n    matches: (delta) =>\n      delta.path.includes('.nullable') &&\n      delta.description.includes('no longer nullable'),\n  },\n  {\n    id: 'method-changed',\n    description: 'HTTP method was changed',\n    severity: 'breaking',\n    matches: (delta) =>\n      delta.path.includes('.http.method') || delta.path.includes('.method'),\n  },\n  {\n    id: 'path-changed',\n    description: 'HTTP path was changed',\n    severity: 'breaking',\n    matches: (delta) =>\n      delta.path.includes('.http.path') || delta.path.includes('.path'),\n  },\n  {\n    id: 'required-field-added-to-input',\n    description: 'Required field was added to input',\n    severity: 'breaking',\n    matches: (delta) =>\n      delta.path.includes('.input.') &&\n      delta.description.includes('Required field'),\n  },\n  {\n    id: 'event-payload-field-removed',\n    description: 'Event payload field was removed',\n    severity: 'breaking',\n    matches: (delta) =>\n      delta.path.includes('.payload.') && delta.description.includes('removed'),\n  },\n];\n\n/**\n * Non-breaking change rules.\n */\nexport const NON_BREAKING_RULES: ImpactRule[] = [\n  {\n    id: 'optional-field-added',\n    description: 'Optional field was added',\n    severity: 'non_breaking',\n    matches: (delta) =>\n      delta.description.includes('Optional field') &&\n      delta.description.includes('added'),\n  },\n  {\n    id: 'endpoint-added',\n    description: 'New endpoint/operation was added',\n    severity: 'non_breaking',\n    matches: (delta) => delta.path.includes('spec.') && delta.type === 'added',\n  },\n  {\n    id: 'enum-value-added',\n    description: 'Enum value was added',\n    severity: 'non_breaking',\n    matches: (delta) =>\n      delta.path.includes('.enumValues') && delta.description.includes('added'),\n  },\n  {\n    id: 'field-made-optional',\n    description: 'Required field became optional',\n    severity: 'non_breaking',\n    matches: (delta) =>\n      delta.path.includes('.required') &&\n      delta.description.includes('required to optional'),\n  },\n  {\n    id: 'nullable-added',\n    description: 'Field is now nullable',\n    severity: 'non_breaking',\n    matches: (delta) =>\n      delta.path.includes('.nullable') &&\n      delta.description.includes('now nullable'),\n  },\n];\n\n/**\n * Info-level change rules.\n */\nexport const INFO_RULES: ImpactRule[] = [\n  {\n    id: 'stability-changed',\n    description: 'Stability level was changed',\n    severity: 'info',\n    matches: (delta) => delta.path.includes('.stability'),\n  },\n  {\n    id: 'description-changed',\n    description: 'Description was changed',\n    severity: 'info',\n    matches: (delta) => delta.path.includes('.description'),\n  },\n  {\n    id: 'owners-changed',\n    description: 'Owners were changed',\n    severity: 'info',\n    matches: (delta) => delta.path.includes('.owners'),\n  },\n  {\n    id: 'tags-changed',\n    description: 'Tags were changed',\n    severity: 'info',\n    matches: (delta) => delta.path.includes('.tags'),\n  },\n];\n\n/**\n * All default rules in priority order (breaking > non_breaking > info).\n */\nexport const DEFAULT_RULES: ImpactRule[] = [\n  ...BREAKING_RULES,\n  ...NON_BREAKING_RULES,\n  ...INFO_RULES,\n];\n\n/**\n * Get rules by severity.\n */\nexport function getRulesBySeverity(severity: ImpactSeverity): ImpactRule[] {\n  return DEFAULT_RULES.filter((rule) => rule.severity === severity);\n}\n\n/**\n * Find matching rule for a delta.\n */\nexport function findMatchingRule(\n  delta: { path: string; description: string; type: string },\n  rules: ImpactRule[] = DEFAULT_RULES\n): ImpactRule | undefined {\n  return rules.find((rule) => rule.matches(delta));\n}\n"],"mappings":";;;;AAWA,MAAa,iBAA+B;CAC1C;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UACR,MAAM,KAAK,SAAS,QAAQ,IAAI,MAAM,SAAS;EAClD;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UACR,MAAM,KAAK,SAAS,WAAW,IAAI,MAAM,YAAY,SAAS,UAAU;EAC3E;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UACR,MAAM,KAAK,SAAS,QAAQ,IAC5B,MAAM,YAAY,SAAS,eAAe;EAC7C;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UACR,MAAM,KAAK,SAAS,YAAY,IAChC,MAAM,YAAY,SAAS,uBAAuB;EACrD;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UACR,MAAM,KAAK,SAAS,cAAc,IAClC,MAAM,YAAY,SAAS,UAAU;EACxC;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UACR,MAAM,KAAK,SAAS,YAAY,IAChC,MAAM,YAAY,SAAS,qBAAqB;EACnD;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UACR,MAAM,KAAK,SAAS,eAAe,IAAI,MAAM,KAAK,SAAS,UAAU;EACxE;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UACR,MAAM,KAAK,SAAS,aAAa,IAAI,MAAM,KAAK,SAAS,QAAQ;EACpE;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UACR,MAAM,KAAK,SAAS,UAAU,IAC9B,MAAM,YAAY,SAAS,iBAAiB;EAC/C;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UACR,MAAM,KAAK,SAAS,YAAY,IAAI,MAAM,YAAY,SAAS,UAAU;EAC5E;CACF;;;;AAKD,MAAa,qBAAmC;CAC9C;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UACR,MAAM,YAAY,SAAS,iBAAiB,IAC5C,MAAM,YAAY,SAAS,QAAQ;EACtC;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UAAU,MAAM,KAAK,SAAS,QAAQ,IAAI,MAAM,SAAS;EACpE;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UACR,MAAM,KAAK,SAAS,cAAc,IAAI,MAAM,YAAY,SAAS,QAAQ;EAC5E;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UACR,MAAM,KAAK,SAAS,YAAY,IAChC,MAAM,YAAY,SAAS,uBAAuB;EACrD;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UACR,MAAM,KAAK,SAAS,YAAY,IAChC,MAAM,YAAY,SAAS,eAAe;EAC7C;CACF;;;;AAKD,MAAa,aAA2B;CACtC;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UAAU,MAAM,KAAK,SAAS,aAAa;EACtD;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UAAU,MAAM,KAAK,SAAS,eAAe;EACxD;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UAAU,MAAM,KAAK,SAAS,UAAU;EACnD;CACD;EACE,IAAI;EACJ,aAAa;EACb,UAAU;EACV,UAAU,UAAU,MAAM,KAAK,SAAS,QAAQ;EACjD;CACF;;;;AAKD,MAAa,gBAA8B;CACzC,GAAG;CACH,GAAG;CACH,GAAG;CACJ;;;;AAKD,SAAgB,mBAAmB,UAAwC;AACzE,QAAO,cAAc,QAAQ,SAAS,KAAK,aAAa,SAAS;;;;;AAMnE,SAAgB,iBACd,OACA,QAAsB,eACE;AACxB,QAAO,MAAM,MAAM,SAAS,KAAK,QAAQ,MAAM,CAAC"}

package/dist/analysis/impact/types.d.ts

@@ -0,0 +1,95 @@
+//#region src/analysis/impact/types.d.ts
+/**
+ * Impact classification types.
+ *
+ * Types for classifying contract changes as breaking or non-breaking.
+ */
+/** Impact severity levels */
+type ImpactSeverity = 'breaking' | 'non_breaking' | 'info';
+/** Status of impact detection */
+type ImpactStatus = 'no-impact' | 'non-breaking' | 'breaking';
+/** A single classified change delta */
+interface ImpactDelta {
+  /** Key of the affected spec */
+  specKey: string;
+  /** Version of the affected spec */
+  specVersion: string;
+  /** Type of the spec (operation, event) */
+  specType: 'operation' | 'event';
+  /** Path to the changed element */
+  path: string;
+  /** Severity classification */
+  severity: ImpactSeverity;
+  /** Rule that triggered this classification */
+  rule: string;
+  /** Human-readable description */
+  description: string;
+  /** Previous value (if applicable) */
+  oldValue?: unknown;
+  /** New value (if applicable) */
+  newValue?: unknown;
+}
+/** Summary counts for impact result */
+interface ImpactSummary {
+  breaking: number;
+  nonBreaking: number;
+  info: number;
+  added: number;
+  removed: number;
+}
+/** Full impact detection result */
+interface ImpactResult {
+  /** Overall status */
+  status: ImpactStatus;
+  /** Whether any breaking changes were detected */
+  hasBreaking: boolean;
+  /** Whether any non-breaking changes were detected */
+  hasNonBreaking: boolean;
+  /** Summary counts */
+  summary: ImpactSummary;
+  /** All classified deltas */
+  deltas: ImpactDelta[];
+  /** Specs that were added */
+  addedSpecs: {
+    key: string;
+    version: string;
+    type: 'operation' | 'event';
+  }[];
+  /** Specs that were removed */
+  removedSpecs: {
+    key: string;
+    version: string;
+    type: 'operation' | 'event';
+  }[];
+  /** Base commit/ref */
+  baseRef?: string;
+  /** Head commit/ref */
+  headRef?: string;
+  /** Detection timestamp */
+  timestamp: string;
+}
+/** Options for impact classification */
+interface ClassifyOptions {
+  /** Custom rules to apply */
+  customRules?: ImpactRule[];
+  /** Treat added required fields as info instead of breaking */
+  lenientAddedRequired?: boolean;
+}
+/** A classification rule */
+interface ImpactRule {
+  /** Unique rule ID */
+  id: string;
+  /** Rule description */
+  description: string;
+  /** Severity when rule matches */
+  severity: ImpactSeverity;
+  /** Matcher function */
+  matches: (delta: {
+    path: string;
+    description: string;
+    type: string;
+  }) => boolean;
+}
+//#endregion
+export { ClassifyOptions, ImpactDelta, ImpactResult, ImpactRule, ImpactSeverity, ImpactStatus, ImpactSummary };
+//# sourceMappingURL=types.d.ts.map

package/dist/analysis/impact/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/analysis/impact/types.ts"],"sourcesContent":[],"mappings":";;AAOA;AAGA;AAGA;AAsBA;AASA;AAEU,KAvCE,cAAA,GAuCF,UAAA,GAAA,cAAA,GAAA,MAAA;;AAQA,KA5CE,YAAA,GA4CF,WAAA,GAAA,cAAA,GAAA,UAAA;;AAkBO,UA3DA,WAAA,CA2De;EAQf;;;;;;;;;YAzDL;;;;;;;;;;;UAYK,aAAA;;;;;;;;UASA,YAAA;;UAEP;;;;;;WAMC;;UAED;;;;;;;;;;;;;;;;;;;;;UAkBO,eAAA;;gBAED;;;;;UAMC,UAAA;;;;;;YAML"}

package/dist/analysis/index.js

@@ -0,0 +1,18 @@
+import { extractTestCoverage, extractTestTarget } from "./spec-parsing-utils.js";
+import { inferSpecTypeFromFilePath, scanAllSpecsFromSource, scanSpecSource } from "./spec-scan.js";
+import { isFeatureFile, scanFeatureSource } from "./feature-scan.js";
+import { isExampleFile, scanExampleSource } from "./example-scan.js";
+import { SpecGroupingStrategies, filterFeatures, filterSpecs, getUniqueSpecDomains, getUniqueSpecOwners, getUniqueSpecTags, groupSpecs, groupSpecsToArray } from "./grouping.js";
+import { computeSemanticDiff } from "./diff/semantic.js";
+import { computeFieldDiff, computeFieldsDiff, computeIoDiff, isBreakingChange } from "./diff/deep-diff.js";
+import { addContractNode, buildReverseEdges, createContractGraph, detectCycles, findMissingDependencies, toDot } from "./deps/graph.js";
+import { parseImportedSpecNames } from "./deps/parse-imports.js";
+import { validateSpecStructure } from "./validate/spec-structure.js";
+import "./validate/index.js";
+import { computeHash, normalizeValue, sortFields, sortSpecs, toCanonicalJson } from "./snapshot/normalizer.js";
+import { generateSnapshot } from "./snapshot/snapshot.js";
+import "./snapshot/index.js";
+import { BREAKING_RULES, DEFAULT_RULES, INFO_RULES, NON_BREAKING_RULES, findMatchingRule, getRulesBySeverity } from "./impact/rules.js";
+import { classifyImpact } from "./impact/classifier.js";
+import "./impact/index.js";
+import { loadSpecFromSource } from "./spec-parser.js";

package/dist/analysis/snapshot/index.js

@@ -0,0 +1,2 @@
+import { computeHash, normalizeValue, sortFields, sortSpecs, toCanonicalJson } from "./normalizer.js";
+import { generateSnapshot } from "./snapshot.js";

package/dist/analysis/snapshot/normalizer.d.ts

@@ -0,0 +1,36 @@
+//#region src/analysis/snapshot/normalizer.d.ts
+/**
+ * JSON normalization utilities for deterministic snapshots.
+ *
+ * Ensures that snapshots are stable across ordering, whitespace,
+ * and other non-semantic differences.
+ */
+/**
+ * Normalize a value for deterministic JSON serialization.
+ * - Sorts object keys alphabetically
+ * - Removes undefined values
+ * - Preserves null values
+ */
+declare function normalizeValue(value: unknown): unknown;
+/**
+ * Serialize a value to deterministic JSON string.
+ */
+declare function toCanonicalJson(value: unknown): string;
+/**
+ * Compute a SHA-256 hash of canonical JSON representation.
+ */
+declare function computeHash(value: unknown): string;
+/**
+ * Sort specs by key and version for deterministic ordering.
+ */
+declare function sortSpecs<T extends {
+  key: string;
+  version: string;
+}>(specs: T[]): T[];
+/**
+ * Sort field snapshots by name for deterministic ordering.
+ */
+declare function sortFields(fields: Record<string, unknown>): Record<string, unknown>;
+//#endregion
+export { computeHash, normalizeValue, sortFields, sortSpecs, toCanonicalJson };
+//# sourceMappingURL=normalizer.d.ts.map

package/dist/analysis/snapshot/normalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizer.d.ts","names":[],"sources":["../../../src/analysis/snapshot/normalizer.ts"],"sourcesContent":[],"mappings":";;AAgBA;AA+BA;AAOA;AAQA;AAaA;;;;;;;iBA3DgB,cAAA;;;;iBA+BA,eAAA;;;;iBAOA,WAAA;;;;iBAQA;;;UACP,MACN;;;;iBAWa,UAAA,SACN,0BACP"}

package/dist/analysis/snapshot/normalizer.js

@@ -0,0 +1,67 @@
+import { createHash } from "crypto";
+import { compareVersions } from "compare-versions";
+
+//#region src/analysis/snapshot/normalizer.ts
+/**
+* JSON normalization utilities for deterministic snapshots.
+*
+* Ensures that snapshots are stable across ordering, whitespace,
+* and other non-semantic differences.
+*/
+/**
+* Normalize a value for deterministic JSON serialization.
+* - Sorts object keys alphabetically
+* - Removes undefined values
+* - Preserves null values
+*/
+function normalizeValue(value) {
+	if (value === null || value === void 0) return value === null ? null : void 0;
+	if (Array.isArray(value)) return value.map(normalizeValue);
+	if (typeof value === "object") {
+		const obj = value;
+		const sortedKeys = Object.keys(obj).sort();
+		const normalized = {};
+		for (const key of sortedKeys) {
+			const normalizedValue = normalizeValue(obj[key]);
+			if (normalizedValue !== void 0) normalized[key] = normalizedValue;
+		}
+		return normalized;
+	}
+	return value;
+}
+/**
+* Serialize a value to deterministic JSON string.
+*/
+function toCanonicalJson(value) {
+	return JSON.stringify(normalizeValue(value), null, 0);
+}
+/**
+* Compute a SHA-256 hash of canonical JSON representation.
+*/
+function computeHash(value) {
+	const canonical = toCanonicalJson(value);
+	return createHash("sha256").update(canonical).digest("hex").slice(0, 16);
+}
+/**
+* Sort specs by key and version for deterministic ordering.
+*/
+function sortSpecs(specs) {
+	return [...specs].sort((a, b) => {
+		const keyCompare = a.key.localeCompare(b.key);
+		if (keyCompare !== 0) return keyCompare;
+		return compareVersions(a.version, b.version);
+	});
+}
+/**
+* Sort field snapshots by name for deterministic ordering.
+*/
+function sortFields(fields) {
+	const sorted = {};
+	const keys = Object.keys(fields).sort();
+	for (const key of keys) sorted[key] = fields[key];
+	return sorted;
+}
+
+//#endregion
+export { computeHash, normalizeValue, sortFields, sortSpecs, toCanonicalJson };
+//# sourceMappingURL=normalizer.js.map

package/dist/analysis/snapshot/normalizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizer.js","names":[],"sources":["../../../src/analysis/snapshot/normalizer.ts"],"sourcesContent":["/**\n * JSON normalization utilities for deterministic snapshots.\n *\n * Ensures that snapshots are stable across ordering, whitespace,\n * and other non-semantic differences.\n */\n\nimport { createHash } from 'crypto';\nimport { compareVersions } from 'compare-versions';\n\n/**\n * Normalize a value for deterministic JSON serialization.\n * - Sorts object keys alphabetically\n * - Removes undefined values\n * - Preserves null values\n */\nexport function normalizeValue(value: unknown): unknown {\n  if (value === null || value === undefined) {\n    return value === null ? null : undefined;\n  }\n\n  if (Array.isArray(value)) {\n    return value.map(normalizeValue);\n  }\n\n  if (typeof value === 'object') {\n    const obj = value as Record<string, unknown>;\n    const sortedKeys = Object.keys(obj).sort();\n    const normalized: Record<string, unknown> = {};\n\n    for (const key of sortedKeys) {\n      const normalizedValue = normalizeValue(obj[key]);\n      // Only include defined values\n      if (normalizedValue !== undefined) {\n        normalized[key] = normalizedValue;\n      }\n    }\n\n    return normalized;\n  }\n\n  return value;\n}\n\n/**\n * Serialize a value to deterministic JSON string.\n */\nexport function toCanonicalJson(value: unknown): string {\n  return JSON.stringify(normalizeValue(value), null, 0);\n}\n\n/**\n * Compute a SHA-256 hash of canonical JSON representation.\n */\nexport function computeHash(value: unknown): string {\n  const canonical = toCanonicalJson(value);\n  return createHash('sha256').update(canonical).digest('hex').slice(0, 16);\n}\n\n/**\n * Sort specs by key and version for deterministic ordering.\n */\nexport function sortSpecs<T extends { key: string; version: string }>(\n  specs: T[]\n): T[] {\n  return [...specs].sort((a, b) => {\n    const keyCompare = a.key.localeCompare(b.key);\n    if (keyCompare !== 0) return keyCompare;\n    return compareVersions(a.version, b.version);\n  });\n}\n\n/**\n * Sort field snapshots by name for deterministic ordering.\n */\nexport function sortFields(\n  fields: Record<string, unknown>\n): Record<string, unknown> {\n  const sorted: Record<string, unknown> = {};\n  const keys = Object.keys(fields).sort();\n  for (const key of keys) {\n    sorted[key] = fields[key];\n  }\n  return sorted;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,SAAgB,eAAe,OAAyB;AACtD,KAAI,UAAU,QAAQ,UAAU,OAC9B,QAAO,UAAU,OAAO,OAAO;AAGjC,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,MAAM,IAAI,eAAe;AAGlC,KAAI,OAAO,UAAU,UAAU;EAC7B,MAAM,MAAM;EACZ,MAAM,aAAa,OAAO,KAAK,IAAI,CAAC,MAAM;EAC1C,MAAM,aAAsC,EAAE;AAE9C,OAAK,MAAM,OAAO,YAAY;GAC5B,MAAM,kBAAkB,eAAe,IAAI,KAAK;AAEhD,OAAI,oBAAoB,OACtB,YAAW,OAAO;;AAItB,SAAO;;AAGT,QAAO;;;;;AAMT,SAAgB,gBAAgB,OAAwB;AACtD,QAAO,KAAK,UAAU,eAAe,MAAM,EAAE,MAAM,EAAE;;;;;AAMvD,SAAgB,YAAY,OAAwB;CAClD,MAAM,YAAY,gBAAgB,MAAM;AACxC,QAAO,WAAW,SAAS,CAAC,OAAO,UAAU,CAAC,OAAO,MAAM,CAAC,MAAM,GAAG,GAAG;;;;;AAM1E,SAAgB,UACd,OACK;AACL,QAAO,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,MAAM;EAC/B,MAAM,aAAa,EAAE,IAAI,cAAc,EAAE,IAAI;AAC7C,MAAI,eAAe,EAAG,QAAO;AAC7B,SAAO,gBAAgB,EAAE,SAAS,EAAE,QAAQ;GAC5C;;;;;AAMJ,SAAgB,WACd,QACyB;CACzB,MAAM,SAAkC,EAAE;CAC1C,MAAM,OAAO,OAAO,KAAK,OAAO,CAAC,MAAM;AACvC,MAAK,MAAM,OAAO,KAChB,QAAO,OAAO,OAAO;AAEvB,QAAO"}

package/dist/analysis/snapshot/snapshot.d.ts

@@ -0,0 +1,18 @@
+import { ContractSnapshot, SnapshotOptions } from "./types.js";
+
+//#region src/analysis/snapshot/snapshot.d.ts
+
+/**
+ * Generate a contract snapshot from spec source files.
+ *
+ * @param specs - Array of { path, content } for each spec file
+ * @param options - Snapshot generation options
+ * @returns Canonical contract snapshot
+ */
+declare function generateSnapshot(specs: {
+  path: string;
+  content: string;
+}[], options?: SnapshotOptions): ContractSnapshot;
+//#endregion
+export { generateSnapshot };
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/analysis/snapshot/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","names":[],"sources":["../../../src/analysis/snapshot/snapshot.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;iBA2BgB,gBAAA;;;eAEL,kBACR"}

package/dist/analysis/snapshot/snapshot.js

@@ -0,0 +1,163 @@
+import { scanSpecSource } from "../spec-scan.js";
+import { computeHash, sortFields, sortSpecs } from "./normalizer.js";
+
+//#region src/analysis/snapshot/snapshot.ts
+/**
+* Contract snapshot generation.
+*
+* Generates canonical, deterministic snapshots from spec source files
+* for comparison and impact detection.
+*/
+/**
+* Generate a contract snapshot from spec source files.
+*
+* @param specs - Array of { path, content } for each spec file
+* @param options - Snapshot generation options
+* @returns Canonical contract snapshot
+*/
+function generateSnapshot(specs, options = {}) {
+	const snapshots = [];
+	for (const { path, content } of specs) {
+		const scanned = scanSpecSource(content, path);
+		if (options.types && !options.types.includes(scanned.specType)) continue;
+		if (scanned.specType === "operation" && scanned.key && scanned.version !== void 0) {
+			const opSnapshot = createOperationSnapshot(scanned, content);
+			if (opSnapshot) snapshots.push(opSnapshot);
+		} else if (scanned.specType === "event" && scanned.key && scanned.version !== void 0) {
+			const eventSnapshot = createEventSnapshot(scanned, content);
+			if (eventSnapshot) snapshots.push(eventSnapshot);
+		}
+	}
+	const sortedSpecs = sortSpecs(snapshots);
+	const hash = computeHash({ specs: sortedSpecs });
+	return {
+		version: "1.0.0",
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		specs: sortedSpecs,
+		hash
+	};
+}
+/**
+* Create an operation snapshot from scanned spec data.
+*/
+function createOperationSnapshot(scanned, content) {
+	if (!scanned.key || scanned.version === void 0) return null;
+	const io = extractIoFromSource(content);
+	const http = extractHttpBinding(content);
+	return {
+		type: "operation",
+		key: scanned.key,
+		version: scanned.version,
+		kind: scanned.kind === "command" || scanned.kind === "query" ? scanned.kind : "command",
+		stability: scanned.stability ?? "experimental",
+		http: http ?? void 0,
+		io,
+		authLevel: extractAuthLevel(content),
+		emittedEvents: scanned.emittedEvents
+	};
+}
+/**
+* Create an event snapshot from scanned spec data.
+*/
+function createEventSnapshot(scanned, content) {
+	if (!scanned.key || scanned.version === void 0) return null;
+	const payload = extractPayloadFromSource(content);
+	return {
+		type: "event",
+		key: scanned.key,
+		version: scanned.version,
+		stability: scanned.stability ?? "experimental",
+		payload
+	};
+}
+/**
+* Extract IO schema from source code.
+* This is a heuristic extraction - not full Zod introspection.
+*/
+function extractIoFromSource(content) {
+	const input = extractSchemaFields(content, "input");
+	const output = extractSchemaFields(content, "output");
+	return {
+		input: sortFields(input),
+		output: sortFields(output)
+	};
+}
+/**
+* Extract payload schema from event source code.
+*/
+function extractPayloadFromSource(content) {
+	return sortFields(extractSchemaFields(content, "payload"));
+}
+/**
+* Extract schema fields from a specific section of the source.
+*/
+function extractSchemaFields(content, section) {
+	const fields = {};
+	const sectionPattern = new RegExp(`${section}\\s*:\\s*z\\.object\\(\\{([^}]+)\\}`, "s");
+	const sectionMatch = content.match(sectionPattern);
+	if (!sectionMatch?.[1]) return fields;
+	const sectionContent = sectionMatch[1];
+	const fieldPattern = /(\w+)\s*:\s*z\.(\w+)\((.*?)\)/g;
+	let match;
+	while ((match = fieldPattern.exec(sectionContent)) !== null) {
+		const [, fieldName, zodType] = match;
+		if (!fieldName || !zodType) continue;
+		const isOptional = sectionContent.includes(`${fieldName}:`) && sectionContent.slice(sectionContent.indexOf(`${fieldName}:`)).includes(".optional()");
+		const isNullable = sectionContent.includes(`${fieldName}:`) && sectionContent.slice(sectionContent.indexOf(`${fieldName}:`)).includes(".nullable()");
+		fields[fieldName] = {
+			name: fieldName,
+			type: mapZodTypeToFieldType(zodType),
+			required: !isOptional,
+			nullable: isNullable
+		};
+	}
+	return fields;
+}
+/**
+* Map Zod type to FieldType.
+*/
+function mapZodTypeToFieldType(zodType) {
+	return {
+		string: "string",
+		number: "number",
+		boolean: "boolean",
+		object: "object",
+		array: "array",
+		enum: "enum",
+		union: "union",
+		literal: "literal",
+		date: "date",
+		coerce: "unknown"
+	}[zodType] ?? "unknown";
+}
+/**
+* Extract HTTP binding from source code.
+*/
+function extractHttpBinding(content) {
+	const methodMatch = content.match(/method\s*:\s*['"](\w+)['"]/);
+	const pathMatch = content.match(/path\s*:\s*['"]([^'"]+)['"]/);
+	if (methodMatch?.[1] && pathMatch?.[1]) {
+		const method = methodMatch[1].toUpperCase();
+		if ([
+			"GET",
+			"POST",
+			"PUT",
+			"PATCH",
+			"DELETE"
+		].includes(method)) return {
+			method,
+			path: pathMatch[1]
+		};
+	}
+	return null;
+}
+/**
+* Extract auth level from source code.
+*/
+function extractAuthLevel(content) {
+	return content.match(/auth\s*:\s*['"](\w+)['"]/)?.[1];
+}
+
+//#endregion
+export { generateSnapshot };
+//# sourceMappingURL=snapshot.js.map

package/dist/analysis/snapshot/snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.js","names":[],"sources":["../../../src/analysis/snapshot/snapshot.ts"],"sourcesContent":["/**\n * Contract snapshot generation.\n *\n * Generates canonical, deterministic snapshots from spec source files\n * for comparison and impact detection.\n */\n\nimport { scanSpecSource } from '../spec-scan';\nimport { computeHash, sortSpecs, sortFields } from './normalizer';\nimport type {\n  ContractSnapshot,\n  EventSnapshot,\n  FieldSnapshot,\n  FieldType,\n  IoSnapshot,\n  OperationSnapshot,\n  SnapshotOptions,\n  SpecSnapshot,\n} from './types';\n\n/**\n * Generate a contract snapshot from spec source files.\n *\n * @param specs - Array of { path, content } for each spec file\n * @param options - Snapshot generation options\n * @returns Canonical contract snapshot\n */\nexport function generateSnapshot(\n  specs: { path: string; content: string }[],\n  options: SnapshotOptions = {}\n): ContractSnapshot {\n  const snapshots: SpecSnapshot[] = [];\n\n  for (const { path, content } of specs) {\n    const scanned = scanSpecSource(content, path);\n\n    // Filter by types if specified\n    if (\n      options.types &&\n      !options.types.includes(scanned.specType as 'operation' | 'event')\n    ) {\n      continue;\n    }\n\n    if (\n      scanned.specType === 'operation' &&\n      scanned.key &&\n      scanned.version !== undefined\n    ) {\n      const opSnapshot = createOperationSnapshot(scanned, content);\n      if (opSnapshot) {\n        snapshots.push(opSnapshot);\n      }\n    } else if (\n      scanned.specType === 'event' &&\n      scanned.key &&\n      scanned.version !== undefined\n    ) {\n      const eventSnapshot = createEventSnapshot(scanned, content);\n      if (eventSnapshot) {\n        snapshots.push(eventSnapshot);\n      }\n    }\n  }\n\n  const sortedSpecs = sortSpecs(snapshots);\n  const hash = computeHash({ specs: sortedSpecs });\n\n  return {\n    version: '1.0.0',\n    generatedAt: new Date().toISOString(),\n    specs: sortedSpecs,\n    hash,\n  };\n}\n\n/**\n * Create an operation snapshot from scanned spec data.\n */\nfunction createOperationSnapshot(\n  scanned: ReturnType<typeof scanSpecSource>,\n  content: string\n): OperationSnapshot | null {\n  if (!scanned.key || scanned.version === undefined) {\n    return null;\n  }\n\n  const io = extractIoFromSource(content);\n  const http = extractHttpBinding(content);\n\n  return {\n    type: 'operation',\n    key: scanned.key,\n    version: scanned.version,\n    kind:\n      scanned.kind === 'command' || scanned.kind === 'query'\n        ? scanned.kind\n        : 'command',\n    stability: scanned.stability ?? 'experimental',\n    http: http ?? undefined,\n    io,\n    authLevel: extractAuthLevel(content),\n    emittedEvents: scanned.emittedEvents,\n  };\n}\n\n/**\n * Create an event snapshot from scanned spec data.\n */\nfunction createEventSnapshot(\n  scanned: ReturnType<typeof scanSpecSource>,\n  content: string\n): EventSnapshot | null {\n  if (!scanned.key || scanned.version === undefined) {\n    return null;\n  }\n\n  const payload = extractPayloadFromSource(content);\n\n  return {\n    type: 'event',\n    key: scanned.key,\n    version: scanned.version,\n    stability: scanned.stability ?? 'experimental',\n    payload,\n  };\n}\n\n/**\n * Extract IO schema from source code.\n * This is a heuristic extraction - not full Zod introspection.\n */\nfunction extractIoFromSource(content: string): IoSnapshot {\n  const input = extractSchemaFields(content, 'input');\n  const output = extractSchemaFields(content, 'output');\n\n  return {\n    input: sortFields(input) as Record<string, FieldSnapshot>,\n    output: sortFields(output) as Record<string, FieldSnapshot>,\n  };\n}\n\n/**\n * Extract payload schema from event source code.\n */\nfunction extractPayloadFromSource(\n  content: string\n): Record<string, FieldSnapshot> {\n  const fields = extractSchemaFields(content, 'payload');\n  return sortFields(fields) as Record<string, FieldSnapshot>;\n}\n\n/**\n * Extract schema fields from a specific section of the source.\n */\nfunction extractSchemaFields(\n  content: string,\n  section: 'input' | 'output' | 'payload'\n): Record<string, FieldSnapshot> {\n  const fields: Record<string, FieldSnapshot> = {};\n\n  // Look for z.object({ ... }) patterns within the section\n  const sectionPattern = new RegExp(\n    `${section}\\\\s*:\\\\s*z\\\\.object\\\\(\\\\{([^}]+)\\\\}`,\n    's'\n  );\n  const sectionMatch = content.match(sectionPattern);\n\n  if (!sectionMatch?.[1]) {\n    return fields;\n  }\n\n  const sectionContent = sectionMatch[1];\n\n  // Match field definitions: fieldName: z.string(), z.number(), etc.\n  const fieldPattern = /(\\w+)\\s*:\\s*z\\.(\\w+)\\((.*?)\\)/g;\n  let match;\n\n  while ((match = fieldPattern.exec(sectionContent)) !== null) {\n    const [, fieldName, zodType] = match;\n    if (!fieldName || !zodType) continue;\n\n    const isOptional =\n      sectionContent.includes(`${fieldName}:`) &&\n      sectionContent\n        .slice(sectionContent.indexOf(`${fieldName}:`))\n        .includes('.optional()');\n    const isNullable =\n      sectionContent.includes(`${fieldName}:`) &&\n      sectionContent\n        .slice(sectionContent.indexOf(`${fieldName}:`))\n        .includes('.nullable()');\n\n    fields[fieldName] = {\n      name: fieldName,\n      type: mapZodTypeToFieldType(zodType),\n      required: !isOptional,\n      nullable: isNullable,\n    };\n  }\n\n  return fields;\n}\n\n/**\n * Map Zod type to FieldType.\n */\nfunction mapZodTypeToFieldType(zodType: string): FieldType {\n  const mapping: Record<string, FieldType> = {\n    string: 'string',\n    number: 'number',\n    boolean: 'boolean',\n    object: 'object',\n    array: 'array',\n    enum: 'enum',\n    union: 'union',\n    literal: 'literal',\n    date: 'date',\n    coerce: 'unknown',\n  };\n  return mapping[zodType] ?? 'unknown';\n}\n\n/**\n * Extract HTTP binding from source code.\n */\nfunction extractHttpBinding(content: string): {\n  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';\n  path: string;\n} | null {\n  // Look for http: { method: 'X', path: 'Y' } pattern\n  const methodMatch = content.match(/method\\s*:\\s*['\"](\\w+)['\"]/);\n  const pathMatch = content.match(/path\\s*:\\s*['\"]([^'\"]+)['\"]/);\n\n  if (methodMatch?.[1] && pathMatch?.[1]) {\n    const method = methodMatch[1].toUpperCase();\n    if (['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].includes(method)) {\n      return {\n        method: method as 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',\n        path: pathMatch[1],\n      };\n    }\n  }\n\n  return null;\n}\n\n/**\n * Extract auth level from source code.\n */\nfunction extractAuthLevel(content: string): string | undefined {\n  const authMatch = content.match(/auth\\s*:\\s*['\"](\\w+)['\"]/);\n  return authMatch?.[1];\n}\n"],"mappings":"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"}