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

package/dist/ai/agents/claude-code-agent.js

@@ -1,14 +1,69 @@
-import{anthropic as e}from"@ai-sdk/anthropic";import{generateText as t}from"ai";var n=class{name=`claude-code`;apiKey;constructor(){this.apiKey=process.env.ANTHROPIC_API_KEY}canHandle(e){return!!this.apiKey}async generate(n){if(!this.apiKey)return{success:!1,errors:[`ANTHROPIC_API_KEY not set. Claude Code agent requires API access.`]};try{let r=e(`claude-3-7-sonnet-20250219`),i=this.buildSystemPrompt(n),a=await t({model:r,prompt:this.buildUserPrompt(n),system:i,temperature:.2});return{success:!0,code:this.extractCode(a.text),metadata:{model:`claude-3-7-sonnet`,agentMode:`claude-code`,usage:a.usage}}}catch(e){return{success:!1,errors:[e instanceof Error?e.message:String(e)]}}}async validate(n){if(!this.apiKey)return{success:!1,errors:[`ANTHROPIC_API_KEY not set`]};try{let r=await t({model:e(`claude-3-7-sonnet-20250219`),prompt:`
+import { anthropic } from "@ai-sdk/anthropic";
+import { generateText } from "ai";
+
+//#region src/ai/agents/claude-code-agent.ts
+/**
+* Claude Code Agent - Uses Anthropic's advanced code capabilities
+* with extended context and agentic workflows
+*/
+var ClaudeCodeAgent = class {
+	name = "claude-code";
+	apiKey;
+	constructor() {
+		this.apiKey = process.env.ANTHROPIC_API_KEY;
+	}
+	canHandle(task) {
+		return !!this.apiKey;
+	}
+	async generate(task) {
+		if (!this.apiKey) return {
+			success: false,
+			errors: ["ANTHROPIC_API_KEY not set. Claude Code agent requires API access."]
+		};
+		try {
+			const model = anthropic("claude-3-7-sonnet-20250219");
+			const systemPrompt = this.buildSystemPrompt(task);
+			const result = await generateText({
+				model,
+				prompt: this.buildUserPrompt(task),
+				system: systemPrompt,
+				temperature: .2
+			});
+			return {
+				success: true,
+				code: this.extractCode(result.text),
+				metadata: {
+					model: "claude-3-7-sonnet",
+					agentMode: "claude-code",
+					usage: result.usage
+				}
+			};
+		} catch (error) {
+			return {
+				success: false,
+				errors: [error instanceof Error ? error.message : String(error)]
+			};
+		}
+	}
+	async validate(task) {
+		if (!this.apiKey) return {
+			success: false,
+			errors: ["ANTHROPIC_API_KEY not set"]
+		};
+		try {
+			const result = await generateText({
+				model: anthropic("claude-3-7-sonnet-20250219"),
+				prompt: `
 You are an expert code reviewer. Carefully analyze this implementation against its specification.
 
 SPECIFICATION:
 \`\`\`typescript
-${n.specCode}
+${task.specCode}
 \`\`\`
 
 IMPLEMENTATION:
 \`\`\`typescript
-${n.existingCode||`// No implementation provided`}
+${task.existingCode || "// No implementation provided"}
 \`\`\`
 
 Provide a structured validation report:
@@ -27,7 +82,31 @@ Provide a structured validation report:
 - Are there any missing edge cases?
 
 Be thorough and precise. Use a critical but constructive tone.
-`,system:`You are a senior software engineer performing a critical code review.`,temperature:.3}),i=this.detectIssues(r.text);return{success:!i,code:r.text,errors:i?this.extractErrors(r.text):[],warnings:this.extractWarnings(r.text),suggestions:this.extractSuggestions(r.text),metadata:{agentMode:`claude-code`,validationType:`comprehensive`}}}catch(e){return{success:!1,errors:[e instanceof Error?e.message:String(e)]}}}buildSystemPrompt(e){let t=`You are an expert TypeScript developer specializing in contract-driven development.
+`,
+				system: "You are a senior software engineer performing a critical code review.",
+				temperature: .3
+			});
+			const hasErrors = this.detectIssues(result.text);
+			return {
+				success: !hasErrors,
+				code: result.text,
+				errors: hasErrors ? this.extractErrors(result.text) : [],
+				warnings: this.extractWarnings(result.text),
+				suggestions: this.extractSuggestions(result.text),
+				metadata: {
+					agentMode: "claude-code",
+					validationType: "comprehensive"
+				}
+			};
+		} catch (error) {
+			return {
+				success: false,
+				errors: [error instanceof Error ? error.message : String(error)]
+			};
+		}
+	}
+	buildSystemPrompt(task) {
+		const basePrompt = `You are an expert TypeScript developer specializing in contract-driven development.
 
 Your code is:
 - Type-safe with comprehensive TypeScript types
@@ -36,9 +115,67 @@ Your code is:
 - Following SOLID principles and best practices
 - Modular and testable
 
-Generate clean, idiomatic TypeScript code that exactly matches the specification.`;return e.type===`test`?t+`
+Generate clean, idiomatic TypeScript code that exactly matches the specification.`;
+		if (task.type === "test") return basePrompt + "\n\nYou are also an expert in testing. Write comprehensive tests using Vitest.";
+		return basePrompt;
+	}
+	buildUserPrompt(task) {
+		const prompts = {
+			generate: `Generate a complete, production-ready implementation for this specification:\n\n${task.specCode}\n\nProvide ONLY the TypeScript code, no explanations.`,
+			test: `Generate comprehensive tests for this code:\n\nSpec:\n${task.specCode}\n\nImplementation:\n${task.existingCode}\n\nProvide complete Vitest test suite.`,
+			refactor: `Refactor this code while preserving functionality:\n\n${task.existingCode}\n\nSpec:\n${task.specCode}`,
+			validate: `Validate this implementation:\n\nSpec:\n${task.specCode}\n\nCode:\n${task.existingCode}`
+		};
+		return prompts[task.type] || prompts.generate;
+	}
+	extractCode(text) {
+		const codeBlockMatch = text.match(/```(?:typescript|ts|tsx)?\n([\s\S]*?)\n```/);
+		if (codeBlockMatch && codeBlockMatch[1]) return codeBlockMatch[1];
+		return text;
+	}
+	detectIssues(reviewText) {
+		const errorIndicators = [
+			"missing",
+			"incorrect",
+			"bug",
+			"error",
+			"violation",
+			"does not",
+			"fails to",
+			"not implemented",
+			"critical"
+		];
+		const lowerText = reviewText.toLowerCase();
+		return errorIndicators.some((indicator) => lowerText.includes(indicator));
+	}
+	extractErrors(text) {
+		const errors = [];
+		const lines = text.split("\n");
+		for (const line of lines) {
+			const lower = line.toLowerCase();
+			if (lower.includes("error") || lower.includes("bug") || lower.includes("incorrect") || lower.includes("missing")) errors.push(line.trim());
+		}
+		return errors.length > 0 ? errors : ["Code review identified issues"];
+	}
+	extractWarnings(text) {
+		const warnings = [];
+		const lines = text.split("\n");
+		for (const line of lines) {
+			const lower = line.toLowerCase();
+			if (lower.includes("warning") || lower.includes("should") || lower.includes("consider")) warnings.push(line.trim());
+		}
+		return warnings;
+	}
+	extractSuggestions(text) {
+		const suggestions = [];
+		const lines = text.split("\n");
+		for (const line of lines) {
+			const lower = line.toLowerCase();
+			if (lower.includes("suggest") || lower.includes("recommend") || lower.includes("could") || lower.includes("improvement")) suggestions.push(line.trim());
+		}
+		return suggestions;
+	}
+};
 
