@alexkroman1/aai-cli 0.9.0

package/dist/cli.mjs

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+import { c as resolveCwd, r as getApiKey, t as fileExists } from "./_discover-BzlCDVZ6.mjs";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineCommand, runMain } from "citty";
+//#region cli.ts
+const cliDir = path.dirname(fileURLToPath(import.meta.url));
+function findPkgJson(dir) {
+	try {
+		return readFileSync(path.join(dir, "package.json"), "utf-8");
+	} catch {
+		return readFileSync(path.join(dir, "..", "package.json"), "utf-8");
+	}
+}
+const VERSION = JSON.parse(findPkgJson(cliDir)).version;
+async function ensureAgent(cwd, yes) {
+	if (!await fileExists(path.join(cwd, "agent.ts"))) {
+		const { runInitCommand } = await import("./init-BWG5OrQa.mjs");
+		await runInitCommand({ yes }, { quiet: true });
+	}
+}
+const init = defineCommand({
+	meta: {
+		name: "init",
+		description: "Scaffold a new agent project"
+	},
+	args: {
+		dir: {
+			type: "positional",
+			description: "Project directory",
+			required: false
+		},
+		template: {
+			type: "string",
+			alias: "t",
+			description: "Template to use"
+		},
+		force: {
+			type: "boolean",
+			alias: "f",
+			description: "Overwrite existing agent.ts"
+		},
+		yes: {
+			type: "boolean",
+			alias: "y",
+			description: "Accept defaults (no prompts)"
+		},
+		skipApi: {
+			type: "boolean",
+			description: "Skip API key check"
+		},
+		skipDeploy: {
+			type: "boolean",
+			description: "Skip post-init deploy"
+		}
+	},
+	async run({ args }) {
+		const { runInitCommand } = await import("./init-BWG5OrQa.mjs");
+		await runInitCommand({
+			dir: args.dir,
+			template: args.template,
+			force: args.force,
+			yes: args.yes,
+			skipApi: args.skipApi,
+			skipDeploy: args.skipDeploy
+		});
+	}
+});
+const dev = defineCommand({
+	meta: {
+		name: "dev",
+		description: "Start a local development server"
+	},
+	args: {
+		port: {
+			type: "string",
+			alias: "p",
+			description: "Port to listen on",
+			default: "3000"
+		},
+		check: {
+			type: "boolean",
+			description: "Start server, verify health, then exit"
+		},
+		yes: {
+			type: "boolean",
+			alias: "y",
+			description: "Accept defaults (no prompts)"
+		}
+	},
+	async run({ args }) {
+		const cwd = resolveCwd();
+		await ensureAgent(cwd, args.yes);
+		await getApiKey();
+		const { runDevCommand } = await import("./dev-DBFvKyzk.mjs");
+		await runDevCommand({
+			cwd,
+			port: args.port,
+			...args.check ? { check: args.check } : {}
+		});
+	}
+});
+const build = defineCommand({
+	meta: {
+		name: "build",
+		description: "Bundle and validate (no server or deploy)"
+	},
+	args: { yes: {
+		type: "boolean",
+		alias: "y",
+		description: "Accept defaults (no prompts)"
+	} },
+	async run({ args }) {
+		const cwd = resolveCwd();
+		await ensureAgent(cwd, args.yes);
+		const { runBuildCommand } = await import("./_build-p1HHkdon.mjs");
+		await runBuildCommand(cwd);
+	}
+});
+const deploy = defineCommand({
+	meta: {
+		name: "deploy",
+		description: "Bundle and deploy to production"
+	},
+	args: {
+		server: {
+			type: "string",
+			alias: "s",
+			description: "Server URL"
+		},
+		dryRun: {
+			type: "boolean",
+			description: "Validate and bundle without deploying"
+		},
+		yes: {
+			type: "boolean",
+			alias: "y",
+			description: "Accept defaults (no prompts)"
+		}
+	},
+	async run({ args }) {
+		const cwd = resolveCwd();
+		await ensureAgent(cwd, args.yes);
+		const { runDeployCommand } = await import("./deploy-KyNJaoP5.mjs");
+		await runDeployCommand({
+			cwd,
+			...args.server ? { server: args.server } : {},
+			...args.dryRun ? { dryRun: args.dryRun } : {}
+		});
+	}
+});
+const start = defineCommand({
+	meta: {
+		name: "start",
+		description: "Start production server from build"
+	},
+	args: {
+		port: {
+			type: "string",
+			alias: "p",
+			description: "Port to listen on",
+			default: "3000"
+		},
+		yes: {
+			type: "boolean",
+			alias: "y",
+			description: "Accept defaults (no prompts)"
+		}
+	},
+	async run({ args }) {
+		const cwd = resolveCwd();
+		await getApiKey();
+		const { runStartCommand } = await import("./start-C1qkhU4O.mjs");
+		await runStartCommand({
+			cwd,
+			port: args.port
+		});
+	}
+});
+const secret = defineCommand({
+	meta: {
+		name: "secret",
+		description: "Manage secrets"
+	},
+	subCommands: {
+		put: defineCommand({
+			meta: {
+				name: "put",
+				description: "Create or update a secret"
+			},
+			args: { name: {
+				type: "positional",
+				description: "Secret name",
+				required: true
+			} },
+			async run({ args }) {
+				const cwd = resolveCwd();
+				await getApiKey();
+				const { runSecretPut } = await import("./secret-CzeHIGzE.mjs");
+				await runSecretPut(cwd, args.name);
+			}
+		}),
+		delete: defineCommand({
+			meta: {
+				name: "delete",
+				description: "Delete a secret"
+			},
+			args: { name: {
+				type: "positional",
+				description: "Secret name",
+				required: true
+			} },
+			async run({ args }) {
+				const cwd = resolveCwd();
+				await getApiKey();
+				const { runSecretDelete } = await import("./secret-CzeHIGzE.mjs");
+				await runSecretDelete(cwd, args.name);
+			}
+		}),
+		list: defineCommand({
+			meta: {
+				name: "list",
+				description: "List secret names"
+			},
+			async run() {
+				const cwd = resolveCwd();
+				await getApiKey();
+				const { runSecretList } = await import("./secret-CzeHIGzE.mjs");
+				await runSecretList(cwd);
+			}
+		})
+	}
+});
+const rag = defineCommand({
+	meta: {
+		name: "rag",
+		description: "Ingest a site's llms-full.txt into the vector store"
+	},
+	args: {
+		url: {
+			type: "positional",
+			description: "URL to ingest",
+			required: true
+		},
+		server: {
+			type: "string",
+			alias: "s",
+			description: "Server URL"
+		},
+		chunkSize: {
+			type: "string",
+			description: "Max chunk size in tokens",
+			default: "512"
+		},
+		yes: {
+			type: "boolean",
+			alias: "y",
+			description: "Accept defaults (no prompts)"
+		}
+	},
+	async run({ args }) {
+		const cwd = resolveCwd();
+		await getApiKey();
+		const { runRagCommand } = await import("./rag-BnCMnccf.mjs");
+		await runRagCommand({
+			url: args.url,
+			cwd,
+			...args.server ? { server: args.server } : {},
+			chunkSize: args.chunkSize
+		});
+	}
+});
+const link = defineCommand({
+	meta: {
+		name: "link",
+		description: "Link local workspace packages into the current project (dev only)"
+	},
+	async run() {
+		const { runLinkCommand } = await import("./_link-BGXGFYWa.mjs");
+		runLinkCommand(resolveCwd());
+	}
+});
+const unlink = defineCommand({
+	meta: {
+		name: "unlink",
+		description: "Restore published package versions (reverses aai link)"
+	},
+	async run() {
+		const { runUnlinkCommand } = await import("./_link-BGXGFYWa.mjs");
+		runUnlinkCommand(resolveCwd());
+	}
+});
+const mainCommand = defineCommand({
+	meta: {
+		name: "aai",
+		version: VERSION,
+		description: "Voice agent development kit"
+	},
+	subCommands: {
+		init,
+		dev,
+		build,
+		deploy,
+		start,
+		secret,
+		rag,
+		link,
+		unlink
+	}
+});
+if (process.env.VITEST !== "true") {
+	const sub = process.argv[2];
+	if (!sub || sub.startsWith("-")) process.argv.splice(2, 0, "init");
+	runMain(mainCommand);
+}
+//#endregion
+export { mainCommand };

