@alexkroman1/aai-cli 0.9.3 → 0.10.0

package/dist/doctor-bWuArZi6.mjs

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+import { n as fileExists } from "./_discover-D7HCLa_N.mjs";
+import { a as runCommand, i as parsePort, o as step } from "./_ui-C9IvR7Fh.mjs";
+import { i as loadAgentDef, r as envFileKeys } from "./_server-common-B6EXxxB2.mjs";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { colorize } from "consola/utils";
+import net from "node:net";
+//#region doctor.ts
+const PASS = colorize("greenBright", "✓");
+const WARN = colorize("yellowBright", "!");
+const FAIL = colorize("redBright", "✗");
+function statusIcon(status) {
+	if (status === "pass") return PASS;
+	if (status === "warn") return WARN;
+	return FAIL;
+}
+async function checkNodeVersion() {
+	const version = process.version;
+	const match = version.match(/^v(\d+)\.(\d+)/);
+	if (!match) return {
+		name: "Node.js",
+		status: "fail",
+		message: `Unknown version: ${version}`
+	};
+	const [major, minor] = [Number(match[1]), Number(match[2])];
+	if (major > 22 || major === 22 && minor >= 6) return {
+		name: "Node.js",
+		status: "pass",
+		message: `${version} (>=22.6 required)`
+	};
+	return {
+		name: "Node.js",
+		status: "fail",
+		message: `${version} — Node >=22.6 is required`,
+		fix: "Install Node.js 22.6+ from https://nodejs.org or via nvm: nvm install 22"
+	};
+}
+async function checkApiKey() {
+	const key = process.env.ASSEMBLYAI_API_KEY || await (async () => {
+		try {
+			const configPath = path.join(process.env.HOME ?? process.env.USERPROFILE ?? ".", ".config", "aai", "config.json");
+			return JSON.parse(await fs.readFile(configPath, "utf-8")).assemblyai_api_key;
+		} catch {}
+	})();
+	if (!key) return {
+		name: "API key",
+		status: "fail",
+		message: "ASSEMBLYAI_API_KEY not found",
+		fix: "Run `aai init` to set up your API key, or set the ASSEMBLYAI_API_KEY environment variable"
+	};
+	if (key.length < 10) return {
+		name: "API key",
+		status: "warn",
+		message: "ASSEMBLYAI_API_KEY looks too short — may be invalid",
+		fix: "Get a valid key from https://www.assemblyai.com/dashboard/signup"
+	};
+	return {
+		name: "API key",
+		status: "pass",
+		message: "ASSEMBLYAI_API_KEY is set"
+	};
+}
+async function checkDependencies(cwd) {
+	if (!await fileExists(path.join(cwd, "package.json"))) return {
+		name: "Dependencies",
+		status: "warn",
+		message: "No package.json found",
+		fix: "Run `aai init` to scaffold a project, or `npm init` to create package.json"
+	};
+	const nodeModules = path.join(cwd, "node_modules");
+	if (!await fileExists(nodeModules)) return {
+		name: "Dependencies",
+		status: "fail",
+		message: "node_modules/ not found — dependencies not installed",
+		fix: "Run `npm install` to install dependencies"
+	};
+	if (!await fileExists(path.join(nodeModules, "@alexkroman1", "aai"))) return {
+		name: "Dependencies",
+		status: "fail",
+		message: "@alexkroman1/aai package not found in node_modules",
+		fix: "Run `npm install @alexkroman1/aai` to add the SDK"
+	};
+	return {
+		name: "Dependencies",
+		status: "pass",
+		message: "node_modules/ present, SDK installed"
+	};
+}
+async function checkEnvFile(cwd) {
+	const envPath = path.join(cwd, ".env");
+	if (!await fileExists(envPath)) {
+		if (await fileExists(path.join(cwd, ".env.example"))) return {
+			name: ".env file",
+			status: "warn",
+			message: ".env not found, but .env.example exists",
+			fix: "Copy .env.example to .env and fill in the values: cp .env.example .env"
+		};
+		return {
+			name: ".env file",
+			status: "pass",
+			message: "No .env file (using environment variables or aai config)"
+		};
+	}
+	try {
+		const content = await fs.readFile(envPath, "utf-8");
+		const keys = envFileKeys(content);
+		if (keys.length === 0) return {
+			name: ".env file",
+			status: "warn",
+			message: ".env file is empty (no keys declared)"
+		};
+		const emptyKeys = [];
+		for (const line of content.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eq = trimmed.indexOf("=");
+			if (eq === -1) continue;
+			const val = trimmed.slice(eq + 1).trim();
+			if (!val || val === "\"\"" || val === "''") emptyKeys.push(trimmed.slice(0, eq).trim());
+		}
+		if (emptyKeys.length > 0) return {
+			name: ".env file",
+			status: "warn",
+			message: `${keys.length} key(s) declared, ${emptyKeys.length} empty: ${emptyKeys.join(", ")}`,
+			fix: "Fill in the empty values in your .env file"
+		};
+		return {
+			name: ".env file",
+			status: "pass",
+			message: `${keys.length} key(s) declared`
+		};
+	} catch {
+		return {
+			name: ".env file",
+			status: "fail",
+			message: "Failed to read .env file"
+		};
+	}
+}
+async function checkPortAvailable(port) {
+	if (await new Promise((resolve) => {
+		const server = net.createServer();
+		server.once("error", () => resolve(false));
+		server.once("listening", () => {
+			server.close(() => resolve(true));
+		});
+		server.listen(port, "127.0.0.1");
+	})) return {
+		name: "Port",
+		status: "pass",
+		message: `Port ${port} is available`
+	};
+	return {
+		name: "Port",
+		status: "warn",
+		message: `Port ${port} is in use`,
+		fix: `Use a different port: aai dev --port <number>, or stop the process using port ${port}`
+	};
+}
+async function checkAgentSyntax(cwd) {
+	if (!await fileExists(path.join(cwd, "agent.ts"))) return {
+		name: "agent.ts",
+		status: "fail",
+		message: "agent.ts not found",
+		fix: "Run `aai init` to scaffold a new agent project"
+	};
+	try {
+		await loadAgentDef(cwd);
+		return {
+			name: "agent.ts",
+			status: "pass",
+			message: "Valid agent definition"
+		};
+	} catch (err) {
+		return {
+			name: "agent.ts",
+			status: "fail",
+			message: `Invalid: ${err instanceof Error ? err.message : String(err)}`,
+			fix: "Check agent.ts — ensure it exports a default defineAgent() call with name, instructions, greeting, maxSteps, and tools"
+		};
+	}
+}
+async function _runDoctor(cwd, port, log) {
+	log("");
+	log(step("Doctor", "Checking environment health..."));
+	log("");
+	const results = [];
+	results.push(await checkNodeVersion());
+	results.push(await checkApiKey());
+	results.push(await checkDependencies(cwd));
+	results.push(await checkEnvFile(cwd));
+	results.push(await checkPortAvailable(port));
+	results.push(await checkAgentSyntax(cwd));
+	for (const r of results) {
+		log(`  ${statusIcon(r.status)} ${colorize("bold", r.name)}: ${r.message}`);
+		if (r.fix) log(colorize("dim", `    → ${r.fix}`));
+	}
+	log("");
+	const fails = results.filter((r) => r.status === "fail").length;
+	const warns = results.filter((r) => r.status === "warn").length;
+	if (fails > 0) log(`  ${FAIL} ${fails} issue(s) found. Fix them to proceed.`);
+	else if (warns > 0) log(`  ${WARN} All clear with ${warns} warning(s).`);
+	else log(`  ${PASS} Everything looks good!`);
+	log("");
+	if (fails > 0) process.exitCode = 1;
+}
+async function runDoctorCommand(opts) {
+	const port = parsePort(opts.port);
+	await runCommand(async ({ log }) => {
+		await _runDoctor(opts.cwd, port, log);
+	});
+}
+//#endregion
+export { runDoctorCommand };