-You are also an expert in testing. Write comprehensive tests using Vitest.`:t}buildUserPrompt(e){let t={generate:`Generate a complete, production-ready implementation for this specification:\n\n${e.specCode}\n\nProvide ONLY the TypeScript code, no explanations.`,test:`Generate comprehensive tests for this code:\n\nSpec:\n${e.specCode}\n\nImplementation:\n${e.existingCode}\n\nProvide complete Vitest test suite.`,refactor:`Refactor this code while preserving functionality:\n\n${e.existingCode}\n\nSpec:\n${e.specCode}`,validate:`Validate this implementation:\n\nSpec:\n${e.specCode}\n\nCode:\n${e.existingCode}`};return t[e.type]||t.generate}extractCode(e){let t=e.match(/```(?:typescript|ts|tsx)?\n([\s\S]*?)\n```/);return t&&t[1]?t[1]:e}detectIssues(e){let t=[`missing`,`incorrect`,`bug`,`error`,`violation`,`does not`,`fails to`,`not implemented`,`critical`],n=e.toLowerCase();return t.some(e=>n.includes(e))}extractErrors(e){let t=[],n=e.split(`
-`);for(let e of n){let n=e.toLowerCase();(n.includes(`error`)||n.includes(`bug`)||n.includes(`incorrect`)||n.includes(`missing`))&&t.push(e.trim())}return t.length>0?t:[`Code review identified issues`]}extractWarnings(e){let t=[],n=e.split(`
-`);for(let e of n){let n=e.toLowerCase();(n.includes(`warning`)||n.includes(`should`)||n.includes(`consider`))&&t.push(e.trim())}return t}extractSuggestions(e){let t=[],n=e.split(`
-`);for(let e of n){let n=e.toLowerCase();(n.includes(`suggest`)||n.includes(`recommend`)||n.includes(`could`)||n.includes(`improvement`))&&t.push(e.trim())}return t}};export{n as ClaudeCodeAgent};
+//#endregion
+export { ClaudeCodeAgent };

package/dist/ai/agents/cursor-agent.js

@@ -1,4 +1,188 @@
-import{join as e}from"path";import{existsSync as t}from"fs";import{exec as n,spawn as r}from"child_process";import{mkdir as i,readFile as a,rm as o,writeFile as s}from"fs/promises";import{homedir as c,tmpdir as l}from"os";import{promisify as u}from"util";u(n);var d=class{name=`cursor`;cursorPath=null;isWindsurf=!1;composerPort;constructor(){this.composerPort=process.env.CURSOR_COMPOSER_PORT||`3000`,this.detectEnvironment()}canHandle(e){return this.isCursorAvailable()}async generate(t){try{let n=e(l(),`cursor-agent-${Date.now()}`);await i(n,{recursive:!0});let r=await this.executeWithBestMethod(t,n);return await this.cleanupWorkDir(n),r}catch(e){return{success:!1,errors:[e instanceof Error?e.message:String(e)]}}}async validate(t){try{let n=e(l(),`cursor-validate-${Date.now()}`);await i(n,{recursive:!0}),await this.setupValidationWorkspace(t,n);let r=await this.executeWithBestMethod({...t,type:`validate`},n);return await this.cleanupWorkDir(n),r}catch(e){return{success:!1,errors:[e instanceof Error?e.message:String(e)]}}}detectEnvironment(){this.isWindsurf=!!(process.env.WINDSURF_SESSION||process.env.CURSOR_USER_DATA||process.env.VSCODE_CWD?.includes(`Cursor`)||process.env.VSCODE_CWD?.includes(`Windsurf`));let n=[`/usr/local/bin/cursor`,`/Applications/Cursor.app/Contents/MacOS/Cursor`,`/Applications/Windsurf.app/Contents/MacOS/Windsurf`,e(c(),`.cursor`,`cursor`),e(c(),`AppData`,`Local`,`Programs`,`cursor`,`Cursor.exe`),e(c(),`AppData`,`Local`,`Programs`,`windsurf`,`Windsurf.exe`),`cursor`,`windsurf`];for(let e of n)if(e.includes(`cursor`)||e.includes(`Cursor`)||e.includes(`windsurf`)||e.includes(`Windsurf`))try{if(t(e)){this.cursorPath=e;break}}catch{continue}}async executeWithBestMethod(e,t){let n=[{name:`cursor-cli`,fn:()=>this.useCursorCLI(e,t)},{name:`file-based`,fn:()=>this.useFileBasedApproach(e,t)}];for(let e of n)try{let t=await e.fn();if(t.success)return t}catch{continue}return{success:!1,warnings:[`Cursor agent could not connect to IDE.`,`Ensure Cursor/Windsurf is running with API enabled.`,`Falling back to simple agent mode is recommended.`],errors:[`All Cursor integration methods failed`],metadata:{agentMode:`cursor`,status:`unavailable`,suggestion:`Use --agent-mode claude-code or --agent-mode simple`}}}async useCursorCLI(n,i){if(!this.cursorPath)throw Error(`Cursor executable not found`);let o=e(i,`spec.ts`),c=e(i,`output.ts`),l=e(i,`INSTRUCTIONS.md`);return await s(o,n.specCode),await s(l,this.buildDetailedPrompt(n)),n.existingCode&&await s(e(i,`existing.ts`),n.existingCode),new Promise((e,n)=>{let o=[`--wait`,`--new-window`,i],s=r(this.cursorPath,o,{cwd:i,stdio:`pipe`,detached:!1}),l=``,u=``;s.stdout?.on(`data`,e=>{l+=e.toString()}),s.stderr?.on(`data`,e=>{u+=e.toString()}),s.on(`error`,e=>{n(e)}),s.on(`close`,async r=>{if(t(c))try{e({success:!0,code:await a(c,`utf-8`),metadata:{agentMode:`cursor`,method:`cli`,exitCode:r}})}catch{n(Error(`Failed to read generated output`))}else n(Error(`Cursor CLI exited with code ${r}. No output generated.`))}),setTimeout(()=>{s.kill(),n(Error(`Cursor CLI timeout`))},6e4)})}async useFileBasedApproach(t,n){let r=e(n,`SPECIFICATION.ts`),i=e(n,`INSTRUCTIONS.md`),a=e(n,`template.ts`);return await s(r,t.specCode),await s(i,this.buildDetailedPrompt(t)),await s(a,this.generateTemplate(t)),await s(e(n,`README.md`),`# Cursor Agent Workspace
+import { join } from "path";
+import { existsSync } from "fs";
+import { exec, spawn } from "child_process";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { homedir, tmpdir } from "os";
+import { promisify } from "util";
+
+//#region src/ai/agents/cursor-agent.ts
+/**
+* Cursor/Windsurf Agent - Fully Implemented
+* Leverages Windsurf AI capabilities and Cursor IDE integration for code generation and validation
+*/
+promisify(exec);
+var CursorAgent = class {
+	name = "cursor";
+	cursorPath = null;
+	isWindsurf = false;
+	composerPort;
+	constructor() {
+		this.composerPort = process.env.CURSOR_COMPOSER_PORT || "3000";
+		this.detectEnvironment();
+	}
+	canHandle(task) {
+		return this.isCursorAvailable();
+	}
+	async generate(task) {
+		try {
+			const workDir = join(tmpdir(), `cursor-agent-${Date.now()}`);
+			await mkdir(workDir, { recursive: true });
+			const result = await this.executeWithBestMethod(task, workDir);
+			await this.cleanupWorkDir(workDir);
+			return result;
+		} catch (error) {
+			return {
+				success: false,
+				errors: [error instanceof Error ? error.message : String(error)]
+			};
+		}
+	}
+	async validate(task) {
+		try {
+			const workDir = join(tmpdir(), `cursor-validate-${Date.now()}`);
+			await mkdir(workDir, { recursive: true });
+			await this.setupValidationWorkspace(task, workDir);
+			const result = await this.executeWithBestMethod({
+				...task,
+				type: "validate"
+			}, workDir);
+			await this.cleanupWorkDir(workDir);
+			return result;
+		} catch (error) {
+			return {
+				success: false,
+				errors: [error instanceof Error ? error.message : String(error)]
+			};
+		}
+	}
+	/**
+	* Detect if running in Cursor/Windsurf environment
+	*/
+	detectEnvironment() {
+		this.isWindsurf = !!(process.env.WINDSURF_SESSION || process.env.CURSOR_USER_DATA || process.env.VSCODE_CWD?.includes("Cursor") || process.env.VSCODE_CWD?.includes("Windsurf"));
+		const possiblePaths = [
+			"/usr/local/bin/cursor",
+			"/Applications/Cursor.app/Contents/MacOS/Cursor",
+			"/Applications/Windsurf.app/Contents/MacOS/Windsurf",
+			join(homedir(), ".cursor", "cursor"),
+			join(homedir(), "AppData", "Local", "Programs", "cursor", "Cursor.exe"),
+			join(homedir(), "AppData", "Local", "Programs", "windsurf", "Windsurf.exe"),
+			"cursor",
+			"windsurf"
+		];
+		for (const path of possiblePaths) if (path.includes("cursor") || path.includes("Cursor") || path.includes("windsurf") || path.includes("Windsurf")) try {
+			if (existsSync(path)) {
+				this.cursorPath = path;
+				break;
+			}
+		} catch {
+			continue;
+		}
+	}
+	/**
+	* Execute task using the best available method
+	*/
+	async executeWithBestMethod(task, workDir) {
+		const methods = [{
+			name: "cursor-cli",
+			fn: () => this.useCursorCLI(task, workDir)
+		}, {
+			name: "file-based",
+			fn: () => this.useFileBasedApproach(task, workDir)
+		}];
+		for (const method of methods) try {
+			const result = await method.fn();
+			if (result.success) return result;
+		} catch (error) {
+			continue;
+		}
+		return {
+			success: false,
+			warnings: [
+				"Cursor agent could not connect to IDE.",
+				"Ensure Cursor/Windsurf is running with API enabled.",
+				"Falling back to simple agent mode is recommended."
+			],
+			errors: ["All Cursor integration methods failed"],
+			metadata: {
+				agentMode: "cursor",
+				status: "unavailable",
+				suggestion: "Use --agent-mode claude-code or --agent-mode simple"
+			}
+		};
+	}
+	/**
+	* Use Windsurf's native API
+	*/
+	/**
+	* Use Cursor Composer API
+	*/
+	/**
+	* Use Cursor CLI directly
+	*/
+	async useCursorCLI(task, workDir) {
+		if (!this.cursorPath) throw new Error("Cursor executable not found");
+		const specPath = join(workDir, "spec.ts");
+		const outputPath = join(workDir, "output.ts");
+		const instructionsPath = join(workDir, "INSTRUCTIONS.md");
+		await writeFile(specPath, task.specCode);
+		await writeFile(instructionsPath, this.buildDetailedPrompt(task));
+		if (task.existingCode) await writeFile(join(workDir, "existing.ts"), task.existingCode);
+		return new Promise((resolve, reject) => {
+			const args = [
+				"--wait",
+				"--new-window",
+				workDir
+			];
+			const cursor = spawn(this.cursorPath, args, {
+				cwd: workDir,
+				stdio: "pipe",
+				detached: false
+			});
+			let stdout = "";
+			let stderr = "";
+			cursor.stdout?.on("data", (data) => {
+				stdout += data.toString();
+			});
+			cursor.stderr?.on("data", (data) => {
+				stderr += data.toString();
+			});
+			cursor.on("error", (error) => {
+				reject(error);
+			});
+			cursor.on("close", async (code) => {
+				if (existsSync(outputPath)) try {
+					resolve({
+						success: true,
+						code: await readFile(outputPath, "utf-8"),
+						metadata: {
+							agentMode: "cursor",
+							method: "cli",
+							exitCode: code
+						}
+					});
+				} catch (error) {
+					reject(/* @__PURE__ */ new Error("Failed to read generated output"));
+				}
+				else reject(/* @__PURE__ */ new Error(`Cursor CLI exited with code ${code}. No output generated.`));
+			});
+			setTimeout(() => {
+				cursor.kill();
+				reject(/* @__PURE__ */ new Error("Cursor CLI timeout"));
+			}, 6e4);
+		});
+	}
+	/**
+	* File-based approach - create workspace and instructions for manual completion
+	*/
+	async useFileBasedApproach(task, workDir) {
+		const specPath = join(workDir, "SPECIFICATION.ts");
+		const instructionsPath = join(workDir, "INSTRUCTIONS.md");
+		const templatePath = join(workDir, "template.ts");
+		await writeFile(specPath, task.specCode);
+		await writeFile(instructionsPath, this.buildDetailedPrompt(task));
+		await writeFile(templatePath, this.generateTemplate(task));
+		await writeFile(join(workDir, "README.md"), `# Cursor Agent Workspace
 
 This workspace was prepared for Cursor AI code generation.
 
@@ -13,8 +197,53 @@ This workspace was prepared for Cursor AI code generation.
 3. Use Cursor AI to generate code based on the spec
 4. Save the result as output.ts
 
-Workspace path: ${n}
-`),{success:!1,warnings:[`Cursor agent created workspace but cannot auto-execute.`,`Workspace prepared at: ${n}`,`Open this folder in Cursor IDE to complete code generation.`],code:this.generateTemplate(t),metadata:{agentMode:`cursor`,method:`file-based`,workDir:n}}}async setupValidationWorkspace(t,n){await s(e(n,`specification.ts`),t.specCode),await s(e(n,`implementation.ts`),t.existingCode||`// No implementation`),await s(e(n,`VALIDATION_INSTRUCTIONS.md`),this.buildValidationPrompt(t))}async prepareFilesForAPI(e,t){let n=[{path:`spec.ts`,content:e.specCode}];return e.existingCode&&n.push({path:`existing.ts`,content:e.existingCode}),n}buildDetailedPrompt(e){let t=`# AI Code Generation Task - Cursor Agent\n\n**Task Type:** ${e.type}\n**Generated:** ${new Date().toISOString()}\n\n`,n=`## Specification\n\n\`\`\`typescript\n${e.specCode}\n\`\`\`\n\n`,r={generate:`## Task: Generate Implementation
+Workspace path: ${workDir}
+`);
+		return {
+			success: false,
+			warnings: [
+				"Cursor agent created workspace but cannot auto-execute.",
+				`Workspace prepared at: ${workDir}`,
+				"Open this folder in Cursor IDE to complete code generation."
+			],
+			code: this.generateTemplate(task),
+			metadata: {
+				agentMode: "cursor",
+				method: "file-based",
+				workDir
+			}
+		};
+	}
+	/**
+	* Setup workspace for validation
+	*/
+	async setupValidationWorkspace(task, workDir) {
+		await writeFile(join(workDir, "specification.ts"), task.specCode);
+		await writeFile(join(workDir, "implementation.ts"), task.existingCode || "// No implementation");
+		await writeFile(join(workDir, "VALIDATION_INSTRUCTIONS.md"), this.buildValidationPrompt(task));
+	}
+	/**
+	* Prepare files for API submission
+	*/
+	async prepareFilesForAPI(task, workDir) {
+		const files = [{
+			path: "spec.ts",
+			content: task.specCode
+		}];
+		if (task.existingCode) files.push({
+			path: "existing.ts",
+			content: task.existingCode
+		});
+		return files;
+	}
+	/**
+	* Build detailed prompt for cursor
+	*/
+	buildDetailedPrompt(task) {
+		const header = `# AI Code Generation Task - Cursor Agent\n\n**Task Type:** ${task.type}\n**Generated:** ${(/* @__PURE__ */ new Date()).toISOString()}\n\n`;
+		const specification = `## Specification\n\n\`\`\`typescript\n${task.specCode}\n\`\`\`\n\n`;
+		const taskInstructions = {
+			generate: `## Task: Generate Implementation
 
 ### Requirements:
 1. **Type Safety**: Use strict TypeScript with comprehensive types
@@ -34,11 +263,12 @@ Workspace path: ${n}
 
 ### Output Format:
 Provide complete, executable TypeScript code that fully implements the specification.
-Include all necessary imports and type definitions.`,validate:`## Task: Validate Implementation
+Include all necessary imports and type definitions.`,
+			validate: `## Task: Validate Implementation
 
 ### Current Implementation:
 \`\`\`typescript
-${e.existingCode||`// No implementation provided`}
+${task.existingCode || "// No implementation provided"}
 \`\`\`
 
 ### Validation Criteria:
@@ -62,11 +292,12 @@ Provide a detailed validation report with:
 - **Status**: Pass/Fail
 - **Issues Found**: List all problems
 - **Recommendations**: Specific improvements needed
-- **Code Quality Score**: Rate the implementation`,test:`## Task: Generate Tests
+- **Code Quality Score**: Rate the implementation`,
+			test: `## Task: Generate Tests
 
 ### Implementation to Test:
 \`\`\`typescript
-${e.existingCode||``}
+${task.existingCode || ""}
 \`\`\`
 
 ### Test Requirements:
@@ -84,11 +315,12 @@ ${e.existingCode||``}
 - Performance tests (if applicable)
 
 ### Output Format:
-Complete Vitest test file with comprehensive test coverage.`,refactor:`## Task: Refactor Code
+Complete Vitest test file with comprehensive test coverage.`,
+			refactor: `## Task: Refactor Code
 
 ### Current Code:
 \`\`\`typescript
-${e.existingCode||``}
+${task.existingCode || ""}
 \`\`\`
 
 ### Refactoring Goals:
@@ -107,16 +339,24 @@ ${e.existingCode||``}
 - Enhance error messages
 
 ### Output Format:
-Refactored code that maintains functionality while improving quality.`};return t+n+(r[e.type]||r.generate)}buildValidationPrompt(e){return`# Implementation Validation Report
+Refactored code that maintains functionality while improving quality.`
+		};
+		return header + specification + (taskInstructions[task.type] || taskInstructions.generate);
+	}
+	/**
+	* Build validation-specific prompt
+	*/
+	buildValidationPrompt(task) {
+		return `# Implementation Validation Report
 
 ## Specification
 \`\`\`typescript
-${e.specCode}
+${task.specCode}
 \`\`\`
 
 ## Implementation
 \`\`\`typescript
-${e.existingCode||`// No implementation`}
+${task.existingCode || "// No implementation"}
 \`\`\`
 
 ## Validation Checklist
@@ -152,11 +392,15 @@ ${e.existingCode||`// No implementation`}
 ## Instructions
 Review the implementation against the specification and complete the checklist.
 Provide detailed feedback for each failed item.
-Suggest specific improvements with code examples where applicable.`}generateTemplate(e){return`// Auto-generated template for ${e.type} task
+Suggest specific improvements with code examples where applicable.`;
+	}
+	/**
+	* Generate basic template for task
+	*/
+	generateTemplate(task) {
+		return `// Auto-generated template for ${task.type} task
 // Specification:
-${e.specCode.split(`
-`).map(e=>`// ${e}`).join(`
-`)}
+${task.specCode.split("\n").map((line) => `// ${line}`).join("\n")}
 
 // TODO: Implement according to specification
 // Use Cursor AI to complete this implementation
@@ -165,4 +409,29 @@ export function implementation() {
   // Implementation goes here
   throw new Error('Not implemented');
 }
-`}async cleanupWorkDir(e){try{await o(e,{recursive:!0,force:!0})}catch{}}isCursorAvailable(){return this.isWindsurf||this.cursorPath!==null||this.hasComposerAPI()}hasComposerAPI(){return!!(process.env.CURSOR_COMPOSER_PORT||process.env.CURSOR_API_ENABLED||this.isWindsurf)}};export{d as CursorAgent};
+`;
+	}
+	/**
+	* Cleanup temporary work directory
+	*/
+	async cleanupWorkDir(workDir) {
+		try {
+			await rm(workDir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+	isCursorAvailable() {
+		return this.isWindsurf || this.cursorPath !== null || this.hasComposerAPI();
+	}
+	/**
+	* Check if Cursor Composer API might be available
+	*/
+	hasComposerAPI() {
+		return !!(process.env.CURSOR_COMPOSER_PORT || process.env.CURSOR_API_ENABLED || this.isWindsurf);
+	}
+};
+
+//#endregion
+export { CursorAgent };

package/dist/ai/agents/index.js

@@ -1 +1,5 @@
-import{SimpleAgent as e}from"./simple-agent.js";import{CursorAgent as t}from"./cursor-agent.js";import{ClaudeCodeAgent as n}from"./claude-code-agent.js";import{OpenAICodexAgent as r}from"./openai-codex-agent.js";import{AgentOrchestrator as i}from"./orchestrator.js";
+import { SimpleAgent } from "./simple-agent.js";
+import { CursorAgent } from "./cursor-agent.js";
+import { ClaudeCodeAgent } from "./claude-code-agent.js";
+import { OpenAICodexAgent } from "./openai-codex-agent.js";
+import { AgentOrchestrator } from "./orchestrator.js";