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

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

@@ -1,437 +0,0 @@
-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.
-
-## Files:
-- **SPECIFICATION.ts**: The contract specification
-- **INSTRUCTIONS.md**: Detailed instructions for the AI
-- **template.ts**: Starting template
-
-## To Complete:
-1. Open this folder in Cursor
-2. Review INSTRUCTIONS.md
-3. Use Cursor AI to generate code based on the spec
-4. Save the result as output.ts
-
-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
-2. **Error Handling**: Implement robust error handling and validation
-3. **Documentation**: Add JSDoc comments for all public APIs
-4. **Best Practices**: Follow SOLID principles and clean code practices
-5. **Testing**: Design code to be easily testable
-6. **Production Ready**: Code should be ready for production use
-
-### Implementation Guidelines:
-- Parse and validate all inputs according to the specification
-- Handle all edge cases and error scenarios
-- Use modern TypeScript features appropriately
-- Ensure proper async/await usage if needed
-- Add meaningful variable and function names
-- Keep functions focused and single-purpose
-
-### Output Format:
-Provide complete, executable TypeScript code that fully implements the specification.
-Include all necessary imports and type definitions.`,
-			validate: `## Task: Validate Implementation
-
-### Current Implementation:
-\`\`\`typescript
-${task.existingCode || "// No implementation provided"}
-\`\`\`
-
-### Validation Criteria:
-1. **Specification Compliance**: Does it match all requirements?
-2. **Type Safety**: Are all types correct and complete?
-3. **Error Handling**: Is error handling adequate?
-4. **Code Quality**: Does it follow best practices?
-5. **Completeness**: Are there missing features?
-
-### Review Checklist:
-- [ ] All specified inputs/outputs are handled
-- [ ] Types match the specification exactly
-- [ ] Error cases are properly handled
-- [ ] Code is production-ready
-- [ ] No obvious bugs or issues
-- [ ] Performance is acceptable
-- [ ] Code is maintainable
-
-### Output Format:
-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
-
-### Implementation to Test:
-\`\`\`typescript
-${task.existingCode || ""}
-\`\`\`
-
-### Test Requirements:
-1. **Coverage**: Test all code paths and edge cases
-2. **Framework**: Use Vitest
-3. **Structure**: Organize tests logically (describe/it blocks)
-4. **Assertions**: Use clear, meaningful assertions
-5. **Mocking**: Mock external dependencies appropriately
-
-### Test Categories Needed:
-- Unit tests for individual functions
-- Integration tests for workflows
-- Edge case tests
-- Error handling tests
-- Performance tests (if applicable)
-
-### Output Format:
-Complete Vitest test file with comprehensive test coverage.`,
-			refactor: `## Task: Refactor Code
-
-### Current Code:
-\`\`\`typescript
-${task.existingCode || ""}
-\`\`\`
-
-### Refactoring Goals:
-1. **Maintainability**: Improve code organization and readability
-2. **Performance**: Optimize where beneficial
-3. **Type Safety**: Enhance type definitions
-4. **Error Handling**: Improve error handling robustness
-5. **Documentation**: Add missing documentation
-
-### Refactoring Guidelines:
-- Preserve all existing functionality
-- Extract reusable components
-- Eliminate code duplication
-- Improve naming and structure
-- Add type guards where beneficial
-- Enhance error messages
-
-### Output Format:
-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
-${task.specCode}
-\`\`\`
-
-## Implementation
-\`\`\`typescript
-${task.existingCode || "// No implementation"}
-\`\`\`
-
-## Validation Checklist
-
-### 1. Specification Compliance
-- [ ] All required features implemented
-- [ ] Input/output types match specification
-- [ ] Behavior matches documented requirements
-
-### 2. Code Quality
-- [ ] Follows TypeScript best practices
-- [ ] Proper error handling
-- [ ] Meaningful variable names
-- [ ] Appropriate code organization
-
-### 3. Type Safety
-- [ ] No type assertions (as) unless necessary
-- [ ] Proper generic usage
-- [ ] Complete type coverage
-
-### 4. Production Readiness
-- [ ] No console.log statements
-- [ ] Proper error handling
-- [ ] Edge cases covered
-- [ ] Performance considerations
-
-### 5. Maintainability
-- [ ] Clear documentation
-- [ ] Testable code structure
-- [ ] No code smells
-- [ ] SOLID principles followed
-
-## 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.`;
-	}
-	/**
-	* Generate basic template for task
-	*/
-	generateTemplate(task) {
-		return `// Auto-generated template for ${task.type} task
-// Specification:
-${task.specCode.split("\n").map((line) => `// ${line}`).join("\n")}
-
-// TODO: Implement according to specification
-// Use Cursor AI to complete this implementation
-
-export function implementation() {
-  // Implementation goes here
-  throw new Error('Not implemented');
-}
-`;
-	}
-	/**
-	* 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,5 +0,0 @@
-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";

package/dist/ai/agents/openai-codex-agent.js

@@ -1,166 +0,0 @@
-import { openai } from "@ai-sdk/openai";
-import { generateText } from "ai";
-
-//#region src/ai/agents/openai-codex-agent.ts
-/**
-* OpenAI Codex Agent - Uses OpenAI's code-optimized models
-* Supports GPT-4o and o1 reasoning models for complex code generation
-*/
-var OpenAICodexAgent = class {
-	name = "openai-codex";
-	apiKey;
-	constructor() {
-		this.apiKey = process.env.OPENAI_API_KEY;
-	}
-	canHandle(task) {
-		return !!this.apiKey;
-	}
-	async generate(task) {
-		if (!this.apiKey) return {
-			success: false,
-			errors: ["OPENAI_API_KEY not set. OpenAI Codex agent requires API access."]
-		};
-		try {
-			const modelName = this.isComplexTask(task) ? "o1" : "gpt-4o";
-			const model = openai(modelName);
-			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: modelName,
-					agentMode: "openai-codex",
-					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: ["OPENAI_API_KEY not set"]
-		};
-		try {
-			const result = await generateText({
-				model: openai("gpt-4o"),
-				prompt: `
-Review this code implementation against its specification.
-
-SPECIFICATION:
-\`\`\`typescript
-${task.specCode}
-\`\`\`
-
-IMPLEMENTATION:
-\`\`\`typescript
-${task.existingCode || "// No implementation"}
-\`\`\`
-
-Provide a detailed validation report including:
-1. Specification compliance
-2. Code quality assessment
-3. Potential bugs or issues
-4. Recommendations for improvement
-
-Format as a structured report.
-`,
-				system: "You are a senior software engineer performing thorough code review.",
-				temperature: .3
-			});
-			const hasIssues = this.detectIssues(result.text);
-			return {
-				success: !hasIssues,
-				code: result.text,
-				errors: hasIssues ? this.extractErrors(result.text) : [],
-				warnings: this.extractWarnings(result.text),
-				metadata: {
-					agentMode: "openai-codex",
-					validationType: "ai-review"
-				}
-			};
-		} catch (error) {
-			return {
-				success: false,
-				errors: [error instanceof Error ? error.message : String(error)]
-			};
-		}
-	}
-	isComplexTask(task) {
-		const complexIndicators = [
-			"algorithm",
-			"optimization",
-			"complex logic",
-			"state management",
-			"concurrent",
-			"distributed"
-		];
-		const taskStr = (task.specCode + (task.existingCode || "")).toLowerCase();
-		return complexIndicators.some((indicator) => taskStr.includes(indicator));
-	}
-	buildSystemPrompt(task) {
-		const basePrompt = `You are an expert TypeScript/JavaScript developer.
-
-Generate production-quality code that is:
-- Type-safe and well-typed
-- Documented with clear comments
-- Following best practices and SOLID principles
-- Properly handling errors and edge cases
-- Testable and maintainable
-
-Output only the code without explanations unless specifically asked.`;
-		if (task.type === "test") return basePrompt + "\n\nGenerate comprehensive test suites using Vitest.";
-		return basePrompt;
-	}
-	buildUserPrompt(task) {
-		switch (task.type) {
-			case "generate": return `Implement this specification:\n\n${task.specCode}\n\nProvide complete, production-ready TypeScript code.`;
-			case "test": return `Create comprehensive tests:\n\nSpec:\n${task.specCode}\n\nImplementation:\n${task.existingCode}\n\nGenerate complete Vitest test suite.`;
-			case "refactor": return `Refactor this code while maintaining functionality:\n\n${task.existingCode}\n\nSpec:\n${task.specCode}`;
-			default: return task.specCode;
-		}
-	}
-	extractCode(text) {
-		const match = text.match(/```(?:typescript|ts|tsx|javascript|js)?\n([\s\S]*?)\n```/);
-		return match && match[1] ? match[1] : text;
-	}
-	detectIssues(text) {
-		const issueKeywords = [
-			"issue",
-			"problem",
-			"bug",
-			"error",
-			"incorrect",
-			"missing",
-			"fails",
-			"violation"
-		];
-		const lower = text.toLowerCase();
-		return issueKeywords.some((keyword) => lower.includes(keyword));
-	}
-	extractErrors(text) {
-		const errors = [];
-		const lines = text.split("\n");
-		for (const line of lines) if (line.toLowerCase().includes("error") || line.toLowerCase().includes("bug") || line.toLowerCase().includes("fails")) errors.push(line.trim());
-		return errors;
-	}
-	extractWarnings(text) {
-		const warnings = [];
-		const lines = text.split("\n");
-		for (const line of lines) if (line.toLowerCase().includes("warning") || line.toLowerCase().includes("should") || line.toLowerCase().includes("consider")) warnings.push(line.trim());
-		return warnings;
-	}
-};
-
-//#endregion
-export { OpenAICodexAgent };