@contractspec/lib.evolution 0.0.0-canary-20260113162409

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chaman Ventures, SASU
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,53 @@
+# @contractspec/lib.evolution
+
+Website: https://contractspec.io/
+
+
+**Safe regeneration for ContractSpec** — Evolve specs automatically while preserving invariants.
+
+Auto-evolution utilities that analyze telemetry, suggest spec improvements, and route changes through approval workflows. Regenerate code safely, one module at a time.
+
+## Capabilities:
+
+- Analyze telemetry to find anomalous specs
+- Convert detected intent into spec suggestions
+- Route suggestions through the AI approval workflow
+- Persist approved specs back into the codebase
+
+> Phase 3 anchor library – pairs with `@contractspec/lib.observability` and `@contractspec/lib.growth`.
+
+## Usage
+
+```ts
+import {
+  SpecAnalyzer,
+  SpecGenerator,
+  SpecSuggestionOrchestrator,
+} from '@contractspec/lib.evolution';
+
+const analyzer = new SpecAnalyzer();
+const stats = analyzer.analyzeSpecUsage(samples);
+const anomalies = analyzer.detectAnomalies(stats);
+
+const generator = new SpecGenerator({ getSpec });
+const suggestion = generator.generateFromIntent(anomalies[0]);
+
+await orchestrator.submit(suggestion, { agent: 'auto-evolve' });
+```
+
+See `app/docs/libraries/evolution` in `@contractspec/app.web-contractspec-landing` for full docs.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/dist/ai-agent/src/approval/index.d.mts

@@ -0,0 +1 @@
+import { ApprovalRequest, ApprovalStatus, ApprovalStore, ApprovalWorkflow } from "./workflow.mjs";

package/dist/ai-agent/src/approval/workflow.d.mts

@@ -0,0 +1,136 @@
+import { ToolCallInfo } from "../types.mjs";
+
+//#region ../ai-agent/src/approval/workflow.d.ts
+type ApprovalStatus = 'pending' | 'approved' | 'rejected';
+/**
+ * Approval request for a tool execution.
+ *
+ * When a tool has `needsApproval: true` in AI SDK v6, the agent
+ * will pause and wait for approval before executing the tool.
+ */
+interface ApprovalRequest {
+  /** Unique request ID */
+  id: string;
+  /** Agent session ID */
+  sessionId: string;
+  /** Agent ID */
+  agentId: string;
+  /** Tenant ID for scoping */
+  tenantId?: string;
+  /** Tool name requiring approval */
+  toolName: string;
+  /** Tool call ID from AI SDK */
+  toolCallId: string;
+  /** Tool arguments */
+  toolArgs: unknown;
+  /** Human-readable reason for approval */
+  reason: string;
+  /** When the approval was requested */
+  requestedAt: Date;
+  /** Current status */
+  status: ApprovalStatus;
+  /** Additional context payload */
+  payload?: Record<string, unknown>;
+  /** Who resolved the approval */
+  reviewer?: string;
+  /** When the approval was resolved */
+  resolvedAt?: Date;
+  /** Reviewer notes */
+  notes?: string;
+}
+/**
+ * Storage interface for approval requests.
+ */
+interface ApprovalStore {
+  create(request: ApprovalRequest): Promise<void>;
+  get(id: string): Promise<ApprovalRequest | null>;
+  getByToolCallId(toolCallId: string): Promise<ApprovalRequest | null>;
+  update(id: string, updates: Partial<Omit<ApprovalRequest, 'id' | 'sessionId'>>): Promise<void>;
+  list(options?: {
+    status?: ApprovalStatus;
+    agentId?: string;
+    tenantId?: string;
+  }): Promise<ApprovalRequest[]>;
+}
+/**
+ * Approval workflow for managing tool execution approvals.
+ *
+ * Integrates with AI SDK v6's `needsApproval` feature on tools.
+ *
+ * @example
+ * ```typescript
+ * const workflow = new ApprovalWorkflow();
+ *
+ * // When a tool needs approval
+ * const request = await workflow.requestApproval({
+ *   sessionId: 'sess_123',
+ *   agentId: 'support.bot.v1',
+ *   toolName: 'delete_account',
+ *   toolCallId: 'call_abc',
+ *   toolArgs: { userId: 'user_123' },
+ *   reason: 'Account deletion requires human approval',
+ * });
+ *
+ * // When approval is granted
+ * await workflow.approve(request.id, 'admin@example.com', 'Verified identity');
+ *
+ * // Or rejected
+ * await workflow.reject(request.id, 'admin@example.com', 'Suspicious activity');
+ * ```
+ */
+declare class ApprovalWorkflow {
+  private readonly store;
+  constructor(store?: ApprovalStore);
+  /**
+   * Request approval for a tool execution.
+   */
+  requestApproval(params: {
+    sessionId: string;
+    agentId: string;
+    tenantId?: string;
+    toolName: string;
+    toolCallId: string;
+    toolArgs: unknown;
+    reason: string;
+    payload?: Record<string, unknown>;
+  }): Promise<ApprovalRequest>;
+  /**
+   * Request approval from an AI SDK tool call.
+   */
+  requestApprovalFromToolCall(toolCall: ToolCallInfo, context: {
+    sessionId: string;
+    agentId: string;
+    tenantId?: string;
+    reason?: string;
+  }): Promise<ApprovalRequest>;
+  /**
+   * Approve a pending request.
+   */
+  approve(id: string, reviewer: string, notes?: string): Promise<void>;
+  /**
+   * Reject a pending request.
+   */
+  reject(id: string, reviewer: string, notes?: string): Promise<void>;
+  /**
+   * Get approval status for a tool call.
+   */
+  getStatus(toolCallId: string): Promise<ApprovalStatus | null>;
+  /**
+   * Check if a tool call is approved.
+   */
+  isApproved(toolCallId: string): Promise<boolean>;
+  /**
+   * List pending approvals.
+   */
+  listPending(options?: {
+    agentId?: string;
+    tenantId?: string;
+  }): Promise<ApprovalRequest[]>;
+  /**
+   * Get approval request by ID.
+   */
+  get(id: string): Promise<ApprovalRequest | null>;
+}
+//#endregion
+export { ApprovalRequest, ApprovalStatus, ApprovalStore, ApprovalWorkflow };
+//# sourceMappingURL=workflow.d.mts.map

