@lssm/bundle.contractspec-workspace 0.0.0-canary-20251217060834 → 0.0.0-canary-20251217072406

package/dist/services/validate-implementation.js

@@ -1 +1,69 @@
-import{scanSpecSource as e}from"@lssm/module.contractspec-workspace";function t(e){return e.replace(/\./g,`-`).replace(/([a-z])([A-Z])/g,`$1-$2`).toLowerCase()}function n(e){return e.split(/[-_.]/).filter(Boolean).map(e=>e.charAt(0).toUpperCase()+e.slice(1)).join(``)}async function r(r,i,a,o={}){let{fs:s}=i,c=[],l=[];if(!await s.exists(r))return{valid:!1,errors:[`Spec file not found: ${r}`],warnings:[],expected:{}};let u=e(await s.readFile(r),r),d=u.name??s.basename(r).replace(/\.[jt]s$/,``),f=o.outputDir??a.outputDir??`./src`,p=t(d),m={};if(u.specType===`operation`&&(m.handlerPath=s.join(f,`handlers`,`${p}.handler.ts`),m.handlerTestPath=s.join(f,`handlers`,`${p}.handler.test.ts`)),u.specType===`presentation`&&(m.componentPath=s.join(f,`components`,`${p}.tsx`),m.componentTestPath=s.join(f,`components`,`${p}.test.tsx`)),u.specType===`form`&&(m.formPath=s.join(f,`forms`,`${p}.form.tsx`),m.formTestPath=s.join(f,`forms`,`${p}.form.test.tsx`)),o.checkHandlers&&m.handlerPath)if(!await s.exists(m.handlerPath))c.push(`Missing handler file: ${m.handlerPath}`);else{let e=await s.readFile(m.handlerPath),t=`${n(d.split(`.`).pop()??d)}Spec`,r=/ContractHandler<\s*typeof\s+\w+\s*>/.test(e),i=RegExp(`typeof\\s+${t}\\b`).test(e);r?i||l.push(`Handler ContractHandler typing does not reference expected spec var (${t}): ${m.handlerPath}`):l.push(`Handler does not appear to type itself as ContractHandler<typeof Spec>: ${m.handlerPath}`)}if(o.checkTests){let e=[m.handlerTestPath,m.componentTestPath,m.formTestPath].filter(e=>typeof e==`string`);for(let t of e)await s.exists(t)||c.push(`Missing test file: ${t}`)}return{valid:c.length===0,errors:c,warnings:l,expected:m}}export{r as validateImplementationFiles};
+import { scanSpecSource } from "../modules/contractspec-workspace/dist/analysis/spec-scan.js";
+
+//#region src/services/validate-implementation.ts
+/**
+* Implementation validation service (handlers + tests).
+*
+* Deterministic, static checks intended for reuse across CLI/VSCode/web tooling.
+* This does NOT execute spec modules.
+*/
+function toKebabCase(value) {
+	return value.replace(/\./g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function toPascalCase(value) {
+	return value.split(/[-_.]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+async function validateImplementationFiles(specFile, adapters, config, options = {}) {
+	const { fs } = adapters;
+	const errors = [];
+	const warnings = [];
+	if (!await fs.exists(specFile)) return {
+		valid: false,
+		errors: [`Spec file not found: ${specFile}`],
+		warnings: [],
+		expected: {}
+	};
+	const scan = scanSpecSource(await fs.readFile(specFile), specFile);
+	const specName = scan.name ?? fs.basename(specFile).replace(/\.[jt]s$/, "");
+	const outRoot = options.outputDir ?? config.outputDir ?? "./src";
+	const kebab = toKebabCase(specName);
+	const expected = {};
+	if (scan.specType === "operation") {
+		expected.handlerPath = fs.join(outRoot, "handlers", `${kebab}.handler.ts`);
+		expected.handlerTestPath = fs.join(outRoot, "handlers", `${kebab}.handler.test.ts`);
+	}
+	if (scan.specType === "presentation") {
+		expected.componentPath = fs.join(outRoot, "components", `${kebab}.tsx`);
+		expected.componentTestPath = fs.join(outRoot, "components", `${kebab}.test.tsx`);
+	}
+	if (scan.specType === "form") {
+		expected.formPath = fs.join(outRoot, "forms", `${kebab}.form.tsx`);
+		expected.formTestPath = fs.join(outRoot, "forms", `${kebab}.form.test.tsx`);
+	}
+	if (options.checkHandlers && expected.handlerPath) if (!await fs.exists(expected.handlerPath)) errors.push(`Missing handler file: ${expected.handlerPath}`);
+	else {
+		const handlerCode = await fs.readFile(expected.handlerPath);
+		const expectedSpecVar = `${toPascalCase(specName.split(".").pop() ?? specName)}Spec`;
+		const hasContractHandlerType = /ContractHandler<\s*typeof\s+\w+\s*>/.test(handlerCode);
+		const referencesExpectedSpec = (/* @__PURE__ */ new RegExp(`typeof\\s+${expectedSpecVar}\\b`)).test(handlerCode);
+		if (!hasContractHandlerType) warnings.push(`Handler does not appear to type itself as ContractHandler<typeof Spec>: ${expected.handlerPath}`);
+		else if (!referencesExpectedSpec) warnings.push(`Handler ContractHandler typing does not reference expected spec var (${expectedSpecVar}): ${expected.handlerPath}`);
+	}
+	if (options.checkTests) {
+		const candidateTests = [
+			expected.handlerTestPath,
+			expected.componentTestPath,
+			expected.formTestPath
+		].filter((p) => typeof p === "string");
+		for (const testPath of candidateTests) if (!await fs.exists(testPath)) errors.push(`Missing test file: ${testPath}`);
+	}
+	return {
+		valid: errors.length === 0,
+		errors,
+		warnings,
+		expected
+	};
+}
+
+//#endregion
+export { validateImplementationFiles };

package/dist/services/validate.js

@@ -1 +1,47 @@
-import{validateSpecStructure as e}from"@lssm/module.contractspec-workspace";async function t(t,n,r={}){let{fs:i}=n;if(!await i.exists(t))return{valid:!1,errors:[`Spec file not found: ${t}`],warnings:[]};let a=await i.readFile(t),o=i.basename(t),s=[],c=[],l;return r.skipStructure||(l=e(a,o),s.push(...l.errors),c.push(...l.warnings)),{valid:s.length===0,structureResult:l,errors:s,warnings:c}}async function n(e,n,r={}){let i=new Map;for(let a of e){let e=await t(a,n,r);i.set(a,e)}return i}export{t as validateSpec,n as validateSpecs};
+import { validateSpecStructure } from "../modules/contractspec-workspace/dist/analysis/validate/spec-structure.js";
+
+//#region src/services/validate.ts
+/**
+* Validation service.
+*/
+/**
+* Validate a spec file.
+*/
+async function validateSpec(specFile, adapters, options = {}) {
+	const { fs } = adapters;
+	if (!await fs.exists(specFile)) return {
+		valid: false,
+		errors: [`Spec file not found: ${specFile}`],
+		warnings: []
+	};
+	const specCode = await fs.readFile(specFile);
+	const fileName = fs.basename(specFile);
+	const allErrors = [];
+	const allWarnings = [];
+	let structureResult;
+	if (!options.skipStructure) {
+		structureResult = validateSpecStructure(specCode, fileName);
+		allErrors.push(...structureResult.errors);
+		allWarnings.push(...structureResult.warnings);
+	}
+	return {
+		valid: allErrors.length === 0,
+		structureResult,
+		errors: allErrors,
+		warnings: allWarnings
+	};
+}
+/**
+* Validate multiple spec files.
+*/
+async function validateSpecs(specFiles, adapters, options = {}) {
+	const results = /* @__PURE__ */ new Map();
+	for (const specFile of specFiles) {
+		const result = await validateSpec(specFile, adapters, options);
+		results.set(specFile, result);
+	}
+	return results;
+}
+
+//#endregion
+export { validateSpec, validateSpecs };

package/dist/services/verification-cache/adapters/filesystem.js

@@ -1 +1,121 @@
-import{__require as e}from"../../../_virtual/rolldown_runtime.js";import{dirname as t,join as n}from"path";import{existsSync as r,mkdirSync as i,readFileSync as a,statSync as o,writeFileSync as s}from"fs";var c=class{filePath;cache;isDirty=!1;constructor(e,t){let r=t??process.cwd();this.filePath=e??n(r,`.contractspec/verification-cache.json`),this.cache=new Map,this.loadSync()}loadSync(){try{if(!r(this.filePath))return;let e=a(this.filePath,`utf-8`),t=JSON.parse(e);if(t.version!==1)return;for(let[e,n]of Object.entries(t.entries))this.cache.set(e,n)}catch{}}saveSync(){if(this.isDirty)try{let n=t(this.filePath);r(n)||i(n,{recursive:!0});let a={version:1,entries:Object.fromEntries(this.cache.entries())},o=`${this.filePath}.tmp`;s(o,JSON.stringify(a,null,2),`utf-8`);let{renameSync:c}=e(`fs`);c(o,this.filePath),this.isDirty=!1}catch{}}async get(e){return this.cache.get(e)??null}async set(e,t){this.cache.set(e,t),this.isDirty=!0,this.saveSync()}async delete(e){let t=this.cache.delete(e);return t&&(this.isDirty=!0,this.saveSync()),t}async has(e){return this.cache.has(e)}async keys(){return Array.from(this.cache.keys())}async clear(){this.cache.clear(),this.isDirty=!0,this.saveSync()}async stats(){let e=0;try{r(this.filePath)&&(e=o(this.filePath).size)}catch{}return{entryCount:this.cache.size,memoryUsage:e}}flush(){this.saveSync()}reload(){this.cache.clear(),this.loadSync(),this.isDirty=!1}};function l(e,t){return new c(e,t)}export{c as FileSystemCacheStorage,l as createFileSystemCacheStorage};
+import { __require } from "../../../_virtual/rolldown_runtime.js";
+import { dirname, join } from "path";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+
+//#region src/services/verification-cache/adapters/filesystem.ts
+/**
+* Filesystem cache storage adapter.
+*
+* Stores cache entries in a JSON file for CLI and CI environments.
+* Uses atomic writes to prevent corruption.
+*/
+/**
+* Default cache file location.
+*/
+const DEFAULT_CACHE_FILE = ".contractspec/verification-cache.json";
+const CURRENT_VERSION = 1;
+/**
+* Filesystem storage adapter.
+*/
+var FileSystemCacheStorage = class {
+	filePath;
+	cache;
+	isDirty = false;
+	constructor(filePath, workspaceRoot) {
+		const root = workspaceRoot ?? process.cwd();
+		this.filePath = filePath ?? join(root, DEFAULT_CACHE_FILE);
+		this.cache = /* @__PURE__ */ new Map();
+		this.loadSync();
+	}
+	/**
+	* Load cache from disk synchronously.
+	*/
+	loadSync() {
+		try {
+			if (!existsSync(this.filePath)) return;
+			const content = readFileSync(this.filePath, "utf-8");
+			const data = JSON.parse(content);
+			if (data.version !== CURRENT_VERSION) return;
+			for (const [key, entry] of Object.entries(data.entries)) this.cache.set(key, entry);
+		} catch {}
+	}
+	/**
+	* Save cache to disk.
+	*/
+	saveSync() {
+		if (!this.isDirty) return;
+		try {
+			const dir = dirname(this.filePath);
+			if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+			const data = {
+				version: CURRENT_VERSION,
+				entries: Object.fromEntries(this.cache.entries())
+			};
+			const tempPath = `${this.filePath}.tmp`;
+			writeFileSync(tempPath, JSON.stringify(data, null, 2), "utf-8");
+			const { renameSync } = __require("fs");
+			renameSync(tempPath, this.filePath);
+			this.isDirty = false;
+		} catch {}
+	}
+	async get(key) {
+		return this.cache.get(key) ?? null;
+	}
+	async set(key, entry) {
+		this.cache.set(key, entry);
+		this.isDirty = true;
+		this.saveSync();
+	}
+	async delete(key) {
+		const existed = this.cache.delete(key);
+		if (existed) {
+			this.isDirty = true;
+			this.saveSync();
+		}
+		return existed;
+	}
+	async has(key) {
+		return this.cache.has(key);
+	}
+	async keys() {
+		return Array.from(this.cache.keys());
+	}
+	async clear() {
+		this.cache.clear();
+		this.isDirty = true;
+		this.saveSync();
+	}
+	async stats() {
+		let fileSize = 0;
+		try {
+			if (existsSync(this.filePath)) fileSize = statSync(this.filePath).size;
+		} catch {}
+		return {
+			entryCount: this.cache.size,
+			memoryUsage: fileSize
+		};
+	}
+	/**
+	* Force save any pending changes.
+	*/
+	flush() {
+		this.saveSync();
+	}
+	/**
+	* Reload cache from disk.
+	*/
+	reload() {
+		this.cache.clear();
+		this.loadSync();
+		this.isDirty = false;
+	}
+};
+/**
+* Create a filesystem cache storage adapter.
+*/
+function createFileSystemCacheStorage(filePath, workspaceRoot) {
+	return new FileSystemCacheStorage(filePath, workspaceRoot);
+}
+
+//#endregion
+export { FileSystemCacheStorage, createFileSystemCacheStorage };

package/dist/services/verification-cache/adapters/in-memory.js

@@ -1 +1,45 @@
-var e=class{cache=new Map;async get(e){return this.cache.get(e)??null}async set(e,t){this.cache.set(e,t)}async delete(e){return this.cache.delete(e)}async has(e){return this.cache.has(e)}async keys(){return Array.from(this.cache.keys())}async clear(){this.cache.clear()}async stats(){let e=0;for(let[t,n]of this.cache.entries())e+=t.length*2,e+=JSON.stringify(n).length*2;return{entryCount:this.cache.size,memoryUsage:e}}};function t(){return new e}export{e as InMemoryCacheStorage,t as createInMemoryCacheStorage};
+//#region src/services/verification-cache/adapters/in-memory.ts
+/**
+* In-memory storage adapter using a Map.
+*/
+var InMemoryCacheStorage = class {
+	cache = /* @__PURE__ */ new Map();
+	async get(key) {
+		return this.cache.get(key) ?? null;
+	}
+	async set(key, entry) {
+		this.cache.set(key, entry);
+	}
+	async delete(key) {
+		return this.cache.delete(key);
+	}
+	async has(key) {
+		return this.cache.has(key);
+	}
+	async keys() {
+		return Array.from(this.cache.keys());
+	}
+	async clear() {
+		this.cache.clear();
+	}
+	async stats() {
+		let memoryUsage = 0;
+		for (const [key, value] of this.cache.entries()) {
+			memoryUsage += key.length * 2;
+			memoryUsage += JSON.stringify(value).length * 2;
+		}
+		return {
+			entryCount: this.cache.size,
+			memoryUsage
+		};
+	}
+};
+/**
+* Create an in-memory cache storage adapter.
+*/
+function createInMemoryCacheStorage() {
+	return new InMemoryCacheStorage();
+}
+
+//#endregion
+export { InMemoryCacheStorage, createInMemoryCacheStorage };

package/dist/services/verification-cache/adapters/index.js

@@ -1 +1,3 @@
-import{InMemoryCacheStorage as e,createInMemoryCacheStorage as t}from"./in-memory.js";import{FileSystemCacheStorage as n,createFileSystemCacheStorage as r}from"./filesystem.js";import{WorkspaceStateCacheStorage as i,createWorkspaceStateCacheStorage as a}from"./workspace-state.js";
+import { InMemoryCacheStorage, createInMemoryCacheStorage } from "./in-memory.js";
+import { FileSystemCacheStorage, createFileSystemCacheStorage } from "./filesystem.js";
+import { WorkspaceStateCacheStorage, createWorkspaceStateCacheStorage } from "./workspace-state.js";

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

@@ -1 +1,90 @@
-const e=`contractspec.verification-cache.`,t=`${e}__index__`;var n=class{store;keyIndex;constructor(e){this.store=e,this.keyIndex=new Set(this.loadKeyIndex())}loadKeyIndex(){try{return this.store.get(t)??[]}catch{return[]}}async saveKeyIndex(){await this.store.update(t,Array.from(this.keyIndex))}getStorageKey(t){return`${e}${t}`}async get(e){let t=this.getStorageKey(e);return this.store.get(t)??null}async set(e,t){let n=this.getStorageKey(e);await this.store.update(n,t),this.keyIndex.has(e)||(this.keyIndex.add(e),await this.saveKeyIndex())}async delete(e){let t=this.getStorageKey(e),n=this.keyIndex.has(e);return n&&(await this.store.update(t,void 0),this.keyIndex.delete(e),await this.saveKeyIndex()),n}async has(e){return this.keyIndex.has(e)}async keys(){return Array.from(this.keyIndex)}async clear(){for(let e of this.keyIndex){let t=this.getStorageKey(e);await this.store.update(t,void 0)}this.keyIndex.clear(),await this.saveKeyIndex()}async stats(){return{entryCount:this.keyIndex.size}}};function r(e){return new n(e)}export{n as WorkspaceStateCacheStorage,r as createWorkspaceStateCacheStorage};
+//#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 };

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

@@ -1 +1,255 @@
-import{DEFAULT_CACHE_CONFIG as e}from"./types.js";import{createHash as t}from"crypto";function n(e){return t(`sha256`).update(e).digest(`hex`)}function r(e){let t=[`spec:${e.specHash.substring(0,16)}`,`impl:${e.implHash.substring(0,16)}`,`tier:${e.tier}`];return e.aiModelVersion&&t.push(`model:${e.aiModelVersion}`),t.join(`|`)}function i(e){try{let t=e.split(`|`),n=new Map;for(let e of t){let[t,r]=e.split(`:`);t&&r&&n.set(t,r)}let r=n.get(`spec`),i=n.get(`impl`),a=n.get(`tier`);return!r||!i||!a?null:{specHash:r,implHash:i,tier:a,aiModelVersion:n.get(`model`)}}catch{return null}}function a(e,t){switch(e){case`structure`:return t.structureTtlMs;case`behavior`:return t.behaviorTtlMs;case`ai_review`:return t.aiTtlMs;default:return t.defaultTtlMs}}var o=class{storage;config;stats;constructor(t,n={}){this.storage=t,this.config={...e,...n},this.stats={hits:0,misses:0}}createKey(e,t,r,i){return{specHash:n(e),implHash:n(t),tier:r,aiModelVersion:r===`ai_review`?i:void 0}}async lookup(e){let t=r(e),n=await this.storage.get(t);if(!n)return this.stats.misses++,{hit:!1,reason:`not_found`};if(n.meta.expiresAt){let e=new Date(n.meta.expiresAt).getTime();if(Date.now()>e)return this.stats.misses++,await this.storage.delete(t),{hit:!1,reason:`expired`}}return n.key.specHash===e.specHash?n.key.implHash===e.implHash?e.tier===`ai_review`&&e.aiModelVersion&&n.key.aiModelVersion!==e.aiModelVersion?(this.stats.misses++,{hit:!1,reason:`model_changed`}):(this.stats.hits++,{hit:!0,entry:n}):(this.stats.misses++,{hit:!1,reason:`impl_changed`}):(this.stats.misses++,{hit:!1,reason:`spec_changed`})}async store(e,t,n={}){let i=r(e),o=a(e.tier,this.config),s={key:e,result:t,meta:{createdAt:new Date().toISOString(),expiresAt:new Date(Date.now()+o).toISOString(),dependencies:n.dependencies??[],specName:n.specName,implPath:n.implPath}};await this.storage.set(i,s),await this.pruneIfNeeded()}async invalidateForFile(e){if(!this.config.transitiveInvalidation)return 0;let t=await this.storage.keys(),n=0;for(let r of t){let t=await this.storage.get(r);t&&(t.meta.dependencies.includes(e)&&(await this.storage.delete(r),n++),(t.meta.specName===e||t.meta.implPath===e)&&(await this.storage.delete(r),n++))}return n}async invalidateForSpec(e){let t=await this.storage.keys(),n=0;for(let r of t){let t=i(r);t&&t.specHash.startsWith(e.substring(0,16))&&(await this.storage.delete(r),n++)}return n}async clear(){await this.storage.clear(),this.stats={hits:0,misses:0}}async getStats(){let e=await this.storage.stats?.();return{totalEntries:e?.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:e?.memoryUsage}}async pruneIfNeeded(){let e=await this.storage.keys();if(e.length<=this.config.maxEntries)return;let t=[];for(let n of e){let e=await this.storage.get(n);e&&t.push({key:n,createdAt:new Date(e.meta.createdAt).getTime()})}t.sort((e,t)=>e.createdAt-t.createdAt);let n=t.length-this.config.maxEntries;for(let e=0;e<n;e++){let n=t[e];n&&await this.storage.delete(n.key)}}};function s(e,t){return new o(e,t)}export{o as VerificationCacheService,r as cacheKeyToString,n as computeContentHash,s as createVerificationCacheService,i as stringToCacheKey};
+import { DEFAULT_CACHE_CONFIG } from "./types.js";
+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 };

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

@@ -1 +1,6 @@
-import{DEFAULT_CACHE_CONFIG as e}from"./types.js";import{VerificationCacheService as t,cacheKeyToString as n,computeContentHash as r,createVerificationCacheService as i,stringToCacheKey as a}from"./cache-service.js";import{InMemoryCacheStorage as o,createInMemoryCacheStorage as s}from"./adapters/in-memory.js";import{FileSystemCacheStorage as c,createFileSystemCacheStorage as l}from"./adapters/filesystem.js";import{WorkspaceStateCacheStorage as u,createWorkspaceStateCacheStorage as d}from"./adapters/workspace-state.js";import"./adapters/index.js";
+import { DEFAULT_CACHE_CONFIG } from "./types.js";
+import { VerificationCacheService, cacheKeyToString, computeContentHash, createVerificationCacheService, stringToCacheKey } from "./cache-service.js";
+import { InMemoryCacheStorage, createInMemoryCacheStorage } from "./adapters/in-memory.js";
+import { FileSystemCacheStorage, createFileSystemCacheStorage } from "./adapters/filesystem.js";
+import { WorkspaceStateCacheStorage, createWorkspaceStateCacheStorage } from "./adapters/workspace-state.js";
+import "./adapters/index.js";

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

@@ -1 +1,15 @@
-const e={maxEntries:1e3,defaultTtlMs:1440*60*1e3,structureTtlMs:10080*60*1e3,behaviorTtlMs:1440*60*1e3,aiTtlMs:1440*60*1e3,transitiveInvalidation:!0};export{e as DEFAULT_CACHE_CONFIG};
+//#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 };