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

package/dist/services/agent-guide/adapters/generic-mcp.js

@@ -1,3 +1,159 @@
-import{AGENT_SYSTEM_PROMPTS as e}from"@lssm/lib.contracts/llm";var t=class{agentType=`generic-mcp`;formatPlan(t){let n=[];if(n.push(`# Implementation Task: ${t.target.name}.v${t.target.version}`),n.push(``),n.push(`## Task`),n.push(``),n.push(`Implement the ${t.target.type} \`${t.target.name}\` version ${t.target.version}.`),n.push(``),n.push(`## Context`),n.push(``),n.push(`**Goal:** ${t.context.goal}`),n.push(``),n.push(`**Description:** ${t.context.description}`),n.push(``),t.context.background&&(n.push(`**Background:**`),n.push(``),n.push(t.context.background),n.push(``)),n.push(`## Specification`),n.push(``),n.push(t.specMarkdown),n.push(``),t.fileStructure.length>0){n.push(`## Files`),n.push(``),n.push(`| Path | Action | Purpose |`),n.push(`|------|--------|---------|`);for(let e of t.fileStructure)n.push(`| \`${e.path}\` | ${e.type} | ${e.purpose} |`);n.push(``)}n.push(`## Implementation Steps`),n.push(``);for(let e of t.steps)if(n.push(`### Step ${e.order}: ${e.title}`),n.push(``),n.push(e.description),n.push(``),e.acceptanceCriteria.length>0){n.push(`**Acceptance Criteria:**`),n.push(``);for(let t of e.acceptanceCriteria)n.push(`- ${t}`);n.push(``)}if(n.push(`## Constraints`),n.push(``),t.constraints.policy.length>0){n.push(`**Policy:**`);for(let e of t.constraints.policy)n.push(`- ${e}`);n.push(``)}if(t.constraints.security.length>0){n.push(`**Security:**`);for(let e of t.constraints.security)n.push(`- ${e}`);n.push(``)}if(t.constraints.pii.length>0){n.push(`**PII Fields (handle with care):**`);for(let e of t.constraints.pii)n.push(`- \`${e}\``);n.push(``)}n.push(`## Verification`),n.push(``),n.push(`After implementation, verify:`),n.push(``);for(let e of t.verificationChecklist)n.push(`- [ ] ${e}`);return n.push(``),{agent:`generic-mcp`,systemPrompt:e[`generic-mcp`],taskPrompt:n.join(`
-`)}}formatAsResource(e){return{uri:`spec://${e.target.name}/v${e.target.version}/plan`,mimeType:`application/json`,data:JSON.stringify({target:e.target,context:e.context,fileStructure:e.fileStructure,steps:e.steps,constraints:e.constraints,verificationChecklist:e.verificationChecklist},null,2)}}formatAsPromptMessage(e){return{role:`user`,content:{type:`text`,text:this.formatPlan(e).taskPrompt}}}generateConfig(e){let t=e.meta,n=[];return n.push(`# ${t.name} v${t.version}`),n.push(``),n.push(`**Type:** ${t.kind}`),n.push(`**Stability:** ${t.stability}`),n.push(``),n.push(`## Goal`),n.push(``),n.push(t.goal),n.push(``),n.push(`## Description`),n.push(``),n.push(t.description),n.push(``),n.join(`
-`)}parseOutput(e){let t=e.match(/```(?:typescript|ts|tsx|javascript|js|python|go|rust)?\n([\s\S]*?)\n```/);if(t?.[1])return{code:t[1]};try{let t=JSON.parse(e);if(typeof t.code==`string`)return{code:t.code};if(typeof t.errors==`object`)return{errors:Array.isArray(t.errors)?t.errors:[String(t.errors)]}}catch{}return{code:e}}};const n=new t;export{t as GenericMCPAdapter,n as genericMCPAdapter};
+import { AGENT_SYSTEM_PROMPTS } from "../../../libs/contracts/dist/llm/prompts.js";
+import "../../../libs/contracts/dist/llm/index.js";
+
+//#region src/services/agent-guide/adapters/generic-mcp.ts
+/**
+* Generic MCP adapter implementation.
+* Works with any MCP-compatible agent (Cline, Aider, etc.).
+*/
+var GenericMCPAdapter = class {
+	agentType = "generic-mcp";
+	/**
+	* Format an implementation plan for generic MCP agents.
+	* Uses a standard markdown format that works across different agents.
+	*/
+	formatPlan(plan) {
+		const lines = [];
+		lines.push(`# Implementation Task: ${plan.target.name}.v${plan.target.version}`);
+		lines.push("");
+		lines.push("## Task");
+		lines.push("");
+		lines.push(`Implement the ${plan.target.type} \`${plan.target.name}\` version ${plan.target.version}.`);
+		lines.push("");
+		lines.push("## Context");
+		lines.push("");
+		lines.push(`**Goal:** ${plan.context.goal}`);
+		lines.push("");
+		lines.push(`**Description:** ${plan.context.description}`);
+		lines.push("");
+		if (plan.context.background) {
+			lines.push("**Background:**");
+			lines.push("");
+			lines.push(plan.context.background);
+			lines.push("");
+		}
+		lines.push("## Specification");
+		lines.push("");
+		lines.push(plan.specMarkdown);
+		lines.push("");
+		if (plan.fileStructure.length > 0) {
+			lines.push("## Files");
+			lines.push("");
+			lines.push("| Path | Action | Purpose |");
+			lines.push("|------|--------|---------|");
+			for (const file of plan.fileStructure) lines.push(`| \`${file.path}\` | ${file.type} | ${file.purpose} |`);
+			lines.push("");
+		}
+		lines.push("## Implementation Steps");
+		lines.push("");
+		for (const step of plan.steps) {
+			lines.push(`### Step ${step.order}: ${step.title}`);
+			lines.push("");
+			lines.push(step.description);
+			lines.push("");
+			if (step.acceptanceCriteria.length > 0) {
+				lines.push("**Acceptance Criteria:**");
+				lines.push("");
+				for (const criteria of step.acceptanceCriteria) lines.push(`- ${criteria}`);
+				lines.push("");
+			}
+		}
+		lines.push("## Constraints");
+		lines.push("");
+		if (plan.constraints.policy.length > 0) {
+			lines.push("**Policy:**");
+			for (const p of plan.constraints.policy) lines.push(`- ${p}`);
+			lines.push("");
+		}
+		if (plan.constraints.security.length > 0) {
+			lines.push("**Security:**");
+			for (const s of plan.constraints.security) lines.push(`- ${s}`);
+			lines.push("");
+		}
+		if (plan.constraints.pii.length > 0) {
+			lines.push("**PII Fields (handle with care):**");
+			for (const pii of plan.constraints.pii) lines.push(`- \`${pii}\``);
+			lines.push("");
+		}
+		lines.push("## Verification");
+		lines.push("");
+		lines.push("After implementation, verify:");
+		lines.push("");
+		for (const check of plan.verificationChecklist) lines.push(`- [ ] ${check}`);
+		lines.push("");
+		return {
+			agent: "generic-mcp",
+			systemPrompt: AGENT_SYSTEM_PROMPTS["generic-mcp"],
+			taskPrompt: lines.join("\n")
+		};
+	}
+	/**
+	* Format the plan as an MCP resource.
+	* Returns JSON that can be served as an MCP resource.
+	*/
+	formatAsResource(plan) {
+		return {
+			uri: `spec://${plan.target.name}/v${plan.target.version}/plan`,
+			mimeType: "application/json",
+			data: JSON.stringify({
+				target: plan.target,
+				context: plan.context,
+				fileStructure: plan.fileStructure,
+				steps: plan.steps,
+				constraints: plan.constraints,
+				verificationChecklist: plan.verificationChecklist
+			}, null, 2)
+		};
+	}
+	/**
+	* Format the plan as an MCP prompt message.
+	*/
+	formatAsPromptMessage(plan) {
+		return {
+			role: "user",
+			content: {
+				type: "text",
+				text: this.formatPlan(plan).taskPrompt
+			}
+		};
+	}
+	/**
+	* Generate configuration (generic markdown for any agent).
+	*/
+	generateConfig(spec) {
+		const m = spec.meta;
+		const lines = [];
+		lines.push(`# ${m.name} v${m.version}`);
+		lines.push("");
+		lines.push(`**Type:** ${m.kind}`);
+		lines.push(`**Stability:** ${m.stability}`);
+		lines.push("");
+		lines.push("## Goal");
+		lines.push("");
+		lines.push(m.goal);
+		lines.push("");
+		lines.push("## Description");
+		lines.push("");
+		lines.push(m.description);
+		lines.push("");
+		return lines.join("\n");
+	}
+	/**
+	* Parse agent output - generic implementation.
+	*/
+	parseOutput(output) {
+		const codeBlockMatch = output.match(/```(?:typescript|ts|tsx|javascript|js|python|go|rust)?\n([\s\S]*?)\n```/);
+		if (codeBlockMatch?.[1]) return { code: codeBlockMatch[1] };
+		try {
+			const parsed = JSON.parse(output);
+			if (typeof parsed.code === "string") return { code: parsed.code };
+			if (typeof parsed.errors === "object") return { errors: Array.isArray(parsed.errors) ? parsed.errors : [String(parsed.errors)] };
+		} catch {}
+		return { code: output };
+	}
+};
+/** Singleton instance */
+const genericMCPAdapter = new GenericMCPAdapter();
+
+//#endregion
+export { GenericMCPAdapter, genericMCPAdapter };