package/dist/generate-D7zJtqoC.mjs

@@ -0,0 +1,393 @@
+#!/usr/bin/env node
+import { i as getApiKey } from "./_discover-D7HCLa_N.mjs";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { consola } from "consola";
+import { z } from "zod";
+import { colorize } from "consola/utils";
+import { execFile } from "node:child_process";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { generateText, stepCountIs } from "ai";
+import { promisify } from "node:util";
+//#region _generate-tools.ts
+const execFileAsync = promisify(execFile);
+const SKIP_DIRS = new Set([
+	"node_modules",
+	".git",
+	".aai",
+	"dist",
+	"coverage"
+]);
+const MAX_READ_LINES = 2e3;
+const MAX_LINE_LENGTH = 2e3;
+const MAX_OUTPUT_BYTES = 50 * 1024;
+function safePath(workDir, filePath) {
+	const abs = path.resolve(workDir, filePath);
+	if (!abs.startsWith(workDir + path.sep) && abs !== workDir) return null;
+	return abs;
+}
+function formatGrepOutput(workDir, stdout) {
+	if (!stdout.trim()) return "No matches found.";
+	const byFile = /* @__PURE__ */ new Map();
+	for (const line of stdout.trim().split("\n")) {
+		const sep = line.indexOf(":");
+		const sep2 = line.indexOf(":", sep + 1);
+		if (sep === -1 || sep2 === -1) continue;
+		const file = path.relative(workDir, line.slice(0, sep));
+		const lineNum = line.slice(sep + 1, sep2);
+		let text = line.slice(sep2 + 1);
+		if (text.length > MAX_LINE_LENGTH) text = `${text.slice(0, MAX_LINE_LENGTH)}...`;
+		const entries = byFile.get(file) ?? [];
+		entries.push(`  Line ${lineNum}: ${text}`);
+		byFile.set(file, entries);
+	}
+	const output = [];
+	for (const [file, lines] of byFile) {
+		output.push(`${file}:`);
+		output.push(...lines);
+	}
+	return output.join("\n");
+}
+function formatExecError(err) {
+	if (err && typeof err === "object" && "stdout" in err) {
+		const e = err;
+		return `Exit code ${e.code}\n${`${e.stdout}\n${e.stderr}`.trim()}`;
+	}
+	return `Error: ${err instanceof Error ? err.message : String(err)}`;
+}
+function truncateOutput(output) {
+	if (!output) return "(no output)";
+	if (output.length > MAX_OUTPUT_BYTES) return `${output.slice(0, MAX_OUTPUT_BYTES)}\n...(truncated, ${output.length} bytes total)`;
+	return output;
+}
+function readFileWithLineNumbers(content, offset, limit) {
+	const allLines = content.split("\n");
+	const startLine = Math.max(1, offset ?? 1);
+	const maxLines = limit ?? MAX_READ_LINES;
+	const endLine = Math.min(allLines.length, startLine + maxLines - 1);
+	const lines = allLines.slice(startLine - 1, endLine);
+	let output = "";
+	let bytes = 0;
+	let truncatedByBytes = false;
+	for (let i = 0; i < lines.length; i++) {
+		const raw = lines[i] ?? "";
+		const text = raw.length > MAX_LINE_LENGTH ? `${raw.slice(0, MAX_LINE_LENGTH)}... (truncated)` : raw;
+		const numbered = `${startLine + i}: ${text}\n`;
+		if (bytes + numbered.length > MAX_OUTPUT_BYTES) {
+			truncatedByBytes = true;
+			break;
+		}
+		output += numbered;
+		bytes += numbered.length;
+	}
+	const total = allLines.length;
+	if (truncatedByBytes || endLine < total) {
+		const shown = endLine - startLine + 1;
+		output += `\n(Showing lines ${startLine}-${startLine + shown - 1} of ${total}. Use offset=${endLine + 1} to continue.)`;
+	}
+	return output;
+}
+function isRgNoMatch(err) {
+	return Boolean(err && typeof err === "object" && "code" in err && err.code === 1);
+}
+function makeFileTools(workDir) {
+	return {
+		read: {
+			description: "Read a file or directory. Returns lines prefixed with line numbers (e.g. `1: content`). Use offset/limit to paginate large files. Defaults to first 2000 lines. For directories, returns a listing of entries. Call this tool in parallel when reading multiple files.",
+			inputSchema: z.object({
+				filePath: z.string().describe("Path to the file or directory to read"),
+				offset: z.number().optional().describe("Line number to start from (1-indexed)"),
+				limit: z.number().optional().describe("Max number of lines to read (default 2000)")
+			}),
+			execute: async (args) => {
+				const { filePath, offset, limit } = args;
+				const abs = safePath(workDir, filePath);
+				if (!abs) return "Error: path outside working directory";
+				let stat;
+				try {
+					stat = await fs.stat(abs);
+				} catch {
+					return `Error: file not found: ${filePath}`;
+				}
+				if (stat.isDirectory()) return (await fs.readdir(abs, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name)).map((e) => e.isDirectory() ? `${e.name}/` : e.name).join("\n");
+				return readFileWithLineNumbers(await fs.readFile(abs, "utf-8"), offset, limit);
+			}
+		},
+		edit: {
+			description: "Performs exact string replacement in a file. You must read the file first before editing. The edit will fail if oldString is not found or matches multiple locations (unless replaceAll is true). Provide enough surrounding context in oldString to make the match unique. Preserve exact indentation from the file.",
+			inputSchema: z.object({
+				filePath: z.string().describe("Path to the file to modify"),
+				oldString: z.string().describe("The exact text to replace"),
+				newString: z.string().describe("The replacement text (must be different from oldString)"),
+				replaceAll: z.boolean().optional().describe("Replace all occurrences of oldString (default false)")
+			}),
+			execute: async (args) => {
+				const { filePath, oldString, newString, replaceAll } = args;
+				if (oldString === newString) return "Error: oldString and newString are identical";
+				const abs = safePath(workDir, filePath);
+				if (!abs) return "Error: path outside working directory";
+				let content;
+				try {
+					content = await fs.readFile(abs, "utf-8");
+				} catch {
+					return `Error: file not found: ${filePath}`;
+				}
+				if (!content.includes(oldString)) return "Error: oldString not found in file. Make sure you are matching the exact text including whitespace and indentation.";
+				if (replaceAll) {
+					await fs.writeFile(abs, content.replaceAll(oldString, newString));
+					return `Replaced ${content.split(oldString).length - 1} occurrence(s).`;
+				}
+				const first = content.indexOf(oldString);
+				if (content.indexOf(oldString, first + 1) !== -1) return "Error: found multiple matches for oldString. Provide more surrounding context to make it unique, or set replaceAll to true.";
+				await fs.writeFile(abs, content.replace(oldString, newString));
+				return "OK";
+			}
+		},
+		write: {
+			description: "Write content to a file, creating it if it doesn't exist or overwriting if it does. Always prefer editing existing files with the edit tool. Only use write for new files or complete rewrites.",
+			inputSchema: z.object({
+				filePath: z.string().describe("Path to the file to write"),
+				content: z.string().describe("The full file content to write")
+			}),
+			execute: async (args) => {
+				const { filePath, content } = args;
+				const abs = safePath(workDir, filePath);
+				if (!abs) return "Error: path outside working directory";
+				await fs.mkdir(path.dirname(abs), { recursive: true });
+				await fs.writeFile(abs, content);
+				return `Wrote ${content.length} bytes to ${filePath}`;
+			}
+		}
+	};
+}
+function makeSearchTools(workDir) {
+	return {
+		glob: {
+			description: "Fast file pattern matching. Supports glob patterns like '**/*.ts' or 'src/**/*.tsx'. Returns matching file paths sorted by modification time (newest first). Use this to find files by name or extension.",
+			inputSchema: z.object({
+				pattern: z.string().describe("Glob pattern to match files against"),
+				path: z.string().optional().describe("Directory to search in (defaults to project root)")
+			}),
+			execute: async (args) => {
+				const { pattern, path: searchPath } = args;
+				const dir = searchPath ? safePath(workDir, searchPath) ?? workDir : workDir;
+				try {
+					const { stdout } = await execFileAsync("rg", [
+						"--files",
+						"--glob",
+						pattern,
+						"--sort=modified",
+						dir
+					], {
+						maxBuffer: 1024 * 1024,
+						timeout: 1e4
+					});
+					const files = stdout.trim().split("\n").filter(Boolean).slice(0, 100).map((f) => path.relative(workDir, f));
+					if (files.length === 0) return "No files found matching pattern.";
+					const truncated = files.length >= 100 ? "\n(Showing first 100 results.)" : "";
+					return files.join("\n") + truncated;
+				} catch (err) {
+					if (isRgNoMatch(err)) return "No files found matching pattern.";
+					return `Error running glob: ${err instanceof Error ? err.message : String(err)}`;
+				}
+			}
+		},
+		grep: {
+			description: "Fast content search using regex. Searches file contents and returns file paths with line numbers and matching lines. Supports full regex syntax. Use the include parameter to filter by file extension (e.g. '*.ts').",
+			inputSchema: z.object({
+				pattern: z.string().describe("Regex pattern to search for"),
+				path: z.string().optional().describe("Directory to search in (defaults to project root)"),
+				include: z.string().optional().describe("File pattern to include (e.g. \"*.ts\", \"*.{ts,tsx}\")")
+			}),
+			execute: async (args) => {
+				const { pattern, path: searchPath, include } = args;
+				const dir = searchPath ? safePath(workDir, searchPath) ?? workDir : workDir;
+				const rgArgs = [
+					"-nH",
+					"--hidden",
+					"--no-messages",
+					"--max-count=100",
+					...include ? ["--glob", include] : [],
+					"--regexp",
+					pattern,
+					dir
+				];
+				try {
+					const { stdout } = await execFileAsync("rg", rgArgs, {
+						maxBuffer: 1024 * 1024,
+						timeout: 1e4
+					});
+					return formatGrepOutput(workDir, stdout);
+				} catch (err) {
+					if (isRgNoMatch(err)) return "No matches found.";
+					return `Error running grep: ${err instanceof Error ? err.message : String(err)}`;
+				}
+			}
+		},
+		bash: {
+			description: "Execute a shell command. Use for git, npm, and other terminal operations. Do NOT use for file reading/writing/searching — use the dedicated tools instead. Commands run in the project directory by default.",
+			inputSchema: z.object({
+				command: z.string().describe("The shell command to execute"),
+				description: z.string().describe("Brief description of what this command does (5-10 words)"),
+				timeout: z.number().optional().describe("Timeout in milliseconds (default 120000)")
+			}),
+			execute: async (args) => {
+				const { command, timeout } = args;
+				try {
+					const { stdout, stderr } = await execFileAsync(process.env.SHELL ?? "bash", ["-c", command], {
+						cwd: workDir,
+						maxBuffer: 1024 * 1024,
+						timeout: timeout ?? 12e4,
+						env: process.env
+					});
+					return truncateOutput(`${stdout}${stderr ? `\n${stderr}` : ""}`.trim());
+				} catch (err) {
+					return formatExecError(err);
+				}
+			}
+		},
+		ls: {
+			description: "List files and directories in a path. Returns entries with '/' suffix for directories. Prefer glob or grep if you know what you're looking for.",
+			inputSchema: z.object({ path: z.string().optional().describe("Directory path (defaults to project root)") }),
+			execute: async (args) => {
+				const { path: dirPath } = args;
+				const abs = dirPath ? safePath(workDir, dirPath) ?? workDir : workDir;
+				try {
+					return (await fs.readdir(abs, { withFileTypes: true })).filter((e) => !SKIP_DIRS.has(e.name)).sort((a, b) => a.name.localeCompare(b.name)).map((e) => e.isDirectory() ? `${e.name}/` : e.name).join("\n");
+				} catch {
+					return `Error: directory not found: ${dirPath ?? "."}`;
+				}
+			}
+		}
+	};
+}
+function makeTools(workDir) {
+	return {
+		...makeFileTools(workDir),
+		...makeSearchTools(workDir)
+	};
+}
+//#endregion
+//#region generate.ts
+const consola$1 = consola.create({
+	defaults: { message: "" },
+	formatOptions: { date: false }
+});
+const TOOL_ICONS = {
+	read: "→",
+	edit: "✎",
+	write: "✏",
+	glob: "✱",
+	grep: "◇",
+	bash: "$",
+	ls: "▪"
+};
+const SYSTEM_PROMPT = `You are a pragmatic, expert coding agent that builds voice agents using the AAI framework. You persist until the task is fully handled — do not stop at analysis or partial fixes.
+
+# Workflow
+
+1. Use glob or ls to see the project structure.
+2. Use read on agent.ts to see the current code.
+3. Plan your approach: what name, instructions, greeting, tools, state, and builtinTools does this agent need?
+4. Use write to update agent.ts with the complete implementation. Write the entire file — no placeholders or TODOs.
+5. Use read to verify your changes. If something is wrong, use edit to fix it.
+
+# Rules
+
+- The API reference is included below — do NOT read CLAUDE.md, it is already in your context.
+- agent.ts must export a default defineAgent() call.
+- Only modify agent.ts (and optionally client.tsx for custom UI).
+- Do NOT create extra files or install packages.
+- Write production-quality code. Tools should have clear descriptions and .describe() on each Zod parameter.
+- Handle edge cases in tool execute functions.
+- Parallelize tool calls when possible — e.g. read multiple files at once.`;
+function toolLabel(name, input) {
+	const icon = TOOL_ICONS[name] ?? "•";
+	const file = input.filePath ?? input.path ?? input.pattern ?? "";
+	if (name === "bash") return `${icon} ${colorize("cyanBright", name)} ${colorize("dim", String(input.command ?? "").slice(0, 60))}`;
+	if (file) return `${icon} ${colorize("cyanBright", name)} ${file}`;
+	return `${icon} ${colorize("cyanBright", name)}`;
+}
+function formatDuration(ms) {
+	if (ms < 1) return "<1ms";
+	if (ms < 1e3) return `${Math.round(ms)}ms`;
+	return `${(ms / 1e3).toFixed(1)}s`;
+}
+function printCode(filePath, content) {
+	const lang = path.extname(filePath).slice(1) || "text";
+	const lines = content.split("\n");
+	const maxLines = 40;
+	const truncated = lines.length > maxLines;
+	const shown = truncated ? lines.slice(0, maxLines) : lines;
+	console.log(colorize("dim", `  ┌── ${filePath} (${lang})`));
+	for (const line of shown) console.log(colorize("dim", `  │ ${line}`));
+	if (truncated) console.log(colorize("dim", `  │ ... (${lines.length - maxLines} more lines)`));
+	console.log(colorize("dim", "  └──"));
+}
+function printBox(text) {
+	const lines = text.split("\n");
+	return [
+		colorize("dim", "  ┌──"),
+		...lines.map((line) => colorize("dim", `  │ ${line}`)),
+		colorize("dim", "  └──")
+	].join("\n");
+}
+function maybeShowCode(toolName, input) {
+	if ((toolName === "write" || toolName === "edit") && input) {
+		const filePath = String(input.filePath ?? "");
+		const content = String(input.content ?? input.newString ?? "");
+		if (filePath && content) printCode(filePath, content);
+	}
+}
+async function runGenerateCommand(opts) {
+	const { cwd, prompt } = opts;
+	const baseURL = process.env.LLM_BASE_URL ?? "https://llm-gateway.assemblyai.com/v1";
+	const modelId = process.env.LLM_MODEL ?? "gpt-5.2";
+	const apiKey = await getApiKey();
+	let systemPrompt = SYSTEM_PROMPT;
+	try {
+		const claudeMd = await fs.readFile(path.join(cwd, "CLAUDE.md"), "utf-8");
+		systemPrompt += `\n\n# API Reference (CLAUDE.md)\n\n${claudeMd}`;
+	} catch {}
+	consola$1.start("Planning...");
+	try {
+		const result = await generateText({
+			model: createOpenAICompatible({
+				name: "assemblyai",
+				baseURL,
+				apiKey
+			})(modelId),
+			system: systemPrompt,
+			prompt,
+			tools: makeTools(cwd),
+			maxOutputTokens: 65536,
+			toolChoice: "auto",
+			stopWhen: stepCountIs(20),
+			experimental_onStepStart: ({ stepNumber }) => {
+				consola$1.start(`Step ${stepNumber + 1} · Thinking...`);
+			},
+			experimental_onToolCallStart: ({ toolCall }) => {
+				const input = toolCall.input;
+				consola$1.info(toolLabel(toolCall.toolName, input ?? {}));
+			},
+			experimental_onToolCallFinish: ({ toolCall, durationMs, ...rest }) => {
+				const input = toolCall.input;
+				const label = toolLabel(toolCall.toolName, input ?? {});
+				const time = formatDuration(durationMs);
+				const ok = "success" in rest && rest.success;
+				const mark = ok ? colorize("greenBright", "✔") : colorize("redBright", "✖");
+				console.log(`${mark} ${label} ${colorize("dim", time)}`);
+				if (ok) maybeShowCode(toolCall.toolName, input);
+			},
+			onStepFinish: ({ finishReason, text }) => {
+				if (finishReason === "stop" && text) console.log(printBox(text));
+			}
+		});
+		consola$1.success(`Done ${colorize("dim", `(${result.steps.length} steps, ${result.usage.totalTokens} tokens)`)}`);
+	} catch (err) {
+		consola$1.error(err instanceof Error ? err.message : String(err));
+		process.exitCode = 1;
+	}
+}
+//#endregion
+export { runGenerateCommand };

