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

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

@@ -1,14 +1,70 @@
-import{openai as e}from"@ai-sdk/openai";import{generateText as t}from"ai";var n=class{name=`openai-codex`;apiKey;constructor(){this.apiKey=process.env.OPENAI_API_KEY}canHandle(e){return!!this.apiKey}async generate(n){if(!this.apiKey)return{success:!1,errors:[`OPENAI_API_KEY not set. OpenAI Codex agent requires API access.`]};try{let r=this.isComplexTask(n)?`o1`:`gpt-4o`,i=e(r),a=this.buildSystemPrompt(n),o=await t({model:i,prompt:this.buildUserPrompt(n),system:a,temperature:.2});return{success:!0,code:this.extractCode(o.text),metadata:{model:r,agentMode:`openai-codex`,usage:o.usage}}}catch(e){return{success:!1,errors:[e instanceof Error?e.message:String(e)]}}}async validate(n){if(!this.apiKey)return{success:!1,errors:[`OPENAI_API_KEY not set`]};try{let r=await t({model:e(`gpt-4o`),prompt:`
+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
-${n.specCode}
+${task.specCode}
 \`\`\`
 
 IMPLEMENTATION:
 \`\`\`typescript
-${n.existingCode||`// No implementation`}
+${task.existingCode || "// No implementation"}
 \`\`\`
 
 Provide a detailed validation report including:
@@ -18,7 +74,42 @@ Provide a detailed validation report including:
 4. Recommendations for improvement
 
 Format as a structured report.
-`,system:`You are a senior software engineer performing thorough 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),metadata:{agentMode:`openai-codex`,validationType:`ai-review`}}}catch(e){return{success:!1,errors:[e instanceof Error?e.message:String(e)]}}}isComplexTask(e){let t=[`algorithm`,`optimization`,`complex logic`,`state management`,`concurrent`,`distributed`],n=(e.specCode+(e.existingCode||``)).toLowerCase();return t.some(e=>n.includes(e))}buildSystemPrompt(e){let t=`You are an expert TypeScript/JavaScript developer.
+`,
+				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
@@ -27,8 +118,49 @@ Generate production-quality code that is:
 - Properly handling errors and edge cases
 - Testable and maintainable
 
-Output only the code without explanations unless specifically asked.`;return e.type===`test`?t+`
+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;
+	}
+};
 
-Generate comprehensive test suites using Vitest.`:t}buildUserPrompt(e){switch(e.type){case`generate`:return`Implement this specification:\n\n${e.specCode}\n\nProvide complete, production-ready TypeScript code.`;case`test`:return`Create comprehensive tests:\n\nSpec:\n${e.specCode}\n\nImplementation:\n${e.existingCode}\n\nGenerate complete Vitest test suite.`;case`refactor`:return`Refactor this code while maintaining functionality:\n\n${e.existingCode}\n\nSpec:\n${e.specCode}`;default:return e.specCode}}extractCode(e){let t=e.match(/```(?:typescript|ts|tsx|javascript|js)?\n([\s\S]*?)\n```/);return t&&t[1]?t[1]:e}detectIssues(e){let t=[`issue`,`problem`,`bug`,`error`,`incorrect`,`missing`,`fails`,`violation`],n=e.toLowerCase();return t.some(e=>n.includes(e))}extractErrors(e){let t=[],n=e.split(`
-`);for(let e of n)(e.toLowerCase().includes(`error`)||e.toLowerCase().includes(`bug`)||e.toLowerCase().includes(`fails`))&&t.push(e.trim());return t}extractWarnings(e){let t=[],n=e.split(`
-`);for(let e of n)(e.toLowerCase().includes(`warning`)||e.toLowerCase().includes(`should`)||e.toLowerCase().includes(`consider`))&&t.push(e.trim());return t}};export{n as OpenAICodexAgent};
+//#endregion
+export { OpenAICodexAgent };

package/dist/ai/agents/orchestrator.js

@@ -1 +1,142 @@
-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 i from"chalk";import a from"ora";var o=class{agents;defaultAgent;constructor(i){this.config=i,this.agents=new Map;let a=new e(i),o=new t,s=new n,c=new r;this.agents.set(`simple`,a),this.agents.set(`cursor`,o),this.agents.set(`claude-code`,s),this.agents.set(`openai-codex`,c),this.defaultAgent=a}async executeTask(e){let t=this.getAgentMode(),n=this.agents.get(t);if(!n)return console.log(i.yellow(`⚠️  Agent '${t}' not found, using simple agent`)),this.defaultAgent.generate(e);if(!n.canHandle(e))return console.log(i.yellow(`⚠️  Agent '${t}' cannot handle this task, falling back to simple agent`)),this.defaultAgent.generate(e);let r=a(`Executing with ${t} agent...`).start();try{let a=e.type===`validate`?await n.validate(e):await n.generate(e);if(a.success)return r.succeed(i.green(`${t} agent completed successfully`)),a;r.warn(i.yellow(`${t} agent failed, trying fallback...`));let o=this.getFallbackMode(t);if(o&&o!==t){let t=this.agents.get(o);if(t&&t.canHandle(e))return e.type===`validate`?await t.validate(e):await t.generate(e)}return r.info(i.gray(`Using simple agent as ultimate fallback`)),e.type===`validate`?await this.defaultAgent.validate(e):await this.defaultAgent.generate(e)}catch{return r.fail(i.red(`Agent execution failed`)),console.log(i.gray(`Falling back to simple agent...`)),e.type===`validate`?await this.defaultAgent.validate(e):await this.defaultAgent.generate(e)}}async generate(e,t){return this.executeTask({type:`generate`,specCode:e,targetPath:t})}async generateTests(e,t){return this.executeTask({type:`test`,specCode:e,existingCode:t})}async validate(e,t){return this.executeTask({type:`validate`,specCode:e,existingCode:t})}async refactor(e,t){return this.executeTask({type:`refactor`,specCode:e,existingCode:t})}async getAvailableAgents(){let e=[];for(let[t,n]of this.agents){let r=n.canHandle({type:`generate`,specCode:`test`});e.push({mode:t,available:r,reason:r?void 0:`Not configured or dependencies missing`})}return e}getAgentMode(){return this.config.agentMode||`simple`}getFallbackMode(e){return{cursor:`claude-code`,"claude-code":`openai-codex`,"openai-codex":`simple`,simple:`simple`}[e]}};export{o as AgentOrchestrator};
+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 chalk from "chalk";
+import ora from "ora";
+
+//#region src/ai/agents/orchestrator.ts
+/**
+* Agent Orchestrator - Coordinates between different AI agents
+* Selects the appropriate agent based on config and task requirements
+*/
+var AgentOrchestrator = class {
+	agents;
+	defaultAgent;
+	constructor(config) {
+		this.config = config;
+		this.agents = /* @__PURE__ */ new Map();
+		const simpleAgent = new SimpleAgent(config);
+		const cursorAgent = new CursorAgent();
+		const claudeAgent = new ClaudeCodeAgent();
+		const openaiAgent = new OpenAICodexAgent();
+		this.agents.set("simple", simpleAgent);
+		this.agents.set("cursor", cursorAgent);
+		this.agents.set("claude-code", claudeAgent);
+		this.agents.set("openai-codex", openaiAgent);
+		this.defaultAgent = simpleAgent;
+	}
+	/**
+	* Execute a task using the configured agent with fallback support
+	*/
+	async executeTask(task) {
+		const agentMode = this.getAgentMode();
+		const agent = this.agents.get(agentMode);
+		if (!agent) {
+			console.log(chalk.yellow(`⚠️  Agent '${agentMode}' not found, using simple agent`));
+			return this.defaultAgent.generate(task);
+		}
+		if (!agent.canHandle(task)) {
+			console.log(chalk.yellow(`⚠️  Agent '${agentMode}' cannot handle this task, falling back to simple agent`));
+			return this.defaultAgent.generate(task);
+		}
+		const spinner = ora(`Executing with ${agentMode} agent...`).start();
+		try {
+			const result = task.type === "validate" ? await agent.validate(task) : await agent.generate(task);
+			if (result.success) {
+				spinner.succeed(chalk.green(`${agentMode} agent completed successfully`));
+				return result;
+			}
+			spinner.warn(chalk.yellow(`${agentMode} agent failed, trying fallback...`));
+			const fallbackMode = this.getFallbackMode(agentMode);
+			if (fallbackMode && fallbackMode !== agentMode) {
+				const fallbackAgent = this.agents.get(fallbackMode);
+				if (fallbackAgent && fallbackAgent.canHandle(task)) return task.type === "validate" ? await fallbackAgent.validate(task) : await fallbackAgent.generate(task);
+			}
+			spinner.info(chalk.gray("Using simple agent as ultimate fallback"));
+			return task.type === "validate" ? await this.defaultAgent.validate(task) : await this.defaultAgent.generate(task);
+		} catch (error) {
+			spinner.fail(chalk.red("Agent execution failed"));
+			console.log(chalk.gray("Falling back to simple agent..."));
+			return task.type === "validate" ? await this.defaultAgent.validate(task) : await this.defaultAgent.generate(task);
+		}
+	}
+	/**
+	* Generate code from specification
+	*/
+	async generate(specCode, targetPath) {
+		return this.executeTask({
+			type: "generate",
+			specCode,
+			targetPath
+		});
+	}
+	/**
+	* Generate tests for implementation
+	*/
+	async generateTests(specCode, implementationCode) {
+		return this.executeTask({
+			type: "test",
+			specCode,
+			existingCode: implementationCode
+		});
+	}
+	/**
+	* Validate implementation against specification
+	*/
+	async validate(specCode, implementationCode) {
+		return this.executeTask({
+			type: "validate",
+			specCode,
+			existingCode: implementationCode
+		});
+	}
+	/**
+	* Refactor existing code
+	*/
+	async refactor(specCode, existingCode) {
+		return this.executeTask({
+			type: "refactor",
+			specCode,
+			existingCode
+		});
+	}
+	/**
+	* List available agents and their status
+	*/
+	async getAvailableAgents() {
+		const results = [];
+		for (const [mode, agent] of this.agents) {
+			const canHandle = agent.canHandle({
+				type: "generate",
+				specCode: "test"
+			});
+			results.push({
+				mode,
+				available: canHandle,
+				reason: canHandle ? void 0 : "Not configured or dependencies missing"
+			});
+		}
+		return results;
+	}
+	/**
+	* Get the configured agent mode
+	*/
+	getAgentMode() {
+		return this.config.agentMode || "simple";
+	}
+	/**
+	* Get fallback mode for an agent
+	*/
+	getFallbackMode(mode) {
+		return {
+			cursor: "claude-code",
+			"claude-code": "openai-codex",
+			"openai-codex": "simple",
+			simple: "simple"
+		}[mode];
+	}
+};
+
+//#endregion
+export { AgentOrchestrator };

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

@@ -1,15 +1,91 @@
-import{getAIProvider as e}from"../providers.js";import{buildComponentPrompt as t,buildFormPrompt as n,buildHandlerPrompt as r,buildTestPrompt as i,getCodeGenSystemPrompt as a}from"../prompts/code-generation.js";import{generateText as o}from"ai";var s=class{name=`simple`;constructor(e){this.config=e}canHandle(e){return!0}async generate(t){try{let n=await o({model:e(this.config),prompt:this.buildPrompt(t),system:a()});return{success:!0,code:n.text,metadata:{model:this.config.aiModel,provider:this.config.aiProvider,tokens:n.usage}}}catch(e){return{success:!1,errors:[e instanceof Error?e.message:String(e)]}}}async validate(t){try{let n=await o({model:e(this.config),prompt:`
+import { getAIProvider } from "../providers.js";
+import { buildComponentPrompt, buildFormPrompt, buildHandlerPrompt, buildTestPrompt, getCodeGenSystemPrompt } from "../prompts/code-generation.js";
+import { generateText } from "ai";
+
+//#region src/ai/agents/simple-agent.ts
+/**
+* Simple LLM-based agent using direct API calls
+* This is the default fallback for basic code generation
+*/
+var SimpleAgent = class {
+	name = "simple";
+	constructor(config) {
+		this.config = config;
+	}
+	canHandle(task) {
+		return true;
+	}
+	async generate(task) {
+		try {
+			const result = await generateText({
+				model: getAIProvider(this.config),
+				prompt: this.buildPrompt(task),
+				system: getCodeGenSystemPrompt()
+			});
+			return {
+				success: true,
+				code: result.text,
+				metadata: {
+					model: this.config.aiModel,
+					provider: this.config.aiProvider,
+					tokens: result.usage
+				}
+			};
+		} catch (error) {
+			return {
+				success: false,
+				errors: [error instanceof Error ? error.message : String(error)]
+			};
+		}
+	}
+	async validate(task) {
+		try {
+			const result = await generateText({
+				model: getAIProvider(this.config),
+				prompt: `
 Review the following implementation against its specification.
 
 Specification:
-${t.specCode}
+${task.specCode}
 
 Implementation:
-${t.existingCode||`// No implementation provided`}
+${task.existingCode || "// No implementation provided"}
 
 Provide a detailed validation report:
 1. Does the implementation match the spec?
 2. Are there any missing features?
 3. Are there any bugs or issues?
 4. Suggestions for improvement
-`,system:`You are a code review expert. Provide thorough, constructive feedback.`}),r=n.text.toLowerCase().includes(`error`)||n.text.toLowerCase().includes(`missing`)||n.text.toLowerCase().includes(`incorrect`);return{success:!r,code:n.text,warnings:r?[`Implementation may not match specification`]:[],metadata:{validationType:`simple-llm`}}}catch(e){return{success:!1,errors:[e instanceof Error?e.message:String(e)]}}}buildPrompt(e){switch(e.type){case`generate`:return e.specCode.includes(`.contracts.`)||e.specCode.includes(`kind:`)?r(e.specCode):e.specCode.includes(`.presentation.`)?t(e.specCode):e.specCode.includes(`.form.`)?n(e.specCode):`Generate implementation for:\n${e.specCode}`;case`test`:return i(e.specCode,e.existingCode||``,`handler`);case`validate`:return`Validate this implementation:\n${e.existingCode}`;default:return e.specCode}}};export{s as SimpleAgent};
+`,
+				system: "You are a code review expert. Provide thorough, constructive feedback."
+			});
+			const hasErrors = result.text.toLowerCase().includes("error") || result.text.toLowerCase().includes("missing") || result.text.toLowerCase().includes("incorrect");
+			return {
+				success: !hasErrors,
+				code: result.text,
+				warnings: hasErrors ? ["Implementation may not match specification"] : [],
+				metadata: { validationType: "simple-llm" }
+			};
+		} catch (error) {
+			return {
+				success: false,
+				errors: [error instanceof Error ? error.message : String(error)]
+			};
+		}
+	}
+	buildPrompt(task) {
+		switch (task.type) {
+			case "generate":
+				if (task.specCode.includes(".contracts.") || task.specCode.includes("kind:")) return buildHandlerPrompt(task.specCode);
+				else if (task.specCode.includes(".presentation.")) return buildComponentPrompt(task.specCode);
+				else if (task.specCode.includes(".form.")) return buildFormPrompt(task.specCode);
+				return `Generate implementation for:\n${task.specCode}`;
+			case "test": return buildTestPrompt(task.specCode, task.existingCode || "", "handler");
+			case "validate": return `Validate this implementation:\n${task.existingCode}`;
+			default: return task.specCode;
+		}
+	}
+};
+
+//#endregion
+export { SimpleAgent };

package/dist/ai/client.js

@@ -1 +1,162 @@
-import{getAIProvider as e}from"./providers.js";import{buildEventSpecPrompt as t,buildOperationSpecPrompt as n,buildPresentationSpecPrompt as r,getSystemPrompt as i}from"./prompts/spec-creation.js";import{buildComponentPrompt as a,buildFormPrompt as o,buildHandlerPrompt as s,buildTestPrompt as c,getCodeGenSystemPrompt as l}from"./prompts/code-generation.js";import{generateObject as u,generateText as d,streamText as f}from"ai";import*as p from"zod";var m=class{constructor(e){this.config=e}async generateOperationSpec(t,r){return(await u({model:e(this.config),schema:p.object({name:p.string().describe(`Dot notation name like "domain.operation"`),version:p.number().int().positive().default(1),description:p.string().describe(`Clear, concise summary`),goal:p.string().describe(`Business purpose`),context:p.string().describe(`Background and constraints`),stability:p.enum([`experimental`,`beta`,`stable`,`deprecated`]).default(`beta`),owners:p.array(p.string()).describe(`Team/person owners with @ prefix`),tags:p.array(p.string()).describe(`Categorization tags`),auth:p.enum([`anonymous`,`user`,`admin`]).describe(`Required auth level`),inputShape:p.string().describe(`Description of input structure`),outputShape:p.string().describe(`Description of output structure`),flags:p.array(p.string()).describe(`Feature flags`).default([]),possibleEvents:p.array(p.string()).describe(`Events this may emit`).default([]),analytics:p.array(p.string()).describe(`Analytics events to track`).default([])}),prompt:n(t,r),system:i()})).object}async generateEventSpec(n){return(await u({model:e(this.config),schema:p.object({name:p.string().describe(`Dot notation name like "domain.event_name"`),version:p.number().int().positive().default(1),description:p.string().describe(`When this event is emitted`),stability:p.enum([`experimental`,`beta`,`stable`,`deprecated`]).default(`beta`),owners:p.array(p.string()).default([]),tags:p.array(p.string()).default([]),payloadShape:p.string().describe(`Description of event payload`),piiFields:p.array(p.string()).describe(`PII field paths`).default([])}),prompt:t(n),system:i()})).object}async generatePresentationSpec(t,n){return(await u({model:e(this.config),schema:p.object({name:p.string(),version:p.number().int().positive().default(1),description:p.string(),stability:p.enum([`experimental`,`beta`,`stable`,`deprecated`]).default(`beta`),owners:p.array(p.string()).default([]),tags:p.array(p.string()).default([]),componentKey:p.string().optional(),propsShape:p.string().optional(),content:p.string().optional(),mimeType:p.string().optional(),dataShape:p.string().optional()}),prompt:r(t,n),system:i()})).object}async generateHandler(t){return(await d({model:e(this.config),prompt:s(t),system:l()})).text}async generateComponent(t){return(await d({model:e(this.config),prompt:a(t),system:l()})).text}async generateForm(t){return(await d({model:e(this.config),prompt:o(t),system:l()})).text}async generateTests(t,n,r){return(await d({model:e(this.config),prompt:c(t,n,r),system:l()})).text}async streamCodeGeneration(t,n){let r=await f({model:e(this.config),prompt:t,system:l()}),i=``;for await(let e of r.textStream)i+=e,n(e);return i}};export{m as AIClient};
+import { getAIProvider } from "./providers.js";
+import { buildEventSpecPrompt, buildOperationSpecPrompt, buildPresentationSpecPrompt, getSystemPrompt } from "./prompts/spec-creation.js";
+import { buildComponentPrompt, buildFormPrompt, buildHandlerPrompt, buildTestPrompt, getCodeGenSystemPrompt } from "./prompts/code-generation.js";
+import { generateObject, generateText, streamText } from "ai";
+import * as z$1 from "zod";
+
+//#region src/ai/client.ts
+/**
+* AI Client for spec creation and code generation
+*/
+var AIClient = class {
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Generate operation spec from natural language description
+	*/
+	async generateOperationSpec(description, kind) {
+		return (await generateObject({
+			model: getAIProvider(this.config),
+			schema: z$1.object({
+				name: z$1.string().describe("Dot notation name like \"domain.operation\""),
+				version: z$1.number().int().positive().default(1),
+				description: z$1.string().describe("Clear, concise summary"),
+				goal: z$1.string().describe("Business purpose"),
+				context: z$1.string().describe("Background and constraints"),
+				stability: z$1.enum([
+					"experimental",
+					"beta",
+					"stable",
+					"deprecated"
+				]).default("beta"),
+				owners: z$1.array(z$1.string()).describe("Team/person owners with @ prefix"),
+				tags: z$1.array(z$1.string()).describe("Categorization tags"),
+				auth: z$1.enum([
+					"anonymous",
+					"user",
+					"admin"
+				]).describe("Required auth level"),
+				inputShape: z$1.string().describe("Description of input structure"),
+				outputShape: z$1.string().describe("Description of output structure"),
+				flags: z$1.array(z$1.string()).describe("Feature flags").default([]),
+				possibleEvents: z$1.array(z$1.string()).describe("Events this may emit").default([]),
+				analytics: z$1.array(z$1.string()).describe("Analytics events to track").default([])
+			}),
+			prompt: buildOperationSpecPrompt(description, kind),
+			system: getSystemPrompt()
+		})).object;
+	}
+	/**
+	* Generate event spec from description
+	*/
+	async generateEventSpec(description) {
+		return (await generateObject({
+			model: getAIProvider(this.config),
+			schema: z$1.object({
+				name: z$1.string().describe("Dot notation name like \"domain.event_name\""),
+				version: z$1.number().int().positive().default(1),
+				description: z$1.string().describe("When this event is emitted"),
+				stability: z$1.enum([
+					"experimental",
+					"beta",
+					"stable",
+					"deprecated"
+				]).default("beta"),
+				owners: z$1.array(z$1.string()).default([]),
+				tags: z$1.array(z$1.string()).default([]),
+				payloadShape: z$1.string().describe("Description of event payload"),
+				piiFields: z$1.array(z$1.string()).describe("PII field paths").default([])
+			}),
+			prompt: buildEventSpecPrompt(description),
+			system: getSystemPrompt()
+		})).object;
+	}
+	/**
+	* Generate presentation spec from description
+	*/
+	async generatePresentationSpec(description, kind) {
+		return (await generateObject({
+			model: getAIProvider(this.config),
+			schema: z$1.object({
+				name: z$1.string(),
+				version: z$1.number().int().positive().default(1),
+				description: z$1.string(),
+				stability: z$1.enum([
+					"experimental",
+					"beta",
+					"stable",
+					"deprecated"
+				]).default("beta"),
+				owners: z$1.array(z$1.string()).default([]),
+				tags: z$1.array(z$1.string()).default([]),
+				componentKey: z$1.string().optional(),
+				propsShape: z$1.string().optional(),
+				content: z$1.string().optional(),
+				mimeType: z$1.string().optional(),
+				dataShape: z$1.string().optional()
+			}),
+			prompt: buildPresentationSpecPrompt(description, kind),
+			system: getSystemPrompt()
+		})).object;
+	}
+	/**
+	* Generate handler implementation from spec
+	*/
+	async generateHandler(specCode) {
+		return (await generateText({
+			model: getAIProvider(this.config),
+			prompt: buildHandlerPrompt(specCode),
+			system: getCodeGenSystemPrompt()
+		})).text;
+	}
+	/**
+	* Generate React component from presentation spec
+	*/
+	async generateComponent(specCode) {
+		return (await generateText({
+			model: getAIProvider(this.config),
+			prompt: buildComponentPrompt(specCode),
+			system: getCodeGenSystemPrompt()
+		})).text;
+	}
+	/**
+	* Generate form component from form spec
+	*/
+	async generateForm(specCode) {
+		return (await generateText({
+			model: getAIProvider(this.config),
+			prompt: buildFormPrompt(specCode),
+			system: getCodeGenSystemPrompt()
+		})).text;
+	}
+	/**
+	* Generate tests for implementation
+	*/
+	async generateTests(specCode, implementationCode, testType) {
+		return (await generateText({
+			model: getAIProvider(this.config),
+			prompt: buildTestPrompt(specCode, implementationCode, testType),
+			system: getCodeGenSystemPrompt()
+		})).text;
+	}
+	/**
+	* Stream code generation for better UX
+	*/
+	async streamCodeGeneration(prompt, onChunk) {
+		const result = await streamText({
+			model: getAIProvider(this.config),
+			prompt,
+			system: getCodeGenSystemPrompt()
+		});
+		let fullText = "";
+		for await (const chunk of result.textStream) {
+			fullText += chunk;
+			onChunk(chunk);
+		}
+		return fullText;
+	}
+};
+
+//#endregion
+export { AIClient };

package/dist/ai/index.js

@@ -1 +1,27 @@
-import{__export as e}from"../_virtual/rolldown_runtime.js";import{getAIProvider as t,getRecommendedModels as n,validateProvider as r}from"./providers.js";import{AIClient as i}from"./client.js";import{SimpleAgent as a}from"./agents/simple-agent.js";import{CursorAgent as o}from"./agents/cursor-agent.js";import{ClaudeCodeAgent as s}from"./agents/claude-code-agent.js";import{OpenAICodexAgent as c}from"./agents/openai-codex-agent.js";import{AgentOrchestrator as l}from"./agents/orchestrator.js";import"./agents/index.js";import{prompts_exports as u}from"./prompts/index.js";var d=e({AIClient:()=>i,AgentOrchestrator:()=>l,ClaudeCodeAgent:()=>s,CursorAgent:()=>o,OpenAICodexAgent:()=>c,SimpleAgent:()=>a,getAIProvider:()=>t,getRecommendedModels:()=>n,prompts:()=>u,validateProvider:()=>r});export{d as ai_exports};
+import { __export } from "../_virtual/rolldown_runtime.js";
+import { getAIProvider, getRecommendedModels, validateProvider } from "./providers.js";
+import { AIClient } from "./client.js";
+import { SimpleAgent } from "./agents/simple-agent.js";
+import { CursorAgent } from "./agents/cursor-agent.js";
+import { ClaudeCodeAgent } from "./agents/claude-code-agent.js";
+import { OpenAICodexAgent } from "./agents/openai-codex-agent.js";
+import { AgentOrchestrator } from "./agents/orchestrator.js";
+import "./agents/index.js";
+import { prompts_exports } from "./prompts/index.js";
+
+//#region src/ai/index.ts
+var ai_exports = /* @__PURE__ */ __export({
+	AIClient: () => AIClient,
+	AgentOrchestrator: () => AgentOrchestrator,
+	ClaudeCodeAgent: () => ClaudeCodeAgent,
+	CursorAgent: () => CursorAgent,
+	OpenAICodexAgent: () => OpenAICodexAgent,
+	SimpleAgent: () => SimpleAgent,
+	getAIProvider: () => getAIProvider,
+	getRecommendedModels: () => getRecommendedModels,
+	prompts: () => prompts_exports,
+	validateProvider: () => validateProvider
+});
+
+//#endregion
+export { ai_exports };