@lssm/bundle.contractspec-workspace 0.0.0-canary-20251217083314 → 0.0.0-canary-20251219202229

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

@@ -1,255 +0,0 @@
-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,6 +0,0 @@
-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,15 +0,0 @@
-//#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 };

package/dist/services/verify/ai-verifier.js

@@ -1,403 +0,0 @@
-import { generateVerificationPrompt } from "../../libs/contracts/dist/llm/prompts.js";
-import "../../libs/contracts/dist/llm/index.js";
-
-//#region src/services/verify/ai-verifier.ts
-/**
-* Parse AI response to structured result.
-*/
-function parseAIResponse(response) {
-	const jsonMatch = response.match(/```json\n?([\s\S]*?)\n?```/);
-	if (jsonMatch?.[1]) try {
-		const parsed = JSON.parse(jsonMatch[1]);
-		return {
-			compliant: parsed.passed ?? false,
-			confidence: (parsed.score ?? 0) / 100,
-			findings: (parsed.issues ?? []).map((issue) => ({
-				category: String(issue.category ?? "semantic"),
-				severity: String(issue.severity ?? "warning"),
-				message: String(issue.message ?? ""),
-				location: issue.location ? String(issue.location) : void 0,
-				suggestion: issue.suggestion ? String(issue.suggestion) : void 0
-			})),
-			rawResponse: response
-		};
-	} catch {}
-	const findings = [];
-	const lines = response.split("\n");
-	let currentSeverity = "info";
-	for (const line of lines) {
-		const lineLower = line.toLowerCase();
-		if (lineLower.includes("error") || lineLower.includes("critical")) currentSeverity = "error";
-		else if (lineLower.includes("warning") || lineLower.includes("should")) currentSeverity = "warning";
-		else if (lineLower.includes("info") || lineLower.includes("note")) currentSeverity = "info";
-		const bulletMatch = line.match(/^[-*•]\s*(.+)$/);
-		const numberedMatch = line.match(/^\d+\.\s*(.+)$/);
-		if (bulletMatch || numberedMatch) {
-			const content = bulletMatch?.[1] ?? numberedMatch?.[1] ?? "";
-			if (content.length > 10) findings.push({
-				category: "semantic",
-				severity: currentSeverity,
-				message: content
-			});
-		}
-	}
-	const hasErrors = findings.some((f) => f.severity === "error");
-	return {
-		compliant: !hasErrors,
-		confidence: hasErrors ? .3 : findings.length === 0 ? .9 : .7,
-		findings,
-		rawResponse: response
-	};
-}
-/**
-* Call AI provider for verification.
-* This is a placeholder - actual implementation would use AI SDK.
-*/
-async function callAI(prompt, config) {
-	if (!config.aiApiKey) return `\`\`\`json
-{
-  "passed": true,
-  "score": 50,
-  "compliance": {
-    "inputTypes": { "match": true, "issues": [] },
-    "outputTypes": { "match": true, "issues": [] },
-    "errorHandling": { "coverage": "unknown", "missing": [] },
-    "eventEmission": { "correct": true, "issues": [] },
-    "policyCompliance": { "auth": true, "rateLimit": true, "pii": true }
-  },
-  "scenarios": [],
-  "issues": [
-    { "severity": "info", "category": "semantic", "message": "AI verification not available - configure AI API key for full analysis" }
-  ],
-  "summary": "AI verification skipped - no API key configured. Structure and behavior checks have been performed."
-}
-\`\`\``;
-	try {
-		const provider = config.aiProvider ?? "anthropic";
-		if (provider === "anthropic") {
-			const { anthropic } = await import("@ai-sdk/anthropic");
-			const { generateText } = await import("ai");
-			return (await generateText({
-				model: anthropic("claude-3-5-sonnet-20241022"),
-				prompt,
-				system: "You are an expert code reviewer analyzing implementation compliance with specifications. Respond with structured JSON."
-			})).text;
-		} else if (provider === "openai") {
-			const { openai } = await import("@ai-sdk/openai");
-			const { generateText } = await import("ai");
-			return (await generateText({
-				model: openai("gpt-4o"),
-				prompt,
-				system: "You are an expert code reviewer analyzing implementation compliance with specifications. Respond with structured JSON."
-			})).text;
-		}
-		throw new Error(`Unknown AI provider: ${provider}`);
-	} catch (error) {
-		return `\`\`\`json
-{
-  "passed": false,
-  "score": 0,
-  "issues": [
-    { "severity": "error", "category": "semantic", "message": "AI verification failed: ${error instanceof Error ? error.message : "Unknown error"}" }
-  ],
-  "summary": "AI verification encountered an error"
-}
-\`\`\``;
-	}
-}
-/**
-* Run AI-powered verification.
-*/
-async function verifyWithAI(input, config = {}) {
-	const { spec, implementationCode, implementationPath } = input;
-	const startTime = Date.now();
-	const result = parseAIResponse(await callAI(generateVerificationPrompt(spec, implementationCode).taskPrompt, config));
-	const issues = result.findings.map((f) => ({
-		severity: f.severity,
-		category: "semantic",
-		message: f.message,
-		location: f.location ? { file: f.location } : implementationPath ? { file: implementationPath } : void 0,
-		suggestion: f.suggestion
-	}));
-	const score = Math.round(result.confidence * 100);
-	const passed = result.compliant;
-	return {
-		tier: "ai_review",
-		passed,
-		score,
-		issues,
-		suggestions: result.findings.filter((f) => f.suggestion).map((f) => f.suggestion),
-		coverage: {
-			scenarios: {
-				total: 0,
-				covered: 0
-			},
-			errors: {
-				total: 0,
-				handled: 0
-			},
-			fields: {
-				total: 1,
-				implemented: passed ? 1 : 0
-			}
-		},
-		meta: {
-			specName: spec.meta.name,
-			specVersion: spec.meta.version,
-			implementationPath: implementationPath ?? "unknown",
-			verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			duration: Date.now() - startTime
-		}
-	};
-}
-/**
-* Create a simpler AI review without calling the API.
-* Used as fallback or for quick checks.
-*/
-function createQuickAIReview(input) {
-	const { spec, implementationCode, implementationPath } = input;
-	const startTime = Date.now();
-	const issues = [];
-	if (implementationCode.includes("console.log")) issues.push({
-		severity: "warning",
-		category: "semantic",
-		message: "Console.log statements found - consider using proper logging",
-		suggestion: "Use a structured logger instead of console.log"
-	});
-	if (implementationCode.includes("// TODO") || implementationCode.includes("// FIXME")) issues.push({
-		severity: "info",
-		category: "semantic",
-		message: "TODO/FIXME comments found - implementation may be incomplete",
-		suggestion: "Address TODO items before finalizing implementation"
-	});
-	if (spec.policy.auth !== "anonymous" && !implementationCode.includes("auth")) issues.push({
-		severity: "warning",
-		category: "semantic",
-		message: `Spec requires ${spec.policy.auth} auth but no auth check found`,
-		suggestion: "Add authentication check at the handler entry point"
-	});
-	const score = issues.filter((i) => i.severity === "error").length === 0 ? 80 : 40;
-	const passed = issues.filter((i) => i.severity === "error").length === 0;
-	return {
-		tier: "ai_review",
-		passed,
-		score,
-		issues,
-		suggestions: issues.filter((i) => i.suggestion).map((i) => i.suggestion),
-		coverage: {
-			scenarios: {
-				total: 0,
-				covered: 0
-			},
-			errors: {
-				total: 0,
-				handled: 0
-			},
-			fields: {
-				total: 1,
-				implemented: passed ? 1 : 0
-			}
-		},
-		meta: {
-			specName: spec.meta.name,
-			specVersion: spec.meta.version,
-			implementationPath: implementationPath ?? "unknown",
-			verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			duration: Date.now() - startTime
-		}
-	};
-}
-/**
-* Generate a prompt for semantic field verification.
-*/
-function generateSemanticFieldPrompt(specFields, implCode) {
-	return `You are analyzing a code implementation against its specification.
-
-## Spec Schema Fields
-${specFields}
-
-## Implementation Code
-\`\`\`typescript
-${implCode}
-\`\`\`
-
-## Task
-Analyze the implementation to verify it correctly implements the spec schema fields.
-
-For each field in the spec:
-1. Find the corresponding field/property in the implementation
-2. Determine if the naming matches (exact, compatible synonym, or mismatch)
-3. Check if the types are compatible
-4. Identify any missing fields
-
-Respond with JSON in this format:
-\`\`\`json
-{
-  "fieldMappings": [
-    {
-      "specField": "nickname",
-      "specType": "string",
-      "implementationField": "username",
-      "implementationType": "string",
-      "match": "compatible",
-      "aiConfidence": 0.85,
-      "suggestion": "Consider renaming 'username' to 'nickname' for exact spec compliance"
-    }
-  ],
-  "intentAlignment": {
-    "score": 85,
-    "issues": ["Field naming differs from spec"],
-    "suggestions": ["Rename fields to match spec exactly for better maintainability"]
-  },
-  "semanticIssues": []
-}
-\`\`\`
-
-Match types:
-- "exact": Field name and type match exactly
-- "compatible": Semantically similar (e.g., "email" vs "emailAddress")
-- "mismatch": Different meaning despite similar naming
-- "missing": Spec field not found in implementation
-`;
-}
-/**
-* Extract field definitions from spec schema.
-*/
-function extractSpecFields(spec) {
-	const fields = [];
-	/**
-	* Helper to safely extract fields from a schema.
-	*/
-	const extractFromSchema = (schema, direction) => {
-		try {
-			const shapeFn = schema?._def?.shape;
-			if (shapeFn && typeof shapeFn === "function") {
-				const shapeObj = shapeFn();
-				for (const [key, value] of Object.entries(shapeObj)) {
-					const typeName = value?._def?.typeName ?? "unknown";
-					fields.push(`- ${key}: ${String(typeName).replace("Zod", "").toLowerCase()} (${direction})`);
-				}
-			}
-		} catch {
-			fields.push(`- [unable to extract ${direction} fields]`);
-		}
-	};
-	if (spec.io.input) extractFromSchema(spec.io.input, "input");
-	if (spec.io.output && !("resourceRef" in spec.io.output)) extractFromSchema(spec.io.output, "output");
-	if (fields.length === 0) return "- [no schema fields could be extracted]";
-	return fields.join("\n");
-}
-/**
-* Parse semantic verification response from AI.
-*/
-function parseSemanticResponse(response) {
-	const jsonMatch = response.match(/```json\n?([\s\S]*?)\n?```/);
-	if (jsonMatch?.[1]) try {
-		const parsed = JSON.parse(jsonMatch[1]);
-		return {
-			fieldMappings: (parsed.fieldMappings ?? []).map((m) => ({
-				specField: String(m.specField ?? ""),
-				specType: String(m.specType ?? "unknown"),
-				implementationField: m.implementationField ? String(m.implementationField) : void 0,
-				implementationType: m.implementationType ? String(m.implementationType) : void 0,
-				match: m.match ?? "missing",
-				aiConfidence: typeof m.aiConfidence === "number" ? m.aiConfidence : .5,
-				suggestion: m.suggestion ? String(m.suggestion) : void 0
-			})),
-			intentAlignment: {
-				score: typeof parsed.intentAlignment?.score === "number" ? parsed.intentAlignment.score : 50,
-				issues: Array.isArray(parsed.intentAlignment?.issues) ? parsed.intentAlignment.issues : [],
-				suggestions: Array.isArray(parsed.intentAlignment?.suggestions) ? parsed.intentAlignment.suggestions : []
-			},
-			semanticIssues: (parsed.semanticIssues ?? []).map((i) => ({
-				category: String(i.category ?? "semantic"),
-				severity: i.severity ?? "warning",
-				message: String(i.message ?? ""),
-				suggestion: i.suggestion ? String(i.suggestion) : void 0
-			})),
-			rawResponse: response
-		};
-	} catch {}
-	return {
-		fieldMappings: [],
-		intentAlignment: {
-			score: 50,
-			issues: ["Unable to parse AI response for semantic analysis"],
-			suggestions: []
-		},
-		semanticIssues: [],
-		rawResponse: response
-	};
-}
-/**
-* Run semantic field-level verification using AI.
-*/
-async function verifySemanticFields(input, config = {}) {
-	const { spec, implementationCode } = input;
-	return parseSemanticResponse(await callAI(generateSemanticFieldPrompt(extractSpecFields(spec), implementationCode), config));
-}
-/**
-* Run enhanced AI verification with semantic field analysis.
-*/
-async function verifyWithAIEnhanced(input, config = {}) {
-	const { spec, implementationCode, implementationPath } = input;
-	const startTime = Date.now();
-	const baseReport = await verifyWithAI(input, config);
-	let semanticResult;
-	if (config.aiApiKey) try {
-		semanticResult = await verifySemanticFields(input, config);
-	} catch {}
-	if (semanticResult) {
-		const semanticIssues = [];
-		for (const mapping of semanticResult.fieldMappings) if (mapping.match === "missing") semanticIssues.push({
-			severity: "error",
-			category: "semantic",
-			message: `Missing field: '${mapping.specField}' (${mapping.specType}) not found in implementation`,
-			suggestion: mapping.suggestion ?? `Add field '${mapping.specField}' to implementation`
-		});
-		else if (mapping.match === "mismatch") semanticIssues.push({
-			severity: "warning",
-			category: "semantic",
-			message: `Field mismatch: '${mapping.specField}' has incorrect implementation as '${mapping.implementationField}'`,
-			suggestion: mapping.suggestion
-		});
-		else if (mapping.match === "compatible" && mapping.aiConfidence < .8) semanticIssues.push({
-			severity: "info",
-			category: "semantic",
-			message: `Field naming: '${mapping.specField}' implemented as '${mapping.implementationField}' (compatible but not exact)`,
-			suggestion: mapping.suggestion
-		});
-		for (const issue of semanticResult.intentAlignment.issues) semanticIssues.push({
-			severity: "warning",
-			category: "semantic",
-			message: issue
-		});
-		for (const issue of semanticResult.semanticIssues) semanticIssues.push({
-			severity: issue.severity,
-			category: "semantic",
-			message: issue.message,
-			suggestion: issue.suggestion
-		});
-		baseReport.issues = [...baseReport.issues, ...semanticIssues];
-		const totalFields = semanticResult.fieldMappings.length;
-		const implementedFields = semanticResult.fieldMappings.filter((m) => m.match === "exact" || m.match === "compatible").length;
-		if (totalFields > 0) {
-			const fieldScore = Math.round(implementedFields / totalFields * 100);
-			baseReport.score = Math.round((baseReport.score + fieldScore) / 2);
-			baseReport.coverage.fields = {
-				total: totalFields,
-				implemented: implementedFields
-			};
-		}
-		if (semanticIssues.some((i) => i.severity === "error")) baseReport.passed = false;
-		baseReport.suggestions = [...baseReport.suggestions, ...semanticResult.intentAlignment.suggestions];
-	}
-	baseReport.meta = {
-		...baseReport.meta,
-		duration: Date.now() - startTime
-	};
-	return baseReport;
-}
-
-//#endregion
-export { createQuickAIReview, verifySemanticFields, verifyWithAI, verifyWithAIEnhanced };