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

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

@@ -1,5 +1,60 @@
-import{generateVerificationPrompt as e,specToFullMarkdown as t}from"@lssm/lib.contracts/llm";function n(e){let t=e.match(/```json\n?([\s\S]*?)\n?```/);if(t?.[1])try{let n=JSON.parse(t[1]);return{compliant:n.passed??!1,confidence:(n.score??0)/100,findings:(n.issues??[]).map(e=>({category:String(e.category??`semantic`),severity:String(e.severity??`warning`),message:String(e.message??``),location:e.location?String(e.location):void 0,suggestion:e.suggestion?String(e.suggestion):void 0})),rawResponse:e}}catch{}let n=[],r=e.split(`
-`),i=`info`;for(let e of r){let t=e.toLowerCase();t.includes(`error`)||t.includes(`critical`)?i=`error`:t.includes(`warning`)||t.includes(`should`)?i=`warning`:(t.includes(`info`)||t.includes(`note`))&&(i=`info`);let r=e.match(/^[-*•]\s*(.+)$/),a=e.match(/^\d+\.\s*(.+)$/);if(r||a){let e=r?.[1]??a?.[1]??``;e.length>10&&n.push({category:`semantic`,severity:i,message:e})}}let a=n.some(e=>e.severity===`error`);return{compliant:!a,confidence:a?.3:n.length===0?.9:.7,findings:n,rawResponse:e}}async function r(e,t){if(!t.aiApiKey)return`\`\`\`json
+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,
@@ -16,23 +71,154 @@ import{generateVerificationPrompt as e,specToFullMarkdown as t}from"@lssm/lib.co
   ],
   "summary": "AI verification skipped - no API key configured. Structure and behavior checks have been performed."
 }
-\`\`\``;try{let n=t.aiProvider??`anthropic`;if(n===`anthropic`){let{anthropic:t}=await import(`../../node_modules/@ai-sdk/anthropic/dist/index.js`),{generateText:n}=await import(`ai`);return(await n({model:t(`claude-3-5-sonnet-20241022`),prompt:e,system:`You are an expert code reviewer analyzing implementation compliance with specifications. Respond with structured JSON.`})).text}else if(n===`openai`){let{openai:t}=await import(`../../node_modules/@ai-sdk/openai/dist/index.js`),{generateText:n}=await import(`ai`);return(await n({model:t(`gpt-4o`),prompt:e,system:`You are an expert code reviewer analyzing implementation compliance with specifications. Respond with structured JSON.`})).text}throw Error(`Unknown AI provider: ${n}`)}catch(e){return`\`\`\`json
+\`\`\``;
+	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: ${e instanceof Error?e.message:`Unknown error`}" }
+    { "severity": "error", "category": "semantic", "message": "AI verification failed: ${error instanceof Error ? error.message : "Unknown error"}" }
   ],
   "summary": "AI verification encountered an error"
 }