package/dist/{init-nHgDq3Om.mjs → init-COkINbH_.mjs}

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
-import { a as isDevMode, c as resolveCwd, f as askText, r as getApiKey, t as fileExists } from "./_discover-DsorPpR_.mjs";
-import { a as step, i as runCommand, r as interactive, s as warn } from "./_ui-kJIua5L9.mjs";
-import { existsSync } from "node:fs";
+import { l as resolveCwd, n as fileExists, o as isDevMode, p as askText, t as ensureApiKeyInEnv } from "./_discover-D7HCLa_N.mjs";
+import { a as runCommand, c as warn, o as step, r as interactive } from "./_ui-C9IvR7Fh.mjs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
-import fs$1 from "node:fs/promises";
+import fs from "node:fs/promises";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 //#region init.ts
@@ -14,13 +12,13 @@ async function installDeps(cwd, log) {
 	if (await fileExists(path.join(cwd, "node_modules"))) return;
 	if (isDevMode()) {
 		log(step("Link", "local workspace packages (dev mode)"));
-		const { runLinkCommand } = await import("./_link-BGXGFYWa.mjs");
+		const { runLinkCommand } = await import("./_link-D6mmDQ0B.mjs");
 		runLinkCommand(cwd);
 		return;
 	}
 	let pkgJson;
 	try {
-		pkgJson = JSON.parse(await fs$1.readFile(path.join(cwd, "package.json"), "utf-8"));
+		pkgJson = JSON.parse(await fs.readFile(path.join(cwd, "package.json"), "utf-8"));
 	} catch {
 		pkgJson = {};
 	}
@@ -30,33 +28,31 @@ async function installDeps(cwd, log) {
 	if (devDeps.length > 0) log(step("Install", `dev: ${devDeps.join(", ")}`));
 	try {
 		await execFileAsync("npm", ["install"], { cwd });
-	} catch {
-		log(warn("npm install failed"));
+	} catch (err) {
+		log(warn(`npm install failed: ${err instanceof Error ? err.message : String(err)}`));
+		log(warn("Run `npm install` manually in the project directory to install dependencies."));
 	}
 }
 async function runInitCommand(opts, extra) {
-	if (!opts.skipApi) await getApiKey();
+	if (!opts.skipApi) await ensureApiKeyInEnv();
 	let dir = opts.dir;
 	if (!dir) dir = await askText("What is your project named?", "my-voice-agent");
 	const cwd = path.resolve(resolveCwd(), dir);
 	if (!opts.force && await fileExists(path.join(cwd, "agent.ts"))) throw new Error(`agent.ts already exists in this directory. Use ${interactive("--force")} to overwrite.`);
-	const cliDir = path.dirname(fileURLToPath(import.meta.url));
-	const templatesDir = existsSync(path.join(cliDir, "templates")) ? path.join(cliDir, "templates") : path.join(cliDir, "..", "templates");
-	const { runInit } = await import("./_init-l_uoyFCN.mjs");
-	const template = opts.template || "simple";
+	const { runInit } = await import("./_init-CweK2mJJ.mjs");
+	const template = opts.template ?? "simple";
 	await runCommand(async ({ log }) => {
 		log(step("Create", dir));
 		await runInit({
 			targetDir: cwd,
-			template,
-			templatesDir
+			template
 		});
 		await installDeps(cwd, log);
 	});
 	process.chdir(cwd);
 	delete process.env.INIT_CWD;
 	if (!(opts.skipDeploy || extra?.quiet)) {
-		const { runDeployCommand } = await import("./deploy-2OxZpIfj.mjs");
+		const { runDeployCommand } = await import("./deploy-DB0PeNtc.mjs");
 		await runDeployCommand({ cwd });
 	}
 	return cwd;