package/dist/services/agent-guide/adapters/index.js

@@ -1 +1,30 @@
-import{ClaudeCodeAdapter as e,claudeCodeAdapter as t}from"./claude-code.js";import{CursorCLIAdapter as n,cursorCLIAdapter as r}from"./cursor-cli.js";import{GenericMCPAdapter as i,genericMCPAdapter as a}from"./generic-mcp.js";const o={"claude-code":t,"cursor-cli":r,"generic-mcp":a};function s(e){let t=o[e];if(!t)throw Error(`Unknown agent type: ${e}`);return t}function c(){return Object.keys(o)}export{o as agentAdapters,s as getAgentAdapter,c as listAgentTypes};
+import { ClaudeCodeAdapter, claudeCodeAdapter } from "./claude-code.js";
+import { CursorCLIAdapter, cursorCLIAdapter } from "./cursor-cli.js";
+import { GenericMCPAdapter, genericMCPAdapter } from "./generic-mcp.js";
+
+//#region src/services/agent-guide/adapters/index.ts
+/**
+* Registry of all available agent adapters.
+*/
+const agentAdapters = {
+	"claude-code": claudeCodeAdapter,
+	"cursor-cli": cursorCLIAdapter,
+	"generic-mcp": genericMCPAdapter
+};
+/**
+* Get an adapter for a specific agent type.
+*/
+function getAgentAdapter(agent) {
+	const adapter = agentAdapters[agent];
+	if (!adapter) throw new Error(`Unknown agent type: ${agent}`);
+	return adapter;
+}
+/**
+* List all available agent types.
+*/
+function listAgentTypes() {
+	return Object.keys(agentAdapters);
+}
+
+//#endregion
+export { agentAdapters, getAgentAdapter, listAgentTypes };