-\`\`\``}}async function i(t,i={}){let{spec:a,implementationCode:o,implementationPath:s}=t,c=Date.now(),l=n(await r(e(a,o).taskPrompt,i)),u=l.findings.map(e=>({severity:e.severity,category:`semantic`,message:e.message,location:e.location?{file:e.location}:s?{file:s}:void 0,suggestion:e.suggestion})),d=Math.round(l.confidence*100),f=l.compliant;return{tier:`ai_review`,passed:f,score:d,issues:u,suggestions:l.findings.filter(e=>e.suggestion).map(e=>e.suggestion),coverage:{scenarios:{total:0,covered:0},errors:{total:0,handled:0},fields:{total:1,implemented:f?1:0}},meta:{specName:a.meta.name,specVersion:a.meta.version,implementationPath:s??`unknown`,verifiedAt:new Date().toISOString(),duration:Date.now()-c}}}function a(e){let{spec:t,implementationCode:n,implementationPath:r}=e,i=Date.now(),a=[];n.includes(`console.log`)&&a.push({severity:`warning`,category:`semantic`,message:`Console.log statements found - consider using proper logging`,suggestion:`Use a structured logger instead of console.log`}),(n.includes(`// TODO`)||n.includes(`// FIXME`))&&a.push({severity:`info`,category:`semantic`,message:`TODO/FIXME comments found - implementation may be incomplete`,suggestion:`Address TODO items before finalizing implementation`}),t.policy.auth!==`anonymous`&&!n.includes(`auth`)&&a.push({severity:`warning`,category:`semantic`,message:`Spec requires ${t.policy.auth} auth but no auth check found`,suggestion:`Add authentication check at the handler entry point`});let o=a.filter(e=>e.severity===`error`).length===0?80:40,s=a.filter(e=>e.severity===`error`).length===0;return{tier:`ai_review`,passed:s,score:o,issues:a,suggestions:a.filter(e=>e.suggestion).map(e=>e.suggestion),coverage:{scenarios:{total:0,covered:0},errors:{total:0,handled:0},fields:{total:1,implemented:s?1:0}},meta:{specName:t.meta.name,specVersion:t.meta.version,implementationPath:r??`unknown`,verifiedAt:new Date().toISOString(),duration:Date.now()-i}}}function o(e,t){return`You are analyzing a code implementation against its specification.
+\`\`\``;
+	}
+}
+/**
+* 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
-${e}
+${specFields}
 
 ## Implementation Code
 \`\`\`typescript
-${t}
+${implCode}
 \`\`\`
 
 ## Task
@@ -72,5 +258,146 @@ Match types:
 - "compatible": Semantically similar (e.g., "email" vs "emailAddress")
 - "mismatch": Different meaning despite similar naming
 - "missing": Spec field not found in implementation
-`}function s(e){let t=[],n=(e,n)=>{try{let r=e?._def?.shape;if(r&&typeof r==`function`){let e=r();for(let[r,i]of Object.entries(e)){let e=i?._def?.typeName??`unknown`;t.push(`- ${r}: ${String(e).replace(`Zod`,``).toLowerCase()} (${n})`)}}}catch{t.push(`- [unable to extract ${n} fields]`)}};return e.io.input&&n(e.io.input,`input`),e.io.output&&!(`resourceRef`in e.io.output)&&n(e.io.output,`output`),t.length===0?`- [no schema fields could be extracted]`:t.join(`
-`)}function c(e){let t=e.match(/```json\n?([\s\S]*?)\n?```/);if(t?.[1])try{let n=JSON.parse(t[1]);return{fieldMappings:(n.fieldMappings??[]).map(e=>({specField:String(e.specField??``),specType:String(e.specType??`unknown`),implementationField:e.implementationField?String(e.implementationField):void 0,implementationType:e.implementationType?String(e.implementationType):void 0,match:e.match??`missing`,aiConfidence:typeof e.aiConfidence==`number`?e.aiConfidence:.5,suggestion:e.suggestion?String(e.suggestion):void 0})),intentAlignment:{score:typeof n.intentAlignment?.score==`number`?n.intentAlignment.score:50,issues:Array.isArray(n.intentAlignment?.issues)?n.intentAlignment.issues:[],suggestions:Array.isArray(n.intentAlignment?.suggestions)?n.intentAlignment.suggestions:[]},semanticIssues:(n.semanticIssues??[]).map(e=>({category:String(e.category??`semantic`),severity:e.severity??`warning`,message:String(e.message??``),suggestion:e.suggestion?String(e.suggestion):void 0})),rawResponse:e}}catch{}return{fieldMappings:[],intentAlignment:{score:50,issues:[`Unable to parse AI response for semantic analysis`],suggestions:[]},semanticIssues:[],rawResponse:e}}async function l(e,t={}){let{spec:n,implementationCode:i}=e;return c(await r(o(s(n),i),t))}async function u(e,t={}){let{spec:n,implementationCode:r,implementationPath:a}=e,o=Date.now(),s=await i(e,t),c;if(t.aiApiKey)try{c=await l(e,t)}catch{}if(c){let e=[];for(let t of c.fieldMappings)t.match===`missing`?e.push({severity:`error`,category:`semantic`,message:`Missing field: '${t.specField}' (${t.specType}) not found in implementation`,suggestion:t.suggestion??`Add field '${t.specField}' to implementation`}):t.match===`mismatch`?e.push({severity:`warning`,category:`semantic`,message:`Field mismatch: '${t.specField}' has incorrect implementation as '${t.implementationField}'`,suggestion:t.suggestion}):t.match===`compatible`&&t.aiConfidence<.8&&e.push({severity:`info`,category:`semantic`,message:`Field naming: '${t.specField}' implemented as '${t.implementationField}' (compatible but not exact)`,suggestion:t.suggestion});for(let t of c.intentAlignment.issues)e.push({severity:`warning`,category:`semantic`,message:t});for(let t of c.semanticIssues)e.push({severity:t.severity,category:`semantic`,message:t.message,suggestion:t.suggestion});s.issues=[...s.issues,...e];let t=c.fieldMappings.length,n=c.fieldMappings.filter(e=>e.match===`exact`||e.match===`compatible`).length;if(t>0){let e=Math.round(n/t*100);s.score=Math.round((s.score+e)/2),s.coverage.fields={total:t,implemented:n}}e.some(e=>e.severity===`error`)&&(s.passed=!1),s.suggestions=[...s.suggestions,...c.intentAlignment.suggestions]}return s.meta={...s.meta,duration:Date.now()-o},s}export{a as createQuickAIReview,l as verifySemanticFields,i as verifyWithAI,u as verifyWithAIEnhanced};
+`;
+}
+/**
+* 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 };

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

@@ -1 +1,185 @@
-import{isEmitDeclRef as e}from"@lssm/lib.contracts/spec";function t(e,t){let n=[...t.given,...t.when,...t.then].flatMap(e=>e.toLowerCase().split(/\s+/).filter(e=>e.length>3)),r=e.toLowerCase(),i=n.filter(e=>r.includes(e)),a=n.length>0?i.length/n.length:0,o=t.name.toLowerCase().replace(/\s+/g,``),s=r.includes(o)||r.includes(`test('${t.name.toLowerCase()}'`)||r.includes(`it('${t.name.toLowerCase()}'`)||r.includes(`describe('${t.name.toLowerCase()}'`),c=a>=.3||s;return{name:t.name,type:`scenario`,passed:c,expected:`Given: ${t.given.join(`; `)}; When: ${t.when.join(`; `)}; Then: ${t.then.join(`; `)}`,details:c?void 0:`Scenario keywords not found in implementation (${Math.round(a*100)}% coverage)`}}function n(e,t){let n=JSON.stringify(t.input),i=JSON.stringify(t.output),a=r(t.input),o=r(t.output),s=e.toLowerCase(),c=a.filter(e=>s.includes(e.toLowerCase())),l=o.filter(e=>s.includes(e.toLowerCase())),u=((a.length>0?c.length/a.length:1)+(o.length>0?l.length/o.length:1))/2,d=u>=.2;return{name:t.name,type:`example`,passed:d,expected:`Input: ${n.slice(0,100)}...; Output: ${i.slice(0,100)}...`,details:d?void 0:`Example values not found in implementation (${Math.round(u*100)}% coverage)`}}function r(e){let t=[];function n(e){typeof e==`string`&&e.length>2?t.push(e):Array.isArray(e)?e.forEach(n):e&&typeof e==`object`&&Object.values(e).forEach(n)}return n(e),t}function i(e,t,n){let r=e.includes(t),i=n.http?e.includes(String(n.http)):!0,a=n.when.toLowerCase().split(/\s+/).filter(e=>e.length>3),o=e.toLowerCase(),s=a.filter(e=>o.includes(e)),c=a.length>0?s.length/a.length:1,l=r&&(i||c>=.3);return{name:`Error: ${t}`,type:`error`,passed:l,expected:`When: ${n.when}; Return: ${t} (HTTP ${n.http??400})`,details:l?void 0:r?`Error condition not properly implemented`:`Error code '${t}' not found in implementation`}}function a(t,n){let r=n.sideEffects?.emits??[],i=[];for(let n of r){let r=e(n)?n.ref.name:n.name,a=n.when,o=a.toLowerCase().split(/\s+/).filter(e=>e.length>3),s=t.toLowerCase(),c=s.includes(r.toLowerCase()),l=o.filter(e=>s.includes(e)),u=o.length>0?l.length/o.length:1;i.push({name:`Event: ${r}`,type:`scenario`,passed:c&&u>=.3,expected:`Emit ${r} when: ${a}`,details:c?u<.3?`Event condition not properly implemented`:void 0:`Event '${r}' not found`})}return i}function o(e,t){if(t.policy.idempotent===void 0||!t.policy.idempotent)return null;let n=[`idempotency`,`idempotent`,`already exists`,`upsert`,`on conflict`,`if not exists`,`dedupe`,`duplicate`],r=e.toLowerCase(),i=n.some(e=>r.includes(e));return{name:`Idempotency`,type:`scenario`,passed:i,expected:`Operation should be idempotent (safe to retry)`,details:i?void 0:`No idempotency pattern found for idempotent operation`}}function s(e){let{spec:r,implementationCode:s,implementationPath:c}=e,l=Date.now(),u=[];for(let e of r.acceptance?.scenarios??[])u.push(t(s,e));for(let e of r.acceptance?.examples??[])u.push(n(s,e));for(let[e,t]of Object.entries(r.io.errors??{}))u.push(i(s,e,t));u.push(...a(s,r));let d=o(s,r);d&&u.push(d);let f=u.filter(e=>!e.passed).map(e=>({severity:e.type===`error`?`error`:`warning`,category:e.type===`scenario`||e.type===`example`?`scenario`:`error_handling`,message:e.details??`${e.type} not covered: ${e.name}`,location:c?{file:c}:void 0,suggestion:e.expected?`Expected: ${e.expected}`:void 0})),p=u.filter(e=>e.type===`scenario`),m=u.filter(e=>e.type===`error`),h=u.filter(e=>e.passed).length,g=u.length>0?Math.round(h/u.length*100):100;return{tier:`behavior`,passed:f.filter(e=>e.severity===`error`).length===0,score:g,issues:f,suggestions:u.filter(e=>!e.passed&&e.expected).map(e=>`${e.name}: ${e.expected}`),coverage:{scenarios:{total:p.length,covered:p.filter(e=>e.passed).length},errors:{total:m.length,handled:m.filter(e=>e.passed).length},fields:{total:u.length,implemented:h}},meta:{specName:r.meta.name,specVersion:r.meta.version,implementationPath:c??`unknown`,verifiedAt:new Date().toISOString(),duration:Date.now()-l}}}export{s as verifyBehavior};
+import { isEmitDeclRef } from "../../libs/contracts/dist/spec.js";
+
+//#region src/services/verify/behavior-verifier.ts
+/**
+* Check if a scenario is likely covered by the implementation.
+*/
+function checkScenarioCoverage(code, scenario) {
+	const keywords = [
+		...scenario.given,
+		...scenario.when,
+		...scenario.then
+	].flatMap((s) => s.toLowerCase().split(/\s+/).filter((w) => w.length > 3));
+	const codeLower = code.toLowerCase();
+	const foundKeywords = keywords.filter((kw) => codeLower.includes(kw));
+	const coverage = keywords.length > 0 ? foundKeywords.length / keywords.length : 0;
+	const scenarioNameLower = scenario.name.toLowerCase().replace(/\s+/g, "");
+	const hasTestForScenario = codeLower.includes(scenarioNameLower) || codeLower.includes(`test('${scenario.name.toLowerCase()}'`) || codeLower.includes(`it('${scenario.name.toLowerCase()}'`) || codeLower.includes(`describe('${scenario.name.toLowerCase()}'`);
+	const passed = coverage >= .3 || hasTestForScenario;
+	return {
+		name: scenario.name,
+		type: "scenario",
+		passed,
+		expected: `Given: ${scenario.given.join("; ")}; When: ${scenario.when.join("; ")}; Then: ${scenario.then.join("; ")}`,
+		details: passed ? void 0 : `Scenario keywords not found in implementation (${Math.round(coverage * 100)}% coverage)`
+	};
+}
+/**
+* Check if an example is likely handled.
+*/
+function checkExampleCoverage(code, example) {
+	const inputStr = JSON.stringify(example.input);
+	const outputStr = JSON.stringify(example.output);
+	const inputValues = extractStringValues(example.input);
+	const outputValues = extractStringValues(example.output);
+	const codeLower = code.toLowerCase();
+	const foundInputValues = inputValues.filter((v) => codeLower.includes(v.toLowerCase()));
+	const foundOutputValues = outputValues.filter((v) => codeLower.includes(v.toLowerCase()));
+	const avgCoverage = ((inputValues.length > 0 ? foundInputValues.length / inputValues.length : 1) + (outputValues.length > 0 ? foundOutputValues.length / outputValues.length : 1)) / 2;
+	const passed = avgCoverage >= .2;
+	return {
+		name: example.name,
+		type: "example",
+		passed,
+		expected: `Input: ${inputStr.slice(0, 100)}...; Output: ${outputStr.slice(0, 100)}...`,
+		details: passed ? void 0 : `Example values not found in implementation (${Math.round(avgCoverage * 100)}% coverage)`
+	};
+}
+/**
+* Extract string values from an object for comparison.
+*/
+function extractStringValues(obj) {
+	const values = [];
+	function extract(value) {
+		if (typeof value === "string" && value.length > 2) values.push(value);
+		else if (Array.isArray(value)) value.forEach(extract);
+		else if (value && typeof value === "object") Object.values(value).forEach(extract);
+	}
+	extract(obj);
+	return values;
+}
+/**
+* Check if an error case is handled.
+*/
+function checkErrorCaseCoverage(code, errorCode, errorDef) {
+	const hasErrorCode = code.includes(errorCode);
+	const hasHttpStatus = errorDef.http ? code.includes(String(errorDef.http)) : true;
+	const whenKeywords = errorDef.when.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+	const codeLower = code.toLowerCase();
+	const foundWhenKeywords = whenKeywords.filter((kw) => codeLower.includes(kw));
+	const whenCoverage = whenKeywords.length > 0 ? foundWhenKeywords.length / whenKeywords.length : 1;
+	const passed = hasErrorCode && (hasHttpStatus || whenCoverage >= .3);
+	return {
+		name: `Error: ${errorCode}`,
+		type: "error",
+		passed,
+		expected: `When: ${errorDef.when}; Return: ${errorCode} (HTTP ${errorDef.http ?? 400})`,
+		details: passed ? void 0 : !hasErrorCode ? `Error code '${errorCode}' not found in implementation` : `Error condition not properly implemented`
+	};
+}
+/**
+* Check if events are emitted in the right conditions.
+*/
+function checkEventConditions(code, spec) {
+	const events = spec.sideEffects?.emits ?? [];
+	const checks = [];
+	for (const event of events) {
+		const eventName = isEmitDeclRef(event) ? event.ref.name : event.name;
+		const when = event.when;
+		const whenKeywords = when.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+		const codeLower = code.toLowerCase();
+		const hasEvent = codeLower.includes(eventName.toLowerCase());
+		const foundKeywords = whenKeywords.filter((kw) => codeLower.includes(kw));
+		const conditionCoverage = whenKeywords.length > 0 ? foundKeywords.length / whenKeywords.length : 1;
+		checks.push({
+			name: `Event: ${eventName}`,
+			type: "scenario",
+			passed: hasEvent && conditionCoverage >= .3,
+			expected: `Emit ${eventName} when: ${when}`,
+			details: !hasEvent ? `Event '${eventName}' not found` : conditionCoverage < .3 ? `Event condition not properly implemented` : void 0
+		});
+	}
+	return checks;
+}
+/**
+* Check if idempotency is properly handled.
+*/
+function checkIdempotency(code, spec) {
+	if (spec.policy.idempotent === void 0) return null;
+	if (!spec.policy.idempotent) return null;
+	const idempotentPatterns = [
+		"idempotency",
+		"idempotent",
+		"already exists",
+		"upsert",
+		"on conflict",
+		"if not exists",
+		"dedupe",
+		"duplicate"
+	];
+	const codeLower = code.toLowerCase();
+	const hasIdempotentPattern = idempotentPatterns.some((p) => codeLower.includes(p));
+	return {
+		name: "Idempotency",
+		type: "scenario",
+		passed: hasIdempotentPattern,
+		expected: "Operation should be idempotent (safe to retry)",
+		details: hasIdempotentPattern ? void 0 : "No idempotency pattern found for idempotent operation"
+	};
+}
+/**
+* Run all behavior checks and produce a verification report.
+*/
+function verifyBehavior(input) {
+	const { spec, implementationCode, implementationPath } = input;
+	const startTime = Date.now();
+	const checks = [];
+	for (const scenario of spec.acceptance?.scenarios ?? []) checks.push(checkScenarioCoverage(implementationCode, scenario));
+	for (const example of spec.acceptance?.examples ?? []) checks.push(checkExampleCoverage(implementationCode, example));
+	for (const [code, errorDef] of Object.entries(spec.io.errors ?? {})) checks.push(checkErrorCaseCoverage(implementationCode, code, errorDef));
+	checks.push(...checkEventConditions(implementationCode, spec));
+	const idempotencyCheck = checkIdempotency(implementationCode, spec);
+	if (idempotencyCheck) checks.push(idempotencyCheck);
+	const issues = checks.filter((c) => !c.passed).map((c) => ({
+		severity: c.type === "error" ? "error" : "warning",
+		category: c.type === "scenario" ? "scenario" : c.type === "example" ? "scenario" : "error_handling",
+		message: c.details ?? `${c.type} not covered: ${c.name}`,
+		location: implementationPath ? { file: implementationPath } : void 0,
+		suggestion: c.expected ? `Expected: ${c.expected}` : void 0
+	}));
+	const scenarioChecks = checks.filter((c) => c.type === "scenario");
+	const errorChecks = checks.filter((c) => c.type === "error");
+	const passedCount = checks.filter((c) => c.passed).length;
+	const score = checks.length > 0 ? Math.round(passedCount / checks.length * 100) : 100;
+	return {
+		tier: "behavior",
+		passed: issues.filter((i) => i.severity === "error").length === 0,
+		score,
+		issues,
+		suggestions: checks.filter((c) => !c.passed && c.expected).map((c) => `${c.name}: ${c.expected}`),
+		coverage: {
+			scenarios: {
+				total: scenarioChecks.length,
+				covered: scenarioChecks.filter((c) => c.passed).length
+			},
+			errors: {
+				total: errorChecks.length,
+				handled: errorChecks.filter((c) => c.passed).length
+			},
+			fields: {
+				total: checks.length,
+				implemented: passedCount
+			}
+		},
+		meta: {
+			specName: spec.meta.name,
+			specVersion: spec.meta.version,
+			implementationPath: implementationPath ?? "unknown",
+			verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			duration: Date.now() - startTime
+		}
+	};
+}
+
+//#endregion
+export { verifyBehavior };

package/dist/services/verify/index.js

@@ -1 +1,4 @@
-import{verifyStructure as e}from"./structure-verifier.js";import{verifyBehavior as t}from"./behavior-verifier.js";import{createQuickAIReview as n,verifySemanticFields as r,verifyWithAI as i,verifyWithAIEnhanced as a}from"./ai-verifier.js";import{VerifyService as o,createVerifyService as s,verifyService as c}from"./verify-service.js";
+import { verifyStructure } from "./structure-verifier.js";
+import { verifyBehavior } from "./behavior-verifier.js";
+import { createQuickAIReview, verifySemanticFields, verifyWithAI, verifyWithAIEnhanced } from "./ai-verifier.js";
+import { VerifyService, createVerifyService, verifyService } from "./verify-service.js";