@nudge-ai/cli 0.0.1-beta.4 → 0.1.0

package/dist/{src-DG37IBZ6.mjs → src-B7X5IQ4U.mjs}

@@ -1,9 +1,8 @@
 import { createRequire } from "node:module";
-import "dotenv/config";
 import * as fs$3 from "fs";
-import { formatStepForAI } from "@nudge-ai/core";
-import * as z from "zod/mini";
 import crypto from "crypto";
+import { formatStepForAI } from "@nudge-ai/core/internal";
+import * as z from "zod/mini";
 import { pathToFileURL } from "url";
 
 //#region rolldown:runtime
@@ -34,13 +33,488 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+//#endregion
+//#region ../../node_modules/dotenv/package.json
+var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "dotenv",
+		"version": "17.2.3",
+		"description": "Loads environment variables from .env file",
+		"main": "lib/main.js",
+		"types": "lib/main.d.ts",
+		"exports": {
+			".": {
+				"types": "./lib/main.d.ts",
+				"require": "./lib/main.js",
+				"default": "./lib/main.js"
+			},
+			"./config": "./config.js",
+			"./config.js": "./config.js",
+			"./lib/env-options": "./lib/env-options.js",
+			"./lib/env-options.js": "./lib/env-options.js",
+			"./lib/cli-options": "./lib/cli-options.js",
+			"./lib/cli-options.js": "./lib/cli-options.js",
+			"./package.json": "./package.json"
+		},
+		"scripts": {
+			"dts-check": "tsc --project tests/types/tsconfig.json",
+			"lint": "standard",
+			"pretest": "npm run lint && npm run dts-check",
+			"test": "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
+			"test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+			"prerelease": "npm test",
+			"release": "standard-version"
+		},
+		"repository": {
+			"type": "git",
+			"url": "git://github.com/motdotla/dotenv.git"
+		},
+		"homepage": "https://github.com/motdotla/dotenv#readme",
+		"funding": "https://dotenvx.com",
+		"keywords": [
+			"dotenv",
+			"env",
+			".env",
+			"environment",
+			"variables",
+			"config",
+			"settings"
+		],
+		"readmeFilename": "README.md",
+		"license": "BSD-2-Clause",
+		"devDependencies": {
+			"@types/node": "^18.11.3",
+			"decache": "^4.6.2",
+			"sinon": "^14.0.1",
+			"standard": "^17.0.0",
+			"standard-version": "^9.5.0",
+			"tap": "^19.2.0",
+			"typescript": "^4.8.4"
+		},
+		"engines": { "node": ">=12" },
+		"browser": { "fs": false }
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/dotenv/lib/main.js
+var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs$4 = __require("fs");
+	const path$9 = __require("path");
+	const os$2 = __require("os");
+	const crypto$1 = __require("crypto");
+	const version = require_package().version;
+	const TIPS = [
+		"🔐 encrypt with Dotenvx: https://dotenvx.com",
+		"🔐 prevent committing .env to code: https://dotenvx.com/precommit",
+		"🔐 prevent building .env in docker: https://dotenvx.com/prebuild",
+		"📡 add observability to secrets: https://dotenvx.com/ops",
+		"👥 sync secrets across teammates & machines: https://dotenvx.com/ops",
+		"🗂️ backup and recover secrets: https://dotenvx.com/ops",
+		"✅ audit secrets and track compliance: https://dotenvx.com/ops",
+		"🔄 add secrets lifecycle management: https://dotenvx.com/ops",
+		"🔑 add access controls to secrets: https://dotenvx.com/ops",
+		"🛠️  run anywhere with `dotenvx run -- yourcommand`",
+		"⚙️  specify custom .env file path with { path: '/custom/path/.env' }",
+		"⚙️  enable debug logging with { debug: true }",
+		"⚙️  override existing env vars with { override: true }",
+		"⚙️  suppress all logs with { quiet: true }",
+		"⚙️  write to custom object with { processEnv: myObject }",
+		"⚙️  load multiple .env files with { path: ['.env.local', '.env'] }"
+	];
+	function _getRandomTip() {
+		return TIPS[Math.floor(Math.random() * TIPS.length)];
+	}
+	function parseBoolean(value) {
+		if (typeof value === "string") return ![
+			"false",
+			"0",
+			"no",
+			"off",
+			""
+		].includes(value.toLowerCase());
+		return Boolean(value);
+	}
+	function supportsAnsi() {
+		return process.stdout.isTTY;
+	}
+	function dim(text) {
+		return supportsAnsi() ? `\x1b[2m${text}\x1b[0m` : text;
+	}
+	const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+	function parse(src) {
+		const obj = {};
+		let lines = src.toString();
+		lines = lines.replace(/\r\n?/gm, "\n");
+		let match;
+		while ((match = LINE.exec(lines)) != null) {
+			const key = match[1];
+			let value = match[2] || "";
+			value = value.trim();
+			const maybeQuote = value[0];
+			value = value.replace(/^(['"`])([\s\S]*)\1$/gm, "$2");
+			if (maybeQuote === "\"") {
+				value = value.replace(/\\n/g, "\n");
+				value = value.replace(/\\r/g, "\r");
+			}
+			obj[key] = value;
+		}
+		return obj;
+	}
+	function _parseVault(options) {
+		options = options || {};
+		const vaultPath = _vaultPath(options);
+		options.path = vaultPath;
+		const result = DotenvModule.configDotenv(options);
+		if (!result.parsed) {
+			const err = /* @__PURE__ */ new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+			err.code = "MISSING_DATA";
+			throw err;
+		}
+		const keys = _dotenvKey(options).split(",");
+		const length = keys.length;
+		let decrypted;
+		for (let i = 0; i < length; i++) try {
+			const attrs = _instructions(result, keys[i].trim());
+			decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+			break;
+		} catch (error) {
+			if (i + 1 >= length) throw error;
+		}
+		return DotenvModule.parse(decrypted);
+	}
+	function _warn(message) {
+		console.error(`[dotenv@${version}][WARN] ${message}`);
+	}
+	function _debug(message) {
+		console.log(`[dotenv@${version}][DEBUG] ${message}`);
+	}
+	function _log(message) {
+		console.log(`[dotenv@${version}] ${message}`);
+	}
+	function _dotenvKey(options) {
+		if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) return options.DOTENV_KEY;
+		if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) return process.env.DOTENV_KEY;
+		return "";
+	}
+	function _instructions(result, dotenvKey) {
+		let uri;
+		try {
+			uri = new URL(dotenvKey);
+		} catch (error) {
+			if (error.code === "ERR_INVALID_URL") {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			}
+			throw error;
+		}
+		const key = uri.password;
+		if (!key) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing key part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environment = uri.searchParams.get("environment");
+		if (!environment) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing environment part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+		const ciphertext = result.parsed[environmentKey];
+		if (!ciphertext) {
+			const err = /* @__PURE__ */ new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+			err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+			throw err;
+		}
+		return {
+			ciphertext,
+			key
+		};
+	}
+	function _vaultPath(options) {
+		let possibleVaultPath = null;
+		if (options && options.path && options.path.length > 0) if (Array.isArray(options.path)) {
+			for (const filepath of options.path) if (fs$4.existsSync(filepath)) possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+		} else possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+		else possibleVaultPath = path$9.resolve(process.cwd(), ".env.vault");
+		if (fs$4.existsSync(possibleVaultPath)) return possibleVaultPath;
+		return null;
+	}
+	function _resolveHome(envPath) {
+		return envPath[0] === "~" ? path$9.join(os$2.homedir(), envPath.slice(1)) : envPath;
+	}
+	function _configVault(options) {
+		const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+		const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+		if (debug || !quiet) _log("Loading env from encrypted .env.vault");
+		const parsed = DotenvModule._parseVault(options);
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		DotenvModule.populate(processEnv, parsed, options);
+		return { parsed };
+	}
+	function configDotenv(options) {
+		const dotenvPath = path$9.resolve(process.cwd(), ".env");
+		let encoding = "utf8";
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+		let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+		if (options && options.encoding) encoding = options.encoding;
+		else if (debug) _debug("No encoding is specified. UTF-8 is used by default");
+		let optionPaths = [dotenvPath];
+		if (options && options.path) if (!Array.isArray(options.path)) optionPaths = [_resolveHome(options.path)];
+		else {
+			optionPaths = [];
+			for (const filepath of options.path) optionPaths.push(_resolveHome(filepath));
+		}
+		let lastError;
+		const parsedAll = {};
+		for (const path$10 of optionPaths) try {
+			const parsed = DotenvModule.parse(fs$4.readFileSync(path$10, { encoding }));
+			DotenvModule.populate(parsedAll, parsed, options);
+		} catch (e) {
+			if (debug) _debug(`Failed to load ${path$10} ${e.message}`);
+			lastError = e;
+		}
+		const populated = DotenvModule.populate(processEnv, parsedAll, options);
+		debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+		quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+		if (debug || !quiet) {
+			const keysCount = Object.keys(populated).length;
+			const shortPaths = [];
+			for (const filePath of optionPaths) try {
+				const relative = path$9.relative(process.cwd(), filePath);
+				shortPaths.push(relative);
+			} catch (e) {
+				if (debug) _debug(`Failed to load ${filePath} ${e.message}`);
+				lastError = e;
+			}
+			_log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+		}
+		if (lastError) return {
+			parsed: parsedAll,
+			error: lastError
+		};
+		else return { parsed: parsedAll };
+	}
+	function config(options) {
+		if (_dotenvKey(options).length === 0) return DotenvModule.configDotenv(options);
+		const vaultPath = _vaultPath(options);
+		if (!vaultPath) {
+			_warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+			return DotenvModule.configDotenv(options);
+		}
+		return DotenvModule._configVault(options);
+	}
+	function decrypt(encrypted, keyStr) {
+		const key = Buffer.from(keyStr.slice(-64), "hex");
+		let ciphertext = Buffer.from(encrypted, "base64");
+		const nonce = ciphertext.subarray(0, 12);
+		const authTag = ciphertext.subarray(-16);
+		ciphertext = ciphertext.subarray(12, -16);
+		try {
+			const aesgcm = crypto$1.createDecipheriv("aes-256-gcm", key, nonce);
+			aesgcm.setAuthTag(authTag);
+			return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+		} catch (error) {
+			const isRange = error instanceof RangeError;
+			const invalidKeyLength = error.message === "Invalid key length";
+			const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+			if (isRange || invalidKeyLength) {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			} else if (decryptionFailed) {
+				const err = /* @__PURE__ */ new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+				err.code = "DECRYPTION_FAILED";
+				throw err;
+			} else throw error;
+		}
+	}
+	function populate(processEnv, parsed, options = {}) {
+		const debug = Boolean(options && options.debug);
+		const override = Boolean(options && options.override);
+		const populated = {};
+		if (typeof parsed !== "object") {
+			const err = /* @__PURE__ */ new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+			err.code = "OBJECT_REQUIRED";
+			throw err;
+		}
+		for (const key of Object.keys(parsed)) if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+			if (override === true) {
+				processEnv[key] = parsed[key];
+				populated[key] = parsed[key];
+			}
+			if (debug) if (override === true) _debug(`"${key}" is already defined and WAS overwritten`);
+			else _debug(`"${key}" is already defined and was NOT overwritten`);
+		} else {
+			processEnv[key] = parsed[key];
+			populated[key] = parsed[key];
+		}
+		return populated;
+	}
+	const DotenvModule = {
+		configDotenv,
+		_configVault,
+		_parseVault,
+		config,
+		decrypt,
+		parse,
+		populate
+	};
+	module.exports.configDotenv = DotenvModule.configDotenv;
+	module.exports._configVault = DotenvModule._configVault;
+	module.exports._parseVault = DotenvModule._parseVault;
+	module.exports.config = DotenvModule.config;
+	module.exports.decrypt = DotenvModule.decrypt;
+	module.exports.parse = DotenvModule.parse;
+	module.exports.populate = DotenvModule.populate;
+	module.exports = DotenvModule;
+}));
+
+//#endregion
+//#region ../../node_modules/dotenv/lib/env-options.js
+var require_env_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const options = {};
+	if (process.env.DOTENV_CONFIG_ENCODING != null) options.encoding = process.env.DOTENV_CONFIG_ENCODING;
+	if (process.env.DOTENV_CONFIG_PATH != null) options.path = process.env.DOTENV_CONFIG_PATH;
+	if (process.env.DOTENV_CONFIG_QUIET != null) options.quiet = process.env.DOTENV_CONFIG_QUIET;
+	if (process.env.DOTENV_CONFIG_DEBUG != null) options.debug = process.env.DOTENV_CONFIG_DEBUG;
+	if (process.env.DOTENV_CONFIG_OVERRIDE != null) options.override = process.env.DOTENV_CONFIG_OVERRIDE;
+	if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) options.DOTENV_KEY = process.env.DOTENV_CONFIG_DOTENV_KEY;
+	module.exports = options;
+}));
+
+//#endregion
+//#region ../../node_modules/dotenv/lib/cli-options.js
+var require_cli_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const re = /^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/;
+	module.exports = function optionMatcher(args) {
+		const options = args.reduce(function(acc, cur) {
+			const matches = cur.match(re);
+			if (matches) acc[matches[1]] = matches[2];
+			return acc;
+		}, {});
+		if (!("quiet" in options)) options.quiet = "true";
+		return options;
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/dotenv/config.js
+(function() {
+	require_main().config(Object.assign({}, require_env_options(), require_cli_options()(process.argv)));
+})();
+
+//#endregion
+//#region src/errors.ts
+/**
+* Format API errors with helpful context for users
+*/
+function formatAPIError(error, context) {
+	const { model, operation } = context;
+	if (error instanceof TypeError && error.message.includes("fetch")) return `
+Network error while ${operation}.
+
+Could not connect to the AI provider. Please check:
+  • Your internet connection
+  • The API base URL in nudge.config.json
+  • If using a local model, ensure it's running
+`;
+	if (error instanceof Error) {
+		const msg = error.message;
+		if (msg.includes("401")) return `
+Authentication failed (401) while ${operation}.
+
+Please check:
+  • Your API key environment variable is set correctly
+  • The API key is valid and not expired
+  • The API key has the required permissions
+`;
+		if (msg.includes("403")) return `
+Access forbidden (403) while ${operation}.
+
+Please check:
+  • Your API key has access to the model "${model}"
+  • You have sufficient quota/credits
+`;
+		if (msg.includes("404")) return `
+Model not found (404) while ${operation}.
+
+The model "${model}" was not found. Please check:
+  • The model name is spelled correctly in nudge.config.json
+  • The model is available with your provider
+  • For OpenRouter: use format "provider/model-name"
+`;
+		if (msg.includes("429")) return `
+Rate limit exceeded (429) while ${operation}.
+
+You've hit the API rate limit. Please:
+  • Wait a moment and try again
+  • Consider using a different model
+  • Check your API plan limits
+`;
+		if (msg.includes("500") || msg.includes("502") || msg.includes("503")) return `
+Server error while ${operation}.
+
+The AI provider is experiencing issues. Please:
+  • Wait a moment and try again
+  • Check the provider's status page
+`;
+		if (msg.includes("empty") || msg.includes("no content")) return `
+Empty response while ${operation}.
+
+The model "${model}" returned an empty response. This can happen with:
+  • Smaller/local models that don't handle the task well
+  • Models with very short context windows
+
+Try using a more capable model (e.g., gpt-4o, claude-3.5-sonnet).
+`;
+		if (msg.includes("JSON") || msg.includes("parse") || msg.includes("Unexpected token")) return `
+Invalid response format while ${operation}.
+
+The model "${model}" didn't return valid JSON. This often happens with:
+  • Smaller models that don't follow instructions well
+  • Local models without proper instruction tuning
+
+Try using a more capable model that follows structured output formats.
+`;
+		if (msg.includes("validation") || msg.includes("Expected")) return `
+Unexpected response structure while ${operation}.
+
+The model "${model}" returned an unexpected format.
+This can happen with models that don't follow instructions precisely.
+
+Try using a more capable model (e.g., gpt-4o, claude-3.5-sonnet).
+`;
+		return msg;
+	}
+	return String(error);
+}
+/**
+* Format a warning message for non-fatal issues
+*/
+function formatWarning(message) {
+	return `⚠️  ${message}`;
+}
+/**
+* Check if a model response looks valid (non-empty, reasonable length)
+*/
+function validateModelResponse(response, context) {
+	if (!response || response.trim().length === 0) throw new Error(formatAPIError(/* @__PURE__ */ new Error("empty response"), context));
+	if (response.trim().length < 10) console.warn(formatWarning(`Model returned a very short response. This may indicate the model "${context.model}" is struggling with the task.`));
+}
+
 //#endregion
 //#region src/ai.ts
-const PROVIDER_BASE_URLS = {
+const PROVIDER_BASE_URLS$2 = {
 	openai: "https://api.openai.com/v1",
 	openrouter: "https://openrouter.ai/api/v1"
 };
-const ChatCompletionResponse = z.object({ choices: z.array(z.object({ message: z.object({ content: z.string() }) })) });
+const ChatCompletionResponse$2 = z.object({ choices: z.array(z.object({ message: z.object({ content: z.string() }) })) });
 const SYSTEM_PROMPT = `You are an expert prompt engineer. Your task is to generate a well-crafted system prompt for an AI assistant.
 
 You will receive a series of building blocks that describe what the system prompt should contain. Each block has a type, instructions, and a value. Some blocks may have a "Nudge" level (1-5) indicating how strongly to convey the instruction.
@@ -75,40 +549,69 @@ Example: "You must keep responses concise. Under no circumstances should you pro
 Bad example (don't do this):
 "## Do
 - Keep responses brief
-## Don't  
+## Don't
 - Use jargon"
 
 Good example (do this instead):
 "Keep your responses brief and accessible. Avoid technical jargon that might confuse users."
 
 Output ONLY the final system prompt text. Do not include any explanations, preamble, or meta-commentary.`;
-async function processPrompt(steps, config) {
-	const apiKey = process.env[config.apiKeyEnvVar];
-	if (!apiKey) throw new Error(`Missing API key: environment variable "${config.apiKeyEnvVar}" is not set`);
-	const baseUrl = PROVIDER_BASE_URLS[config.provider];
+async function processPrompt(steps, config, options) {
+	let baseUrl;
+	if (config.baseUrl) {
+		if (!config.baseUrl.startsWith("http://") && !config.baseUrl.startsWith("https://")) throw new Error(`Invalid baseUrl "${config.baseUrl}": must start with http:// or https://`);
+		baseUrl = config.baseUrl;
+	} else if (config.provider === "local") throw new Error("Local provider requires \"baseUrl\" in config (e.g., \"http://localhost:8080/v1\")");
+	else baseUrl = PROVIDER_BASE_URLS$2[config.provider];
+	let apiKey;
+	if (config.apiKeyEnvVar) {
+		apiKey = process.env[config.apiKeyEnvVar];
+		if (!apiKey) throw new Error(`Missing API key: environment variable "${config.apiKeyEnvVar}" is not set`);
+	} else if (config.provider !== "local") throw new Error(`Missing "apiKeyEnvVar" in config for provider "${config.provider}"`);
+	const headers = { "Content-Type": "application/json" };
+	if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
 	const stepsDescription = steps.map(formatStepForAI).join("\n\n");
-	const response = await fetch(`${baseUrl}/chat/completions`, {
-		method: "POST",
-		headers: {
-			Authorization: `Bearer ${apiKey}`,
-			"Content-Type": "application/json"
-		},
-		body: JSON.stringify({
-			model: config.model,
-			messages: [{
-				role: "system",
-				content: SYSTEM_PROMPT
-			}, {
-				role: "user",
-				content: `Generate a system prompt from these building blocks:\n\n${stepsDescription}`
-			}]
-		})
-	});
+	let response;
+	try {
+		response = await fetch(`${baseUrl}/chat/completions`, {
+			method: "POST",
+			headers,
+			body: JSON.stringify({
+				model: config.model,
+				messages: [{
+					role: "system",
+					content: SYSTEM_PROMPT
+				}, {
+					role: "user",
+					content: `Generate a system prompt from these building blocks:\n\n${stepsDescription}`
+				}]
+			})
+		});
+	} catch (e) {
+		throw e;
+	}
 	if (!response.ok) {
-		const error = await response.text();
-		throw new Error(`AI request failed: ${response.status} - ${error}`);
+		const errorText = await response.text();
+		throw new Error(formatAPIError(/* @__PURE__ */ new Error(`${response.status} - ${errorText}`), {
+			model: config.model,
+			operation: "generating prompt"
+		}));
+	}
+	let data;
+	try {
+		data = ChatCompletionResponse$2.parse(await response.json());
+	} catch (e) {
+		throw new Error(formatAPIError(e, {
+			model: config.model,
+			operation: "generating prompt"
+		}));
 	}
-	return ChatCompletionResponse.parse(await response.json()).choices[0]?.message.content ?? "";
+	const content = data.choices[0]?.message.content ?? "";
+	validateModelResponse(content, {
+		model: config.model,
+		operation: "generating prompt"
+	});
+	return content;
 }
 
 //#endregion
@@ -1481,7 +1984,7 @@ var require_braces = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region ../../node_modules/micromatch/node_modules/picomatch/lib/constants.js
+//#region ../../node_modules/picomatch/lib/constants.js
 var require_constants$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const path$7 = __require("path");
 	const WIN_SLASH = "\\\\/";
@@ -1645,7 +2148,7 @@ var require_constants$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region ../../node_modules/micromatch/node_modules/picomatch/lib/utils.js
+//#region ../../node_modules/picomatch/lib/utils.js
 var require_utils$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const path$6 = __require("path");
 	const win32 = process.platform === "win32";
@@ -1691,7 +2194,7 @@ var require_utils$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/micromatch/node_modules/picomatch/lib/scan.js
+//#region ../../node_modules/picomatch/lib/scan.js
 var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const utils = require_utils$2();
 	const { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = require_constants$1();
@@ -1979,7 +2482,7 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region ../../node_modules/micromatch/node_modules/picomatch/lib/parse.js
+//#region ../../node_modules/picomatch/lib/parse.js
 var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const constants = require_constants$1();
 	const utils = require_utils$2();
@@ -2841,7 +3344,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region ../../node_modules/micromatch/node_modules/picomatch/lib/picomatch.js
+//#region ../../node_modules/picomatch/lib/picomatch.js
 var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const path$5 = __require("path");
 	const scan = require_scan();
@@ -3135,7 +3638,7 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region ../../node_modules/micromatch/node_modules/picomatch/index.js
+//#region ../../node_modules/picomatch/index.js
 var require_picomatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = require_picomatch$1();
 }));
@@ -3965,8 +4468,8 @@ var require_tasks = /* @__PURE__ */ __commonJSMin(((exports) => {
 var require_async$5 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.read = void 0;
-	function read(path$9, settings, callback) {
-		settings.fs.lstat(path$9, (lstatError, lstat) => {
+	function read(path$10, settings, callback) {
+		settings.fs.lstat(path$10, (lstatError, lstat) => {
 			if (lstatError !== null) {
 				callFailureCallback(callback, lstatError);
 				return;
@@ -3975,7 +4478,7 @@ var require_async$5 = /* @__PURE__ */ __commonJSMin(((exports) => {
 				callSuccessCallback(callback, lstat);
 				return;
 			}
-			settings.fs.stat(path$9, (statError, stat) => {
+			settings.fs.stat(path$10, (statError, stat) => {
 				if (statError !== null) {
 					if (settings.throwErrorOnBrokenSymbolicLink) {
 						callFailureCallback(callback, statError);
@@ -4003,11 +4506,11 @@ var require_async$5 = /* @__PURE__ */ __commonJSMin(((exports) => {
 var require_sync$5 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.read = void 0;
-	function read(path$9, settings) {
-		const lstat = settings.fs.lstatSync(path$9);
+	function read(path$10, settings) {
+		const lstat = settings.fs.lstatSync(path$10);
 		if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) return lstat;
 		try {
-			const stat = settings.fs.statSync(path$9);
+			const stat = settings.fs.statSync(path$10);
 			if (settings.markSymbolicLink) stat.isSymbolicLink = () => true;
 			return stat;
 		} catch (error) {
@@ -4066,17 +4569,17 @@ var require_out$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const sync = require_sync$5();
 	const settings_1 = require_settings$3();
 	exports.Settings = settings_1.default;
-	function stat(path$9, optionsOrSettingsOrCallback, callback) {
+	function stat(path$10, optionsOrSettingsOrCallback, callback) {
 		if (typeof optionsOrSettingsOrCallback === "function") {
-			async.read(path$9, getSettings(), optionsOrSettingsOrCallback);
+			async.read(path$10, getSettings(), optionsOrSettingsOrCallback);
 			return;
 		}
-		async.read(path$9, getSettings(optionsOrSettingsOrCallback), callback);
+		async.read(path$10, getSettings(optionsOrSettingsOrCallback), callback);
 	}
 	exports.stat = stat;
-	function statSync(path$9, optionsOrSettings) {
+	function statSync(path$10, optionsOrSettings) {
 		const settings = getSettings(optionsOrSettings);
-		return sync.read(path$9, settings);
+		return sync.read(path$10, settings);
 	}
 	exports.statSync = statSync;
 	function getSettings(settingsOrOptions = {}) {
@@ -4275,16 +4778,16 @@ var require_async$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
 				return;
 			}
 			rpl(names.map((name) => {
-				const path$9 = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
+				const path$10 = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
 				return (done) => {
-					fsStat.stat(path$9, settings.fsStatSettings, (error, stats) => {
+					fsStat.stat(path$10, settings.fsStatSettings, (error, stats) => {
 						if (error !== null) {
 							done(error);
 							return;
 						}
 						const entry = {
 							name,
-							path: path$9,
+							path: path$10,
 							dirent: utils.fs.createDirentFromStats(name, stats)
 						};
 						if (settings.stats) entry.stats = stats;
@@ -4414,17 +4917,17 @@ var require_out$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const sync = require_sync$4();
 	const settings_1 = require_settings$2();
 	exports.Settings = settings_1.default;
-	function scandir(path$9, optionsOrSettingsOrCallback, callback) {
+	function scandir(path$10, optionsOrSettingsOrCallback, callback) {
 		if (typeof optionsOrSettingsOrCallback === "function") {
-			async.read(path$9, getSettings(), optionsOrSettingsOrCallback);
+			async.read(path$10, getSettings(), optionsOrSettingsOrCallback);
 			return;
 		}
-		async.read(path$9, getSettings(optionsOrSettingsOrCallback), callback);
+		async.read(path$10, getSettings(optionsOrSettingsOrCallback), callback);
 	}
 	exports.scandir = scandir;
-	function scandirSync(path$9, optionsOrSettings) {
+	function scandirSync(path$10, optionsOrSettings) {
 		const settings = getSettings(optionsOrSettings);
-		return sync.read(path$9, settings);
+		return sync.read(path$10, settings);
 	}
 	exports.scandirSync = scandirSync;
 	function getSettings(settingsOrOptions = {}) {
@@ -5765,44 +6268,518 @@ async function discoverPrompts(dir, pattern) {
 	return prompts;
 }
 
+//#endregion
+//#region src/eval.ts
+const ChatCompletionResponse$1 = z.object({ choices: z.array(z.object({ message: z.object({ content: z.string() }) })) });
+const JudgeResponse = z.object({
+	passed: z.boolean(),
+	reason: z.string()
+});
+const PROVIDER_BASE_URLS$1 = {
+	openai: "https://api.openai.com/v1",
+	openrouter: "https://openrouter.ai/api/v1"
+};
+const JUDGE_SYSTEM_PROMPT = `You are evaluating whether an AI's output meets a specific assertion.
+
+You will receive:
+1. The input that was given to the AI
+2. The AI's output
+3. An assertion describing what the output should do/contain
+
+Evaluate whether the output satisfies the assertion. Be strict but fair.
+
+Respond in JSON format:
+{
+  "passed": true/false,
+  "reason": "Brief explanation of why it passed or failed"
+}`;
+async function callAI$1(systemPrompt, userMessage, config) {
+	let baseUrl;
+	if (config.baseUrl) baseUrl = config.baseUrl;
+	else if (config.provider === "local") throw new Error("Local provider requires baseUrl");
+	else baseUrl = PROVIDER_BASE_URLS$1[config.provider];
+	let apiKey;
+	if (config.apiKeyEnvVar) apiKey = process.env[config.apiKeyEnvVar];
+	const headers = { "Content-Type": "application/json" };
+	if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+	const response = await fetch(`${baseUrl}/chat/completions`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify({
+			model: config.model,
+			messages: [{
+				role: "system",
+				content: systemPrompt
+			}, {
+				role: "user",
+				content: userMessage
+			}]
+		})
+	});
+	if (!response.ok) {
+		const errorText = await response.text();
+		throw new Error(formatAPIError(/* @__PURE__ */ new Error(`${response.status} - ${errorText}`), {
+			model: config.model,
+			operation: "running evaluation"
+		}));
+	}
+	let data;
+	try {
+		data = ChatCompletionResponse$1.parse(await response.json());
+	} catch (e) {
+		throw new Error(formatAPIError(e, {
+			model: config.model,
+			operation: "running evaluation"
+		}));
+	}
+	return data.choices[0]?.message.content ?? "";
+}
+async function runJudge(input, output, assertion, config) {
+	const response = await callAI$1(JUDGE_SYSTEM_PROMPT, `## Input given to AI
+${input}
+
+## AI's Output
+${output}
+
+## Assertion to check
+${assertion}`, config);
+	const jsonStr = (response.match(/```json\s*([\s\S]*?)\s*```/) || response.match(/```\s*([\s\S]*?)\s*```/) || [null, response])[1] || response;
+	try {
+		return JudgeResponse.parse(JSON.parse(jsonStr));
+	} catch {
+		const lowerResponse = response.toLowerCase();
+		const passed = lowerResponse.includes("\"passed\": true") || lowerResponse.includes("\"passed\":true") || lowerResponse.includes("passed: true");
+		const failed = lowerResponse.includes("\"passed\": false") || lowerResponse.includes("\"passed\":false") || lowerResponse.includes("passed: false");
+		if (!passed && !failed) return {
+			passed: false,
+			reason: `Judge model didn't return valid JSON. Consider using a more capable model. Response: "${response.slice(0, 100)}${response.length > 100 ? "..." : ""}"`
+		};
+		return {
+			passed,
+			reason: "Inferred from non-JSON response"
+		};
+	}
+}
+async function runTest(systemPrompt, test, config, useJudge) {
+	const output = await callAI$1(systemPrompt, test.input, config);
+	let passed;
+	let reason;
+	if (typeof test.assert === "function") try {
+		passed = test.assert(output);
+		if (!passed) reason = "Assertion function returned false";
+	} catch (e) {
+		passed = false;
+		reason = `Assertion threw: ${e}`;
+	}
+	else if (useJudge) {
+		const judgeResult = await runJudge(test.input, output, test.assert, config);
+		passed = judgeResult.passed;
+		reason = judgeResult.reason;
+	} else {
+		passed = true;
+		reason = "String assertion skipped (use --judge to evaluate)";
+	}
+	return {
+		input: test.input,
+		output,
+		passed,
+		description: test.description,
+		reason
+	};
+}
+async function evaluateVariant(promptId, variantName, systemPrompt, tests, config, useJudge) {
+	const results = [];
+	for (let i = 0; i < tests.length; i++) {
+		const test = tests[i];
+		const result = await runTest(systemPrompt, test, config, useJudge);
+		results.push(result);
+	}
+	const passed = results.filter((r) => r.passed).length;
+	const failed = results.filter((r) => !r.passed).length;
+	const total = results.length;
+	return {
+		promptId,
+		variantName,
+		results,
+		passed,
+		failed,
+		total,
+		successRate: total > 0 ? passed / total * 100 : 100
+	};
+}
+
+//#endregion
+//#region src/improve-ai.ts
+const PromptChangeSchema = z.object({
+	action: z.enum([
+		"add",
+		"modify",
+		"remove"
+	]),
+	original: z.optional(z.string()),
+	replacement: z.string(),
+	reason: z.string()
+});
+const SourceHintSchema = z.object({
+	stepType: z.string(),
+	action: z.enum([
+		"add",
+		"modify",
+		"remove",
+		"adjust_nudge"
+	]),
+	suggestion: z.string(),
+	reason: z.string()
+});
+const ImprovementSuggestionSchema = z.object({
+	analysis: z.string(),
+	promptChanges: z.array(PromptChangeSchema),
+	sourceHints: z.array(SourceHintSchema),
+	confidence: z.number()
+});
+const ChatCompletionResponse = z.object({ choices: z.array(z.object({ message: z.object({ content: z.string() }) })) });
+const PROVIDER_BASE_URLS = {
+	openai: "https://api.openai.com/v1",
+	openrouter: "https://openrouter.ai/api/v1"
+};
+const IMPROVEMENT_SYSTEM_PROMPT = `You are an expert prompt engineer improving AI system prompts based on test failures.
+
+## Input
+1. Current system prompt text
+2. Failing tests with: input, expected assertion, actual output, failure reason
+
+## Your Task
+1. Analyze why tests are failing
+2. Suggest specific text modifications to the system prompt
+3. Provide "source hints" - what builder step changes would help permanently
+
+IMPORTANT: You MUST respond with ONLY a valid JSON object. No explanations, no markdown, just the JSON.
+
+## Response Format
+{
+  "analysis": "Brief explanation of failure pattern",
+  "promptChanges": [
+    { "action": "add", "replacement": "new text to add to prompt", "reason": "why this helps" },
+    { "action": "modify", "original": "exact text to find", "replacement": "replacement text", "reason": "why" },
+    { "action": "remove", "original": "text to remove", "replacement": "", "reason": "why" }
+  ],
+  "sourceHints": [
+    { "stepType": "dont", "action": "add", "suggestion": ".dont(\"add interpretive language\")", "reason": "prevents qualitative assessments" }
+  ],
+  "confidence": 0.85
+}
+
+## Guidelines
+- Make minimal changes to fix failures without breaking passing tests
+- For "add" actions, the replacement text will be appended to the prompt
+- For "modify" actions, provide the EXACT original text to find (copy from the prompt)
+- For sourceHints, suggest actual TypeScript code for .prompt.ts files
+- Available step types: persona, context, input, output, do, dont, constraint, example, raw
+- Nudge levels 1-5 control instruction strength (1=soft, 5=absolute)
+- Be conservative - prefer small targeted changes over large rewrites
+
+Output ONLY the JSON object, nothing else.`;
+async function callAI(systemPrompt, userMessage, config) {
+	let baseUrl;
+	if (config.baseUrl) baseUrl = config.baseUrl;
+	else if (config.provider === "local") throw new Error("Local provider requires baseUrl");
+	else baseUrl = PROVIDER_BASE_URLS[config.provider];
+	let apiKey;
+	if (config.apiKeyEnvVar) apiKey = process.env[config.apiKeyEnvVar];
+	const headers = { "Content-Type": "application/json" };
+	if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+	const response = await fetch(`${baseUrl}/chat/completions`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify({
+			model: config.model,
+			messages: [{
+				role: "system",
+				content: systemPrompt
+			}, {
+				role: "user",
+				content: userMessage
+			}]
+		})
+	});
+	if (!response.ok) {
+		const errorText = await response.text();
+		throw new Error(formatAPIError(/* @__PURE__ */ new Error(`${response.status} - ${errorText}`), {
+			model: config.model,
+			operation: "improving prompt"
+		}));
+	}
+	let data;
+	try {
+		data = ChatCompletionResponse.parse(await response.json());
+	} catch (e) {
+		throw new Error(formatAPIError(e, {
+			model: config.model,
+			operation: "improving prompt"
+		}));
+	}
+	return data.choices[0]?.message.content ?? "";
+}
+async function requestImprovement(currentPrompt, failingTests, config, verbose = false) {
+	const response = await callAI(IMPROVEMENT_SYSTEM_PROMPT, `## Current System Prompt
+\`\`\`
+${currentPrompt}
+\`\`\`
+
+## Failing Tests
+${failingTests.map((t, i) => {
+		return `### Test ${i + 1}${t.description ? ` (${t.description})` : ""}
+Input: ${t.input}
+Assertion: ${t.assertion}
+Actual Output: ${t.output}
+Failure Reason: ${t.reason || "Assertion not satisfied"}`;
+	}).join("\n\n")}
+
+Respond with ONLY a JSON object containing your analysis and suggested changes.`, config);
+	const jsonStr = ((response.match(/```json\s*([\s\S]*?)\s*```/) || response.match(/```\s*([\s\S]*?)\s*```/) || response.match(/(\{[\s\S]*\})/) || [null, response])[1] || response).trim();
+	try {
+		const parsed = JSON.parse(jsonStr);
+		return ImprovementSuggestionSchema.parse(parsed);
+	} catch (e) {
+		if (verbose) {
+			console.log("\n  ⚠️  Model returned invalid JSON");
+			console.log("  Raw AI response:");
+			const lines = response.split("\n");
+			for (const line of lines.slice(0, 15)) console.log(`    ${line}`);
+			if (lines.length > 15) console.log(`    ... (${lines.length - 15} more lines)`);
+			console.log(`\n  Parse error: ${e instanceof Error ? e.message : String(e)}`);
+		} else console.log("  ⚠️  Model returned invalid JSON. Use --verbose to see the raw response.");
+		console.log("  💡 Tip: The improve command works best with capable models (gpt-4o, claude-3.5-sonnet).\n");
+		return {
+			analysis: "Model did not return valid JSON. Try using a more capable model.",
+			promptChanges: [],
+			sourceHints: [],
+			confidence: 0
+		};
+	}
+}
+function applyPromptChanges(prompt, changes) {
+	let result = prompt;
+	for (const change of changes) switch (change.action) {
+		case "add":
+			result = result.trim() + "\n\n" + change.replacement;
+			break;
+		case "modify":
+			if (change.original && result.includes(change.original)) result = result.replace(change.original, change.replacement);
+			break;
+		case "remove":
+			if (change.original) result = result.replace(change.original, "");
+			break;
+	}
+	return result.trim();
+}
+
+//#endregion
+//#region src/improve.ts
+function escapeForTemplateLiteral$1(text) {
+	return text.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+}
+function updatePromptsGenFile(outputPath, promptId, variantName, newPromptText) {
+	const content = fs$3.readFileSync(outputPath, "utf-8");
+	const escaped = escapeForTemplateLiteral$1(newPromptText);
+	const escapedVariantKey = JSON.stringify(variantName).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const variantRegex = new RegExp(`(${escapedVariantKey}:\\s*)\`(?:[^\`\\\\]|\\\\.)*\``, "gs");
+	const promptKey = JSON.stringify(promptId);
+	const promptSectionRegex = new RegExp(`${promptKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:\\s*\\{[\\s\\S]*?\\n  \\}`, "g");
+	const newContent = content.replace(promptSectionRegex, (promptSection) => {
+		return promptSection.replace(variantRegex, `$1\`${escaped}\``);
+	});
+	fs$3.writeFileSync(outputPath, newContent, "utf-8");
+}
+function getAssertionString(test) {
+	if (typeof test.assert === "function") return test.assert.toString();
+	return test.assert;
+}
+function resultsAreSame(prev, current) {
+	if (prev.length !== current.length) return false;
+	const prevFailing = prev.filter((r) => !r.passed).map((r) => r.input).sort();
+	const currFailing = current.filter((r) => !r.passed).map((r) => r.input).sort();
+	if (prevFailing.length !== currFailing.length) return false;
+	return prevFailing.every((input, i) => input === currFailing[i]);
+}
+async function improveVariant(promptId, variantName, currentPrompt, tests, config, options, outputPath) {
+	let prompt = currentPrompt;
+	const allSourceHints = [];
+	options.onStatus?.(promptId, variantName, "Evaluating current prompt...");
+	let evaluation = await evaluateVariant(promptId, variantName, prompt, tests, config, options.judge);
+	const initialFailures = evaluation.failed;
+	if (initialFailures === 0) return {
+		promptId,
+		variantName,
+		iterations: 0,
+		initialFailures: 0,
+		finalFailures: 0,
+		sourceHints: [],
+		status: "improved"
+	};
+	let previousResults = evaluation.results;
+	for (let i = 0; i < options.maxIterations; i++) {
+		options.onIterationStart?.(promptId, variantName, i + 1);
+		const failingTestInfos = evaluation.results.filter((r) => !r.passed).map((r) => {
+			const test = tests.find((t) => t.input === r.input);
+			return {
+				input: r.input,
+				output: r.output,
+				assertion: test ? getAssertionString(test) : "unknown",
+				reason: r.reason,
+				description: r.description
+			};
+		});
+		options.onStatus?.(promptId, variantName, "Requesting AI improvement...");
+		const suggestion = await requestImprovement(prompt, failingTestInfos, config, options.verbose);
+		allSourceHints.push(...suggestion.sourceHints);
+		if (suggestion.promptChanges.length === 0) {
+			const result$1 = {
+				promptId,
+				variantName,
+				iterations: i + 1,
+				initialFailures,
+				finalFailures: evaluation.failed,
+				sourceHints: allSourceHints,
+				status: "plateau"
+			};
+			options.onIterationDone?.(promptId, variantName, result$1);
+			return result$1;
+		}
+		prompt = applyPromptChanges(prompt, suggestion.promptChanges);
+		updatePromptsGenFile(outputPath, promptId, variantName, prompt);
+		options.onStatus?.(promptId, variantName, "Re-evaluating prompt...");
+		evaluation = await evaluateVariant(promptId, variantName, prompt, tests, config, options.judge);
+		if (evaluation.failed === 0) {
+			const result$1 = {
+				promptId,
+				variantName,
+				iterations: i + 1,
+				initialFailures,
+				finalFailures: 0,
+				sourceHints: allSourceHints,
+				status: "improved"
+			};
+			options.onIterationDone?.(promptId, variantName, result$1);
+			return result$1;
+		}
+		if (resultsAreSame(previousResults, evaluation.results)) {
+			const result$1 = {
+				promptId,
+				variantName,
+				iterations: i + 1,
+				initialFailures,
+				finalFailures: evaluation.failed,
+				sourceHints: allSourceHints,
+				status: "plateau"
+			};
+			options.onIterationDone?.(promptId, variantName, result$1);
+			return result$1;
+		}
+		previousResults = evaluation.results;
+	}
+	const result = {
+		promptId,
+		variantName,
+		iterations: options.maxIterations,
+		initialFailures,
+		finalFailures: evaluation.failed,
+		sourceHints: allSourceHints,
+		status: "max_iterations"
+	};
+	options.onIterationDone?.(promptId, variantName, result);
+	return result;
+}
+async function improve$1(targetDir, outputPath, options) {
+	const prompts = await discoverPrompts(targetDir, options.promptFilenamePattern ?? "**/*.prompt.{ts,js}");
+	const existingPrompts = loadExistingPrompts(outputPath);
+	if (Object.keys(existingPrompts).length === 0) throw new Error("No generated prompts found. Run 'npx nudge generate' first.");
+	let promptsWithTests = prompts.filter((p) => p.state.tests && p.state.tests.length > 0);
+	if (options.promptIds && options.promptIds.length > 0) promptsWithTests = promptsWithTests.filter((p) => options.promptIds.includes(p.id));
+	if (promptsWithTests.length === 0) throw new Error("No prompts with tests found.");
+	const results = [];
+	for (const prompt of promptsWithTests) {
+		const existing = existingPrompts[prompt.id];
+		if (!existing) continue;
+		const tests = prompt.state.tests;
+		for (const [variantName, text] of Object.entries(existing.variants)) {
+			const result = await improveVariant(prompt.id, variantName, text, tests, options.aiConfig, options, outputPath);
+			results.push(result);
+		}
+	}
+	return results;
+}
+
 //#endregion
 //#region src/index.ts
+function escapeForTemplateLiteral(text) {
+	return text.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+}
+function extractVariables(variants) {
+	const allVars = /* @__PURE__ */ new Set();
+	for (const text of Object.values(variants)) for (const match of text.matchAll(/\{\{(?![#\/])(\w+)\}\}/g)) allVars.add(match[1]);
+	return [...allVars];
+}
 async function generate(targetDir, outputPath, options = {}) {
 	const prompts = await discoverPrompts(targetDir, options.promptFilenamePattern ?? "**/*.prompt.{ts,js}");
 	if (!options.aiConfig) throw new Error("AI config is required in nudge.config.json");
 	const existingPrompts = loadExistingPrompts(outputPath);
-	console.log(`Processing ${prompts.length} prompt(s)...`);
-	const results = await Promise.all(prompts.map(async (prompt) => {
+	const results = [];
+	for (const prompt of prompts) {
 		const hash = hashState(prompt.state);
 		const existing = existingPrompts[prompt.id];
-		let text;
+		let variants;
 		if (!options.noCache && existing && existing.hash === hash) {
-			console.log(`  ✓ "${prompt.id}" unchanged (cached)`);
-			text = existing.text;
+			options.onPromptCached?.(prompt.id);
+			variants = existing.variants;
 		} else {
-			console.log(`  → "${prompt.id}" processing with AI...`);
-			text = await processPrompt(prompt.state, options.aiConfig);
+			const definedVariants = prompt.state.variants ?? [];
+			const variantCount = definedVariants.length || 1;
+			try {
+				options.onPromptStart?.(prompt.id, variantCount);
+				if (definedVariants.length === 0) variants = { default: await processPrompt(prompt.state.steps, options.aiConfig, { silent: true }) };
+				else {
+					const variantEntries$1 = [];
+					for (let i = 0; i < definedVariants.length; i++) {
+						const v = definedVariants[i];
+						const text = await processPrompt([...prompt.state.steps, ...v.steps], options.aiConfig, { silent: true });
+						variantEntries$1.push([v.name, text]);
+					}
+					variants = Object.fromEntries(variantEntries$1);
+				}
+				options.onPromptDone?.(prompt.id, variantCount);
+			} catch (error) {
+				options.onPromptError?.(prompt.id, error);
+				throw error;
+			}
 		}
-		const variables = [...new Set([...text.matchAll(/\{\{(?![#\/])(\w+)\}\}/g)].map((m) => m[1]))];
-		const escaped = text.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
-		return {
+		const variables = extractVariables(variants);
+		const variantNames = Object.keys(variants).filter((k) => k !== "default");
+		const variantEntriesStr = Object.entries(variants).map(([name, text]) => {
+			const escaped = escapeForTemplateLiteral(text);
+			return `      ${JSON.stringify(name)}: \`${escaped}\``;
+		}).join(",\n");
+		results.push({
 			id: prompt.id,
-			entry: `  ${JSON.stringify(prompt.id)}: {\n    text: \`${escaped}\`,\n    hash: ${JSON.stringify(hash)},\n  }`,
+			entry: `  ${JSON.stringify(prompt.id)}: {\n    variants: {\n${variantEntriesStr},\n    },\n    hash: ${JSON.stringify(hash)},\n  }`,
 			registry: `    ${JSON.stringify(prompt.id)}: true;`,
-			variables: variables.length > 0 ? `    ${JSON.stringify(prompt.id)}: ${variables.map((v) => JSON.stringify(v)).join(" | ")};` : null
-		};
-	}));
+			variables: variables.length > 0 ? `    ${JSON.stringify(prompt.id)}: ${variables.map((v) => JSON.stringify(v)).join(" | ")};` : null,
+			variantNames: variantNames.length > 0 ? `    ${JSON.stringify(prompt.id)}: ${variantNames.map((v) => JSON.stringify(v)).join(" | ")};` : null
+		});
+	}
 	const promptEntries = results.map((r) => r.entry);
 	const registryEntries = results.map((r) => r.registry);
 	const variableEntries = results.map((r) => r.variables).filter((v) => v !== null);
+	const variantEntries = results.map((r) => r.variantNames).filter((v) => v !== null);
 	const variablesInterface = variableEntries.length > 0 ? `\n  interface PromptVariables {\n${variableEntries.join("\n")}\n  }` : "";
+	const variantsInterface = variantEntries.length > 0 ? `\n  interface PromptVariants {\n${variantEntries.join("\n")}\n  }` : "";
 	const code = `// This file is auto-generated by @nudge-ai/cli. Do not edit manually.
-import { registerPrompts } from "@nudge-ai/core";
+import { registerPrompts } from "@nudge-ai/core/internal";
 
 declare module "@nudge-ai/core" {
   interface PromptRegistry {
 ${registryEntries.join("\n")}
-  }${variablesInterface}
+  }${variablesInterface}${variantsInterface}
 }
 
 const prompts = {
@@ -5812,9 +6789,32 @@ ${promptEntries.join(",\n")}
 registerPrompts(prompts);
 `;
 	fs$3.writeFileSync(outputPath, code, "utf-8");
-	console.log(`Generated ${outputPath} with ${prompts.length} prompt(s)`);
+}
+async function evaluate(targetDir, outputPath, options = {}) {
+	const prompts = await discoverPrompts(targetDir, options.promptFilenamePattern ?? "**/*.prompt.{ts,js}");
+	if (!options.aiConfig) throw new Error("AI config is required in nudge.config.json");
+	const existingPrompts = loadExistingPrompts(outputPath);
+	if (Object.keys(existingPrompts).length === 0) throw new Error("No generated prompts found. Run 'nudge generate' first.");
+	const promptsWithTests = prompts.filter((p) => p.state.tests && p.state.tests.length > 0);
+	if (promptsWithTests.length === 0) throw new Error("No prompts with tests found. Add tests using .test(input, assertion)");
+	const evaluations = [];
+	for (const prompt of promptsWithTests) {
+		const existing = existingPrompts[prompt.id];
+		if (!existing) continue;
+		const tests = prompt.state.tests;
+		for (const [variantName, text] of Object.entries(existing.variants)) {
+			options.onVariantStart?.(prompt.id, variantName);
+			const evaluation = await evaluateVariant(prompt.id, variantName, text, tests, options.aiConfig, options.judge ?? false);
+			evaluations.push(evaluation);
+			options.onVariantDone?.(evaluation);
+		}
+	}
+	return evaluations;
+}
+async function improve(targetDir, outputPath, options) {
+	return improve$1(targetDir, outputPath, options);
 }
 
 //#endregion
-export { discoverPrompts as n, generate as t };
-//# sourceMappingURL=src-DG37IBZ6.mjs.map
+export { discoverPrompts as i, generate as n, improve as r, evaluate as t };
+//# sourceMappingURL=src-B7X5IQ4U.mjs.map