package/dist/services/agent-guide/agent-guide-service.js

@@ -1 +1,148 @@
-import{getAgentAdapter as e,listAgentTypes as t}from"./adapters/index.js";import{featureToMarkdown as n,generateImplementationPlan as r,specToAgentPrompt as i,specToFullMarkdown as a}from"@lssm/lib.contracts/llm";const o={defaultAgent:`generic-mcp`,verbose:!1};var s=class{config;constructor(e={}){this.config={...o,...e}}generateGuide(t,n={}){let i=e(n.agent??this.config.defaultAgent),o=r(t,{projectRoot:this.config.projectRoot,existingFiles:n.targetPath?[n.targetPath]:void 0});return{plan:o,prompt:i.formatPlan(o),markdown:a(t)}}generateFeatureGuide(t,i,a={}){let o=e(a.agent??this.config.defaultAgent),s=t.operations?.[0],c=s?i.specs?.getSpec(s.name,s.version):void 0,l;c?(l=r(c,{projectRoot:this.config.projectRoot}),l.target={type:`feature`,name:t.meta.key,version:1},l.context.goal=t.meta.description??l.context.goal):l={target:{type:`feature`,name:t.meta.key,version:1},context:{goal:t.meta.description??`Implement feature ${t.meta.key}`,description:t.meta.title??t.meta.key,background:``},specMarkdown:n(t,i),fileStructure:[],steps:[{order:1,title:`Implement Feature`,description:`Implement the ${t.meta.key} feature`,acceptanceCriteria:[]}],constraints:{policy:[],security:[],pii:[]},verificationChecklist:[]},l.specMarkdown=n(t,i,{format:`full`,includeRelatedSpecs:!0,includeRelatedEvents:!0,includeRelatedPresentations:!0}),t.operations?.length&&(l.steps=t.operations.map((e,t)=>({order:t+1,title:`Implement ${e.name}`,description:`Implement operation ${e.name}.v${e.version}`,acceptanceCriteria:[`Operation ${e.name} works as specified`]})));let u=o.formatPlan(l),d=n(t,i);return{plan:l,prompt:u,markdown:d}}generateAgentConfig(t,n){return e(n??this.config.defaultAgent).generateConfig?.(t)}exportForAgent(e,t,n=`implement`,r){return i(e,{taskType:n,existingCode:r})}listAgentTypes(){return t()}getDefaultAgent(){return this.config.defaultAgent}configure(e){this.config={...this.config,...e}}};function c(e){return new s(e)}const l=new s;export{s as AgentGuideService,l as agentGuideService,c as createAgentGuideService};
+import { featureToMarkdown, specToAgentPrompt, specToFullMarkdown } from "../../libs/contracts/dist/llm/exporters.js";
+import { generateImplementationPlan } from "../../libs/contracts/dist/llm/prompts.js";
+import "../../libs/contracts/dist/llm/index.js";
+import { getAgentAdapter, listAgentTypes } from "./adapters/index.js";
+
+//#region src/services/agent-guide/agent-guide-service.ts
+const DEFAULT_CONFIG = {
+	defaultAgent: "generic-mcp",
+	verbose: false
+};
+/**
+* Agent Guide Service
+*
+* Main service for generating implementation guidance for AI coding agents.
+*/
+var AgentGuideService = class {
+	config;
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+	}
+	/**
+	* Generate an implementation guide for a spec.
+	*/
+	generateGuide(spec, options = {}) {
+		const adapter = getAgentAdapter(options.agent ?? this.config.defaultAgent);
+		const plan = generateImplementationPlan(spec, {
+			projectRoot: this.config.projectRoot,
+			existingFiles: options.targetPath ? [options.targetPath] : void 0
+		});
+		return {
+			plan,
+			prompt: adapter.formatPlan(plan),
+			markdown: specToFullMarkdown(spec)
+		};
+	}
+	/**
+	* Generate a guide for a feature (includes all related specs).
+	*/
+	generateFeatureGuide(feature, deps, options = {}) {
+		const adapter = getAgentAdapter(options.agent ?? this.config.defaultAgent);
+		const firstOp = feature.operations?.[0];
+		const spec = firstOp ? deps.specs?.getSpec(firstOp.name, firstOp.version) : void 0;
+		let plan;
+		if (spec) {
+			plan = generateImplementationPlan(spec, { projectRoot: this.config.projectRoot });
+			plan.target = {
+				type: "feature",
+				name: feature.meta.key,
+				version: 1
+			};
+			plan.context.goal = feature.meta.description ?? plan.context.goal;
+		} else plan = {
+			target: {
+				type: "feature",
+				name: feature.meta.key,
+				version: 1
+			},
+			context: {
+				goal: feature.meta.description ?? `Implement feature ${feature.meta.key}`,
+				description: feature.meta.title ?? feature.meta.key,
+				background: ""
+			},
+			specMarkdown: featureToMarkdown(feature, deps),
+			fileStructure: [],
+			steps: [{
+				order: 1,
+				title: "Implement Feature",
+				description: `Implement the ${feature.meta.key} feature`,
+				acceptanceCriteria: []
+			}],
+			constraints: {
+				policy: [],
+				security: [],
+				pii: []
+			},
+			verificationChecklist: []
+		};
+		plan.specMarkdown = featureToMarkdown(feature, deps, {
+			format: "full",
+			includeRelatedSpecs: true,
+			includeRelatedEvents: true,
+			includeRelatedPresentations: true
+		});
+		if (feature.operations?.length) plan.steps = feature.operations.map((op, idx) => ({
+			order: idx + 1,
+			title: `Implement ${op.name}`,
+			description: `Implement operation ${op.name}.v${op.version}`,
+			acceptanceCriteria: [`Operation ${op.name} works as specified`]
+		}));
+		const prompt = adapter.formatPlan(plan);
+		const markdown = featureToMarkdown(feature, deps);
+		return {
+			plan,
+			prompt,
+			markdown
+		};
+	}
+	/**
+	* Generate agent-specific configuration (e.g., cursor rules).
+	*/
+	generateAgentConfig(spec, agent) {
+		return getAgentAdapter(agent ?? this.config.defaultAgent).generateConfig?.(spec);
+	}
+	/**
+	* Export a spec in a specific format for an agent.
+	*/
+	exportForAgent(spec, agent, taskType = "implement", existingCode) {
+		return specToAgentPrompt(spec, {
+			taskType,
+			existingCode
+		});
+	}
+	/**
+	* List available agent types.
+	*/
+	listAgentTypes() {
+		return listAgentTypes();
+	}
+	/**
+	* Get the default agent type.
+	*/
+	getDefaultAgent() {
+		return this.config.defaultAgent;
+	}
+	/**
+	* Update configuration.
+	*/
+	configure(config) {
+		this.config = {
+			...this.config,
+			...config
+		};
+	}
+};
+/**
+* Create a new AgentGuideService instance.
+*/
+function createAgentGuideService(config) {
+	return new AgentGuideService(config);
+}
+/** Default singleton instance */
+const agentGuideService = new AgentGuideService();
+
+//#endregion
+export { AgentGuideService, agentGuideService, createAgentGuideService };

