@contractspec/bundle.workspace 0.0.0-canary-20260113162409

package/dist/services/verification-cache/adapters/workspace-state.d.mts

@@ -0,0 +1,49 @@
+import { CacheKeyString, CacheStorageAdapter, VerificationCacheEntry } from "../types.mjs";
+
+//#region src/services/verification-cache/adapters/workspace-state.d.ts
+
+/**
+ * Interface for key-value store (compatible with VSCode's Memento).
+ */
+interface KeyValueStore {
+  get<T>(key: string): T | undefined;
+  update(key: string, value: unknown): Thenable<void>;
+  keys?(): readonly string[];
+}
+/**
+ * Workspace state storage adapter.
+ */
+declare class WorkspaceStateCacheStorage implements CacheStorageAdapter {
+  private store;
+  private keyIndex;
+  constructor(store: KeyValueStore);
+  /**
+   * Load the key index from storage.
+   */
+  private loadKeyIndex;
+  /**
+   * Save the key index to storage.
+   */
+  private saveKeyIndex;
+  /**
+   * Get the storage key for a cache key.
+   */
+  private getStorageKey;
+  get(key: CacheKeyString): Promise<VerificationCacheEntry | null>;
+  set(key: CacheKeyString, entry: VerificationCacheEntry): Promise<void>;
+  delete(key: CacheKeyString): Promise<boolean>;
+  has(key: CacheKeyString): Promise<boolean>;
+  keys(): Promise<CacheKeyString[]>;
+  clear(): Promise<void>;
+  stats(): Promise<{
+    entryCount: number;
+    memoryUsage?: number;
+  }>;
+}
+/**
+ * Create a workspace state cache storage adapter.
+ */
+declare function createWorkspaceStateCacheStorage(store: KeyValueStore): WorkspaceStateCacheStorage;
+//#endregion
+export { KeyValueStore, WorkspaceStateCacheStorage, createWorkspaceStateCacheStorage };
+//# sourceMappingURL=workspace-state.d.mts.map

package/dist/services/verification-cache/adapters/workspace-state.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-state.d.mts","names":[],"sources":["../../../../src/services/verification-cache/adapters/workspace-state.ts"],"sourcesContent":[],"mappings":";;;;;;;AA4EwC,UA5DvB,aAAA,CA4DuB;EAAyB,GAAA,CAAA,CAAA,CAAA,CAAA,GAAA,EAAA,MAAA,CAAA,EA3D1C,CA2D0C,GAAA,SAAA;EAU7C,MAAA,CAAA,GAAA,EAAA,MAAA,EAAA,KAAA,EAAA,OAAA,CAAA,EApEmB,QAoEnB,CAAA,IAAA,CAAA;EAAiB,IAAA,GAAA,EAAA,SAAA,MAAA,EAAA;;;;;AAqBpB,cAxEJ,0BAAA,YAAsC,mBAwElC,CAAA;EAYA,QAAA,KAAA;EApFkC,QAAA,QAAA;EAAmB,WAAA,CAAA,KAAA,EAIjD,aAJiD;EA8FtD;;;;;;;;;;;;WA3DC,iBAAiB,QAAQ;WAMzB,uBAAuB,yBAAyB;cAU7C,iBAAiB;WAapB,iBAAiB;UAIlB,QAAQ;WAIP;WAYA;;;;;;;;iBAUD,gCAAA,QACP,gBACN"}

package/dist/services/verification-cache/adapters/workspace-state.mjs

@@ -0,0 +1,91 @@
+//#region src/services/verification-cache/adapters/workspace-state.ts
+/**
+* Cache key prefix to avoid collisions.
+*/
+const CACHE_PREFIX = "contractspec.verification-cache.";
+/**
+* Index key for tracking all cache keys.
+*/
+const INDEX_KEY = `${CACHE_PREFIX}__index__`;
+/**
+* Workspace state storage adapter.
+*/
+var WorkspaceStateCacheStorage = class {
+	store;
+	keyIndex;
+	constructor(store) {
+		this.store = store;
+		this.keyIndex = new Set(this.loadKeyIndex());
+	}
+	/**
+	* Load the key index from storage.
+	*/
+	loadKeyIndex() {
+		try {
+			return this.store.get(INDEX_KEY) ?? [];
+		} catch {
+			return [];
+		}
+	}
+	/**
+	* Save the key index to storage.
+	*/
+	async saveKeyIndex() {
+		await this.store.update(INDEX_KEY, Array.from(this.keyIndex));
+	}
+	/**
+	* Get the storage key for a cache key.
+	*/
+	getStorageKey(key) {
+		return `${CACHE_PREFIX}${key}`;
+	}
+	async get(key) {
+		const storageKey = this.getStorageKey(key);
+		return this.store.get(storageKey) ?? null;
+	}
+	async set(key, entry) {
+		const storageKey = this.getStorageKey(key);
+		await this.store.update(storageKey, entry);
+		if (!this.keyIndex.has(key)) {
+			this.keyIndex.add(key);
+			await this.saveKeyIndex();
+		}
+	}
+	async delete(key) {
+		const storageKey = this.getStorageKey(key);
+		const existed = this.keyIndex.has(key);
+		if (existed) {
+			await this.store.update(storageKey, void 0);
+			this.keyIndex.delete(key);
+			await this.saveKeyIndex();
+		}
+		return existed;
+	}
+	async has(key) {
+		return this.keyIndex.has(key);
+	}
+	async keys() {
+		return Array.from(this.keyIndex);
+	}
+	async clear() {
+		for (const key of this.keyIndex) {
+			const storageKey = this.getStorageKey(key);
+			await this.store.update(storageKey, void 0);
+		}
+		this.keyIndex.clear();
+		await this.saveKeyIndex();
+	}
+	async stats() {
+		return { entryCount: this.keyIndex.size };
+	}
+};
+/**
+* Create a workspace state cache storage adapter.
+*/
+function createWorkspaceStateCacheStorage(store) {
+	return new WorkspaceStateCacheStorage(store);
+}
+
+//#endregion
+export { WorkspaceStateCacheStorage, createWorkspaceStateCacheStorage };
+//# sourceMappingURL=workspace-state.mjs.map