package/dist/ai-agent/src/approval/workflow.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.mts","names":[],"sources":["../../../../../ai-agent/src/approval/workflow.ts"],"sourcesContent":[],"mappings":";;;KAGY,cAAA;;AAAZ;AAQA;;;;AA0Be,UA1BE,eAAA,CA0BF;EAAI;EAQF,EAAA,EAAA,MAAA;EACC;EAAkB,SAAA,EAAA,MAAA;EACT;EAAR,OAAA,EAAA,MAAA;EAC4B;EAAR,QAAA,CAAA,EAAA,MAAA;EAGb;EAAL,QAAA,EAAA,MAAA;EAAR;EACR,UAAA,EAAA,MAAA;EAEQ;EAGC,QAAA,EAAA,OAAA;EAAR;EAAO,MAAA,EAAA,MAAA;EAyFA;EAEe,WAAA,EAvHb,IAuHa;EAcd;EACA,MAAA,EApIJ,cAoII;EAAR;EAuBQ,OAAA,CAAA,EAzJF,MAyJE,CAAA,MAAA,EAAA,OAAA,CAAA;EAOD;EAAR,QAAA,CAAA,EAAA,MAAA;EAe0D;EAYD,UAAA,CAAA,EAvL/C,IAuL+C;EAYf;EAAR,KAAA,CAAA,EAAA,MAAA;;;;;AA0Bd,UArNR,aAAA,CAqNQ;EAAO,MAAA,CAAA,OAAA,EApNd,eAoNc,CAAA,EApNI,OAoNJ,CAAA,IAAA,CAAA;mBAnNb,QAAQ;uCACY,QAAQ;8BAGlC,QAAQ,KAAK,wCACrB;;aAEQ;;;MAGP,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyFD,gBAAA;;sBAEe;;;;;;;;;;;;cAcd;MACR,QAAQ;;;;wCAuBA;;;;;MAOT,QAAQ;;;;yDAekD;;;;wDAYD;;;;iCAYvB,QAAQ;;;;kCAQP;;;;;;;MAWlC,QAAQ;;;;mBAOW,QAAQ"}

package/dist/ai-agent/src/types.d.mts

@@ -0,0 +1,30 @@
+import { ModelMessage, StepResult, ToolSet } from "ai";
+
+//#region ../ai-agent/src/types.d.ts
+
+/**
+ * Simplified tool call type for ContractSpec usage.
+ * Compatible with AI SDK v6 TypedToolCall.
+ */
+interface ToolCallInfo {
+  type: 'tool-call';
+  toolCallId: string;
+  toolName: string;
+  args: unknown;
+}
+type AgentStatus = 'idle' | 'running' | 'waiting' | 'completed' | 'failed' | 'escalated';
+interface AgentSessionState {
+  sessionId: string;
+  agentId: string;
+  tenantId?: string;
+  actorId?: string;
+  status: AgentStatus;
+  messages: ModelMessage[];
+  steps: StepResult<ToolSet>[];
+  createdAt: Date;
+  updatedAt: Date;
+  metadata?: Record<string, string>;
+}
+//#endregion
+export { AgentSessionState, ToolCallInfo };
+//# sourceMappingURL=types.d.mts.map

package/dist/ai-agent/src/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../ai-agent/src/types.ts"],"sourcesContent":[],"mappings":";;;;;AAWA;AAoCA;AA8DA;AAKU,UAvGO,YAAA,CAuGP;EACE,IAAA,EAAA,WAAA;EACQ,UAAA,EAAA,MAAA;EAAX,QAAA,EAAA,MAAA;EACI,IAAA,EAAA,OAAA;;KAtED,WAAA;UA8DK,iBAAA;;;;;UAKP;YACE;SACH,WAAW;aACP;aACA;aACA"}

package/dist/analyzer/spec-analyzer.d.mts

