@contractspec/module.workspace 1.44.0

package/dist/analysis/grouping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grouping.js","names":["items"],"sources":["../../src/analysis/grouping.ts"],"sourcesContent":["/**\n * Grouping and filtering utilities for ContractSpec workspace analysis.\n * Provides services to filter and group scan results.\n */\n\nimport type {\n  FeatureScanResult,\n  SpecScanResult,\n} from '../types/analysis-types';\nimport type { Stability } from '../types/spec-types';\n\n/**\n * Filter criteria for spec scan results.\n */\nexport interface SpecFilter {\n  /** Filter by tags (item must have at least one matching tag) */\n  tags?: string[];\n  /** Filter by owners (item must have at least one matching owner) */\n  owners?: string[];\n  /** Filter by stability levels */\n  stability?: Stability[];\n  /** Filter by spec type */\n  specType?: SpecScanResult['specType'][];\n  /** Filter by name pattern (glob) */\n  namePattern?: string;\n}\n\n/**\n * Grouping key function type.\n */\nexport type GroupKeyFn<T> = (item: T) => string;\n\n/**\n * Grouped items result.\n */\nexport interface GroupedItems<T> {\n  key: string;\n  items: T[];\n}\n\n/**\n * Pre-built grouping strategies for spec scan results.\n */\nexport const SpecGroupingStrategies = {\n  /** Group by first tag. */\n  byTag: (item: SpecScanResult): string => item.tags?.[0] ?? 'untagged',\n\n  /** Group by first owner. */\n  byOwner: (item: SpecScanResult): string => item.owners?.[0] ?? 'unowned',\n\n  /** Group by domain (first segment of name). */\n  byDomain: (item: SpecScanResult): string => {\n    const key = item.key ?? '';\n    if (key.includes('.')) {\n      return key.split('.')[0] ?? 'default';\n    }\n    return 'default';\n  },\n\n  /** Group by stability. */\n  byStability: (item: SpecScanResult): string => item.stability ?? 'stable',\n\n  /** Group by spec type. */\n  bySpecType: (item: SpecScanResult): string => item.specType,\n\n  /** Group by file directory. */\n  byDirectory: (item: SpecScanResult): string => {\n    const parts = item.filePath.split('/');\n    // Return parent directory\n    return parts.slice(0, -1).join('/') || '.';\n  },\n};\n\n/**\n * Filter specs by criteria.\n */\nexport function filterSpecs(\n  specs: SpecScanResult[],\n  filter: SpecFilter\n): SpecScanResult[] {\n  return specs.filter((spec) => {\n    // Filter by tags\n    if (filter.tags?.length) {\n      const hasMatchingTag = filter.tags.some((tag) =>\n        spec.tags?.includes(tag)\n      );\n      if (!hasMatchingTag) return false;\n    }\n\n    // Filter by owners\n    if (filter.owners?.length) {\n      const hasMatchingOwner = filter.owners.some((owner) =>\n        spec.owners?.includes(owner)\n      );\n      if (!hasMatchingOwner) return false;\n    }\n\n    // Filter by stability\n    if (filter.stability?.length) {\n      if (!filter.stability.includes(spec.stability ?? 'stable')) {\n        return false;\n      }\n    }\n\n    // Filter by spec type\n    if (filter.specType?.length) {\n      if (!filter.specType.includes(spec.specType)) {\n        return false;\n      }\n    }\n\n    // Filter by name pattern\n    if (filter.namePattern) {\n      const key = spec.key ?? '';\n      const pattern = filter.namePattern\n        .replace(/\\*/g, '.*')\n        .replace(/\\?/g, '.');\n      const regex = new RegExp(`^${pattern}$`, 'i');\n      if (!regex.test(key)) return false;\n    }\n\n    return true;\n  });\n}\n\n/**\n * Group specs by key function.\n */\nexport function groupSpecs<T>(\n  items: T[],\n  keyFn: GroupKeyFn<T>\n): Map<string, T[]> {\n  const groups = new Map<string, T[]>();\n\n  for (const item of items) {\n    const key = keyFn(item);\n    const existing = groups.get(key);\n    if (existing) {\n      existing.push(item);\n    } else {\n      groups.set(key, [item]);\n    }\n  }\n\n  return groups;\n}\n\n/**\n * Group specs and return as array.\n */\nexport function groupSpecsToArray<T>(\n  items: T[],\n  keyFn: GroupKeyFn<T>\n): GroupedItems<T>[] {\n  const map = groupSpecs(items, keyFn);\n  return Array.from(map.entries())\n    .map(([key, items]) => ({ key, items }))\n    .sort((a, b) => a.key.localeCompare(b.key));\n}\n\n/**\n * Get unique tags from spec results.\n */\nexport function getUniqueSpecTags(specs: SpecScanResult[]): string[] {\n  const tags = new Set<string>();\n  for (const spec of specs) {\n    for (const tag of spec.tags ?? []) {\n      tags.add(tag);\n    }\n  }\n  return Array.from(tags).sort();\n}\n\n/**\n * Get unique owners from spec results.\n */\nexport function getUniqueSpecOwners(specs: SpecScanResult[]): string[] {\n  const owners = new Set<string>();\n  for (const spec of specs) {\n    for (const owner of spec.owners ?? []) {\n      owners.add(owner);\n    }\n  }\n  return Array.from(owners).sort();\n}\n\n/**\n * Get unique domains from spec results.\n */\nexport function getUniqueSpecDomains(specs: SpecScanResult[]): string[] {\n  const domains = new Set<string>();\n  for (const spec of specs) {\n    domains.add(SpecGroupingStrategies.byDomain(spec));\n  }\n  return Array.from(domains).sort();\n}\n\n/**\n * Filter features by criteria.\n */\nexport function filterFeatures(\n  features: FeatureScanResult[],\n  filter: SpecFilter\n): FeatureScanResult[] {\n  return features.filter((feature) => {\n    // Filter by tags\n    if (filter.tags?.length) {\n      const hasMatchingTag = filter.tags.some((tag) =>\n        feature.tags?.includes(tag)\n      );\n      if (!hasMatchingTag) return false;\n    }\n\n    // Filter by owners\n    if (filter.owners?.length) {\n      const hasMatchingOwner = filter.owners.some((owner) =>\n        feature.owners?.includes(owner)\n      );\n      if (!hasMatchingOwner) return false;\n    }\n\n    // Filter by stability\n    if (filter.stability?.length) {\n      if (!filter.stability.includes(feature.stability ?? 'stable')) {\n        return false;\n      }\n    }\n\n    // Filter by name pattern\n    if (filter.namePattern) {\n      const pattern = filter.namePattern\n        .replace(/\\*/g, '.*')\n        .replace(/\\?/g, '.');\n      const regex = new RegExp(`^${pattern}$`, 'i');\n      if (!regex.test(feature.key)) return false;\n    }\n\n    return true;\n  });\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,19 @@
+import { SemanticDiffItem } from "../../types/analysis-types.js";
+import { SpecSnapshot } from "../snapshot/types.js";
+import { ClassifyOptions, ImpactResult } from "./types.js";
+
+//#region src/analysis/impact/classifier.d.ts
+
+/**
+ * Classify the impact of changes between base and head snapshots.
+ *
+ * @param baseSpecs - Specs from the base (baseline) version
+ * @param headSpecs - Specs from the head (current) version
+ * @param diffs - Semantic diff items from comparison
+ * @param options - Classification options
+ * @returns Classified impact result
+ */
+declare function classifyImpact(baseSpecs: SpecSnapshot[], headSpecs: SpecSnapshot[], diffs: SemanticDiffItem[], options?: ClassifyOptions): ImpactResult;
+//#endregion
+export { classifyImpact };
+//# sourceMappingURL=classifier.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"classifier.d.ts","names":[],"sources":["../../../src/analysis/impact/classifier.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;iBA0BgB,cAAA,YACH,2BACA,uBACJ,8BACE,kBACR"}

package/dist/analysis/impact/classifier.js

@@ -0,0 +1,135 @@
+import { DEFAULT_RULES, findMatchingRule } from "./rules.js";
+
+//#region src/analysis/impact/classifier.ts
+/**
+* Classify the impact of changes between base and head snapshots.
+*
+* @param baseSpecs - Specs from the base (baseline) version
+* @param headSpecs - Specs from the head (current) version
+* @param diffs - Semantic diff items from comparison
+* @param options - Classification options
+* @returns Classified impact result
+*/
+function classifyImpact(baseSpecs, headSpecs, diffs, options = {}) {
+	const rules = options.customRules ?? DEFAULT_RULES;
+	const deltas = [];
+	const baseMap = new Map(baseSpecs.map((s) => [`${s.key}@${s.version}`, s]));
+	const headMap = new Map(headSpecs.map((s) => [`${s.key}@${s.version}`, s]));
+	const addedSpecs = [];
+	for (const spec of headSpecs) {
+		const lookupKey = `${spec.key}@${spec.version}`;
+		if (!baseMap.has(lookupKey)) addedSpecs.push({
+			key: spec.key,
+			version: spec.version,
+			type: spec.type
+		});
+	}
+	const removedSpecs = [];
+	for (const spec of baseSpecs) {
+		const lookupKey = `${spec.key}@${spec.version}`;
+		if (!headMap.has(lookupKey)) {
+			removedSpecs.push({
+				key: spec.key,
+				version: spec.version,
+				type: spec.type
+			});
+			deltas.push({
+				specKey: spec.key,
+				specVersion: spec.version,
+				specType: spec.type,
+				path: `spec.${spec.key}`,
+				severity: "breaking",
+				rule: "endpoint-removed",
+				description: `${spec.type === "operation" ? "Operation" : "Event"} '${spec.key}' was removed`
+			});
+		}
+	}
+	for (const diff of diffs) {
+		const matchingRule = findMatchingRule({
+			path: diff.path,
+			description: diff.description,
+			type: diff.type
+		}, rules);
+		const specInfo = findSpecInfo(extractSpecKey(diff.path, baseSpecs, headSpecs), baseSpecs, headSpecs);
+		deltas.push({
+			specKey: specInfo?.key ?? "unknown",
+			specVersion: specInfo?.version ?? 0,
+			specType: specInfo?.type ?? "operation",
+			path: diff.path,
+			severity: matchingRule?.severity ?? mapDiffTypeToSeverity(diff.type),
+			rule: matchingRule?.id ?? "unknown",
+			description: diff.description,
+			oldValue: diff.oldValue,
+			newValue: diff.newValue
+		});
+	}
+	for (const spec of addedSpecs) deltas.push({
+		specKey: spec.key,
+		specVersion: spec.version,
+		specType: spec.type,
+		path: `spec.${spec.key}`,
+		severity: "non_breaking",
+		rule: "endpoint-added",
+		description: `${spec.type === "operation" ? "Operation" : "Event"} '${spec.key}' was added`
+	});
+	const summary = calculateSummary(deltas, addedSpecs, removedSpecs);
+	const hasBreaking = summary.breaking > 0 || summary.removed > 0;
+	const hasNonBreaking = summary.nonBreaking > 0 || summary.added > 0;
+	return {
+		status: determineStatus(hasBreaking, hasNonBreaking),
+		hasBreaking,
+		hasNonBreaking,
+		summary,
+		deltas,
+		addedSpecs,
+		removedSpecs,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+/**
+* Calculate summary counts from deltas.
+*/
+function calculateSummary(deltas, addedSpecs, removedSpecs) {
+	return {
+		breaking: deltas.filter((d) => d.severity === "breaking").length,
+		nonBreaking: deltas.filter((d) => d.severity === "non_breaking").length,
+		info: deltas.filter((d) => d.severity === "info").length,
+		added: addedSpecs.length,
+		removed: removedSpecs.length
+	};
+}
+/**
+* Determine overall status from flags.
+*/
+function determineStatus(hasBreaking, hasNonBreaking) {
+	if (hasBreaking) return "breaking";
+	if (hasNonBreaking) return "non-breaking";
+	return "no-impact";
+}
+/**
+* Map semantic diff type to impact severity.
+*/
+function mapDiffTypeToSeverity(type) {
+	switch (type) {
+		case "breaking": return "breaking";
+		case "removed": return "breaking";
+		case "added": return "non_breaking";
+		case "changed": return "info";
+		default: return "info";
+	}
+}
+/**
+* Extract spec key from a diff path (heuristic).
+*/
+function extractSpecKey(_path, _baseSpecs, _headSpecs) {}
+/**
+* Find spec info from key.
+*/
+function findSpecInfo(key, baseSpecs, headSpecs) {
+	if (!key) return headSpecs[0] ?? baseSpecs[0];
+	return headSpecs.find((s) => s.key === key) ?? baseSpecs.find((s) => s.key === key);
+}
+
+//#endregion
+export { classifyImpact };
+//# sourceMappingURL=classifier.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"classifier.js","names":["deltas: ImpactDelta[]","addedSpecs: ImpactResult['addedSpecs']","removedSpecs: ImpactResult['removedSpecs']"],"sources":["../../../src/analysis/impact/classifier.ts"],"sourcesContent":["/**\n * Impact classifier.\n *\n * Classifies contract changes as breaking, non-breaking, or info.\n */\n\nimport type { SemanticDiffItem } from '../../types/analysis-types';\nimport type { SpecSnapshot } from '../snapshot/types';\nimport { DEFAULT_RULES, findMatchingRule } from './rules';\nimport type {\n  ClassifyOptions,\n  ImpactDelta,\n  ImpactResult,\n  ImpactStatus,\n  ImpactSummary,\n} from './types';\n\n/**\n * Classify the impact of changes between base and head snapshots.\n *\n * @param baseSpecs - Specs from the base (baseline) version\n * @param headSpecs - Specs from the head (current) version\n * @param diffs - Semantic diff items from comparison\n * @param options - Classification options\n * @returns Classified impact result\n */\nexport function classifyImpact(\n  baseSpecs: SpecSnapshot[],\n  headSpecs: SpecSnapshot[],\n  diffs: SemanticDiffItem[],\n  options: ClassifyOptions = {}\n): ImpactResult {\n  const rules = options.customRules ?? DEFAULT_RULES;\n  const deltas: ImpactDelta[] = [];\n\n  // Create lookup maps\n  const baseMap = new Map(baseSpecs.map((s) => [`${s.key}@${s.version}`, s]));\n  const headMap = new Map(headSpecs.map((s) => [`${s.key}@${s.version}`, s]));\n\n  // Detect added specs\n  const addedSpecs: ImpactResult['addedSpecs'] = [];\n  for (const spec of headSpecs) {\n    const lookupKey = `${spec.key}@${spec.version}`;\n    if (!baseMap.has(lookupKey)) {\n      addedSpecs.push({\n        key: spec.key,\n        version: spec.version,\n        type: spec.type,\n      });\n    }\n  }\n\n  // Detect removed specs\n  const removedSpecs: ImpactResult['removedSpecs'] = [];\n  for (const spec of baseSpecs) {\n    const lookupKey = `${spec.key}@${spec.version}`;\n    if (!headMap.has(lookupKey)) {\n      removedSpecs.push({\n        key: spec.key,\n        version: spec.version,\n        type: spec.type,\n      });\n\n      // Removed spec is always breaking\n      deltas.push({\n        specKey: spec.key,\n        specVersion: spec.version,\n        specType: spec.type,\n        path: `spec.${spec.key}`,\n        severity: 'breaking',\n        rule: 'endpoint-removed',\n        description: `${spec.type === 'operation' ? 'Operation' : 'Event'} '${spec.key}' was removed`,\n      });\n    }\n  }\n\n  // Classify diffs\n  for (const diff of diffs) {\n    const matchingRule = findMatchingRule(\n      { path: diff.path, description: diff.description, type: diff.type },\n      rules\n    );\n\n    // Extract spec key from path (heuristic)\n    const specKey = extractSpecKey(diff.path, baseSpecs, headSpecs);\n    const specInfo = findSpecInfo(specKey, baseSpecs, headSpecs);\n\n    deltas.push({\n      specKey: specInfo?.key ?? 'unknown',\n      specVersion: specInfo?.version ?? 0,\n      specType: specInfo?.type ?? 'operation',\n      path: diff.path,\n      severity: matchingRule?.severity ?? mapDiffTypeToSeverity(diff.type),\n      rule: matchingRule?.id ?? 'unknown',\n      description: diff.description,\n      oldValue: diff.oldValue,\n      newValue: diff.newValue,\n    });\n  }\n\n  // Add added specs as non-breaking changes\n  for (const spec of addedSpecs) {\n    deltas.push({\n      specKey: spec.key,\n      specVersion: spec.version,\n      specType: spec.type,\n      path: `spec.${spec.key}`,\n      severity: 'non_breaking',\n      rule: 'endpoint-added',\n      description: `${spec.type === 'operation' ? 'Operation' : 'Event'} '${spec.key}' was added`,\n    });\n  }\n\n  // Calculate summary\n  const summary = calculateSummary(deltas, addedSpecs, removedSpecs);\n\n  // Determine status\n  const hasBreaking = summary.breaking > 0 || summary.removed > 0;\n  const hasNonBreaking = summary.nonBreaking > 0 || summary.added > 0;\n  const status = determineStatus(hasBreaking, hasNonBreaking);\n\n  return {\n    status,\n    hasBreaking,\n    hasNonBreaking,\n    summary,\n    deltas,\n    addedSpecs,\n    removedSpecs,\n    timestamp: new Date().toISOString(),\n  };\n}\n\n/**\n * Calculate summary counts from deltas.\n */\nfunction calculateSummary(\n  deltas: ImpactDelta[],\n  addedSpecs: ImpactResult['addedSpecs'],\n  removedSpecs: ImpactResult['removedSpecs']\n): ImpactSummary {\n  return {\n    breaking: deltas.filter((d) => d.severity === 'breaking').length,\n    nonBreaking: deltas.filter((d) => d.severity === 'non_breaking').length,\n    info: deltas.filter((d) => d.severity === 'info').length,\n    added: addedSpecs.length,\n    removed: removedSpecs.length,\n  };\n}\n\n/**\n * Determine overall status from flags.\n */\nfunction determineStatus(\n  hasBreaking: boolean,\n  hasNonBreaking: boolean\n): ImpactStatus {\n  if (hasBreaking) return 'breaking';\n  if (hasNonBreaking) return 'non-breaking';\n  return 'no-impact';\n}\n\n/**\n * Map semantic diff type to impact severity.\n */\nfunction mapDiffTypeToSeverity(type: string): ImpactDelta['severity'] {\n  switch (type) {\n    case 'breaking':\n      return 'breaking';\n    case 'removed':\n      return 'breaking';\n    case 'added':\n      return 'non_breaking';\n    case 'changed':\n      return 'info';\n    default:\n      return 'info';\n  }\n}\n\n/**\n * Extract spec key from a diff path (heuristic).\n */\nfunction extractSpecKey(\n  _path: string,\n  _baseSpecs: SpecSnapshot[],\n  _headSpecs: SpecSnapshot[]\n): string | undefined {\n  // This is a simplified heuristic; in practice would need more context\n  return undefined;\n}\n\n/**\n * Find spec info from key.\n */\nfunction findSpecInfo(\n  key: string | undefined,\n  baseSpecs: SpecSnapshot[],\n  headSpecs: SpecSnapshot[]\n): SpecSnapshot | undefined {\n  if (!key) return headSpecs[0] ?? baseSpecs[0];\n  return (\n    headSpecs.find((s) => s.key === key) ?? baseSpecs.find((s) => s.key === key)\n  );\n}\n"],"mappings":"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"}

package/dist/analysis/impact/index.js

@@ -0,0 +1,2 @@
+import { BREAKING_RULES, DEFAULT_RULES, INFO_RULES, NON_BREAKING_RULES, findMatchingRule, getRulesBySeverity } from "./rules.js";
+import { classifyImpact } from "./classifier.js";

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

@@ -0,0 +1,35 @@
+import { ImpactRule, ImpactSeverity } from "./types.js";
+
+//#region src/analysis/impact/rules.d.ts
+
+/**
+ * Default breaking change rules.
+ */
+declare const BREAKING_RULES: ImpactRule[];
+/**
+ * Non-breaking change rules.
+ */
+declare const NON_BREAKING_RULES: ImpactRule[];
+/**
+ * Info-level change rules.
+ */
+declare const INFO_RULES: ImpactRule[];
+/**
+ * All default rules in priority order (breaking > non_breaking > info).
+ */
+declare const DEFAULT_RULES: ImpactRule[];
+/**
+ * Get rules by severity.
+ */
+declare function getRulesBySeverity(severity: ImpactSeverity): ImpactRule[];
+/**
+ * Find matching rule for a delta.
+ */
+declare function findMatchingRule(delta: {
+  path: string;
+  description: string;
+  type: string;
+}, rules?: ImpactRule[]): ImpactRule | undefined;
+//#endregion
+export { BREAKING_RULES, DEFAULT_RULES, INFO_RULES, NON_BREAKING_RULES, findMatchingRule, getRulesBySeverity };
+//# sourceMappingURL=rules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","names":[],"sources":["../../../src/analysis/impact/rules.ts"],"sourcesContent":[],"mappings":";;;;AAqKA;AASA;AAOA;cA1Ka,gBAAgB;;;;cAiFhB,oBAAoB;;;;cA2CpB,YAAY;;;;cA8BZ,eAAe;;;;iBASZ,kBAAA,WAA6B,iBAAiB;;;;iBAO9C,gBAAA;;;;WAEP,eACN"}

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":["BREAKING_RULES: ImpactRule[]","NON_BREAKING_RULES: ImpactRule[]","INFO_RULES: ImpactRule[]","DEFAULT_RULES: ImpactRule[]"],"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":"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"}

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: number;
+  /** 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: number;
+    type: 'operation' | 'event';
+  }[];
+  /** Specs that were removed */
+  removedSpecs: {
+    key: string;
+    version: number;
+    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,14 @@
+import { extractEmittedEvents, extractPolicyRefs, extractTestRefs, inferSpecTypeFromFilePath, scanAllSpecsFromSource, scanSpecSource } from "./spec-scan.js";
+import { isFeatureFile, scanFeatureSource } from "./feature-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 { 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";

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: number;
+}>(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":";;AAeA;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,66 @@
+import { createHash } from "crypto";
+
+//#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 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":["normalized: Record<string, unknown>","sorted: Record<string, unknown>"],"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';\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: number }>(\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 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":";;;;;;;;;;;;;;;AAeA,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,MAAMA,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,EAAE,UAAU,EAAE;GACrB;;;;;AAMJ,SAAgB,WACd,QACyB;CACzB,MAAMC,SAAkC,EAAE;CAC1C,MAAM,OAAO,OAAO,KAAK,OAAO,CAAC,MAAM;AACvC,MAAK,MAAM,OAAO,KAChB,QAAO,OAAO,OAAO;AAEvB,QAAO"}