package/dist/services/verification-cache/adapters/workspace-state.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-state.mjs","names":[],"sources":["../../../../src/services/verification-cache/adapters/workspace-state.ts"],"sourcesContent":["/**\n * Workspace state cache storage adapter.\n *\n * Generic adapter for key-value stores like VSCode's ExtensionContext.workspaceState.\n * Can also be used with localStorage-like APIs.\n */\n\nimport type {\n  CacheKeyString,\n  CacheStorageAdapter,\n  VerificationCacheEntry,\n} from '../types';\n\n/**\n * Interface for key-value store (compatible with VSCode's Memento).\n */\nexport interface KeyValueStore {\n  get<T>(key: string): T | undefined;\n  update(key: string, value: unknown): Thenable<void>;\n  keys?(): readonly string[];\n}\n\n/**\n * Cache key prefix to avoid collisions.\n */\nconst CACHE_PREFIX = 'contractspec.verification-cache.';\n\n/**\n * Index key for tracking all cache keys.\n */\nconst INDEX_KEY = `${CACHE_PREFIX}__index__`;\n\n/**\n * Workspace state storage adapter.\n */\nexport class WorkspaceStateCacheStorage implements CacheStorageAdapter {\n  private store: KeyValueStore;\n  private keyIndex: Set<string>;\n\n  constructor(store: KeyValueStore) {\n    this.store = store;\n    this.keyIndex = new Set(this.loadKeyIndex());\n  }\n\n  /**\n   * Load the key index from storage.\n   */\n  private loadKeyIndex(): string[] {\n    try {\n      const index = this.store.get<string[]>(INDEX_KEY);\n      return index ?? [];\n    } catch {\n      return [];\n    }\n  }\n\n  /**\n   * Save the key index to storage.\n   */\n  private async saveKeyIndex(): Promise<void> {\n    await this.store.update(INDEX_KEY, Array.from(this.keyIndex));\n  }\n\n  /**\n   * Get the storage key for a cache key.\n   */\n  private getStorageKey(key: CacheKeyString): string {\n    return `${CACHE_PREFIX}${key}`;\n  }\n\n  async get(key: CacheKeyString): Promise<VerificationCacheEntry | null> {\n    const storageKey = this.getStorageKey(key);\n    const entry = this.store.get<VerificationCacheEntry>(storageKey);\n    return entry ?? null;\n  }\n\n  async set(key: CacheKeyString, entry: VerificationCacheEntry): Promise<void> {\n    const storageKey = this.getStorageKey(key);\n    await this.store.update(storageKey, entry);\n\n    if (!this.keyIndex.has(key)) {\n      this.keyIndex.add(key);\n      await this.saveKeyIndex();\n    }\n  }\n\n  async delete(key: CacheKeyString): Promise<boolean> {\n    const storageKey = this.getStorageKey(key);\n    const existed = this.keyIndex.has(key);\n\n    if (existed) {\n      await this.store.update(storageKey, undefined);\n      this.keyIndex.delete(key);\n      await this.saveKeyIndex();\n    }\n\n    return existed;\n  }\n\n  async has(key: CacheKeyString): Promise<boolean> {\n    return this.keyIndex.has(key);\n  }\n\n  async keys(): Promise<CacheKeyString[]> {\n    return Array.from(this.keyIndex);\n  }\n\n  async clear(): Promise<void> {\n    // Delete all entries\n    for (const key of this.keyIndex) {\n      const storageKey = this.getStorageKey(key);\n      await this.store.update(storageKey, undefined);\n    }\n\n    // Clear index\n    this.keyIndex.clear();\n    await this.saveKeyIndex();\n  }\n\n  async stats(): Promise<{ entryCount: number; memoryUsage?: number }> {\n    return {\n      entryCount: this.keyIndex.size,\n    };\n  }\n}\n\n/**\n * Create a workspace state cache storage adapter.\n */\nexport function createWorkspaceStateCacheStorage(\n  store: KeyValueStore\n): WorkspaceStateCacheStorage {\n  return new WorkspaceStateCacheStorage(store);\n}\n"],"mappings":";;;;AAyBA,MAAM,eAAe;;;;AAKrB,MAAM,YAAY,GAAG,aAAa;;;;AAKlC,IAAa,6BAAb,MAAuE;CACrE,AAAQ;CACR,AAAQ;CAER,YAAY,OAAsB;AAChC,OAAK,QAAQ;AACb,OAAK,WAAW,IAAI,IAAI,KAAK,cAAc,CAAC;;;;;CAM9C,AAAQ,eAAyB;AAC/B,MAAI;AAEF,UADc,KAAK,MAAM,IAAc,UAAU,IACjC,EAAE;UACZ;AACN,UAAO,EAAE;;;;;;CAOb,MAAc,eAA8B;AAC1C,QAAM,KAAK,MAAM,OAAO,WAAW,MAAM,KAAK,KAAK,SAAS,CAAC;;;;;CAM/D,AAAQ,cAAc,KAA6B;AACjD,SAAO,GAAG,eAAe;;CAG3B,MAAM,IAAI,KAA6D;EACrE,MAAM,aAAa,KAAK,cAAc,IAAI;AAE1C,SADc,KAAK,MAAM,IAA4B,WAAW,IAChD;;CAGlB,MAAM,IAAI,KAAqB,OAA8C;EAC3E,MAAM,aAAa,KAAK,cAAc,IAAI;AAC1C,QAAM,KAAK,MAAM,OAAO,YAAY,MAAM;AAE1C,MAAI,CAAC,KAAK,SAAS,IAAI,IAAI,EAAE;AAC3B,QAAK,SAAS,IAAI,IAAI;AACtB,SAAM,KAAK,cAAc;;;CAI7B,MAAM,OAAO,KAAuC;EAClD,MAAM,aAAa,KAAK,cAAc,IAAI;EAC1C,MAAM,UAAU,KAAK,SAAS,IAAI,IAAI;AAEtC,MAAI,SAAS;AACX,SAAM,KAAK,MAAM,OAAO,YAAY,OAAU;AAC9C,QAAK,SAAS,OAAO,IAAI;AACzB,SAAM,KAAK,cAAc;;AAG3B,SAAO;;CAGT,MAAM,IAAI,KAAuC;AAC/C,SAAO,KAAK,SAAS,IAAI,IAAI;;CAG/B,MAAM,OAAkC;AACtC,SAAO,MAAM,KAAK,KAAK,SAAS;;CAGlC,MAAM,QAAuB;AAE3B,OAAK,MAAM,OAAO,KAAK,UAAU;GAC/B,MAAM,aAAa,KAAK,cAAc,IAAI;AAC1C,SAAM,KAAK,MAAM,OAAO,YAAY,OAAU;;AAIhD,OAAK,SAAS,OAAO;AACrB,QAAM,KAAK,cAAc;;CAG3B,MAAM,QAA+D;AACnE,SAAO,EACL,YAAY,KAAK,SAAS,MAC3B;;;;;;AAOL,SAAgB,iCACd,OAC4B;AAC5B,QAAO,IAAI,2BAA2B,MAAM"}

package/dist/services/verification-cache/cache-service.d.mts

@@ -0,0 +1,70 @@
+import { CacheKeyString, CacheLookupResult, CacheStats, CacheStorageAdapter, VerificationCacheConfig, VerificationCacheKey } from "./types.mjs";
+import { VerificationReport, VerificationTier } from "@contractspec/lib.contracts/llm";
+
+//#region src/services/verification-cache/cache-service.d.ts
+
+/**
+ * Compute SHA256 hash of content.
+ */
+declare function computeContentHash(content: string): string;
+/**
+ * Convert cache key to string for storage.
+ */
+declare function cacheKeyToString(key: VerificationCacheKey): CacheKeyString;
+/**
+ * Parse cache key string back to object.
+ */
+declare function stringToCacheKey(str: CacheKeyString): VerificationCacheKey | null;
+/**
+ * Verification cache service.
+ */
+declare class VerificationCacheService {
+  private storage;
+  private config;
+  private stats;
+  constructor(storage: CacheStorageAdapter, config?: Partial<VerificationCacheConfig>);
+  /**
+   * Create a cache key from spec and implementation content.
+   */
+  createKey(specContent: string, implContent: string, tier: VerificationTier, aiModelVersion?: string): VerificationCacheKey;
+  /**
+   * Look up a cached verification result.
+   */
+  lookup(key: VerificationCacheKey): Promise<CacheLookupResult>;
+  /**
+   * Store a verification result in cache.
+   */
+  store(key: VerificationCacheKey, result: VerificationReport, options?: {
+    dependencies?: string[];
+    specName?: string;
+    implPath?: string;
+  }): Promise<void>;
+  /**
+   * Invalidate cache entries for a specific file.
+   * Used when a file changes to invalidate dependent caches.
+   */
+  invalidateForFile(filePath: string): Promise<number>;
+  /**
+   * Invalidate all cache entries for a specific spec.
+   */
+  invalidateForSpec(specHash: string): Promise<number>;
+  /**
+   * Clear all cache entries.
+   */
+  clear(): Promise<void>;
+  /**
+   * Get cache statistics.
+   */
+  getStats(): Promise<CacheStats>;
+  /**
+   * Prune cache if over the maximum entry limit.
+   */
+  private pruneIfNeeded;
+}
+/**
+ * Create a verification cache service with the given storage adapter.
+ */
+declare function createVerificationCacheService(storage: CacheStorageAdapter, config?: Partial<VerificationCacheConfig>): VerificationCacheService;
+//#endregion
+export { VerificationCacheService, cacheKeyToString, computeContentHash, createVerificationCacheService, stringToCacheKey };
+//# sourceMappingURL=cache-service.d.mts.map

package/dist/services/verification-cache/cache-service.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-service.d.mts","names":[],"sources":["../../../src/services/verification-cache/cache-service.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA6HU,iBAnGM,kBAAA,CAmGN,OAAA,EAAA,MAAA,CAAA,EAAA,MAAA;;;;AAciC,iBA1G3B,gBAAA,CA0G2B,GAAA,EA1GL,oBA0GK,CAAA,EA1GkB,cA0GlB;;;;AAiFE,iBA1K7B,gBAAA,CA0K6B,GAAA,EAzKtC,cAyKsC,CAAA,EAxK1C,oBAwK0C,GAAA,IAAA;;;;AA4DzB,cA/KP,wBAAA,CA+KO;EAAO,QAAA,OAAA;EA0DX,QAAA,MAAA;EACL,QAAA,KAAA;EACQ,WAAA,CAAA,OAAA,EArON,mBAqOM,EAAA,MAAA,CAAA,EApOP,OAoOO,CApOC,uBAoOD,CAAA;EAAR;;;4DAvND,4CAEL;;;;cAYe,uBAAuB,QAAQ;;;;aAgD1C,8BACG;;;;MAMP;;;;;uCA0BwC;;;;uCAkCA;;;;WAkB5B;;;;cAQG,QAAQ;;;;;;;;;iBA0DZ,8BAAA,UACL,8BACA,QAAQ,2BAChB"}

package/dist/services/verification-cache/cache-service.mjs

@@ -0,0 +1,256 @@
+import { DEFAULT_CACHE_CONFIG } from "./types.mjs";
+import { createHash } from "crypto";
+
+//#region src/services/verification-cache/cache-service.ts
+/**
+* Verification cache service.
+*
+* Provides content-hash based caching for verification results
+* to avoid redundant checks and reduce AI costs.
+*/
+/**
+* Compute SHA256 hash of content.
+*/
+function computeContentHash(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+/**
+* Convert cache key to string for storage.
+*/
+function cacheKeyToString(key) {
+	const parts = [
+		`spec:${key.specHash.substring(0, 16)}`,
+		`impl:${key.implHash.substring(0, 16)}`,
+		`tier:${key.tier}`
+	];
+	if (key.aiModelVersion) parts.push(`model:${key.aiModelVersion}`);
+	return parts.join("|");
+}
+/**
+* Parse cache key string back to object.
+*/
+function stringToCacheKey(str) {
+	try {
+		const parts = str.split("|");
+		const keyMap = /* @__PURE__ */ new Map();
+		for (const part of parts) {
+			const [prefix, value] = part.split(":");
+			if (prefix && value) keyMap.set(prefix, value);
+		}
+		const specHash = keyMap.get("spec");
+		const implHash = keyMap.get("impl");
+		const tier = keyMap.get("tier");
+		if (!specHash || !implHash || !tier) return null;
+		return {
+			specHash,
+			implHash,
+			tier,
+			aiModelVersion: keyMap.get("model")
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Get TTL for a specific tier.
+*/
+function getTtlForTier(tier, config) {
+	switch (tier) {
+		case "structure": return config.structureTtlMs;
+		case "behavior": return config.behaviorTtlMs;
+		case "ai_review": return config.aiTtlMs;
+		default: return config.defaultTtlMs;
+	}
+}
+/**
+* Verification cache service.
+*/
+var VerificationCacheService = class {
+	storage;
+	config;
+	stats;
+	constructor(storage, config = {}) {
+		this.storage = storage;
+		this.config = {
+			...DEFAULT_CACHE_CONFIG,
+			...config
+		};
+		this.stats = {
+			hits: 0,
+			misses: 0
+		};
+	}
+	/**
+	* Create a cache key from spec and implementation content.
+	*/
+	createKey(specContent, implContent, tier, aiModelVersion) {
+		return {
+			specHash: computeContentHash(specContent),
+			implHash: computeContentHash(implContent),
+			tier,
+			aiModelVersion: tier === "ai_review" ? aiModelVersion : void 0
+		};
+	}
+	/**
+	* Look up a cached verification result.
+	*/
+	async lookup(key) {
+		const keyStr = cacheKeyToString(key);
+		const entry = await this.storage.get(keyStr);
+		if (!entry) {
+			this.stats.misses++;
+			return {
+				hit: false,
+				reason: "not_found"
+			};
+		}
+		if (entry.meta.expiresAt) {
+			const expiresAt = new Date(entry.meta.expiresAt).getTime();
+			if (Date.now() > expiresAt) {
+				this.stats.misses++;
+				await this.storage.delete(keyStr);
+				return {
+					hit: false,
+					reason: "expired"
+				};
+			}
+		}
+		if (entry.key.specHash !== key.specHash) {
+			this.stats.misses++;
+			return {
+				hit: false,
+				reason: "spec_changed"
+			};
+		}
+		if (entry.key.implHash !== key.implHash) {
+			this.stats.misses++;
+			return {
+				hit: false,
+				reason: "impl_changed"
+			};
+		}
+		if (key.tier === "ai_review" && key.aiModelVersion && entry.key.aiModelVersion !== key.aiModelVersion) {
+			this.stats.misses++;
+			return {
+				hit: false,
+				reason: "model_changed"
+			};
+		}
+		this.stats.hits++;
+		return {
+			hit: true,
+			entry
+		};
+	}
+	/**
+	* Store a verification result in cache.
+	*/
+	async store(key, result, options = {}) {
+		const keyStr = cacheKeyToString(key);
+		const ttl = getTtlForTier(key.tier, this.config);
+		const entry = {
+			key,
+			result,
+			meta: {
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				expiresAt: new Date(Date.now() + ttl).toISOString(),
+				dependencies: options.dependencies ?? [],
+				specName: options.specName,
+				implPath: options.implPath
+			}
+		};
+		await this.storage.set(keyStr, entry);
+		await this.pruneIfNeeded();
+	}
+	/**
+	* Invalidate cache entries for a specific file.
+	* Used when a file changes to invalidate dependent caches.
+	*/
+	async invalidateForFile(filePath) {
+		if (!this.config.transitiveInvalidation) return 0;
+		const keys = await this.storage.keys();
+		let invalidated = 0;
+		for (const keyStr of keys) {
+			const entry = await this.storage.get(keyStr);
+			if (!entry) continue;
+			if (entry.meta.dependencies.includes(filePath)) {
+				await this.storage.delete(keyStr);
+				invalidated++;
+			}
+			if (entry.meta.specName === filePath || entry.meta.implPath === filePath) {
+				await this.storage.delete(keyStr);
+				invalidated++;
+			}
+		}
+		return invalidated;
+	}
+	/**
+	* Invalidate all cache entries for a specific spec.
+	*/
+	async invalidateForSpec(specHash) {
+		const keys = await this.storage.keys();
+		let invalidated = 0;
+		for (const keyStr of keys) {
+			const parsed = stringToCacheKey(keyStr);
+			if (parsed && parsed.specHash.startsWith(specHash.substring(0, 16))) {
+				await this.storage.delete(keyStr);
+				invalidated++;
+			}
+		}
+		return invalidated;
+	}
+	/**
+	* Clear all cache entries.
+	*/
+	async clear() {
+		await this.storage.clear();
+		this.stats = {
+			hits: 0,
+			misses: 0
+		};
+	}
+	/**
+	* Get cache statistics.
+	*/
+	async getStats() {
+		const storageStats = await this.storage.stats?.();
+		return {
+			totalEntries: storageStats?.entryCount ?? (await this.storage.keys()).length,
+			hits: this.stats.hits,
+			misses: this.stats.misses,
+			hitRate: this.stats.hits + this.stats.misses > 0 ? Math.round(this.stats.hits / (this.stats.hits + this.stats.misses) * 100) : 0,
+			memoryUsage: storageStats?.memoryUsage
+		};
+	}
+	/**
+	* Prune cache if over the maximum entry limit.
+	*/
+	async pruneIfNeeded() {
+		const keys = await this.storage.keys();
+		if (keys.length <= this.config.maxEntries) return;
+		const entries = [];
+		for (const keyStr of keys) {
+			const entry = await this.storage.get(keyStr);
+			if (entry) entries.push({
+				key: keyStr,
+				createdAt: new Date(entry.meta.createdAt).getTime()
+			});
+		}
+		entries.sort((a, b) => a.createdAt - b.createdAt);
+		const toRemove = entries.length - this.config.maxEntries;
+		for (let i = 0; i < toRemove; i++) {
+			const entry = entries[i];
+			if (entry) await this.storage.delete(entry.key);
+		}
+	}
+};
+/**
+* Create a verification cache service with the given storage adapter.
+*/
+function createVerificationCacheService(storage, config) {
+	return new VerificationCacheService(storage, config);
+}
+
+//#endregion
+export { VerificationCacheService, cacheKeyToString, computeContentHash, createVerificationCacheService, stringToCacheKey };
+//# sourceMappingURL=cache-service.mjs.map

package/dist/services/verification-cache/cache-service.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-service.mjs","names":[],"sources":["../../../src/services/verification-cache/cache-service.ts"],"sourcesContent":["/**\n * Verification cache service.\n *\n * Provides content-hash based caching for verification results\n * to avoid redundant checks and reduce AI costs.\n */\n\nimport { createHash } from 'crypto';\nimport type {\n  VerificationReport,\n  VerificationTier,\n} from '@contractspec/lib.contracts/llm';\nimport type {\n  CacheKeyString,\n  CacheLookupResult,\n  CacheStats,\n  CacheStorageAdapter,\n  VerificationCacheConfig,\n  VerificationCacheEntry,\n  VerificationCacheKey,\n} from './types';\nimport { DEFAULT_CACHE_CONFIG } from './types';\n\n/**\n * Compute SHA256 hash of content.\n */\nexport function computeContentHash(content: string): string {\n  return createHash('sha256').update(content).digest('hex');\n}\n\n/**\n * Convert cache key to string for storage.\n */\nexport function cacheKeyToString(key: VerificationCacheKey): CacheKeyString {\n  const parts = [\n    `spec:${key.specHash.substring(0, 16)}`,\n    `impl:${key.implHash.substring(0, 16)}`,\n    `tier:${key.tier}`,\n  ];\n\n  if (key.aiModelVersion) {\n    parts.push(`model:${key.aiModelVersion}`);\n  }\n\n  return parts.join('|');\n}\n\n/**\n * Parse cache key string back to object.\n */\nexport function stringToCacheKey(\n  str: CacheKeyString\n): VerificationCacheKey | null {\n  try {\n    const parts = str.split('|');\n    const keyMap = new Map<string, string>();\n\n    for (const part of parts) {\n      const [prefix, value] = part.split(':');\n      if (prefix && value) {\n        keyMap.set(prefix, value);\n      }\n    }\n\n    const specHash = keyMap.get('spec');\n    const implHash = keyMap.get('impl');\n    const tier = keyMap.get('tier') as VerificationTier;\n\n    if (!specHash || !implHash || !tier) {\n      return null;\n    }\n\n    return {\n      specHash,\n      implHash,\n      tier,\n      aiModelVersion: keyMap.get('model'),\n    };\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Get TTL for a specific tier.\n */\nfunction getTtlForTier(\n  tier: VerificationTier,\n  config: Required<VerificationCacheConfig>\n): number {\n  switch (tier) {\n    case 'structure':\n      return config.structureTtlMs;\n    case 'behavior':\n      return config.behaviorTtlMs;\n    case 'ai_review':\n      return config.aiTtlMs;\n    default:\n      return config.defaultTtlMs;\n  }\n}\n\n/**\n * Verification cache service.\n */\nexport class VerificationCacheService {\n  private storage: CacheStorageAdapter;\n  private config: Required<VerificationCacheConfig>;\n  private stats: { hits: number; misses: number };\n\n  constructor(\n    storage: CacheStorageAdapter,\n    config: Partial<VerificationCacheConfig> = {}\n  ) {\n    this.storage = storage;\n    this.config = { ...DEFAULT_CACHE_CONFIG, ...config };\n    this.stats = { hits: 0, misses: 0 };\n  }\n\n  /**\n   * Create a cache key from spec and implementation content.\n   */\n  createKey(\n    specContent: string,\n    implContent: string,\n    tier: VerificationTier,\n    aiModelVersion?: string\n  ): VerificationCacheKey {\n    return {\n      specHash: computeContentHash(specContent),\n      implHash: computeContentHash(implContent),\n      tier,\n      aiModelVersion: tier === 'ai_review' ? aiModelVersion : undefined,\n    };\n  }\n\n  /**\n   * Look up a cached verification result.\n   */\n  async lookup(key: VerificationCacheKey): Promise<CacheLookupResult> {\n    const keyStr = cacheKeyToString(key);\n    const entry = await this.storage.get(keyStr);\n\n    if (!entry) {\n      this.stats.misses++;\n      return { hit: false, reason: 'not_found' };\n    }\n\n    // Check expiration\n    if (entry.meta.expiresAt) {\n      const expiresAt = new Date(entry.meta.expiresAt).getTime();\n      if (Date.now() > expiresAt) {\n        this.stats.misses++;\n        await this.storage.delete(keyStr);\n        return { hit: false, reason: 'expired' };\n      }\n    }\n\n    // Validate hashes still match\n    if (entry.key.specHash !== key.specHash) {\n      this.stats.misses++;\n      return { hit: false, reason: 'spec_changed' };\n    }\n\n    if (entry.key.implHash !== key.implHash) {\n      this.stats.misses++;\n      return { hit: false, reason: 'impl_changed' };\n    }\n\n    // For AI tier, check model version\n    if (\n      key.tier === 'ai_review' &&\n      key.aiModelVersion &&\n      entry.key.aiModelVersion !== key.aiModelVersion\n    ) {\n      this.stats.misses++;\n      return { hit: false, reason: 'model_changed' };\n    }\n\n    this.stats.hits++;\n    return { hit: true, entry };\n  }\n\n  /**\n   * Store a verification result in cache.\n   */\n  async store(\n    key: VerificationCacheKey,\n    result: VerificationReport,\n    options: {\n      dependencies?: string[];\n      specName?: string;\n      implPath?: string;\n    } = {}\n  ): Promise<void> {\n    const keyStr = cacheKeyToString(key);\n    const ttl = getTtlForTier(key.tier, this.config);\n\n    const entry: VerificationCacheEntry = {\n      key,\n      result,\n      meta: {\n        createdAt: new Date().toISOString(),\n        expiresAt: new Date(Date.now() + ttl).toISOString(),\n        dependencies: options.dependencies ?? [],\n        specName: options.specName,\n        implPath: options.implPath,\n      },\n    };\n\n    await this.storage.set(keyStr, entry);\n\n    // Prune if over limit\n    await this.pruneIfNeeded();\n  }\n\n  /**\n   * Invalidate cache entries for a specific file.\n   * Used when a file changes to invalidate dependent caches.\n   */\n  async invalidateForFile(filePath: string): Promise<number> {\n    if (!this.config.transitiveInvalidation) {\n      return 0;\n    }\n\n    const keys = await this.storage.keys();\n    let invalidated = 0;\n\n    for (const keyStr of keys) {\n      const entry = await this.storage.get(keyStr);\n      if (!entry) continue;\n\n      // Check if this file is in dependencies\n      if (entry.meta.dependencies.includes(filePath)) {\n        await this.storage.delete(keyStr);\n        invalidated++;\n      }\n\n      // Check if file matches spec or impl path\n      if (\n        entry.meta.specName === filePath ||\n        entry.meta.implPath === filePath\n      ) {\n        await this.storage.delete(keyStr);\n        invalidated++;\n      }\n    }\n\n    return invalidated;\n  }\n\n  /**\n   * Invalidate all cache entries for a specific spec.\n   */\n  async invalidateForSpec(specHash: string): Promise<number> {\n    const keys = await this.storage.keys();\n    let invalidated = 0;\n\n    for (const keyStr of keys) {\n      const parsed = stringToCacheKey(keyStr);\n      if (parsed && parsed.specHash.startsWith(specHash.substring(0, 16))) {\n        await this.storage.delete(keyStr);\n        invalidated++;\n      }\n    }\n\n    return invalidated;\n  }\n\n  /**\n   * Clear all cache entries.\n   */\n  async clear(): Promise<void> {\n    await this.storage.clear();\n    this.stats = { hits: 0, misses: 0 };\n  }\n\n  /**\n   * Get cache statistics.\n   */\n  async getStats(): Promise<CacheStats> {\n    const storageStats = await this.storage.stats?.();\n\n    return {\n      totalEntries:\n        storageStats?.entryCount ?? (await this.storage.keys()).length,\n      hits: this.stats.hits,\n      misses: this.stats.misses,\n      hitRate:\n        this.stats.hits + this.stats.misses > 0\n          ? Math.round(\n              (this.stats.hits / (this.stats.hits + this.stats.misses)) * 100\n            )\n          : 0,\n      memoryUsage: storageStats?.memoryUsage,\n    };\n  }\n\n  /**\n   * Prune cache if over the maximum entry limit.\n   */\n  private async pruneIfNeeded(): Promise<void> {\n    const keys = await this.storage.keys();\n\n    if (keys.length <= this.config.maxEntries) {\n      return;\n    }\n\n    // Get all entries with their creation times\n    const entries: { key: string; createdAt: number }[] = [];\n\n    for (const keyStr of keys) {\n      const entry = await this.storage.get(keyStr);\n      if (entry) {\n        entries.push({\n          key: keyStr,\n          createdAt: new Date(entry.meta.createdAt).getTime(),\n        });\n      }\n    }\n\n    // Sort by creation time (oldest first)\n    entries.sort((a, b) => a.createdAt - b.createdAt);\n\n    // Remove oldest entries until under limit\n    const toRemove = entries.length - this.config.maxEntries;\n    for (let i = 0; i < toRemove; i++) {\n      const entry = entries[i];\n      if (entry) {\n        await this.storage.delete(entry.key);\n      }\n    }\n  }\n}\n\n/**\n * Create a verification cache service with the given storage adapter.\n */\nexport function createVerificationCacheService(\n  storage: CacheStorageAdapter,\n  config?: Partial<VerificationCacheConfig>\n): VerificationCacheService {\n  return new VerificationCacheService(storage, config);\n}\n"],"mappings":"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"}

package/dist/services/verification-cache/index.d.mts

@@ -0,0 +1,6 @@
+import { CacheEntryMeta, CacheKeyString, CacheLookupResult, CacheMissReason, CacheStats, CacheStorageAdapter, DEFAULT_CACHE_CONFIG, VerificationCacheConfig, VerificationCacheEntry, VerificationCacheKey } from "./types.mjs";
+import { VerificationCacheService, cacheKeyToString, computeContentHash, createVerificationCacheService, stringToCacheKey } from "./cache-service.mjs";
+import { InMemoryCacheStorage, createInMemoryCacheStorage } from "./adapters/in-memory.mjs";
+import { FileSystemCacheStorage, createFileSystemCacheStorage } from "./adapters/filesystem.mjs";
+import { KeyValueStore, WorkspaceStateCacheStorage, createWorkspaceStateCacheStorage } from "./adapters/workspace-state.mjs";
+import "./adapters/index.mjs";

package/dist/services/verification-cache/index.mjs

@@ -0,0 +1,8 @@
+import { DEFAULT_CACHE_CONFIG } from "./types.mjs";
+import { VerificationCacheService, cacheKeyToString, computeContentHash, createVerificationCacheService, stringToCacheKey } from "./cache-service.mjs";
+import { InMemoryCacheStorage, createInMemoryCacheStorage } from "./adapters/in-memory.mjs";
+import { FileSystemCacheStorage, createFileSystemCacheStorage } from "./adapters/filesystem.mjs";
+import { WorkspaceStateCacheStorage, createWorkspaceStateCacheStorage } from "./adapters/workspace-state.mjs";
+import "./adapters/index.mjs";
+
+export {  };

package/dist/services/verification-cache/types.d.mts

@@ -0,0 +1,124 @@
+import { VerificationReport, VerificationTier } from "@contractspec/lib.contracts/llm";
+
+//#region src/services/verification-cache/types.d.ts
+
+/**
+ * Cache key for verification results.
+ */
+interface VerificationCacheKey {
+  /** SHA256 hash of spec file content */
+  specHash: string;
+  /** SHA256 hash of implementation file content */
+  implHash: string;
+  /** Verification tier */
+  tier: VerificationTier;
+  /** AI model version (for AI tier, ensures cache invalidation on model change) */
+  aiModelVersion?: string;
+}
+/**
+ * Serializable cache key string.
+ */
+type CacheKeyString = string;
+/**
+ * Cache entry metadata.
+ */
+interface CacheEntryMeta {
+  /** When this entry was created */
+  createdAt: string;
+  /** When this entry expires (optional TTL) */
+  expiresAt?: string;
+  /** Paths to files that affect this result (for transitive invalidation) */
+  dependencies: string[];
+  /** Human-readable spec name for debugging */
+  specName?: string;
+  /** Human-readable impl path for debugging */
+  implPath?: string;
+}
+/**
+ * Full cache entry with result.
+ */
+interface VerificationCacheEntry {
+  /** The cache key */
+  key: VerificationCacheKey;
+  /** The verification result */
+  result: VerificationReport;
+  /** Entry metadata */
+  meta: CacheEntryMeta;
+}
+/**
+ * Cache lookup result.
+ */
+type CacheLookupResult = {
+  hit: true;
+  entry: VerificationCacheEntry;
+} | {
+  hit: false;
+  reason: CacheMissReason;
+};
+/**
+ * Reasons for cache miss.
+ */
+type CacheMissReason = 'not_found' | 'expired' | 'spec_changed' | 'impl_changed' | 'dependency_changed' | 'model_changed';
+/**
+ * Cache statistics.
+ */
+interface CacheStats {
+  /** Total entries in cache */
+  totalEntries: number;
+  /** Number of cache hits since startup */
+  hits: number;
+  /** Number of cache misses since startup */
+  misses: number;
+  /** Hit rate percentage (0-100) */
+  hitRate: number;
+  /** Estimated memory usage in bytes */
+  memoryUsage?: number;
+  /** Last time cache was pruned */
+  lastPruned?: string;
+}
+/**
+ * Cache configuration.
+ */
+interface VerificationCacheConfig {
+  /** Maximum number of entries to keep */
+  maxEntries?: number;
+  /** Default TTL in milliseconds (AI tier uses this) */
+  defaultTtlMs?: number;
+  /** TTL for structure tier (usually longer) */
+  structureTtlMs?: number;
+  /** TTL for behavior tier */
+  behaviorTtlMs?: number;
+  /** TTL for AI tier (usually shorter) */
+  aiTtlMs?: number;
+  /** Enable transitive invalidation */
+  transitiveInvalidation?: boolean;
+}
+/**
+ * Default cache configuration.
+ */
+declare const DEFAULT_CACHE_CONFIG: Required<VerificationCacheConfig>;
+/**
+ * Storage adapter interface for cache persistence.
+ */
+interface CacheStorageAdapter {
+  /** Get an entry by key */
+  get(key: CacheKeyString): Promise<VerificationCacheEntry | null>;
+  /** Set an entry */
+  set(key: CacheKeyString, entry: VerificationCacheEntry): Promise<void>;
+  /** Delete an entry */
+  delete(key: CacheKeyString): Promise<boolean>;
+  /** Check if key exists */
+  has(key: CacheKeyString): Promise<boolean>;
+  /** List all keys */
+  keys(): Promise<CacheKeyString[]>;
+  /** Clear all entries */
+  clear(): Promise<void>;
+  /** Get stats (optional) */
+  stats?(): Promise<{
+    entryCount: number;
+    memoryUsage?: number;
+  }>;
+}
+//#endregion
+export { CacheEntryMeta, CacheKeyString, CacheLookupResult, CacheMissReason, CacheStats, CacheStorageAdapter, DEFAULT_CACHE_CONFIG, VerificationCacheConfig, VerificationCacheEntry, VerificationCacheKey };
+//# sourceMappingURL=types.d.mts.map

package/dist/services/verification-cache/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../src/services/verification-cache/types.ts"],"sourcesContent":[],"mappings":";;;;AA0BA;AAKA;AAgBA;AAEO,UArCU,oBAAA,CAqCV;EAEG;EAEF,QAAA,EAAA,MAAA;EAAc;EAMV,QAAA,EAAA,MAAA;EAOA;EAWK,IAAA,EA3DT,gBA2DmB;EAkBV;EAkBJ,cAAA,CAAA,EAAA,MAOZ;AAKD;;;;AAIW,KAvGC,cAAA,GAuGD,MAAA;;;;AAEoB,UApGd,cAAA,CAoGc;EAEpB;EAAiB,SAAA,EAAA,MAAA;EAEV;EAAR,SAAA,CAAA,EAAA,MAAA;EAEC;EAEC,YAAA,EAAA,MAAA,EAAA;EAAO;;;;;;;;UA5FF,sBAAA;;OAEV;;UAEG;;QAEF;;;;;KAMI,iBAAA;;SACY;;;UACE;;;;;KAKd,eAAA;;;;UAWK,UAAA;;;;;;;;;;;;;;;;;UAkBA,uBAAA;;;;;;;;;;;;;;;;;cAkBJ,sBAAsB,SAAS;;;;UAY3B,mBAAA;;WAEN,iBAAiB,QAAQ;;WAEzB,uBAAuB,yBAAyB;;cAE7C,iBAAiB;;WAEpB,iBAAiB;;UAElB,QAAQ;;WAEP;;YAEC"}

package/dist/services/verification-cache/types.mjs

@@ -0,0 +1,16 @@
+//#region src/services/verification-cache/types.ts
+/**
+* Default cache configuration.
+*/
+const DEFAULT_CACHE_CONFIG = {
+	maxEntries: 1e3,
+	defaultTtlMs: 1440 * 60 * 1e3,
+	structureTtlMs: 10080 * 60 * 1e3,
+	behaviorTtlMs: 1440 * 60 * 1e3,
+	aiTtlMs: 1440 * 60 * 1e3,
+	transitiveInvalidation: true
+};
+
+//#endregion
+export { DEFAULT_CACHE_CONFIG };
+//# sourceMappingURL=types.mjs.map