@@ -0,0 +1,35 @@
+import { IntentPattern, OperationMetricSample, OptimizationHint, SpecAnomaly, SpecUsageStats } from "../types.mjs";
+import { Logger } from "@contractspec/lib.observability";
+import { LifecycleStage } from "@contractspec/lib.lifecycle";
+
+//#region src/analyzer/spec-analyzer.d.ts
+interface SpecAnalyzerOptions {
+  logger?: Logger;
+  minSampleSize?: number;
+  errorRateThreshold?: number;
+  latencyP99ThresholdMs?: number;
+  throughputDropThreshold?: number;
+}
+declare class SpecAnalyzer {
+  private readonly logger?;
+  private readonly minSampleSize;
+  private readonly errorRateThreshold;
+  private readonly latencyP99ThresholdMs;
+  private readonly throughputDropThreshold;
+  constructor(options?: SpecAnalyzerOptions);
+  analyzeSpecUsage(samples: OperationMetricSample[]): SpecUsageStats[];
+  detectAnomalies(stats: SpecUsageStats[], baseline?: SpecUsageStats[]): SpecAnomaly[];
+  toIntentPatterns(anomalies: SpecAnomaly[], stats: SpecUsageStats[]): IntentPattern[];
+  suggestOptimizations(stats: SpecUsageStats[], anomalies: SpecAnomaly[], lifecycleContext?: {
+    stage: LifecycleStage;
+  }): OptimizationHint[];
+  private operationKey;
+  private buildUsageStats;
+  private toSeverity;
+  private mapMetricToIntent;
+  private groupByOperation;
+  private applyLifecycleContext;
+}
+//#endregion
+export { SpecAnalyzer, SpecAnalyzerOptions };
+//# sourceMappingURL=spec-analyzer.d.mts.map

package/dist/analyzer/spec-analyzer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec-analyzer.d.mts","names":[],"sources":["../../src/analyzer/spec-analyzer.ts"],"sourcesContent":[],"mappings":";;;;;UAciB,mBAAA;WACN;EADM,aAAA,CAAA,EAAA,MAAmB;EAmBvB,kBAAY,CAAA,EAAA,MAAA;EAOF,qBAAA,CAAA,EAAA,MAAA;EAUK,uBAAA,CAAA,EAAA,MAAA;;AAoCjB,cArDE,YAAA,CAqDF;EACI,iBAAA,MAAA;EACV,iBAAA,aAAA;EAsFU,iBAAA,kBAAA;EACJ,iBAAA,qBAAA;EACN,iBAAA,uBAAA;EA8BM,WAAA,CAAA,OAAA,CAAA,EAtKY,mBAsKZ;EACI,gBAAA,CAAA,OAAA,EA7Ja,qBA6Jb,EAAA,CAAA,EA7JuC,cA6JvC,EAAA;EACiB,eAAA,CAAA,KAAA,EA1HrB,cA0HqB,EAAA,EAAA,QAAA,CAAA,EAzHjB,cAyHiB,EAAA,CAAA,EAxH3B,WAwH2B,EAAA;EAC3B,gBAAA,CAAA,SAAA,EAnCU,WAmCV,EAAA,EAAA,KAAA,EAlCM,cAkCN,EAAA,CAAA,EAjCA,aAiCA,EAAA;EAAgB,oBAAA,CAAA,KAAA,EAHV,cAGU,EAAA,EAAA,SAAA,EAFN,WAEM,EAAA,EAAA,iBAAA,EAAA;WADW;MAC3B"}

package/dist/analyzer/spec-analyzer.mjs

