opencode-design-lab 0.0.0

package/.opencode/plugins/design-lab.js

@@ -0,0 +1,1015 @@
+import { z } from "zod";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { tool } from "@opencode-ai/plugin";
+import pino from "pino";
+
+//#region src/config/schema.ts
+/**
+* Configuration schema for OpenCode Design Lab plugin
+*/
+const DesignLabConfigSchema = z.object({
+	design_models: z.array(z.string()).min(2, "At least 2 design models required"),
+	review_models: z.array(z.string()).optional(),
+	base_output_dir: z.string().default(".design-lab"),
+	design_agent_temperature: z.number().min(0).max(2).default(.7),
+	review_agent_temperature: z.number().min(0).max(2).default(.1),
+	topic_generator_model: z.string().optional()
+});
+/**
+* Design artifact schema - what each design agent must produce
+*/
+const DesignArtifactSchema = z.object({
+	title: z.string(),
+	summary: z.string(),
+	assumptions: z.array(z.string()),
+	architecture_overview: z.string(),
+	components: z.array(z.object({
+		name: z.string(),
+		description: z.string(),
+		responsibilities: z.array(z.string())
+	})),
+	data_flow: z.string(),
+	tradeoffs: z.array(z.object({
+		aspect: z.string(),
+		options: z.array(z.string()),
+		chosen: z.string(),
+		rationale: z.string()
+	})),
+	risks: z.array(z.object({
+		risk: z.string(),
+		impact: z.enum([
+			"low",
+			"medium",
+			"high"
+		]),
+		mitigation: z.string()
+	})),
+	open_questions: z.array(z.string())
+});
+/**
+* Score schema - what review agents must produce
+*/
+const ScoreSchema = z.object({
+	design_id: z.string(),
+	reviewer_model: z.string(),
+	scores: z.object({
+		clarity: z.number().min(0).max(10),
+		feasibility: z.number().min(0).max(10),
+		scalability: z.number().min(0).max(10),
+		maintainability: z.number().min(0).max(10),
+		completeness: z.number().min(0).max(10),
+		overall: z.number().min(0).max(10)
+	}),
+	justification: z.string(),
+	strengths: z.array(z.string()),
+	weaknesses: z.array(z.string()),
+	missing_considerations: z.array(z.string())
+});
+/**
+* Aggregated ranking schema
+*/
+const RankingSchema = z.object({
+	design_id: z.string(),
+	rank: z.number().int().positive(),
+	average_score: z.number(),
+	score_breakdown: z.record(z.string(), z.number()),
+	variance: z.number(),
+	reviewer_count: z.number().int()
+});
+
+//#endregion
+//#region src/config/loader.ts
+/**
+* Deep merge two objects, with override taking precedence
+*/
+function deepMerge(base, override) {
+	const result = { ...base };
+	for (const key in override) {
+		const overrideValue = override[key];
+		const baseValue = base[key];
+		if (typeof overrideValue === "object" && overrideValue !== null && !Array.isArray(overrideValue) && typeof baseValue === "object" && baseValue !== null && !Array.isArray(baseValue)) result[key] = deepMerge(baseValue, overrideValue);
+		else result[key] = overrideValue;
+	}
+	return result;
+}
+/**
+* Parse JSONC (JSON with comments)
+*/
+function parseJsonc(content) {
+	const withoutComments = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*/g, "");
+	return JSON.parse(withoutComments);
+}
+/**
+* Load config from a specific path if it exists
+*/
+function loadConfigFromPath(configPath) {
+	try {
+		const possiblePaths = [
+			configPath,
+			`${configPath}.json`,
+			`${configPath}.jsonc`
+		];
+		for (const fullPath of possiblePaths) if (fs.existsSync(fullPath)) {
+			const rawConfig = parseJsonc(fs.readFileSync(fullPath, "utf-8"));
+			const result = DesignLabConfigSchema.partial().safeParse(rawConfig);
+			if (!result.success) {
+				console.error(`Config validation error in ${fullPath}:`, result.error.issues);
+				return null;
+			}
+			return result.data;
+		}
+	} catch (err) {
+		const errorMsg = err instanceof Error ? err.message : String(err);
+		console.error(`Error loading config from ${configPath}:`, errorMsg);
+	}
+	return null;
+}
+/**
+* Get the user config directory (cross-platform)
+* OpenCode uses ~/.config/opencode on all Unix-like platforms
+*/
+function getUserConfigDir() {
+	if (process.platform === "win32") return process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+	return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+}
+/**
+* Load and merge plugin configuration from multiple sources
+*
+* Priority (highest to lowest):
+* 1. Project-level config: .opencode/design-lab.json(c)
+* 2. User-level config: ~/.config/opencode/design-lab.json(c)
+*
+* @param directory - Project directory
+* @returns Merged and validated configuration
+*/
+function loadPluginConfig(directory) {
+	const userConfigPath = path.join(getUserConfigDir(), "opencode", "design-lab");
+	const projectConfigPath = path.join(directory, ".opencode", "design-lab");
+	const userConfig = loadConfigFromPath(userConfigPath);
+	const projectConfig = loadConfigFromPath(projectConfigPath);
+	let mergedConfig = {};
+	if (userConfig) mergedConfig = deepMerge(mergedConfig, userConfig);
+	if (projectConfig) mergedConfig = deepMerge(mergedConfig, projectConfig);
+	const result = DesignLabConfigSchema.safeParse(mergedConfig);
+	if (!result.success) throw new Error(`Invalid design-lab configuration: ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`);
+	return result.data;
+}
+
+//#endregion
+//#region src/agents/index.ts
+/**
+* System prompt for design generation agents
+*/
+const DESIGN_AGENT_SYSTEM_PROMPT = `You are a senior software architect generating a design proposal for a technical system.
+
+## Your Task
+
+You will receive design requirements and must produce a comprehensive design document as structured JSON.
+
+## Critical Rules
+
+1. **Output ONLY valid JSON** - No markdown, no explanations, no code blocks, just pure JSON
+2. **Follow the schema exactly** - All required fields must be present
+3. **Be specific and actionable** - Avoid vague statements
+4. **Consider real-world constraints** - Think about scalability, maintainability, and security
+5. **Identify risks proactively** - Every design has risks, acknowledge them
+6. **List open questions** - What would you need to clarify with stakeholders?
+
+## Required Output Schema
+
+Your response must be a JSON object with this exact structure:
+
+{
+  "title": "Short, descriptive title for the design",
+  "summary": "2-3 paragraph executive summary of the design",
+  "assumptions": ["List of assumptions you're making"],
+  "architecture_overview": "High-level description of the architecture approach",
+  "components": [
+    {
+      "name": "Component name",
+      "description": "What this component does",
+      "responsibilities": ["List of responsibilities"]
+    }
+  ],
+  "data_flow": "Description of how data flows through the system",
+  "tradeoffs": [
+    {
+      "aspect": "What aspect this tradeoff concerns",
+      "options": ["Option 1", "Option 2"],
+      "chosen": "Which option you chose",
+      "rationale": "Why you chose this option"
+    }
+  ],
+  "risks": [
+    {
+      "risk": "Description of the risk",
+      "impact": "low|medium|high",
+      "mitigation": "How to mitigate this risk"
+    }
+  ],
+  "open_questions": ["Questions that need stakeholder input"]
+}
+
+Remember: Your entire response must be valid JSON. No other text.`;
+/**
+* Create a design agent configuration for a specific model
+*/
+function createDesignAgent(model, temperature) {
+	return {
+		model,
+		temperature,
+		mode: "subagent",
+		prompt: DESIGN_AGENT_SYSTEM_PROMPT,
+		tools: {
+			write: false,
+			edit: false,
+			bash: false,
+			task: false,
+			delegate_task: false
+		}
+	};
+}
+/**
+* System prompt for review agents
+*/
+const REVIEW_AGENT_SYSTEM_PROMPT = `You are a senior technical reviewer evaluating software design proposals.
+
+## Your Task
+
+You will receive multiple design proposals for the same requirements. You must:
+1. Analyze each design thoroughly
+2. Compare them objectively
+3. Provide scores for each design
+4. Generate a markdown review with your analysis
+
+## Scoring Criteria (0-10 scale)
+
+- **Clarity**: How well-explained and understandable is the design?
+- **Feasibility**: Can this design be realistically implemented?
+- **Scalability**: Will this design handle growth well?
+- **Maintainability**: Will this design be easy to maintain and evolve?
+- **Completeness**: Does this design address all requirements?
+- **Overall**: Your overall assessment
+
+## Review Format
+
+First, provide a detailed markdown review comparing all designs:
+
+1. Executive summary of each design
+2. Comparative analysis across dimensions
+3. Strengths and weaknesses of each
+4. Your recommendation
+
+Then, provide a score table in markdown like:
+
+| Design | Clarity | Feasibility | Scalability | Maintainability | Completeness | Overall |
+|--------|---------|-------------|-------------|-----------------|--------------|---------|
+| model-name | 8 | 9 | 7 | 8 | 8 | 8 |
+
+## Important
+
+- Be objective and fair
+- Support your scores with reasoning
+- Consider the requirements when scoring
+- Do not be biased by model names`;
+/**
+* Create a review agent configuration for a specific model
+*/
+function createReviewAgent(model, temperature) {
+	return {
+		model,
+		temperature,
+		mode: "subagent",
+		prompt: REVIEW_AGENT_SYSTEM_PROMPT,
+		tools: {
+			write: false,
+			edit: false,
+			bash: false,
+			task: false,
+			delegate_task: false
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/logger.ts
+const logLevel = process.env.LOG_LEVEL || "info";
+const levelNames = {
+	10: "TRACE",
+	20: "DEBUG",
+	30: "INFO",
+	40: "WARN",
+	50: "ERROR",
+	60: "FATAL"
+};
+function formatTimestamp() {
+	const now = /* @__PURE__ */ new Date();
+	return `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}.${String(now.getMilliseconds()).padStart(3, "0")}`;
+}
+function createLogStream() {
+	const logPath = path.join(process.cwd(), "design-lab.log");
+	const stream = fs.createWriteStream(logPath, { flags: "a" });
+	return pino.multistream([{
+		level: "trace",
+		stream: { write: (chunk) => {
+			try {
+				const log = JSON.parse(chunk);
+				const timestamp = formatTimestamp();
+				const level = levelNames[log.level] || "UNKNOWN";
+				const message = log.msg || "";
+				stream.write(`[${timestamp}] ${level}: ${message}\n`);
+			} catch (e) {
+				stream.write(chunk + "\n");
+			}
+		} }
+	}]);
+}
+const logger = pino({
+	level: logLevel,
+	timestamp: false
+}, createLogStream());
+
+//#endregion
+//#region src/utils/session-helpers.ts
+/**
+* Poll interval for checking session completion
+*/
+const POLL_INTERVAL_MS = 500;
+/**
+* Maximum time to wait for a session to complete
+*/
+const MAX_POLL_TIME_MS = 600 * 1e3;
+/**
+* Create a new agent session
+*/
+async function createAgentSession(ctx, parentSessionID, title, directory) {
+	logger.info({
+		parentSessionID,
+		title
+	}, "Creating agent session");
+	const createResult = await ctx.client.session.create({
+		body: {
+			parentID: parentSessionID,
+			title
+		},
+		query: { directory }
+	});
+	if (createResult.error) {
+		logger.error({ error: createResult.error }, "Failed to create session");
+		throw new Error(`Failed to create session: ${createResult.error}`);
+	}
+	logger.info({ sessionID: createResult.data.id }, "Session created successfully");
+	return createResult.data.id;
+}
+/**
+* Send a prompt to a session with timeout
+*/
+async function sendPrompt(ctx, sessionID, prompt, tools) {
+	logger.info({
+		sessionID,
+		promptLength: prompt.length,
+		tools
+	}, "Sending prompt");
+	const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Prompt send timeout after 180 seconds")), 18e4));
+	const sendPromise = ctx.client.session.prompt({
+		path: { id: sessionID },
+		body: {
+			tools: {
+				...tools,
+				task: false,
+				delegate_task: false
+			},
+			parts: [{
+				type: "text",
+				text: prompt
+			}]
+		}
+	});
+	const result = await Promise.race([sendPromise, timeoutPromise]);
+	if (result.error) {
+		logger.error({
+			sessionID,
+			error: result.error
+		}, "Failed to send prompt");
+		throw new Error(`Failed to send prompt: ${result.error}`);
+	}
+	logger.info({ sessionID }, "Prompt sent successfully");
+}
+/**
+* Poll for session completion
+*/
+async function pollForCompletion(ctx, sessionID, abortSignal) {
+	const pollStart = Date.now();
+	let lastMsgCount = 0;
+	let stablePolls = 0;
+	const STABILITY_REQUIRED = 3;
+	let pollCount = 0;
+	logger.info({ sessionID }, "Starting polling for completion");
+	while (Date.now() - pollStart < MAX_POLL_TIME_MS) {
+		pollCount++;
+		if (abortSignal?.aborted) {
+			logger.warn({ sessionID }, "Polling aborted by signal");
+			throw new Error("Task aborted");
+		}
+		await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+		const sessionStatus = ((await ctx.client.session.status()).data ?? {})[sessionID];
+		if (pollCount % 10 === 0) logger.info({
+			sessionID,
+			status: sessionStatus?.type,
+			pollCount,
+			elapsed: Date.now() - pollStart
+		}, "Polling status check");
+		if (sessionStatus && sessionStatus.type !== "idle") {
+			stablePolls = 0;
+			lastMsgCount = 0;
+			continue;
+		}
+		const messagesCheck = await ctx.client.session.messages({ path: { id: sessionID } });
+		const currentMsgCount = (messagesCheck.data ?? messagesCheck).length;
+		if (currentMsgCount > 0 && currentMsgCount === lastMsgCount) {
+			stablePolls++;
+			logger.debug({
+				sessionID,
+				stablePolls,
+				currentMsgCount
+			}, "Message count stable");
+			if (stablePolls >= STABILITY_REQUIRED) {
+				logger.info({
+					sessionID,
+					totalPolls: pollCount,
+					elapsed: Date.now() - pollStart
+				}, "Session completion confirmed");
+				return;
+			}
+		} else {
+			stablePolls = 0;
+			lastMsgCount = currentMsgCount;
+		}
+	}
+	logger.error({
+		sessionID,
+		totalPolls: pollCount,
+		elapsed: MAX_POLL_TIME_MS
+	}, "Session timed out");
+	throw new Error("Session timed out after 10 minutes");
+}
+/**
+* Extract text content from session messages
+*/
+async function extractSessionOutput(ctx, sessionID) {
+	const messagesResult = await ctx.client.session.messages({ path: { id: sessionID } });
+	if (messagesResult.error) throw new Error(`Failed to get messages: ${messagesResult.error}`);
+	const assistantMessages = messagesResult.data.filter((m) => m.info?.role === "assistant");
+	if (assistantMessages.length === 0) throw new Error("No assistant response found");
+	const extractedContent = [];
+	for (const message of assistantMessages) for (const part of message.parts ?? []) if ((part.type === "text" || part.type === "reasoning") && part.text) extractedContent.push(part.text);
+	return extractedContent.join("\n\n");
+}
+/**
+* Extract JSON from text that may contain markdown code blocks
+*/
+function extractJSON(text) {
+	const jsonBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+	if (jsonBlockMatch) return JSON.parse(jsonBlockMatch[1].trim());
+	const jsonMatch = text.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
+	if (jsonMatch) return JSON.parse(jsonMatch[1]);
+	return JSON.parse(text.trim());
+}
+/**
+* Extract short model name from full model string
+* e.g., "zhipuai-coding-plan/glm-4.6" -> "glm-4.6"
+*/
+function getModelShortName(modelName) {
+	const parts = modelName.split("/");
+	return parts[parts.length - 1] || modelName;
+}
+/**
+* Sanitize a string for use in file/directory names
+*/
+function sanitizeForFilename(text) {
+	return text.toLowerCase().replace(/\//g, "-").replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").substring(0, 50);
+}
+
+//#endregion
+//#region src/tools/generate-designs.ts
+/**
+* Create the generate_designs tool
+*/
+function createGenerateDesignsTool(ctx, config) {
+	return tool({
+		description: `Generate multiple independent design proposals for a technical system.
+
+This tool creates design proposals using ${config.design_models.length} different AI models:
+${config.design_models.map((m) => `- ${m}`).join("\n")}
+
+Each model generates a design completely independently, without seeing other models' outputs.
+
+Use this when you want to explore multiple approaches to a design problem and compare them.`,
+		args: {
+			requirements: tool.schema.string().describe("Detailed requirements for the design. Include problem statement, constraints, and non-functional requirements."),
+			topic: tool.schema.string().describe("Optional short topic name (2-4 words) for the design session. If not provided, one will be generated.").optional()
+		},
+		async execute(args, toolContext) {
+			const { requirements, topic: userTopic } = args;
+			const sessionID = toolContext.sessionID;
+			const topic = userTopic ? sanitizeForFilename(userTopic) : await generateTopic(ctx, config, requirements, sessionID);
+			const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+			const labDir = path.join(ctx.directory, config.base_output_dir, `${date}-${topic}`);
+			if (fs.existsSync(labDir)) {
+				logger.warn({ labDir }, "Lab directory already exists, using existing");
+				return `Error: Lab directory already exists at ${labDir}. This may be from a previous attempt. Please check the existing designs or delete the directory to retry.`;
+			}
+			const designsDir = path.join(labDir, "designs");
+			const reviewsDir = path.join(labDir, "reviews");
+			const scoresDir = path.join(labDir, "scores");
+			fs.mkdirSync(designsDir, { recursive: true });
+			fs.mkdirSync(reviewsDir, { recursive: true });
+			fs.mkdirSync(scoresDir, { recursive: true });
+			const taskData = {
+				requirements,
+				topic,
+				created: (/* @__PURE__ */ new Date()).toISOString(),
+				design_models: config.design_models,
+				review_models: config.review_models ?? config.design_models
+			};
+			fs.writeFileSync(path.join(labDir, "task.json"), JSON.stringify(taskData, null, 2));
+			const results = [];
+			for (const model of config.design_models) try {
+				logger.info({ model }, `Starting design generation for model: ${model}`);
+				const design = await generateDesign(ctx, config, model, requirements, sessionID);
+				const validationResult = DesignArtifactSchema.safeParse(design);
+				if (!validationResult.success) {
+					logger.error({
+						model,
+						errors: validationResult.error.issues
+					}, "Design schema validation failed");
+					results.push({
+						model,
+						success: false,
+						error: `Schema validation failed: ${validationResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`
+					});
+					continue;
+				}
+				const modelShortName = getModelShortName(model);
+				const designFile = path.join(designsDir, `${sanitizeForFilename(modelShortName)}.json`);
+				fs.writeFileSync(designFile, JSON.stringify(design, null, 2));
+				logger.info({
+					model,
+					designFile
+				}, "Design saved as JSON");
+				const markdownFile = path.join(designsDir, `${sanitizeForFilename(modelShortName)}.md`);
+				const markdown = formatDesignAsMarkdown(design, model);
+				fs.writeFileSync(markdownFile, markdown);
+				logger.info({
+					model,
+					markdownFile
+				}, "Design saved as Markdown");
+				results.push({
+					model,
+					success: true
+				});
+			} catch (err) {
+				const errorMsg = err instanceof Error ? err.message : String(err);
+				logger.error({
+					model,
+					error: errorMsg
+				}, "Design generation failed");
+				results.push({
+					model,
+					success: false,
+					error: errorMsg
+				});
+			}
+			const successCount = results.filter((r) => r.success).length;
+			return `Design generation complete.
+
+**Lab Directory**: ${labDir}
+
+**Results**: ${successCount} successful, ${results.filter((r) => !r.success).length} failed
+
+${results.map((r) => r.success ? `✅ ${r.model}: Generated successfully` : `❌ ${r.model}: ${r.error}`).join("\n")}
+
+${successCount >= 2 ? `\nNext step: Run the review_designs tool to evaluate and compare the designs.` : `\nWarning: At least 2 successful designs are needed for meaningful comparison.`}`;
+		}
+	});
+}
+/**
+* Format a design artifact as markdown for human readability
+*/
+function formatDesignAsMarkdown(design, model) {
+	let md = `# ${design.title}\n\n`;
+	md += `**Model**: ${model}\n\n`;
+	md += `## Summary\n\n${design.summary}\n\n`;
+	md += `## Assumptions\n\n`;
+	design.assumptions.forEach((a) => md += `- ${a}\n`);
+	md += `\n`;
+	md += `## Architecture Overview\n\n${design.architecture_overview}\n\n`;
+	md += `## Components\n\n`;
+	design.components.forEach((c) => {
+		md += `### ${c.name}\n\n${c.description}\n\n**Responsibilities**:\n`;
+		c.responsibilities.forEach((r) => md += `- ${r}\n`);
+		md += `\n`;
+	});
+	md += `## Data Flow\n\n${design.data_flow}\n\n`;
+	md += `## Tradeoffs\n\n`;
+	design.tradeoffs.forEach((t) => {
+		md += `### ${t.aspect}\n\n`;
+		md += `**Options**: ${t.options.join(", ")}\n\n`;
+		md += `**Chosen**: ${t.chosen}\n\n`;
+		md += `**Rationale**: ${t.rationale}\n\n`;
+	});
+	md += `## Risks\n\n`;
+	design.risks.forEach((r) => {
+		md += `### ${r.risk} (Impact: ${r.impact})\n\n`;
+		md += `**Mitigation**: ${r.mitigation}\n\n`;
+	});
+	md += `## Open Questions\n\n`;
+	design.open_questions.forEach((q) => md += `- ${q}\n`);
+	return md;
+}
+/**
+* Generate a topic name from requirements
+*/
+async function generateTopic(ctx, config, requirements, parentSessionID) {
+	config.topic_generator_model || config.design_models[0];
+	const sessionID = await createAgentSession(ctx, parentSessionID, "Topic Generation", ctx.directory);
+	await sendPrompt(ctx, sessionID, `Generate a concise 2-4 word topic name for this design task. Output ONLY the topic name, nothing else.
+
+Requirements:
+${requirements.substring(0, 500)}`, {
+		write: false,
+		edit: false,
+		bash: false
+	});
+	await pollForCompletion(ctx, sessionID);
+	return sanitizeForFilename((await extractSessionOutput(ctx, sessionID)).trim());
+}
+/**
+* Generate a single design using a specific model
+*/
+async function generateDesign(ctx, config, model, requirements, parentSessionID) {
+	const agentConfig = createDesignAgent(model, config.design_agent_temperature);
+	const sessionID = await createAgentSession(ctx, parentSessionID, `Design Generation - ${model}`, ctx.directory);
+	const prompt = `Generate a comprehensive design proposal for the following requirements.
+
+## Requirements
+
+${requirements}
+
+## Instructions
+
+1. Analyze the requirements thoroughly
+2. Consider multiple approaches before deciding
+3. Output your design as valid JSON following the required schema
+4. Be specific and actionable in your design
+
+Remember: Your entire response must be valid JSON with no other text.`;
+	const fullPrompt = `${agentConfig.prompt}\n\n${prompt}`;
+	logger.info({
+		model,
+		sessionID
+	}, "Sending design prompt to agent");
+	await sendPrompt(ctx, sessionID, fullPrompt, agentConfig.tools);
+	logger.info({
+		model,
+		sessionID
+	}, "Polling for completion");
+	await pollForCompletion(ctx, sessionID);
+	logger.info({
+		model,
+		sessionID
+	}, "Extracting session output");
+	const output = await extractSessionOutput(ctx, sessionID);
+	logger.info({
+		model,
+		outputLength: output.length
+	}, "Extracting JSON from output");
+	return extractJSON(output);
+}
+
+//#endregion
+//#region src/tools/review-designs.ts
+/**
+* Create the review_designs tool
+*/
+function createReviewDesignsTool(ctx, config) {
+	const reviewModels = config.review_models ?? config.design_models;
+	return tool({
+		description: `Review and score design proposals using ${reviewModels.length} reviewer models.
+
+Each reviewer analyzes all designs and provides:
+1. A markdown review comparing the designs
+2. Numeric scores (0-10) across dimensions: clarity, feasibility, scalability, maintainability, completeness, overall
+
+Use this after generate_designs to evaluate and compare the generated designs.`,
+		args: { lab_path: tool.schema.string().describe(`Path to the design lab directory (e.g., .design-lab/2024-01-15-api-gateway). If not provided, uses the most recent lab.`).optional() },
+		async execute(args, toolContext) {
+			const sessionID = toolContext.sessionID;
+			const labDir = args.lab_path ? path.resolve(ctx.directory, args.lab_path) : findMostRecentLab$1(ctx.directory, config.base_output_dir);
+			if (!labDir) return "Error: No design lab found. Run generate_designs first.";
+			const designsDir = path.join(labDir, "designs");
+			const reviewsDir = path.join(labDir, "reviews");
+			const scoresDir = path.join(labDir, "scores");
+			const designFiles = fs.readdirSync(designsDir).filter((f) => f.endsWith(".json"));
+			if (designFiles.length === 0) return "Error: No designs found in the lab directory.";
+			const designs = {};
+			for (const file of designFiles) {
+				const designId = file.replace(".json", "");
+				const content = fs.readFileSync(path.join(designsDir, file), "utf-8");
+				designs[designId] = JSON.parse(content);
+			}
+			const taskPath = path.join(labDir, "task.json");
+			const requirements = JSON.parse(fs.readFileSync(taskPath, "utf-8")).requirements;
+			const results = [];
+			for (const model of reviewModels) try {
+				const { review, scores } = await generateReview(ctx, config, model, requirements, designs, sessionID);
+				const reviewFile = path.join(reviewsDir, `review-${sanitizeForFilename(getModelShortName(model))}.md`);
+				fs.writeFileSync(reviewFile, review);
+				logger.info({
+					model,
+					reviewFile
+				}, "Review saved");
+				for (const score of scores) {
+					const validationResult = ScoreSchema.safeParse(score);
+					if (!validationResult.success) console.warn(`Score validation warning for ${score.design_id}:`, validationResult.error);
+					const designShortName = getModelShortName(score.design_id);
+					const reviewerShortName = getModelShortName(model);
+					const scoreFile = path.join(scoresDir, `${sanitizeForFilename(designShortName)}-reviewed-by-${sanitizeForFilename(reviewerShortName)}.json`);
+					fs.writeFileSync(scoreFile, JSON.stringify(score, null, 2));
+				}
+				results.push({
+					model,
+					success: true
+				});
+			} catch (err) {
+				const errorMsg = err instanceof Error ? err.message : String(err);
+				results.push({
+					model,
+					success: false,
+					error: errorMsg
+				});
+			}
+			const successCount = results.filter((r) => r.success).length;
+			return `Review complete.
+
+**Lab Directory**: ${labDir}
+
+**Results**: ${successCount} successful, ${results.filter((r) => !r.success).length} failed
+
+${results.map((r) => r.success ? `✅ ${r.model}: Review generated` : `❌ ${r.model}: ${r.error}`).join("\n")}
+
+**Reviews saved to**: ${reviewsDir}
+**Scores saved to**: ${scoresDir}
+
+${successCount > 0 ? `\nNext step: Run the aggregate_scores tool to generate final rankings.` : ""}`;
+		}
+	});
+}
+/**
+* Find the most recent design lab directory
+*/
+function findMostRecentLab$1(projectDir, baseDir) {
+	const labBaseDir = path.join(projectDir, baseDir);
+	if (!fs.existsSync(labBaseDir)) return null;
+	const labs = fs.readdirSync(labBaseDir).filter((d) => fs.statSync(path.join(labBaseDir, d)).isDirectory()).sort().reverse();
+	if (labs.length === 0) return null;
+	return path.join(labBaseDir, labs[0]);
+}
+/**
+* Generate a review using a specific model
+*/
+async function generateReview(ctx, config, model, requirements, designs, parentSessionID) {
+	const agentConfig = createReviewAgent(model, config.review_agent_temperature);
+	const sessionID = await createAgentSession(ctx, parentSessionID, `Design Review - ${model}`, ctx.directory);
+	const prompt = `Review and compare the following design proposals.
+
+## Original Requirements
+
+${requirements}
+
+## Designs to Review
+
+${Object.entries(designs).map(([id, design]) => `## Design: ${id}\n\n\`\`\`json\n${JSON.stringify(design, null, 2)}\n\`\`\``).join("\n\n---\n\n")}
+
+## Your Task
+
+1. Analyze each design thoroughly
+2. Compare them across dimensions: clarity, feasibility, scalability, maintainability, completeness
+3. Provide a detailed markdown review with your analysis
+4. At the end, include a score table in markdown format
+5. Identify strengths and weaknesses of each design
+
+Be objective and support your assessments with specific observations.`;
+	await sendPrompt(ctx, sessionID, `${agentConfig.prompt}\n\n${prompt}`, agentConfig.tools);
+	await pollForCompletion(ctx, sessionID);
+	const review = await extractSessionOutput(ctx, sessionID);
+	await sendPrompt(ctx, sessionID, `Now output the scores for each design as a JSON array. Each element should have this structure:
+
+{
+  "design_id": "EXACT_DESIGN_ID_FROM_LIST_BELOW",
+  "reviewer_model": "${model}",
+  "scores": {
+    "clarity": 0-10,
+    "feasibility": 0-10,
+    "scalability": 0-10,
+    "maintainability": 0-10,
+    "completeness": 0-10,
+    "overall": 0-10
+  },
+  "justification": "Brief overall justification",
+  "strengths": ["list", "of", "strengths"],
+  "weaknesses": ["list", "of", "weaknesses"],
+  "missing_considerations": ["list", "of", "things", "missing"]
+}
+
+**IMPORTANT**: The "design_id" field MUST be one of these exact values:
+${Object.keys(designs).map((id) => `- "${id}"`).join("\n")}
+
+Output ONLY the JSON array with one score object per design. No other text.`, agentConfig.tools);
+	await pollForCompletion(ctx, sessionID);
+	return {
+		review,
+		scores: extractJSON(await extractSessionOutput(ctx, sessionID))
+	};
+}
+
+//#endregion
+//#region src/tools/aggregate-scores.ts
+/**
+* Create the aggregate_scores tool
+*/
+function createAggregateScoresTool(ctx, config) {
+	return tool({
+		description: `Aggregate scores from all reviewers and generate final rankings.
+
+This tool:
+1. Reads all score files from the reviews
+2. Calculates average scores per design
+3. Computes variance/disagreement metrics
+4. Generates a final ranking with results.md
+
+Use this after review_designs to get the final comparison.`,
+		args: { lab_path: tool.schema.string().describe(`Path to the design lab directory. If not provided, uses the most recent lab.`).optional() },
+		async execute(args) {
+			const labDir = args.lab_path ? path.resolve(ctx.directory, args.lab_path) : findMostRecentLab(ctx.directory, config.base_output_dir);
+			if (!labDir) return "Error: No design lab found. Run generate_designs first.";
+			const scoresDir = path.join(labDir, "scores");
+			const resultsDir = path.join(labDir, "results");
+			if (!fs.existsSync(scoresDir)) return "Error: No scores directory found. Run review_designs first.";
+			fs.mkdirSync(resultsDir, { recursive: true });
+			const scoreFiles = fs.readdirSync(scoresDir).filter((f) => f.endsWith(".json"));
+			if (scoreFiles.length === 0) return "Error: No score files found. Run review_designs first.";
+			const allScores = [];
+			for (const file of scoreFiles) {
+				const content = fs.readFileSync(path.join(scoresDir, file), "utf-8");
+				allScores.push(JSON.parse(content));
+			}
+			const scoresByDesign = {};
+			for (const score of allScores) {
+				if (!scoresByDesign[score.design_id]) scoresByDesign[score.design_id] = [];
+				scoresByDesign[score.design_id].push(score);
+			}
+			const rankings = [];
+			for (const [designId, scores] of Object.entries(scoresByDesign)) {
+				const overallScores = scores.map((s) => s.scores.overall);
+				const avgOverall = overallScores.reduce((a, b) => a + b, 0) / overallScores.length;
+				const variance = overallScores.reduce((sum, s) => sum + Math.pow(s - avgOverall, 2), 0) / overallScores.length;
+				const dimensions = [
+					"clarity",
+					"feasibility",
+					"scalability",
+					"maintainability",
+					"completeness",
+					"overall"
+				];
+				const scoreBreakdown = {};
+				for (const dim of dimensions) {
+					const dimScores = scores.map((s) => s.scores[dim]);
+					scoreBreakdown[dim] = dimScores.reduce((a, b) => a + b, 0) / dimScores.length;
+				}
+				rankings.push({
+					design_id: designId,
+					rank: 0,
+					average_score: avgOverall,
+					score_breakdown: scoreBreakdown,
+					variance,
+					reviewer_count: scores.length
+				});
+			}
+			rankings.sort((a, b) => b.average_score - a.average_score);
+			rankings.forEach((r, i) => {
+				r.rank = i + 1;
+			});
+			fs.writeFileSync(path.join(resultsDir, "ranking.json"), JSON.stringify(rankings, null, 2));
+			const resultsMarkdown = generateResultsMarkdown(rankings, allScores);
+			fs.writeFileSync(path.join(resultsDir, "results.md"), resultsMarkdown);
+			return `Aggregation complete.
+
+**Rankings saved to**: ${path.join(resultsDir, "ranking.json")}
+**Results summary saved to**: ${path.join(resultsDir, "results.md")}
+
+## Final Rankings
+
+${rankings.map((r) => `${r.rank}. **${r.design_id}** - Score: ${r.average_score.toFixed(1)}/10 (variance: ${r.variance.toFixed(2)})`).join("\n")}
+
+View the full results in ${path.join(resultsDir, "results.md")}`;
+		}
+	});
+}
+/**
+* Find the most recent design lab directory
+*/
+function findMostRecentLab(projectDir, baseDir) {
+	const labBaseDir = path.join(projectDir, baseDir);
+	if (!fs.existsSync(labBaseDir)) return null;
+	const labs = fs.readdirSync(labBaseDir).filter((d) => fs.statSync(path.join(labBaseDir, d)).isDirectory()).sort().reverse();
+	if (labs.length === 0) return null;
+	return path.join(labBaseDir, labs[0]);
+}
+/**
+* Generate the results markdown file
+*/
+function generateResultsMarkdown(rankings, allScores) {
+	const dimensions = [
+		"clarity",
+		"feasibility",
+		"scalability",
+		"maintainability",
+		"completeness",
+		"overall"
+	];
+	const reviewers = [...new Set(allScores.map((s) => s.reviewer_model))];
+	let md = `# Design Lab Results
+
+Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## Summary
+
+| Rank | Design | Avg Score | Variance | Reviewers |
+|------|--------|-----------|----------|-----------|
+${rankings.map((r) => `| ${r.rank} | ${r.design_id} | ${r.average_score.toFixed(1)} | ${r.variance.toFixed(2)} | ${r.reviewer_count} |`).join("\n")}
+
+## Detailed Score Breakdown
+
+### Average Scores by Dimension
+
+| Design | ${dimensions.join(" | ")} |
+|--------|${"---|".repeat(dimensions.length)}
+${rankings.map((r) => `| ${r.design_id} | ${dimensions.map((d) => r.score_breakdown[d].toFixed(1)).join(" | ")} |`).join("\n")}
+
+## Reviewer × Design Matrix
+
+### Overall Scores
+
+| Reviewer | ${rankings.map((r) => r.design_id).join(" | ")} |
+|----------|${"---|".repeat(rankings.length)}
+${reviewers.map((reviewer) => {
+		return `| ${reviewer} | ${rankings.map((r) => {
+			const score = allScores.find((s) => s.design_id === r.design_id && s.reviewer_model === reviewer);
+			return score ? score.scores.overall.toFixed(1) : "N/A";
+		}).join(" | ")} |`;
+	}).join("\n")}
+
+## Key Observations
+
+`;
+	const topDesign = rankings[0];
+	md += `### Winner: ${topDesign.design_id}
+
+- **Average Score**: ${topDesign.average_score.toFixed(1)}/10
+- **Variance**: ${topDesign.variance.toFixed(2)} (${topDesign.variance < 1 ? "high consensus" : topDesign.variance < 2 ? "moderate consensus" : "low consensus"})
+
+`;
+	md += `### Strengths and Weaknesses\n\n`;
+	for (const ranking of rankings.slice(0, 3)) {
+		const designScores = allScores.filter((s) => s.design_id === ranking.design_id);
+		const strengths = [...new Set(designScores.flatMap((s) => s.strengths))].slice(0, 3);
+		const weaknesses = [...new Set(designScores.flatMap((s) => s.weaknesses))].slice(0, 3);
+		md += `#### ${ranking.rank}. ${ranking.design_id}\n\n`;
+		md += `**Strengths**:\n${strengths.map((s) => `- ${s}`).join("\n")}\n\n`;
+		md += `**Weaknesses**:\n${weaknesses.map((w) => `- ${w}`).join("\n")}\n\n`;
+	}
+	return md;
+}
+
+//#endregion
+//#region src/design-lab.ts
+/**
+* OpenCode Design Lab Plugin
+*
+* Generates multiple independent design proposals using different AI models,
+* then systematically evaluates, compares, and ranks those designs.
+*/
+const DesignLab = async (ctx) => {
+	const config = loadPluginConfig(ctx.directory);
+	return { tool: {
+		generate_designs: createGenerateDesignsTool(ctx, config),
+		review_designs: createReviewDesignsTool(ctx, config),
+		aggregate_scores: createAggregateScoresTool(ctx, config)
+	} };
+};
+
+//#endregion
+export { DesignLab };