package/dist/deploy-KyNJaoP5.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { l as resolveServerUrl, n as generateSlug, r as getApiKey, s as readProjectConfig, u as writeProjectConfig } from "./_discover-BzlCDVZ6.mjs";
+import { a as step, i as runCommand, o as stepInfo } from "./_ui-kJIua5L9.mjs";
+import { buildAgentBundle } from "./_build-p1HHkdon.mjs";
+//#region _deploy.ts
+async function attemptDeploy(fetchFn, url, slug, apiKey, env, worker, clientFiles) {
+	try {
+		return await fetchFn(`${url}/${slug}/deploy`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${apiKey}`
+			},
+			body: JSON.stringify({
+				env,
+				worker,
+				clientFiles
+			})
+		});
+	} catch {
+		throw new Error(`deployment failed: could not reach ${url}`);
+	}
+}
+const MAX_RETRIES = 20;
+async function runDeploy(opts) {
+	const { worker, clientFiles } = opts.bundle;
+	const fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);
+	let slug = opts.slug;
+	for (let i = 0; i < MAX_RETRIES; i++) {
+		const resp = await attemptDeploy(fetchFn, opts.url, slug, opts.apiKey, opts.env, worker, clientFiles);
+		if (resp.ok) return { slug };
+		const text = await resp.text();
+		if (resp.status === 403 && text.includes("Slug")) {
+			slug = generateSlug();
+			continue;
+		}
+		throw new Error(`deploy failed (${resp.status}): ${text}`);
+	}
+	throw new Error(`deploy failed: could not find available slug after ${MAX_RETRIES} attempts`);
+}
+//#endregion
+//#region deploy.ts
+async function deployBundle(opts) {
+	const { bundle, serverUrl, apiKey, cwd, log } = opts;
+	let { slug } = opts;
+	log(step("Deploy", slug));
+	slug = (await runDeploy({
+		url: serverUrl,
+		bundle,
+		env: { ASSEMBLYAI_API_KEY: apiKey },
+		slug,
+		apiKey
+	})).slug;
+	await writeProjectConfig(cwd, {
+		slug,
+		serverUrl
+	});
+	const agentUrl = `${serverUrl}/${slug}`;
+	log(step("Ready", agentUrl));
+	return agentUrl;
+}
+async function runDeployCommand(opts) {
+	const { cwd } = opts;
+	const dryRun = opts.dryRun ?? false;
+	const apiKey = dryRun ? "" : await getApiKey();
+	const projectConfig = await readProjectConfig(cwd);
+	const serverUrl = resolveServerUrl(opts.server, projectConfig?.serverUrl);
+	const slug = projectConfig?.slug ?? generateSlug();
+	await runCommand(async ({ log }) => {
+		const bundle = await buildAgentBundle(cwd, log);
+		if (dryRun) {
+			log(stepInfo("Dry run", `would deploy as ${slug}`));
+			return;
+		}
+		await deployBundle({
+			bundle,
+			serverUrl,
+			apiKey,
+			slug,
+			cwd,
+			log
+		});
+	});
+}
+//#endregion
+export { runDeployCommand };

package/dist/dev-DBFvKyzk.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import "./_discover-BzlCDVZ6.mjs";
+import { a as step, i as runCommand, n as info } from "./_ui-kJIua5L9.mjs";
+import { buildAgentBundle } from "./_build-p1HHkdon.mjs";
+import { n as loadAgentDef, r as resolveServerEnv, t as bootServer } from "./_server-common-qLA1QU2C.mjs";
+//#region dev.ts
+async function _startDevServer(cwd, port, log, opts) {
+	const bundle = await buildAgentBundle(cwd, log);
+	const agentDef = await loadAgentDef(cwd);
+	const env = await resolveServerEnv();
+	const server = await bootServer(agentDef, bundle.clientDir, env, port);
+	log(step("Ready", `http://localhost:${port}`));
+	const base = `http://localhost:${port}`;
+	try {
+		const healthRes = await fetch(`${base}/health`);
+		if (!healthRes.ok) throw new Error(`GET /health returned ${healthRes.status}`);
+		const health = await healthRes.json();
+		if (health.status !== "ok") throw new Error(`GET /health returned ${JSON.stringify(health)}`);
+		log(step("Health", health.name ?? "ok"));
+		const pageRes = await fetch(`${base}/`);
+		if (!pageRes.ok) throw new Error(`GET / returned ${pageRes.status}`);
+		const html = await pageRes.text();
+		if (!(html.includes("<") && html.includes("html"))) throw new Error("GET / did not return valid HTML");
+		log(step("Client", "ok"));
+	} catch (err) {
+		await server.close();
+		throw err;
+	}
+	if (opts?.check) await server.close();
+	else log(info("Ctrl-C to quit"));
+}
+async function runDevCommand(opts) {
+	const port = Number.parseInt(opts.port, 10);
+	await runCommand(async ({ log }) => {
+		await _startDevServer(opts.cwd, port, log, opts.check ? { check: true } : void 0);
+	});
+}
+//#endregion
+export { runDevCommand };

package/dist/init-BWG5OrQa.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { a as isDevMode, c as resolveCwd, f as askText, r as getApiKey, t as fileExists } from "./_discover-BzlCDVZ6.mjs";
+import { a as step, i as runCommand, r as interactive, s as warn } from "./_ui-kJIua5L9.mjs";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import fs$1 from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region init.ts
+const execFileAsync = promisify(execFile);
+/** Install deps — uses `aai link` in dev mode, `npm install` otherwise. */
+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");
+		runLinkCommand(cwd);
+		return;
+	}
+	let pkgJson;
+	try {
+		pkgJson = JSON.parse(await fs$1.readFile(path.join(cwd, "package.json"), "utf-8"));
+	} catch {
+		pkgJson = {};
+	}
+	const deps = Object.keys(pkgJson.dependencies ?? {});
+	const devDeps = Object.keys(pkgJson.devDependencies ?? {});
+	if (deps.length > 0) log(step("Install", deps.join(", ")));
+	if (devDeps.length > 0) log(step("Install", `dev: ${devDeps.join(", ")}`));
+	try {
+		await execFileAsync("npm", ["install"], { cwd });
+	} catch {
+		log(warn("npm install failed"));
+	}
+}
+async function runInitCommand(opts, extra) {
+	if (!opts.skipApi) await getApiKey();
+	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";
+	await runCommand(async ({ log }) => {
+		log(step("Create", dir));
+		await runInit({
+			targetDir: cwd,
+			template,
+			templatesDir
+		});
+		await installDeps(cwd, log);
+	});
+	process.chdir(cwd);
+	delete process.env.INIT_CWD;
+	if (!(opts.skipDeploy || extra?.quiet)) {
+		const { runDeployCommand } = await import("./deploy-KyNJaoP5.mjs");
+		await runDeployCommand({ cwd });
+	}
+	return cwd;
+}
+//#endregion
+export { runInitCommand };