@@ -0,0 +1,305 @@
+import { Logger } from "@contractspec/lib.observability";
+import { randomUUID } from "node:crypto";
+import { LifecycleStage } from "@contractspec/lib.lifecycle";
+
+//#region src/analyzer/spec-analyzer.ts
+const DEFAULT_OPTIONS = {
+	minSampleSize: 50,
+	errorRateThreshold: .05,
+	latencyP99ThresholdMs: 750
+};
+var SpecAnalyzer = class {
+	logger;
+	minSampleSize;
+	errorRateThreshold;
+	latencyP99ThresholdMs;
+	throughputDropThreshold;
+	constructor(options = {}) {
+		this.logger = options.logger;
+		this.minSampleSize = options.minSampleSize ?? DEFAULT_OPTIONS.minSampleSize;
+		this.errorRateThreshold = options.errorRateThreshold ?? DEFAULT_OPTIONS.errorRateThreshold;
+		this.latencyP99ThresholdMs = options.latencyP99ThresholdMs ?? DEFAULT_OPTIONS.latencyP99ThresholdMs;
+		this.throughputDropThreshold = options.throughputDropThreshold ?? .2;
+	}
+	analyzeSpecUsage(samples) {
+		if (!samples.length) {
+			this.logger?.debug("SpecAnalyzer.analyzeSpecUsage.skip", { reason: "no-samples" });
+			return [];
+		}
+		const groups = /* @__PURE__ */ new Map();
+		for (const sample of samples) {
+			const key = this.operationKey(sample);
+			const arr = groups.get(key) ?? [];
+			arr.push(sample);
+			groups.set(key, arr);
+		}
+		return [...groups.values()].filter((samplesForOp) => {
+			const valid = samplesForOp.length >= this.minSampleSize;
+			if (!valid) this.logger?.debug("SpecAnalyzer.analyzeSpecUsage.skipOperation", {
+				operation: this.operationKey(samplesForOp[0]),
+				sampleSize: samplesForOp.length,
+				minSampleSize: this.minSampleSize
+			});
+			return valid;
+		}).map((operationSamples) => this.buildUsageStats(operationSamples));
+	}
+	detectAnomalies(stats, baseline) {
+		const anomalies = [];
+		if (!stats.length) {
+			this.logger?.debug("SpecAnalyzer.detectAnomalies.skip", { reason: "no-stats" });
+			return anomalies;
+		}
+		const baselineByOp = new Map((baseline ?? []).map((item) => [this.operationKey(item.operation), item]));
+		for (const stat of stats) {
+			const evidence = [];
+			if (stat.errorRate >= this.errorRateThreshold) {
+				evidence.push({
+					type: "telemetry",
+					description: `Error rate ${stat.errorRate.toFixed(2)} exceeded threshold ${this.errorRateThreshold}`,
+					data: { errorRate: stat.errorRate }
+				});
+				anomalies.push({
+					operation: stat.operation,
+					severity: this.toSeverity(stat.errorRate / this.errorRateThreshold),
+					metric: "error-rate",
+					description: "Error rate spike",
+					detectedAt: /* @__PURE__ */ new Date(),
+					threshold: this.errorRateThreshold,
+					observedValue: stat.errorRate,
+					evidence
+				});
+				continue;
+			}
+			if (stat.p99LatencyMs >= this.latencyP99ThresholdMs) {
+				evidence.push({
+					type: "telemetry",
+					description: `P99 latency ${stat.p99LatencyMs}ms exceeded threshold ${this.latencyP99ThresholdMs}ms`,
+					data: { p99LatencyMs: stat.p99LatencyMs }
+				});
+				anomalies.push({
+					operation: stat.operation,
+					severity: this.toSeverity(stat.p99LatencyMs / this.latencyP99ThresholdMs),
+					metric: "latency",
+					description: "Latency regression detected",
+					detectedAt: /* @__PURE__ */ new Date(),
+					threshold: this.latencyP99ThresholdMs,
+					observedValue: stat.p99LatencyMs,
+					evidence
+				});
+				continue;
+			}
+			const baselineStat = baselineByOp.get(this.operationKey(stat.operation));
+			if (baselineStat) {
+				const drop = (baselineStat.totalCalls - stat.totalCalls) / baselineStat.totalCalls;
+				if (drop >= this.throughputDropThreshold) {
+					evidence.push({
+						type: "telemetry",
+						description: `Throughput dropped by ${(drop * 100).toFixed(1)}% compared to baseline`,
+						data: {
+							baselineCalls: baselineStat.totalCalls,
+							currentCalls: stat.totalCalls
+						}
+					});
+					anomalies.push({
+						operation: stat.operation,
+						severity: this.toSeverity(drop / this.throughputDropThreshold),
+						metric: "throughput",
+						description: "Usage drop detected",
+						detectedAt: /* @__PURE__ */ new Date(),
+						threshold: this.throughputDropThreshold,
+						observedValue: drop,
+						evidence
+					});
+				}
+			}
+		}
+		return anomalies;
+	}
+	toIntentPatterns(anomalies, stats) {
+		const statsByOp = new Map(stats.map((item) => [this.operationKey(item.operation), item]));
+		return anomalies.map((anomaly) => {
+			const stat = statsByOp.get(this.operationKey(anomaly.operation));
+			const confidence = {
+				score: Math.min(1, (anomaly.observedValue ?? 0) / (anomaly.threshold ?? 1)),
+				sampleSize: stat?.totalCalls ?? 0,
+				pValue: void 0
+			};
+			return {
+				id: randomUUID(),
+				type: this.mapMetricToIntent(anomaly.metric),
+				description: anomaly.description,
+				operation: anomaly.operation,
+				confidence,
+				metadata: {
+					observedValue: anomaly.observedValue,
+					threshold: anomaly.threshold
+				},
+				evidence: anomaly.evidence
+			};
+		});
+	}
+	suggestOptimizations(stats, anomalies, lifecycleContext) {
+		const anomaliesByOp = new Map(this.groupByOperation(anomalies));
+		const hints = [];
+		for (const stat of stats) {
+			const opKey = this.operationKey(stat.operation);
+			const opAnomalies = anomaliesByOp.get(opKey) ?? [];
+			for (const anomaly of opAnomalies) if (anomaly.metric === "latency") hints.push(this.applyLifecycleContext({
+				operation: stat.operation,
+				category: "performance",
+				summary: "Latency regression detected",
+				justification: `P99 latency at ${stat.p99LatencyMs}ms`,
+				recommendedActions: ["Add batching or caching layer", "Replay golden tests to capture slow inputs"]
+			}, lifecycleContext?.stage));
+			else if (anomaly.metric === "error-rate") {
+				const topError = Object.entries(stat.topErrors).sort((a, b) => b[1] - a[1])[0]?.[0];
+				hints.push(this.applyLifecycleContext({
+					operation: stat.operation,
+					category: "error-handling",
+					summary: "Error spike detected",
+					justification: topError ? `Dominant error code ${topError}` : "Increase in failures",
+					recommendedActions: ["Generate regression spec from failing payloads", "Add policy guardrails before rollout"]
+				}, lifecycleContext?.stage));
+			} else if (anomaly.metric === "throughput") hints.push(this.applyLifecycleContext({
+				operation: stat.operation,
+				category: "performance",
+				summary: "Throughput drop detected",
+				justification: "Significant traffic reduction relative to baseline",
+				recommendedActions: ["Validate routing + feature flag bucketing", "Backfill spec variant to rehydrate demand"]
+			}, lifecycleContext?.stage));
+		}
+		return hints;
+	}
+	operationKey(op) {
+		const coordinate = "operation" in op ? op.operation : op;
+		return `${coordinate.key}.v${coordinate.version}${coordinate.tenantId ? `@${coordinate.tenantId}` : ""}`;
+	}
+	buildUsageStats(samples) {
+		const durations = samples.map((s) => s.durationMs).sort((a, b) => a - b);
+		const errors = samples.filter((s) => !s.success);
+		const totalCalls = samples.length;
+		const successRate = (totalCalls - errors.length) / totalCalls;
+		const errorRate = errors.length / totalCalls;
+		const averageLatencyMs = durations.reduce((sum, value) => sum + value, 0) / totalCalls;
+		const topErrors = errors.reduce((acc, sample) => {
+			if (!sample.errorCode) return acc;
+			acc[sample.errorCode] = (acc[sample.errorCode] ?? 0) + 1;
+			return acc;
+		}, {});
+		const timestamps = samples.map((s) => s.timestamp.getTime());
+		const windowStart = new Date(Math.min(...timestamps));
+		const windowEnd = new Date(Math.max(...timestamps));
+		return {
+			operation: samples[0].operation,
+			totalCalls,
+			successRate,
+			errorRate,
+			averageLatencyMs,
+			p95LatencyMs: percentile(durations, .95),
+			p99LatencyMs: percentile(durations, .99),
+			maxLatencyMs: Math.max(...durations),
+			lastSeenAt: windowEnd,
+			windowStart,
+			windowEnd,
+			topErrors
+		};
+	}
+	toSeverity(ratio) {
+		if (ratio >= 2) return "high";
+		if (ratio >= 1.3) return "medium";
+		return "low";
+	}
+	mapMetricToIntent(metric) {
+		switch (metric) {
+			case "error-rate": return "error-spike";
+			case "latency": return "latency-regression";
+			case "throughput": return "throughput-drop";
+			default: return "schema-mismatch";
+		}
+	}
+	groupByOperation(items) {
+		const map = /* @__PURE__ */ new Map();
+		for (const item of items) {
+			const key = this.operationKey(item.operation);
+			const arr = map.get(key) ?? [];
+			arr.push(item);
+			map.set(key, arr);
+		}
+		return map;
+	}
+	applyLifecycleContext(hint, stage) {
+		if (stage === void 0) return hint;
+		const advice = LIFECYCLE_HINTS[mapStageBand(stage)]?.[hint.category];
+		if (!advice) return {
+			...hint,
+			lifecycleStage: stage
+		};
+		return {
+			...hint,
+			lifecycleStage: stage,
+			lifecycleNotes: advice.message,
+			recommendedActions: dedupeActions([...hint.recommendedActions, ...advice.supplementalActions])
+		};
+	}
+};
+function percentile(values, p) {
+	if (!values.length) return 0;
+	if (values.length === 1) return values[0];
+	return values[Math.min(values.length - 1, Math.floor(p * values.length))];
+}
+const mapStageBand = (stage) => {
+	if (stage <= 2) return "early";
+	if (stage === LifecycleStage.ProductMarketFit) return "pmf";
+	if (stage === LifecycleStage.GrowthScaleUp || stage === LifecycleStage.ExpansionPlatform) return "scale";
+	return "mature";
+};
+const LIFECYCLE_HINTS = {
+	early: {
+		performance: {
+			message: "Favor guardrails that protect learning velocity before heavy rewrites.",
+			supplementalActions: ["Wrap risky changes behind progressive delivery flags"]
+		},
+		"error-handling": {
+			message: "Make failures loud and recoverable so you can learn faster.",
+			supplementalActions: ["Add auto-rollbacks or manual kill switches"]
+		}
+	},
+	pmf: { performance: {
+		message: "Stabilize the core use case to avoid regressions while demand grows.",
+		supplementalActions: ["Instrument regression tests on critical specs"]
+	} },
+	scale: {
+		performance: {
+			message: "Prioritize resilience and multi-tenant safety as volumes expand.",
+			supplementalActions: ["Introduce workload partitioning or isolation per tenant"]
+		},
+		"error-handling": {
+			message: "Contain blast radius with policy fallbacks and circuit breakers.",
+			supplementalActions: ["Add circuit breakers to high-risk operations"]
+		}
+	},
+	mature: {
+		performance: {
+			message: "Optimize for margins and predictable SLAs.",
+			supplementalActions: ["Capture unit-cost impacts alongside latency fixes"]
+		},
+		"error-handling": {
+			message: "Prevent regressions with automated regression specs before deploy.",
+			supplementalActions: ["Run auto-evolution simulations on renewal scenarios"]
+		}
+	}
+};
+const dedupeActions = (actions) => {
+	const seen = /* @__PURE__ */ new Set();
+	const ordered = [];
+	for (const action of actions) {
+		if (seen.has(action)) continue;
+		seen.add(action);
+		ordered.push(action);
+	}
+	return ordered;
+};
+
+//#endregion
+export { SpecAnalyzer };
+//# sourceMappingURL=spec-analyzer.mjs.map