package/dist/services/agent-guide/index.js

@@ -1 +1,5 @@
-import{ClaudeCodeAdapter as e,claudeCodeAdapter as t}from"./adapters/claude-code.js";import{CursorCLIAdapter as n,cursorCLIAdapter as r}from"./adapters/cursor-cli.js";import{GenericMCPAdapter as i,genericMCPAdapter as a}from"./adapters/generic-mcp.js";import{agentAdapters as o,getAgentAdapter as s,listAgentTypes as c}from"./adapters/index.js";import{AgentGuideService as l,agentGuideService as u,createAgentGuideService as d}from"./agent-guide-service.js";
+import { ClaudeCodeAdapter, claudeCodeAdapter } from "./adapters/claude-code.js";
+import { CursorCLIAdapter, cursorCLIAdapter } from "./adapters/cursor-cli.js";
+import { GenericMCPAdapter, genericMCPAdapter } from "./adapters/generic-mcp.js";
+import { agentAdapters, getAgentAdapter, listAgentTypes } from "./adapters/index.js";
+import { AgentGuideService, agentGuideService, createAgentGuideService } from "./agent-guide-service.js";

package/dist/services/build.js

@@ -1 +1,140 @@
-import{generateComponentTemplate as e,generateHandlerTemplate as t,generateTestTemplate as n,inferSpecTypeFromFilePath as r,scanSpecSource as i}from"@lssm/module.contractspec-workspace";async function a(e,t,n,a={}){let{fs:c,logger:l}=t,{targets:u=s(e),outputDir:d=n.outputDir,overwrite:f=!1,dryRun:p=!1}=a,m=await c.readFile(e),h=i(m,e),g=r(e);l.info(`Building from spec: ${e}`,{specType:g});let _=[];for(let t of u)try{let n=await o(t,e,m,h,g,{fs:c,logger:l},d,f,p);_.push(n)}catch(e){_.push({target:t,outputPath:``,success:!1,error:e instanceof Error?e.message:String(e)})}return{specPath:e,specInfo:h,results:_}}async function o(r,i,a,o,s,l,u,d,f){let{fs:p,logger:m}=l,h,g;switch(r){case`handler`:{if(s!==`operation`)return{target:r,outputPath:``,success:!1,skipped:!0,error:`Handler generation only supported for operation specs (got ${s})`};let e=o.kind===`command`||o.kind===`query`?o.kind:`command`;h=t(o.name??`unknown`,e),g=c(i,u,`handlers`,o.name??`unknown`,`.handler.ts`,l.fs);break}case`component`:if(s!==`presentation`)return{target:r,outputPath:``,success:!1,skipped:!0,error:`Component generation only supported for presentation specs (got ${s})`};h=e(o.name??`unknown`,o.description??``),g=c(i,u,`components`,o.name??`unknown`,`.tsx`,l.fs);break;case`test`:{let e=s===`operation`?`handler`:`component`;h=n(o.name??`unknown`,e),g=c(i,u,`__tests__`,o.name??`unknown`,`.test.ts`,l.fs);break}default:return{target:r,outputPath:``,success:!1,error:`Unknown target: ${r}`}}if(await p.exists(g)&&!d)return{target:r,outputPath:g,success:!1,skipped:!0,error:`File already exists (use overwrite option)`};if(f)return m.info(`[dry-run] Would write: ${g}`),{target:r,outputPath:g,success:!0};let _=p.dirname(g);return await p.mkdir(_),await p.writeFile(g,h),m.info(`Generated: ${g}`),{target:r,outputPath:g,success:!0}}function s(e){switch(r(e)){case`operation`:return[`handler`];case`presentation`:return[`component`];default:return[]}}function c(e,t,n,r,i,a){let o=l(r.split(`.`).pop()??`unknown`),s;return s=t.startsWith(`.`)?a.resolve(a.dirname(e),`..`,t,n):a.resolve(t,n),a.join(s,`${o}${i}`)}function l(e){return e.replace(/\./g,`-`).replace(/([a-z])([A-Z])/g,`$1-$2`).toLowerCase()}export{a as buildSpec};
+import { inferSpecTypeFromFilePath, scanSpecSource } from "../modules/contractspec-workspace/dist/analysis/spec-scan.js";
+import { generateComponentTemplate, generateHandlerTemplate, generateTestTemplate } from "../modules/contractspec-workspace/dist/templates/handler.js";
+
+//#region src/services/build.ts
+/**
+* Build/scaffold service for generating implementation files from specs.
+*
+* Uses templates from @lssm/module.contractspec-workspace to generate
+* handler, component, and test skeletons without requiring AI.
+*/
+/**
+* Build implementation files from a spec.
+*/
+async function buildSpec(specPath, adapters, config, options = {}) {
+	const { fs, logger } = adapters;
+	const { targets = detectDefaultTargets(specPath), outputDir = config.outputDir, overwrite = false, dryRun = false } = options;
+	const specCode = await fs.readFile(specPath);
+	const specInfo = scanSpecSource(specCode, specPath);
+	const specType = inferSpecTypeFromFilePath(specPath);
+	logger.info(`Building from spec: ${specPath}`, { specType });
+	const results = [];
+	for (const target of targets) try {
+		const result = await buildTarget(target, specPath, specCode, specInfo, specType, {
+			fs,
+			logger
+		}, outputDir, overwrite, dryRun);
+		results.push(result);
+	} catch (error) {
+		results.push({
+			target,
+			outputPath: "",
+			success: false,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return {
+		specPath,
+		specInfo,
+		results
+	};
+}
+/**
+* Build a single target from a spec.
+*/
+async function buildTarget(target, specPath, _specCode, specInfo, specType, adapters, outputDir, overwrite, dryRun) {
+	const { fs, logger } = adapters;
+	let code;
+	let outputPath;
+	switch (target) {
+		case "handler": {
+			if (specType !== "operation") return {
+				target,
+				outputPath: "",
+				success: false,
+				skipped: true,
+				error: `Handler generation only supported for operation specs (got ${specType})`
+			};
+			const kind = specInfo.kind === "command" || specInfo.kind === "query" ? specInfo.kind : "command";
+			code = generateHandlerTemplate(specInfo.name ?? "unknown", kind);
+			outputPath = resolveOutputPath(specPath, outputDir, "handlers", specInfo.name ?? "unknown", ".handler.ts", adapters.fs);
+			break;
+		}
+		case "component":
+			if (specType !== "presentation") return {
+				target,
+				outputPath: "",
+				success: false,
+				skipped: true,
+				error: `Component generation only supported for presentation specs (got ${specType})`
+			};
+			code = generateComponentTemplate(specInfo.name ?? "unknown", specInfo.description ?? "");
+			outputPath = resolveOutputPath(specPath, outputDir, "components", specInfo.name ?? "unknown", ".tsx", adapters.fs);
+			break;
+		case "test": {
+			const testType = specType === "operation" ? "handler" : "component";
+			code = generateTestTemplate(specInfo.name ?? "unknown", testType);
+			outputPath = resolveOutputPath(specPath, outputDir, "__tests__", specInfo.name ?? "unknown", ".test.ts", adapters.fs);
+			break;
+		}
+		default: return {
+			target,
+			outputPath: "",
+			success: false,
+			error: `Unknown target: ${target}`
+		};
+	}
+	if (await fs.exists(outputPath) && !overwrite) return {
+		target,
+		outputPath,
+		success: false,
+		skipped: true,
+		error: "File already exists (use overwrite option)"
+	};
+	if (dryRun) {
+		logger.info(`[dry-run] Would write: ${outputPath}`);
+		return {
+			target,
+			outputPath,
+			success: true
+		};
+	}
+	const dirPath = fs.dirname(outputPath);
+	await fs.mkdir(dirPath);
+	await fs.writeFile(outputPath, code);
+	logger.info(`Generated: ${outputPath}`);
+	return {
+		target,
+		outputPath,
+		success: true
+	};
+}
+/**
+* Detect default targets based on spec type.
+*/
+function detectDefaultTargets(specPath) {
+	switch (inferSpecTypeFromFilePath(specPath)) {
+		case "operation": return ["handler"];
+		case "presentation": return ["component"];
+		default: return [];
+	}
+}
+/**
+* Resolve output path for generated file.
+*/
+function resolveOutputPath(specPath, outputDir, subdir, specName, extension, fs) {
+	const sanitizedName = toKebabCase(specName.split(".").pop() ?? "unknown");
+	let baseDir;
+	if (outputDir.startsWith(".")) baseDir = fs.resolve(fs.dirname(specPath), "..", outputDir, subdir);
+	else baseDir = fs.resolve(outputDir, subdir);
+	return fs.join(baseDir, `${sanitizedName}${extension}`);
+}
+/**
+* Convert string to kebab-case.
+*/
+function toKebabCase(str) {
+	return str.replace(/\./g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+
+//#endregion
+export { buildSpec };