@lssm/bundle.contractspec-workspace 0.0.0-canary-20251217063201 → 0.0.0-canary-20251217073102

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

@@ -1,2 +1,195 @@
-import{e}from"../../libs/contracts/dist/spec.js";function t(e){let t=/export\s+(async\s+)?function\s+\w+/.test(e)||/export\s+const\s+\w+\s*=\s*(async\s*)?\(/.test(e)||/export\s+default\s+(async\s+)?function/.test(e)||/export\s+\{\s*\w+/.test(e);return{name:`handler_export`,passed:t,details:t?void 0:`No exported handler function found`,suggestion:`Export a function that handles the operation: export async function handle(...) { }`}}function n(e){let t=e.includes(`from '@lssm/lib.contracts'`)||e.includes(`from "@lssm/lib.contracts"`);return{name:`contracts_import`,passed:t,details:t?void 0:`Missing import from @lssm/lib.contracts`,suggestion:`Add: import { ... } from '@lssm/lib.contracts';`}}function r(e,t){if(!(t.io.input!==null||t.io.output!==null))return{name:`schema_import`,passed:!0};let n=e.includes(`from '@lssm/lib.schema'`)||e.includes(`from "@lssm/lib.schema"`);return{name:`schema_import`,passed:n,details:n?void 0:`Missing import from @lssm/lib.schema`,suggestion:`Add: import { ... } from '@lssm/lib.schema';`}}function i(e){let t=/:\s*any\b|as\s+any\b|<any>/,n=e.split(`
-`),r=[];for(let e=0;e<n.length;e++){let i=n[e]??``;i.trim().startsWith(`//`)||i.trim().startsWith(`*`)||t.test(i)&&r.push(e+1)}return{name:`no_any_type`,passed:r.length===0,details:r.length>0?`Found 'any' type on lines: ${r.slice(0,5).join(`, `)}${r.length>5?`...`:``}`:void 0,suggestion:`Replace any with proper types from the spec schema`}}function a(e,t){let n=t.io.errors;if(!n||Object.keys(n).length===0)return{name:`error_handling`,passed:!0};let r=Object.keys(n),i=[];for(let t of r)e.includes(t)||i.push(t);return{name:`error_handling`,passed:i.length===0,details:i.length>0?`Missing error handling for: ${i.join(`, `)}`:void 0,suggestion:`Implement handlers for all error cases defined in the spec`}}function o(t,n){let r=n.sideEffects?.emits;if(!r||r.length===0)return{name:`event_emission`,passed:!0};let i=t.includes(`emit(`)||t.includes(`.emit(`)||t.includes(`publish(`)||t.includes(`.publish(`)||t.includes(`dispatchEvent`)||t.includes(`eventBus`),a=r.map(t=>e(t)?t.ref.name:t.name),o=a.filter(e=>t.includes(e));return{name:`event_emission`,passed:i&&o.length>0,details:i?o.length===0?`Events not referenced: ${a.join(`, `)}`:void 0:`No event emission pattern found`,suggestion:`Emit events as specified in sideEffects.emits`}}function s(e,t){if(!t.io.input)return{name:`input_validation`,passed:!0};let n=e.includes(`.parse(`)||e.includes(`.safeParse(`)||e.includes(`validate(`)||e.includes(`.validate(`)||e.includes(`schema.`)||e.includes(`zodSchema`)||e.includes(`.getZod()`);return{name:`input_validation`,passed:n,details:n?void 0:`No input validation pattern found`,suggestion:`Validate input using the schema: schema.parse(input) or schema.safeParse(input)`}}function c(e,t){let n=/export\s+(const\s+\w+\s*=\s*)?async/.test(e)||/async\s+function/.test(e);return t.meta.kind===`command`?{name:`async_patterns`,passed:n,details:n?void 0:`Handler should be async for command operations`,suggestion:`Make the handler function async: export async function handle(...)`}:{name:`async_patterns`,passed:!0}}function l(e){let{spec:l,implementationCode:u,implementationPath:d}=e,f=Date.now(),p=[t(u),n(u),r(u,l),i(u),a(u,l),o(u,l),s(u,l),c(u,l)],m=p.filter(e=>!e.passed).map(e=>({severity:e.name===`no_any_type`?`warning`:`error`,category:e.name.includes(`import`)?`import`:e.name.includes(`export`)?`export`:`type`,message:e.details??`Check failed: ${e.name}`,location:d?{file:d}:void 0,suggestion:e.suggestion})),h=p.filter(e=>e.passed).length,g=Math.round(h/p.length*100),_=m.filter(e=>e.severity===`error`).length===0,v=p.filter(e=>!e.passed&&e.suggestion).map(e=>e.suggestion),y=Object.keys(l.io.errors??{}).length;return{tier:`structure`,passed:_,score:g,issues:m,suggestions:v,coverage:{scenarios:{total:0,covered:0},errors:{total:y,handled:p.find(e=>e.name===`error_handling`)?.passed?y:0},fields:{total:p.length,implemented:h}},meta:{specName:l.meta.name,specVersion:l.meta.version,implementationPath:d??`unknown`,verifiedAt:new Date().toISOString(),duration:Date.now()-f}}}export{l as verifyStructure};
+import { isEmitDeclRef } from "../../libs/contracts/dist/spec.js";
+
+//#region src/services/verify/structure-verifier.ts
+/**
+* Check if code exports a handler function.
+*/
+function checkHandlerExport(code) {
+	const hasExport = /export\s+(async\s+)?function\s+\w+/.test(code) || /export\s+const\s+\w+\s*=\s*(async\s*)?\(/.test(code) || /export\s+default\s+(async\s+)?function/.test(code) || /export\s+\{\s*\w+/.test(code);
+	return {
+		name: "handler_export",
+		passed: hasExport,
+		details: hasExport ? void 0 : "No exported handler function found",
+		suggestion: "Export a function that handles the operation: export async function handle(...) { }"
+	};
+}
+/**
+* Check if code imports from @lssm/lib.contracts.
+*/
+function checkContractsImport(code) {
+	const hasImport = code.includes("from '@lssm/lib.contracts'") || code.includes("from \"@lssm/lib.contracts\"");
+	return {
+		name: "contracts_import",
+		passed: hasImport,
+		details: hasImport ? void 0 : "Missing import from @lssm/lib.contracts",
+		suggestion: "Add: import { ... } from '@lssm/lib.contracts';"
+	};
+}
+/**
+* Check if code imports from @lssm/lib.schema.
+*/
+function checkSchemaImport(code, spec) {
+	if (!(spec.io.input !== null || spec.io.output !== null)) return {
+		name: "schema_import",
+		passed: true
+	};
+	const hasImport = code.includes("from '@lssm/lib.schema'") || code.includes("from \"@lssm/lib.schema\"");
+	return {
+		name: "schema_import",
+		passed: hasImport,
+		details: hasImport ? void 0 : "Missing import from @lssm/lib.schema",
+		suggestion: "Add: import { ... } from '@lssm/lib.schema';"
+	};
+}
+/**
+* Check for TypeScript any usage.
+*/
+function checkNoAnyType(code) {
+	const anyPattern = /:\s*any\b|as\s+any\b|<any>/;
+	const lines = code.split("\n");
+	const anyUsages = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i] ?? "";
+		if (line.trim().startsWith("//") || line.trim().startsWith("*")) continue;
+		if (anyPattern.test(line)) anyUsages.push(i + 1);
+	}
+	return {
+		name: "no_any_type",
+		passed: anyUsages.length === 0,
+		details: anyUsages.length > 0 ? `Found 'any' type on lines: ${anyUsages.slice(0, 5).join(", ")}${anyUsages.length > 5 ? "..." : ""}` : void 0,
+		suggestion: "Replace any with proper types from the spec schema"
+	};
+}
+/**
+* Check if error codes from spec are handled.
+*/
+function checkErrorHandling(code, spec) {
+	const errors = spec.io.errors;
+	if (!errors || Object.keys(errors).length === 0) return {
+		name: "error_handling",
+		passed: true
+	};
+	const errorCodes = Object.keys(errors);
+	const missingErrors = [];
+	for (const errorCode of errorCodes) if (!code.includes(errorCode)) missingErrors.push(errorCode);
+	return {
+		name: "error_handling",
+		passed: missingErrors.length === 0,
+		details: missingErrors.length > 0 ? `Missing error handling for: ${missingErrors.join(", ")}` : void 0,
+		suggestion: "Implement handlers for all error cases defined in the spec"
+	};
+}
+/**
+* Check if events are emitted.
+*/
+function checkEventEmission(code, spec) {
+	const events = spec.sideEffects?.emits;
+	if (!events || events.length === 0) return {
+		name: "event_emission",
+		passed: true
+	};
+	const hasEmitPattern = code.includes("emit(") || code.includes(".emit(") || code.includes("publish(") || code.includes(".publish(") || code.includes("dispatchEvent") || code.includes("eventBus");
+	const eventNames = events.map((e) => {
+		if (isEmitDeclRef(e)) return e.ref.name;
+		return e.name;
+	});
+	const mentionedEvents = eventNames.filter((name) => code.includes(name));
+	return {
+		name: "event_emission",
+		passed: hasEmitPattern && mentionedEvents.length > 0,
+		details: !hasEmitPattern ? "No event emission pattern found" : mentionedEvents.length === 0 ? `Events not referenced: ${eventNames.join(", ")}` : void 0,
+		suggestion: "Emit events as specified in sideEffects.emits"
+	};
+}
+/**
+* Check for validation of input.
+*/
+function checkInputValidation(code, spec) {
+	if (!spec.io.input) return {
+		name: "input_validation",
+		passed: true
+	};
+	const hasValidation = code.includes(".parse(") || code.includes(".safeParse(") || code.includes("validate(") || code.includes(".validate(") || code.includes("schema.") || code.includes("zodSchema") || code.includes(".getZod()");
+	return {
+		name: "input_validation",
+		passed: hasValidation,
+		details: hasValidation ? void 0 : "No input validation pattern found",
+		suggestion: "Validate input using the schema: schema.parse(input) or schema.safeParse(input)"
+	};
+}
+/**
+* Check for async/await usage on async operations.
+*/
+function checkAsyncPatterns(code, spec) {
+	const isAsync = /export\s+(const\s+\w+\s*=\s*)?async/.test(code) || /async\s+function/.test(code);
+	if (!(spec.meta.kind === "command")) return {
+		name: "async_patterns",
+		passed: true
+	};
+	return {
+		name: "async_patterns",
+		passed: isAsync,
+		details: isAsync ? void 0 : "Handler should be async for command operations",
+		suggestion: "Make the handler function async: export async function handle(...)"
+	};
+}
+/**
+* Run all structure checks and produce a verification report.
+*/
+function verifyStructure(input) {
+	const { spec, implementationCode, implementationPath } = input;
+	const startTime = Date.now();
+	const checks = [
+		checkHandlerExport(implementationCode),
+		checkContractsImport(implementationCode),
+		checkSchemaImport(implementationCode, spec),
+		checkNoAnyType(implementationCode),
+		checkErrorHandling(implementationCode, spec),
+		checkEventEmission(implementationCode, spec),
+		checkInputValidation(implementationCode, spec),
+		checkAsyncPatterns(implementationCode, spec)
+	];
+	const issues = checks.filter((c) => !c.passed).map((c) => ({
+		severity: c.name === "no_any_type" ? "warning" : "error",
+		category: c.name.includes("import") ? "import" : c.name.includes("export") ? "export" : "type",
+		message: c.details ?? `Check failed: ${c.name}`,
+		location: implementationPath ? { file: implementationPath } : void 0,
+		suggestion: c.suggestion
+	}));
+	const passedCount = checks.filter((c) => c.passed).length;
+	const score = Math.round(passedCount / checks.length * 100);
+	const passed = issues.filter((i) => i.severity === "error").length === 0;
+	const suggestions = checks.filter((c) => !c.passed && c.suggestion).map((c) => c.suggestion);
+	const errorCount = Object.keys(spec.io.errors ?? {}).length;
+	return {
+		tier: "structure",
+		passed,
+		score,
+		issues,
+		suggestions,
+		coverage: {
+			scenarios: {
+				total: 0,
+				covered: 0
+			},
+			errors: {
+				total: errorCount,
+				handled: checks.find((c) => c.name === "error_handling")?.passed ? errorCount : 0
+			},
+			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 { verifyStructure };

package/dist/services/verify/verify-service.js

@@ -1,3 +1,203 @@
-import{verifyStructure as e}from"./structure-verifier.js";import{verifyBehavior as t}from"./behavior-verifier.js";import{createQuickAIReview as n,verifyWithAI as r}from"./ai-verifier.js";const i={verbose:!1},a=[`structure`,`behavior`,`ai_review`];var o=class{config;constructor(e={}){this.config={...i,...e}}async verify(i,o,s={}){let c=Date.now(),l=new Map,u=[],d={spec:i,implementationCode:o},f=s.tiers??[`structure`,`behavior`];for(let i of a){if(!f.includes(i))continue;let a;switch(i){case`structure`:a=e(d);break;case`behavior`:a=t(d);break;case`ai_review`:a=this.config.aiApiKey?await r(d,this.config):n(d);break;default:continue}if(l.set(i,a),u.push(...a.issues),s.failFast&&!a.passed)break}let p=Array.from(l.values());return{passed:p.every(e=>e.passed),score:p.length>0?Math.round(p.reduce((e,t)=>e+t.score,0)/p.length):100,reports:l,allIssues:u,summary:this.generateSummary(p,u),duration:Date.now()-c}}verifyStructure(t,n,r){return e({spec:t,implementationCode:n,implementationPath:r})}verifyBehavior(e,n,r){return t({spec:e,implementationCode:n,implementationPath:r})}async verifyAI(e,t,i){let a={spec:e,implementationCode:t,implementationPath:i};return this.config.aiApiKey?r(a,this.config):n(a)}quickVerify(t,n){return e({spec:t,implementationCode:n})}generateSummary(e,t){let n=[],r=e.every(e=>e.passed),i=e.length>0?Math.round(e.reduce((e,t)=>e+t.score,0)/e.length):100;n.push(r?`✓ Verification passed`:`✗ Verification failed`),n.push(`Score: ${i}/100`),n.push(``);for(let t of e){let e=t.passed?`✓`:`✗`;n.push(`${e} ${t.tier}: ${t.score}/100`)}n.push(``);let a=t.filter(e=>e.severity===`error`),o=t.filter(e=>e.severity===`warning`),s=t.filter(e=>e.severity===`info`);return a.length>0&&n.push(`Errors: ${a.length}`),o.length>0&&n.push(`Warnings: ${o.length}`),s.length>0&&n.push(`Info: ${s.length}`),n.join(`
-`)}formatAsMarkdown(e){let t=[];t.push(`# Verification Report`),t.push(``),t.push(`**Status:** ${e.passed?`✓ Passed`:`✗ Failed`}`),t.push(`**Score:** ${e.score}/100`),t.push(`**Duration:** ${e.duration}ms`),t.push(``);for(let[n,r]of e.reports){if(t.push(`## ${this.formatTierName(n)}`),t.push(``),t.push(`**Status:** ${r.passed?`✓ Passed`:`✗ Failed`}`),t.push(`**Score:** ${r.score}/100`),t.push(``),r.issues.length>0){t.push(`### Issues`),t.push(``);for(let e of r.issues){let n=e.severity===`error`?`❌`:e.severity===`warning`?`⚠️`:`ℹ️`;t.push(`${n} **${e.category}**: ${e.message}`),e.suggestion&&t.push(`  - Suggestion: ${e.suggestion}`)}t.push(``)}r.coverage.scenarios.total>0&&t.push(`**Scenarios:** ${r.coverage.scenarios.covered}/${r.coverage.scenarios.total}`),r.coverage.errors.total>0&&t.push(`**Errors handled:** ${r.coverage.errors.handled}/${r.coverage.errors.total}`),t.push(``)}let n=Array.from(e.reports.values()).flatMap(e=>e.suggestions);if(n.length>0){t.push(`## Suggestions`),t.push(``);for(let e of n.slice(0,10))t.push(`- ${e}`);n.length>10&&t.push(`- ... and ${n.length-10} more`),t.push(``)}return t.join(`
-`)}formatTierName(e){switch(e){case`structure`:return`Tier 1: Structure`;case`behavior`:return`Tier 2: Behavior`;case`ai_review`:return`Tier 3: AI Review`;default:return e}}configure(e){this.config={...this.config,...e}}};function s(e){return new o(e)}const c=new o;export{o as VerifyService,s as createVerifyService,c as verifyService};
+import { verifyStructure } from "./structure-verifier.js";
+import { verifyBehavior } from "./behavior-verifier.js";
+import { createQuickAIReview, verifyWithAI } from "./ai-verifier.js";
+
+//#region src/services/verify/verify-service.ts
+const DEFAULT_CONFIG = { verbose: false };
+const TIER_ORDER = [
+	"structure",
+	"behavior",
+	"ai_review"
+];
+/**
+* Verification Service
+*
+* Main service for verifying implementations against specs.
+*/
+var VerifyService = class {
+	config;
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+	}
+	/**
+	* Run verification on an implementation.
+	*/
+	async verify(spec, implementationCode, options = {}) {
+		const startTime = Date.now();
+		const reports = /* @__PURE__ */ new Map();
+		const allIssues = [];
+		const input = {
+			spec,
+			implementationCode
+		};
+		const tiersToRun = options.tiers ?? ["structure", "behavior"];
+		for (const tier of TIER_ORDER) {
+			if (!tiersToRun.includes(tier)) continue;
+			let report;
+			switch (tier) {
+				case "structure":
+					report = verifyStructure(input);
+					break;
+				case "behavior":
+					report = verifyBehavior(input);
+					break;
+				case "ai_review":
+					if (this.config.aiApiKey) report = await verifyWithAI(input, this.config);
+					else report = createQuickAIReview(input);
+					break;
+				default: continue;
+			}
+			reports.set(tier, report);
+			allIssues.push(...report.issues);
+			if (options.failFast && !report.passed) break;
+		}
+		const reportsArray = Array.from(reports.values());
+		return {
+			passed: reportsArray.every((r) => r.passed),
+			score: reportsArray.length > 0 ? Math.round(reportsArray.reduce((sum, r) => sum + r.score, 0) / reportsArray.length) : 100,
+			reports,
+			allIssues,
+			summary: this.generateSummary(reportsArray, allIssues),
+			duration: Date.now() - startTime
+		};
+	}
+	/**
+	* Run only structure verification (Tier 1).
+	*/
+	verifyStructure(spec, implementationCode, implementationPath) {
+		return verifyStructure({
+			spec,
+			implementationCode,
+			implementationPath
+		});
+	}
+	/**
+	* Run only behavior verification (Tier 2).
+	*/
+	verifyBehavior(spec, implementationCode, implementationPath) {
+		return verifyBehavior({
+			spec,
+			implementationCode,
+			implementationPath
+		});
+	}
+	/**
+	* Run only AI verification (Tier 3).
+	*/
+	async verifyAI(spec, implementationCode, implementationPath) {
+		const input = {
+			spec,
+			implementationCode,
+			implementationPath
+		};
+		if (this.config.aiApiKey) return verifyWithAI(input, this.config);
+		return createQuickAIReview(input);
+	}
+	/**
+	* Quick verification (structure only, fast).
+	*/
+	quickVerify(spec, implementationCode) {
+		return verifyStructure({
+			spec,
+			implementationCode
+		});
+	}
+	/**
+	* Generate a human-readable summary of verification results.
+	*/
+	generateSummary(reports, allIssues) {
+		const parts = [];
+		const passed = reports.every((r) => r.passed);
+		const avgScore = reports.length > 0 ? Math.round(reports.reduce((sum, r) => sum + r.score, 0) / reports.length) : 100;
+		parts.push(passed ? "✓ Verification passed" : "✗ Verification failed");
+		parts.push(`Score: ${avgScore}/100`);
+		parts.push("");
+		for (const report of reports) {
+			const icon = report.passed ? "✓" : "✗";
+			parts.push(`${icon} ${report.tier}: ${report.score}/100`);
+		}
+		parts.push("");
+		const errors = allIssues.filter((i) => i.severity === "error");
+		const warnings = allIssues.filter((i) => i.severity === "warning");
+		const infos = allIssues.filter((i) => i.severity === "info");
+		if (errors.length > 0) parts.push(`Errors: ${errors.length}`);
+		if (warnings.length > 0) parts.push(`Warnings: ${warnings.length}`);
+		if (infos.length > 0) parts.push(`Info: ${infos.length}`);
+		return parts.join("\n");
+	}
+	/**
+	* Format verification result as markdown.
+	*/
+	formatAsMarkdown(result) {
+		const lines = [];
+		lines.push(`# Verification Report`);
+		lines.push("");
+		lines.push(`**Status:** ${result.passed ? "✓ Passed" : "✗ Failed"}`);
+		lines.push(`**Score:** ${result.score}/100`);
+		lines.push(`**Duration:** ${result.duration}ms`);
+		lines.push("");
+		for (const [tier, report] of result.reports) {
+			lines.push(`## ${this.formatTierName(tier)}`);
+			lines.push("");
+			lines.push(`**Status:** ${report.passed ? "✓ Passed" : "✗ Failed"}`);
+			lines.push(`**Score:** ${report.score}/100`);
+			lines.push("");
+			if (report.issues.length > 0) {
+				lines.push("### Issues");
+				lines.push("");
+				for (const issue of report.issues) {
+					const icon = issue.severity === "error" ? "❌" : issue.severity === "warning" ? "⚠️" : "ℹ️";
+					lines.push(`${icon} **${issue.category}**: ${issue.message}`);
+					if (issue.suggestion) lines.push(`  - Suggestion: ${issue.suggestion}`);
+				}
+				lines.push("");
+			}
+			if (report.coverage.scenarios.total > 0) lines.push(`**Scenarios:** ${report.coverage.scenarios.covered}/${report.coverage.scenarios.total}`);
+			if (report.coverage.errors.total > 0) lines.push(`**Errors handled:** ${report.coverage.errors.handled}/${report.coverage.errors.total}`);
+			lines.push("");
+		}
+		const allSuggestions = Array.from(result.reports.values()).flatMap((r) => r.suggestions);
+		if (allSuggestions.length > 0) {
+			lines.push("## Suggestions");
+			lines.push("");
+			for (const suggestion of allSuggestions.slice(0, 10)) lines.push(`- ${suggestion}`);
+			if (allSuggestions.length > 10) lines.push(`- ... and ${allSuggestions.length - 10} more`);
+			lines.push("");
+		}
+		return lines.join("\n");
+	}
+	/**
+	* Format tier name for display.
+	*/
+	formatTierName(tier) {
+		switch (tier) {
+			case "structure": return "Tier 1: Structure";
+			case "behavior": return "Tier 2: Behavior";
+			case "ai_review": return "Tier 3: AI Review";
+			default: return tier;
+		}
+	}
+	/**
+	* Update configuration.
+	*/
+	configure(config) {
+		this.config = {
+			...this.config,
+			...config
+		};
+	}
+};
+/**
+* Create a new VerifyService instance.
+*/
+function createVerifyService(config) {
+	return new VerifyService(config);
+}
+/** Default singleton instance */
+const verifyService = new VerifyService();
+
+//#endregion
+export { VerifyService, createVerifyService, verifyService };

package/dist/services/watch.js

@@ -1 +1,31 @@
-import{validateSpec as e}from"./validate.js";import{buildSpec as t}from"./build.js";function n(n,r,i,a){let{watcher:o,fs:s,logger:c}=n,l=o.watch(i),u=a?.validate??(async t=>{await e(t,{fs:s,logger:c})}),d=a?.build??(async e=>{await t(e,{fs:s,logger:c},r)});return l.on(async e=>{e.type===`change`&&(c.info(`watchSpecs.changed`,{path:e.path}),i.runValidate&&await u(e.path),i.runBuild&&(i.dryRun?c.info(`[dry-run] watchSpecs skipped build`,{path:e.path}):await d(e.path)))}),l}export{n as watchSpecs};
+import { validateSpec } from "./validate.js";
+import { buildSpec } from "./build.js";
+
+//#region src/services/watch.ts
+function watchSpecs(adapters, config, options, overrides) {
+	const { watcher, fs, logger } = adapters;
+	const w = watcher.watch(options);
+	const validateFn = overrides?.validate ?? (async (specPath) => {
+		await validateSpec(specPath, {
+			fs,
+			logger
+		});
+	});
+	const buildFn = overrides?.build ?? (async (specPath) => {
+		await buildSpec(specPath, {
+			fs,
+			logger
+		}, config);
+	});
+	w.on(async (event) => {
+		if (event.type !== "change") return;
+		logger.info("watchSpecs.changed", { path: event.path });
+		if (options.runValidate) await validateFn(event.path);
+		if (options.runBuild) if (options.dryRun) logger.info("[dry-run] watchSpecs skipped build", { path: event.path });
+		else await buildFn(event.path);
+	});
+	return w;
+}
+
+//#endregion
+export { watchSpecs };

package/dist/services/workspace-info.js

@@ -1,2 +1,102 @@
-import{detectPackageManager as e,findPackageRoot as t,findWorkspaceRoot as n,getWorkspaceInfo as r}from"../adapters/workspace.js";async function i(e,t){let n=r(t),i=e.join(n.workspaceRoot,`.contractsrc.json`),a=e.join(n.packageRoot,`.contractsrc.json`),o=await e.exists(i),s=n.workspaceRoot===n.packageRoot?!1:await e.exists(a),c;if(o)try{let t=await e.readFile(i),n=JSON.parse(t);(n.packages||n.excludePackages||n.recursive)&&(c={packages:n.packages,excludePackages:n.excludePackages,recursive:n.recursive})}catch{}return{...n,monorepoConfig:c,workspaceConfigPath:o?i:void 0,packageConfigPath:s?a:void 0}}async function a(e,t){let n=[],r=e.join(t,`.contractsrc.json`);await e.exists(r)&&n.push(r);let i=await e.glob({pattern:`**/.contractsrc.json`,ignore:[`node_modules/**`,`.git/**`]});for(let e of i)e!==r&&n.push(e);return n}async function o(e,t,n){let r={};if(t&&await e.exists(t))try{let n=await e.readFile(t);r=JSON.parse(n)}catch{}if(n&&await e.exists(n))try{let t=await e.readFile(n),i=JSON.parse(t);r=s(r,i)}catch{}return r}function s(e,t){let n={...e};for(let r of Object.keys(t)){let i=e[r],a=t[r];typeof i==`object`&&i&&!Array.isArray(i)&&typeof a==`object`&&a&&!Array.isArray(a)?n[r]=s(i,a):n[r]=a}return n}function c(e){let t=[];return t.push(`Package Manager: ${e.packageManager}`),t.push(`Workspace Root: ${e.workspaceRoot}`),e.isMonorepo?(t.push(`Monorepo: Yes`),t.push(`Package Root: ${e.packageRoot}`),e.packageName&&t.push(`Current Package: ${e.packageName}`),e.packages&&e.packages.length>0&&t.push(`Package Patterns: ${e.packages.join(`, `)}`)):t.push(`Monorepo: No`),e.workspaceConfigPath&&t.push(`Workspace Config: ${e.workspaceConfigPath}`),e.packageConfigPath&&t.push(`Package Config: ${e.packageConfigPath}`),t.join(`
-`)}export{a as findAllConfigFiles,c as formatWorkspaceInfo,i as getExtendedWorkspaceInfo,o as mergeMonorepoConfigs};
+import { detectPackageManager, findPackageRoot, findWorkspaceRoot, getWorkspaceInfo } from "../adapters/workspace.js";
+
+//#region src/services/workspace-info.ts
+/**
+* Workspace info service.
+*
+* Provides workspace detection and configuration loading
+* with support for monorepos.
+*/
+/**
+* Get extended workspace information including config paths.
+*/
+async function getExtendedWorkspaceInfo(fs, startDir) {
+	const baseInfo = getWorkspaceInfo(startDir);
+	const workspaceConfigPath = fs.join(baseInfo.workspaceRoot, ".contractsrc.json");
+	const packageConfigPath = fs.join(baseInfo.packageRoot, ".contractsrc.json");
+	const hasWorkspaceConfig = await fs.exists(workspaceConfigPath);
+	const hasPackageConfig = baseInfo.workspaceRoot !== baseInfo.packageRoot ? await fs.exists(packageConfigPath) : false;
+	let monorepoConfig;
+	if (hasWorkspaceConfig) try {
+		const content = await fs.readFile(workspaceConfigPath);
+		const config = JSON.parse(content);
+		if (config.packages || config.excludePackages || config.recursive) monorepoConfig = {
+			packages: config.packages,
+			excludePackages: config.excludePackages,
+			recursive: config.recursive
+		};
+	} catch {}
+	return {
+		...baseInfo,
+		monorepoConfig,
+		workspaceConfigPath: hasWorkspaceConfig ? workspaceConfigPath : void 0,
+		packageConfigPath: hasPackageConfig ? packageConfigPath : void 0
+	};
+}
+/**
+* Find all .contractsrc.json files in a monorepo.
+*
+* Returns paths in order of priority (workspace first, then packages).
+*/
+async function findAllConfigFiles(fs, workspaceRoot) {
+	const configFiles = [];
+	const rootConfig = fs.join(workspaceRoot, ".contractsrc.json");
+	if (await fs.exists(rootConfig)) configFiles.push(rootConfig);
+	const packageConfigs = await fs.glob({
+		pattern: "**/.contractsrc.json",
+		ignore: ["node_modules/**", ".git/**"]
+	});
+	for (const config of packageConfigs) if (config !== rootConfig) configFiles.push(config);
+	return configFiles;
+}
+/**
+* Merge workspace and package configurations.
+*
+* Package config overrides workspace config.
+*/
+async function mergeMonorepoConfigs(fs, workspaceConfigPath, packageConfigPath) {
+	let merged = {};
+	if (workspaceConfigPath && await fs.exists(workspaceConfigPath)) try {
+		const content = await fs.readFile(workspaceConfigPath);
+		merged = JSON.parse(content);
+	} catch {}
+	if (packageConfigPath && await fs.exists(packageConfigPath)) try {
+		const content = await fs.readFile(packageConfigPath);
+		const packageConfig = JSON.parse(content);
+		merged = deepMerge(merged, packageConfig);
+	} catch {}
+	return merged;
+}
+/**
+* Deep merge two objects.
+*/
+function deepMerge(base, override) {
+	const result = { ...base };
+	for (const key of Object.keys(override)) {
+		const baseValue = base[key];
+		const overrideValue = override[key];
+		if (typeof baseValue === "object" && baseValue !== null && !Array.isArray(baseValue) && typeof overrideValue === "object" && overrideValue !== null && !Array.isArray(overrideValue)) result[key] = deepMerge(baseValue, overrideValue);
+		else result[key] = overrideValue;
+	}
+	return result;
+}
+/**
+* Format workspace info for display.
+*/
+function formatWorkspaceInfo(info) {
+	const lines = [];
+	lines.push(`Package Manager: ${info.packageManager}`);
+	lines.push(`Workspace Root: ${info.workspaceRoot}`);
+	if (info.isMonorepo) {
+		lines.push(`Monorepo: Yes`);
+		lines.push(`Package Root: ${info.packageRoot}`);
+		if (info.packageName) lines.push(`Current Package: ${info.packageName}`);
+		if (info.packages && info.packages.length > 0) lines.push(`Package Patterns: ${info.packages.join(", ")}`);
+	} else lines.push(`Monorepo: No`);
+	if (info.workspaceConfigPath) lines.push(`Workspace Config: ${info.workspaceConfigPath}`);
+	if (info.packageConfigPath) lines.push(`Package Config: ${info.packageConfigPath}`);
+	return lines.join("\n");
+}
+
+//#endregion
+export { findAllConfigFiles, formatWorkspaceInfo, getExtendedWorkspaceInfo, mergeMonorepoConfigs };