package/dist/rag-BnCMnccf.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import { i as getServerInfo } from "./_discover-BzlCDVZ6.mjs";
+import { a as step, i as runCommand, n as info, s as warn, t as detail } from "./_ui-kJIua5L9.mjs";
+import { errorMessage } from "@alexkroman1/aai/utils";
+import pLimit from "p-limit";
+//#region rag.ts
+const FETCH_TIMEOUT_MS = 6e4;
+async function runRag(opts) {
+	const { url, apiKey, serverUrl, slug, chunkSize, log, setStatus } = opts;
+	log(step("Fetch", url));
+	const resp = await fetch(url, {
+		headers: { "User-Agent": "aai-cli/1.0" },
+		redirect: "follow",
+		signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+	});
+	if (!resp.ok) throw new Error(`Failed to fetch: ${resp.status} ${resp.statusText}`);
+	const content = await resp.text();
+	if (content.length === 0) {
+		log(warn("File is empty"));
+		return;
+	}
+	log(info(`${(content.length / 1024).toFixed(0)} KB`));
+	const origin = new URL(url).origin;
+	const pages = splitPages(content);
+	log(step("Parse", `${pages.length} pages`));
+	const { RecursiveChunker } = await import("@chonkiejs/core");
+	const allChunks = await chunkPages(pages, await RecursiveChunker.create({ chunkSize }), origin, slugify(origin));
+	log(step("Chunk", `${allChunks.length} chunks`));
+	const vectorUrl = `${serverUrl}/${slug}/vector`;
+	log(info(`target: ${vectorUrl}`));
+	const result = await upsertChunks(allChunks, vectorUrl, apiKey, setStatus);
+	log(step("Done", `${result.upserted} chunks upserted`));
+	if (result.errors > 0) {
+		log(warn(`${result.errors} failed`));
+		if (result.lastError) log(info(`last error: ${result.lastError}`));
+	}
+	log(detail(`Agent: ${slug}`));
+}
+async function chunkPages(pages, chunker, origin, siteSlug) {
+	const allChunks = [];
+	for (const page of pages) {
+		page.body = stripNoise(page.body);
+		if (!page.body) continue;
+		const raw = await chunker.chunk(page.body);
+		for (const [i, c] of raw.entries()) {
+			const data = page.title ? `${page.title}\n\n${c.text}` : c.text;
+			const id = `${siteSlug}:${slugify(page.title || "page")}:${i}`;
+			allChunks.push({
+				id,
+				data,
+				metadata: {
+					source: origin,
+					...page.title ? { title: page.title } : {},
+					tokenCount: c.tokenCount
+				}
+			});
+		}
+	}
+	return allChunks;
+}
+async function upsertChunks(chunks, vectorUrl, apiKey, setStatus, fetchFn = globalThis.fetch) {
+	const total = chunks.length;
+	let completed = 0;
+	let upserted = 0;
+	let errors = 0;
+	let lastError = "";
+	const updateStatus = () => {
+		const pct = Math.round(completed / total * 100);
+		setStatus(`   Upsert ${completed}/${total} (${pct}%)`);
+	};
+	updateStatus();
+	const limit = pLimit(5);
+	await Promise.all(chunks.map((chunk) => limit(async () => {
+		try {
+			const r = await fetchFn(vectorUrl, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${apiKey}`
+				},
+				body: JSON.stringify({
+					op: "upsert",
+					id: chunk.id,
+					data: chunk.data,
+					metadata: chunk.metadata
+				})
+			});
+			if (!r.ok) {
+				lastError = await r.text();
+				errors++;
+			} else upserted++;
+		} catch (err) {
+			lastError = errorMessage(err);
+			errors++;
+		}
+		completed++;
+		updateStatus();
+	})));
+	setStatus(null);
+	return {
+		upserted,
+		errors,
+		lastError
+	};
+}
+async function runRagCommand(opts) {
+	const { url, cwd } = opts;
+	try {
+		new URL(url);
+	} catch {
+		throw new Error(`Invalid URL: ${url}`);
+	}
+	const { apiKey, serverUrl, slug } = await getServerInfo(cwd, opts.server);
+	const chunkSize = Number.parseInt(opts.chunkSize ?? "512", 10);
+	await runCommand(async ({ log, setStatus }) => {
+		await runRag({
+			url,
+			apiKey,
+			serverUrl,
+			slug,
+			chunkSize,
+			log,
+			setStatus
+		});
+	});
+}
+/** Split llms-full.txt on `***` page separators and extract titles. */
+function splitPages(content) {
+	const raw = content.split(/^\*{3,}$/m);
+	const pages = [];
+	for (const section of raw) {
+		const trimmed = section.trim();
+		if (!trimmed) continue;
+		const page = parsePage(trimmed);
+		if (page.body.length > 0) pages.push(page);
+	}
+	return pages;
+}
+/** Extract title and body from a single page section. */
+function parsePage(trimmed) {
+	let title = "";
+	let body = trimmed;
+	const dashIndex = trimmed.search(/^-{3,}$/m);
+	if (dashIndex !== -1) {
+		const frontmatter = trimmed.slice(0, dashIndex);
+		body = trimmed.slice(dashIndex).replace(/^-+$/m, "").trim();
+		const titleMatch = frontmatter.match(/^title:\s*(.+)$/m);
+		if (titleMatch) title = titleMatch[1]?.trim() ?? "";
+	}
+	if (!title) {
+		const titleLineMatch = body.match(/^#{1,2}\s+title:\s*(.+)$/m);
+		if (titleLineMatch) {
+			title = titleLineMatch[1]?.trim() ?? "";
+			body = body.replace(/^#{1,2}\s+title:\s*.+\n?/m, "").trim();
+		} else {
+			const headingMatch = body.match(/^(#{1,3})\s+(.+)$/m);
+			if (headingMatch) title = headingMatch[2]?.trim() ?? "";
+		}
+	}
+	return {
+		title,
+		body
+	};
+}
+/** Strip code blocks, HTML/JSX tags, and collapse whitespace from markdown. */
+function stripNoise(text) {
+	return text.replace(/^(`{3,}|~{3,}).*[\s\S]*?^\1/gm, "").replace(/^(?:[ ]{4,}|\t).+$/gm, "").replace(/`[^`]+`/g, "").replace(/\{\/\*[\s\S]*?\*\/\}/g, "").replace(/<[^>]+>/g, "").replace(/^\s*\}[^}\n]*$/gm, "").replace(/^\s+$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function slugify(s) {
+	return s.replace(/^https?:\/\//, "").replace(/^#+\s*/, "").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase().slice(0, 80);
+}
+//#endregion
+export { runRagCommand };