package/dist/analyzer/spec-analyzer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec-analyzer.mjs","names":[],"sources":["../../src/analyzer/spec-analyzer.ts"],"sourcesContent":["import { Logger } from '@contractspec/lib.observability';\nimport { randomUUID } from 'node:crypto';\nimport { LifecycleStage } from '@contractspec/lib.lifecycle';\nimport {\n  type IntentPattern,\n  type OperationCoordinate,\n  type OperationMetricSample,\n  type OptimizationHint,\n  type PatternConfidence,\n  type SpecAnomaly,\n  type SpecUsageStats,\n  type SuggestionEvidence,\n} from '../types';\n\nexport interface SpecAnalyzerOptions {\n  logger?: Logger;\n  minSampleSize?: number;\n  errorRateThreshold?: number;\n  latencyP99ThresholdMs?: number;\n  throughputDropThreshold?: number;\n}\n\nconst DEFAULT_OPTIONS: Required<\n  Pick<\n    SpecAnalyzerOptions,\n    'minSampleSize' | 'errorRateThreshold' | 'latencyP99ThresholdMs'\n  >\n> = {\n  minSampleSize: 50,\n  errorRateThreshold: 0.05,\n  latencyP99ThresholdMs: 750,\n};\n\nexport class SpecAnalyzer {\n  private readonly logger?: Logger;\n  private readonly minSampleSize: number;\n  private readonly errorRateThreshold: number;\n  private readonly latencyP99ThresholdMs: number;\n  private readonly throughputDropThreshold: number;\n\n  constructor(options: SpecAnalyzerOptions = {}) {\n    this.logger = options.logger;\n    this.minSampleSize = options.minSampleSize ?? DEFAULT_OPTIONS.minSampleSize;\n    this.errorRateThreshold =\n      options.errorRateThreshold ?? DEFAULT_OPTIONS.errorRateThreshold;\n    this.latencyP99ThresholdMs =\n      options.latencyP99ThresholdMs ?? DEFAULT_OPTIONS.latencyP99ThresholdMs;\n    this.throughputDropThreshold = options.throughputDropThreshold ?? 0.2;\n  }\n\n  analyzeSpecUsage(samples: OperationMetricSample[]): SpecUsageStats[] {\n    if (!samples.length) {\n      this.logger?.debug('SpecAnalyzer.analyzeSpecUsage.skip', {\n        reason: 'no-samples',\n      });\n      return [];\n    }\n\n    const groups = new Map<string, OperationMetricSample[]>();\n    for (const sample of samples) {\n      const key = this.operationKey(sample);\n      const arr = groups.get(key) ?? [];\n      arr.push(sample);\n      groups.set(key, arr);\n    }\n\n    const entries = [...groups.values()];\n    const usable = entries.filter((samplesForOp) => {\n      const valid = samplesForOp.length >= this.minSampleSize;\n      if (!valid) {\n        this.logger?.debug('SpecAnalyzer.analyzeSpecUsage.skipOperation', {\n          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n          operation: this.operationKey(samplesForOp[0]!),\n          sampleSize: samplesForOp.length,\n          minSampleSize: this.minSampleSize,\n        });\n      }\n      return valid;\n    });\n\n    return usable.map((operationSamples) =>\n      this.buildUsageStats(operationSamples)\n    );\n  }\n\n  detectAnomalies(\n    stats: SpecUsageStats[],\n    baseline?: SpecUsageStats[]\n  ): SpecAnomaly[] {\n    const anomalies: SpecAnomaly[] = [];\n    if (!stats.length) {\n      this.logger?.debug('SpecAnalyzer.detectAnomalies.skip', {\n        reason: 'no-stats',\n      });\n      return anomalies;\n    }\n    const baselineByOp = new Map(\n      (baseline ?? []).map((item) => [this.operationKey(item.operation), item])\n    );\n\n    for (const stat of stats) {\n      const evidence: SuggestionEvidence[] = [];\n\n      if (stat.errorRate >= this.errorRateThreshold) {\n        evidence.push({\n          type: 'telemetry',\n          description: `Error rate ${stat.errorRate.toFixed(2)} exceeded threshold ${this.errorRateThreshold}`,\n          data: { errorRate: stat.errorRate },\n        });\n        anomalies.push({\n          operation: stat.operation,\n          severity: this.toSeverity(stat.errorRate / this.errorRateThreshold),\n          metric: 'error-rate',\n          description: 'Error rate spike',\n          detectedAt: new Date(),\n          threshold: this.errorRateThreshold,\n          observedValue: stat.errorRate,\n          evidence,\n        });\n        continue;\n      }\n\n      if (stat.p99LatencyMs >= this.latencyP99ThresholdMs) {\n        evidence.push({\n          type: 'telemetry',\n          description: `P99 latency ${stat.p99LatencyMs}ms exceeded threshold ${this.latencyP99ThresholdMs}ms`,\n          data: { p99LatencyMs: stat.p99LatencyMs },\n        });\n        anomalies.push({\n          operation: stat.operation,\n          severity: this.toSeverity(\n            stat.p99LatencyMs / this.latencyP99ThresholdMs\n          ),\n          metric: 'latency',\n          description: 'Latency regression detected',\n          detectedAt: new Date(),\n          threshold: this.latencyP99ThresholdMs,\n          observedValue: stat.p99LatencyMs,\n          evidence,\n        });\n        continue;\n      }\n\n      const baselineStat = baselineByOp.get(this.operationKey(stat.operation));\n      if (baselineStat) {\n        const drop =\n          (baselineStat.totalCalls - stat.totalCalls) / baselineStat.totalCalls;\n        if (drop >= this.throughputDropThreshold) {\n          evidence.push({\n            type: 'telemetry',\n            description: `Throughput dropped by ${(drop * 100).toFixed(1)}% compared to baseline`,\n            data: {\n              baselineCalls: baselineStat.totalCalls,\n              currentCalls: stat.totalCalls,\n            },\n          });\n          anomalies.push({\n            operation: stat.operation,\n            severity: this.toSeverity(drop / this.throughputDropThreshold),\n            metric: 'throughput',\n            description: 'Usage drop detected',\n            detectedAt: new Date(),\n            threshold: this.throughputDropThreshold,\n            observedValue: drop,\n            evidence,\n          });\n        }\n      }\n    }\n\n    return anomalies;\n  }\n\n  toIntentPatterns(\n    anomalies: SpecAnomaly[],\n    stats: SpecUsageStats[]\n  ): IntentPattern[] {\n    const statsByOp = new Map(\n      stats.map((item) => [this.operationKey(item.operation), item])\n    );\n    return anomalies.map((anomaly) => {\n      const stat = statsByOp.get(this.operationKey(anomaly.operation));\n      const confidence: PatternConfidence = {\n        score: Math.min(\n          1,\n          (anomaly.observedValue ?? 0) / (anomaly.threshold ?? 1)\n        ),\n        sampleSize: stat?.totalCalls ?? 0,\n        pValue: undefined,\n      };\n      return {\n        id: randomUUID(),\n        type: this.mapMetricToIntent(anomaly.metric),\n        description: anomaly.description,\n        operation: anomaly.operation,\n        confidence,\n        metadata: {\n          observedValue: anomaly.observedValue,\n          threshold: anomaly.threshold,\n        },\n        evidence: anomaly.evidence,\n      };\n    });\n  }\n\n  suggestOptimizations(\n    stats: SpecUsageStats[],\n    anomalies: SpecAnomaly[],\n    lifecycleContext?: { stage: LifecycleStage }\n  ): OptimizationHint[] {\n    const anomaliesByOp = new Map<string, SpecAnomaly[]>(\n      this.groupByOperation(anomalies)\n    );\n    const hints: OptimizationHint[] = [];\n\n    for (const stat of stats) {\n      const opKey = this.operationKey(stat.operation);\n      const opAnomalies = anomaliesByOp.get(opKey) ?? [];\n      for (const anomaly of opAnomalies) {\n        if (anomaly.metric === 'latency') {\n          hints.push(\n            this.applyLifecycleContext(\n              {\n                operation: stat.operation,\n                category: 'performance',\n                summary: 'Latency regression detected',\n                justification: `P99 latency at ${stat.p99LatencyMs}ms`,\n                recommendedActions: [\n                  'Add batching or caching layer',\n                  'Replay golden tests to capture slow inputs',\n                ],\n              },\n              lifecycleContext?.stage\n            )\n          );\n        } else if (anomaly.metric === 'error-rate') {\n          const topError = Object.entries(stat.topErrors).sort(\n            (a, b) => b[1] - a[1]\n          )[0]?.[0];\n          hints.push(\n            this.applyLifecycleContext(\n              {\n                operation: stat.operation,\n                category: 'error-handling',\n                summary: 'Error spike detected',\n                justification: topError\n                  ? `Dominant error code ${topError}`\n                  : 'Increase in failures',\n                recommendedActions: [\n                  'Generate regression spec from failing payloads',\n                  'Add policy guardrails before rollout',\n                ],\n              },\n              lifecycleContext?.stage\n            )\n          );\n        } else if (anomaly.metric === 'throughput') {\n          hints.push(\n            this.applyLifecycleContext(\n              {\n                operation: stat.operation,\n                category: 'performance',\n                summary: 'Throughput drop detected',\n                justification:\n                  'Significant traffic reduction relative to baseline',\n                recommendedActions: [\n                  'Validate routing + feature flag bucketing',\n                  'Backfill spec variant to rehydrate demand',\n                ],\n              },\n              lifecycleContext?.stage\n            )\n          );\n        }\n      }\n    }\n    return hints;\n  }\n\n  private operationKey(\n    op:\n      | OperationCoordinate\n      | SpecUsageStats\n      | SpecAnomaly\n      | OperationMetricSample\n  ) {\n    const coordinate =\n      'operation' in op ? (op.operation as OperationCoordinate) : op;\n    return `${coordinate.key}.v${coordinate.version}${\n      coordinate.tenantId ? `@${coordinate.tenantId}` : ''\n    }`;\n  }\n\n  private buildUsageStats(samples: OperationMetricSample[]): SpecUsageStats {\n    const durations = samples.map((s) => s.durationMs).sort((a, b) => a - b);\n    const errors = samples.filter((s) => !s.success);\n    const totalCalls = samples.length;\n    const successRate = (totalCalls - errors.length) / totalCalls;\n    const errorRate = errors.length / totalCalls;\n    const averageLatencyMs =\n      durations.reduce((sum, value) => sum + value, 0) / totalCalls;\n\n    const topErrors = errors.reduce<Record<string, number>>((acc, sample) => {\n      if (!sample.errorCode) return acc;\n      acc[sample.errorCode] = (acc[sample.errorCode] ?? 0) + 1;\n      return acc;\n    }, {});\n\n    const timestamps = samples.map((s) => s.timestamp.getTime());\n    const windowStart = new Date(Math.min(...timestamps));\n    const windowEnd = new Date(Math.max(...timestamps));\n\n    return {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      operation: samples[0]!.operation,\n      totalCalls,\n      successRate,\n      errorRate,\n      averageLatencyMs,\n      p95LatencyMs: percentile(durations, 0.95),\n      p99LatencyMs: percentile(durations, 0.99),\n      maxLatencyMs: Math.max(...durations),\n      lastSeenAt: windowEnd,\n      windowStart,\n      windowEnd,\n      topErrors,\n    };\n  }\n\n  private toSeverity(ratio: number): SpecAnomaly['severity'] {\n    if (ratio >= 2) return 'high';\n    if (ratio >= 1.3) return 'medium';\n    return 'low';\n  }\n\n  private mapMetricToIntent(\n    metric: SpecAnomaly['metric']\n  ): IntentPattern['type'] {\n    switch (metric) {\n      case 'error-rate':\n        return 'error-spike';\n      case 'latency':\n        return 'latency-regression';\n      case 'throughput':\n        return 'throughput-drop';\n      default:\n        return 'schema-mismatch';\n    }\n  }\n\n  private groupByOperation<T extends { operation: OperationCoordinate }>(\n    items: T[]\n  ): Map<string, T[]> {\n    const map = new Map<string, T[]>();\n    for (const item of items) {\n      const key = this.operationKey(item.operation);\n      const arr = map.get(key) ?? [];\n      arr.push(item);\n      map.set(key, arr);\n    }\n    return map;\n  }\n\n  private applyLifecycleContext(\n    hint: OptimizationHint,\n    stage?: LifecycleStage\n  ): OptimizationHint {\n    if (stage === undefined) return hint;\n    const band = mapStageBand(stage);\n    const advice = LIFECYCLE_HINTS[band]?.[hint.category];\n    if (!advice) {\n      return { ...hint, lifecycleStage: stage };\n    }\n    return {\n      ...hint,\n      lifecycleStage: stage,\n      lifecycleNotes: advice.message,\n      recommendedActions: dedupeActions([\n        ...hint.recommendedActions,\n        ...advice.supplementalActions,\n      ]),\n    };\n  }\n}\n\nfunction percentile(values: number[], p: number): number {\n  if (!values.length) return 0;\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  if (values.length === 1) return values[0]!;\n  const idx = Math.min(values.length - 1, Math.floor(p * values.length));\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  return values[idx]!;\n}\n\ntype StageBand = 'early' | 'pmf' | 'scale' | 'mature';\n\nconst mapStageBand = (stage: LifecycleStage): StageBand => {\n  if (stage <= 2) return 'early';\n  if (stage === LifecycleStage.ProductMarketFit) return 'pmf';\n  if (\n    stage === LifecycleStage.GrowthScaleUp ||\n    stage === LifecycleStage.ExpansionPlatform\n  ) {\n    return 'scale';\n  }\n  return 'mature';\n};\n\nconst LIFECYCLE_HINTS: Record<\n  StageBand,\n  Partial<\n    Record<\n      OptimizationHint['category'],\n      { message: string; supplementalActions: string[] }\n    >\n  >\n> = {\n  early: {\n    performance: {\n      message:\n        'Favor guardrails that protect learning velocity before heavy rewrites.',\n      supplementalActions: [\n        'Wrap risky changes behind progressive delivery flags',\n      ],\n    },\n    'error-handling': {\n      message: 'Make failures loud and recoverable so you can learn faster.',\n      supplementalActions: ['Add auto-rollbacks or manual kill switches'],\n    },\n  },\n  pmf: {\n    performance: {\n      message:\n        'Stabilize the core use case to avoid regressions while demand grows.',\n      supplementalActions: ['Instrument regression tests on critical specs'],\n    },\n  },\n  scale: {\n    performance: {\n      message:\n        'Prioritize resilience and multi-tenant safety as volumes expand.',\n      supplementalActions: [\n        'Introduce workload partitioning or isolation per tenant',\n      ],\n    },\n    'error-handling': {\n      message:\n        'Contain blast radius with policy fallbacks and circuit breakers.',\n      supplementalActions: ['Add circuit breakers to high-risk operations'],\n    },\n  },\n  mature: {\n    performance: {\n      message: 'Optimize for margins and predictable SLAs.',\n      supplementalActions: [\n        'Capture unit-cost impacts alongside latency fixes',\n      ],\n    },\n    'error-handling': {\n      message:\n        'Prevent regressions with automated regression specs before deploy.',\n      supplementalActions: [\n        'Run auto-evolution simulations on renewal scenarios',\n      ],\n    },\n  },\n};\n\nconst dedupeActions = (actions: string[]): string[] => {\n  const seen = new Set<string>();\n  const ordered: string[] = [];\n  for (const action of actions) {\n    if (seen.has(action)) continue;\n    seen.add(action);\n    ordered.push(action);\n  }\n  return ordered;\n};\n"],"mappings":"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"}