@resolveio/server-lib 22.3.219 → 22.3.221

package/src/util/tokenizer.ts

@@ -0,0 +1,38 @@
+import { encodingForModel, getEncoding, Tiktoken } from 'js-tiktoken';
+
+const DEFAULT_ENCODING = 'o200k_base';
+
+const resolveEncoding = (model?: string): Tiktoken => {
+	const normalized = String(model || '').trim();
+	if (normalized) {
+		try {
+			return encodingForModel(normalized as any);
+		}
+		catch {}
+	}
+	return getEncoding(DEFAULT_ENCODING);
+};
+
+export const countTokens = (text: string, model?: string): number => {
+	const encoding = resolveEncoding(model);
+	try {
+		const tokens = encoding.encode(text || '');
+		return tokens.length;
+	}
+	finally {
+		const maybeEncoding = encoding as unknown as { free?: () => void; dispose?: () => void };
+		if (typeof maybeEncoding?.free === 'function') {
+			maybeEncoding.free();
+		}
+		else if (typeof maybeEncoding?.dispose === 'function') {
+			maybeEncoding.dispose();
+		}
+	}
+};
+
+export const countChatTokens = (messages: Array<{ role: string; content: string }>, model?: string): number => {
+	const flattened = (messages || [])
+		.map((msg) => `${msg?.role || 'user'}:\n${msg?.content || ''}`)
+		.join('\n\n');
+	return countTokens(flattened, model);
+};

package/src/workers/codex-runner.worker.ts

@@ -0,0 +1,142 @@
+import { parentPort, workerData } from 'worker_threads';
+import { CodexClient, CodexConfig, CodexRunOptions } from '../services/codex-client';
+
+type CodexWorkerInput = {
+	prompt: string;
+	runOptions?: CodexRunOptions;
+	config: CodexConfig;
+	streamStatus?: boolean;
+};
+
+type CodexWorkerMessage = {
+	ok: boolean;
+	type?: 'stream' | 'final';
+	result?: string;
+	error?: string;
+	status?: string;
+};
+
+async function run(): Promise<void> {
+	if (!parentPort) {
+		return;
+	}
+
+	const data = workerData as CodexWorkerInput;
+	if (!data || typeof data.prompt !== 'string' || !data.config) {
+		parentPort.postMessage({ ok: false, error: 'Invalid AI worker payload.' } as CodexWorkerMessage);
+		return;
+	}
+
+	try {
+		const client = new CodexClient(data.config);
+		const runOptions = data.runOptions || {};
+		const streamStatusEnabled = data.streamStatus === true;
+		const emitStatus = streamStatusEnabled ? createStreamStatusEmitter(parentPort) : null;
+		const runOptionsWithStream = streamStatusEnabled
+			? {
+				...runOptions,
+				onStreamEvent: (event: any) => {
+					const status = deriveStreamStatus(event);
+					if (status && emitStatus) {
+						emitStatus(status);
+					}
+				}
+			}
+			: runOptions;
+		const result = await client.run(data.prompt, runOptionsWithStream);
+		parentPort.postMessage({ ok: true, result, type: 'final' } as CodexWorkerMessage);
+	}
+	catch (error) {
+		const message = error instanceof Error ? error.message : String(error || 'Unknown error');
+		parentPort.postMessage({ ok: false, error: message, type: 'final' } as CodexWorkerMessage);
+	}
+}
+
+function deriveStreamStatus(event: any): string | null {
+	if (!event || !event.type) {
+		return null;
+	}
+	if (event.type === 'thread.started' || event.type === 'turn.started') {
+		return 'Reviewing request';
+	}
+	if (event.type === 'turn.completed') {
+		return 'Drafting response';
+	}
+	if (event.type === 'item.started' || event.type === 'item.updated' || event.type === 'item.completed') {
+		const itemType = String(event?.item?.type || '').trim().toLowerCase();
+		if (!itemType) {
+			return null;
+		}
+		if (itemType === 'mcp_tool_call') {
+			return 'Calling tool';
+		}
+		if (itemType === 'command_execution') {
+			return deriveCommandExecutionStatus(event?.item?.command);
+		}
+		if (itemType === 'web_search') {
+			return 'Searching references';
+		}
+		if (itemType === 'file_change') {
+			return 'Drafting response';
+		}
+		if (itemType === 'agent_message') {
+			return 'Drafting response';
+		}
+		if (itemType === 'reasoning') {
+			return 'Analyzing';
+		}
+	}
+	return null;
+}
+
+function deriveCommandExecutionStatus(commandValue: any): string {
+	const command = String(commandValue || '').trim().toLowerCase();
+	if (!command) {
+		return 'Running command';
+	}
+	if (/\b(rg|grep|ripgrep|ag|ack)\b/.test(command)) {
+		return 'Searching files';
+	}
+	if (/\bfind\b/.test(command)) {
+		return 'Finding files';
+	}
+	if (/\b(cat|sed|awk|head|tail|less|more)\b/.test(command)) {
+		return 'Opening files';
+	}
+	if (/\b(ls|tree)\b/.test(command)) {
+		return 'Scanning files';
+	}
+	return 'Running command';
+}
+
+function createStreamStatusEmitter(port: any) {
+	let lastStatus = '';
+	let lastSentAt = 0;
+	return (status: string) => {
+		const trimmed = String(status || '').trim();
+		if (!trimmed) {
+			return;
+		}
+		const now = Date.now();
+		if (trimmed === lastStatus && now - lastSentAt < 3000) {
+			return;
+		}
+		lastStatus = trimmed;
+		lastSentAt = now;
+		port.postMessage({ ok: true, type: 'stream', status: trimmed } as CodexWorkerMessage);
+	};
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+void (async () => {
+	try {
+		await run();
+	}
+	catch (error) {
+		if (!parentPort) {
+			return;
+		}
+		const message = error instanceof Error ? error.message : String(error || 'Unknown error');
+		parentPort.postMessage({ ok: false, error: message, type: 'final' } as CodexWorkerMessage);
+	}
+})();

package/start_server.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+source ~/.nvm/nvm.sh   # Ensure this path is correct for your nvm installation
+nvm use 22
+node_modules/gulp/bin/gulp.js mongo-start
+node_modules/gulp/bin/gulp.js

package/tests/ai-assistant-corpus-build.ts

@@ -0,0 +1,484 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { ResolveIOServer } from '../src/resolveio-server-app';
+
+type CorpusPrompt = {
+	id: string;
+	prompt: string;
+	score: number;
+	sources: string[];
+	seenCount: number;
+	issueCount: number;
+	lastSeenAt?: string;
+	conversationIds: string[];
+	issueReasons?: string[];
+	issueExpected?: string[];
+};
+
+type PromptAccumulator = {
+	prompt: string;
+	key: string;
+	score: number;
+	seenCount: number;
+	issueCount: number;
+	lastSeenAt?: Date;
+	sources: Set<string>;
+	conversationIds: Set<string>;
+	issueReasons: Set<string>;
+	issueExpected: Set<string>;
+};
+
+const SEED_PROMPTS: string[] = [
+	'How many active clients do I have right now?',
+	'Show me the last 20 work orders created this week, grouped by status.',
+	'Show me the last 20 work orders created this week by status.',
+	'For the last 30 days, how many work orders were completed per day?',
+	'List the top 10 customers by number of work orders in the last 6 months.',
+	'Show open work orders with missing required fields (customer, location, or scheduled date).',
+	'For blending: summarize the last 10 blend tickets with product, total volume, and created date.',
+	'Show blend throughput by day for the last 2 weeks.',
+	'Which blends used Chemical Red Ultra Lift in the last 30 days? Include lot/batch and volume.',
+	'Show top 10 customers by invoice total in the last 6 months.',
+	'Break down my total revenue over the last 6 month by month',
+	'Break down my total revenue over the last 6 month by month by each customer',
+	'Break down my total revenue over the last 6 month per month per customer',
+	'Break up the support tickets last 6 months, give me a total per user per month of the amount of hours they are billing for',
+	'Break down my total revenue over the last 12 weeks by week',
+	'Break down my total revenue over the last 30 days by day',
+	'Break down my total revenue over the last 8 quarters by quarter',
+	'Break down my total revenue over the last 3 years by year',
+	'List invoices missing an invoiced date but created this month.',
+	'Break down the number of deliveries per driver last month',
+	'Deliveries by driver for the last 30 days (top 10 drivers).',
+	'List the last 20 deliveries with product, volume, and destination.',
+	'Which jobs have the highest treatment volume in the last 90 days?',
+	'Show me all invoices over $10,000 from the last 60 days.',
+	'Show me overdue invoices grouped by customer.',
+	'Show monthly invoice count and total for the last 12 months.',
+	'Show work orders created yesterday and their status.',
+	'Show closed work orders this month by customer.',
+	'Show completed work orders this month by driver.',
+	'Show work orders with no assigned driver.',
+	'Show deliveries by destination for last month.',
+	'Show top products delivered in the last 30 days.',
+	'Show blends with missing batch number in the last 60 days.',
+	'Show chemical usage totals by product for last month.',
+	'Show customers with no invoices in the last 90 days.',
+	'Show invoice totals by status for this quarter.',
+	'Show unpaid invoice balance by customer.',
+	'Show daily revenue for this month.',
+	'Show weekly work order volume for the last 12 weeks.',
+	'Show month-over-month revenue growth for the last year.',
+	'When was the last time the invoice document was updated?',
+	'When does this dropdown for XYZ get added to this page? What does it do?',
+	'What changed on this page?',
+	'What changed on the invoice page?',
+	'What changed on the work order page in the last update?',
+	'What did the last update just do?',
+	'What did the last system update do?',
+	"Why don't I see this asset in this dropdown?",
+	"Why won't this work order let me close it, it's greyed out?",
+	'The submit button is red and I filled out everything. What is likely wrong?'
+];
+
+function parseBoolean(value: any): boolean {
+	return ['true', '1', 'yes', 'y', 'on'].includes(String(value || '').trim().toLowerCase());
+}
+
+function normalizeOptionalString(value: any): string {
+	return String(value ?? '').trim();
+}
+
+function parseInteger(value: any, fallback: number, min: number, max: number): number {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed)) {
+		return fallback;
+	}
+	return Math.min(Math.max(Math.round(parsed), min), max);
+}
+
+function loadDotEnvFile(filePath: string): Record<string, string> {
+	const parsed: Record<string, string> = {};
+	if (!fs.existsSync(filePath)) {
+		return parsed;
+	}
+	const content = fs.readFileSync(filePath, 'utf8');
+	content.split(/\r?\n/g).forEach((lineRaw) => {
+		const line = lineRaw.trim();
+		if (!line || line.startsWith('#')) {
+			return;
+		}
+		const jsonLike = line.match(/^"([A-Za-z_][A-Za-z0-9_]*)"\s*:\s*(.+?)\s*,?$/);
+		if (jsonLike?.[1]) {
+			const key = jsonLike[1];
+			let value = String(jsonLike[2] || '').trim();
+			if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith('\'') && value.endsWith('\''))) {
+				value = value.slice(1, -1);
+			}
+			if (key) {
+				parsed[key] = value;
+			}
+			return;
+		}
+		const separator = line.indexOf('=');
+		if (separator <= 0) {
+			return;
+		}
+		const key = line.slice(0, separator).trim();
+		let value = line.slice(separator + 1).trim();
+		if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith('\'') && value.endsWith('\''))) {
+			value = value.slice(1, -1);
+		}
+		if (key) {
+			parsed[key] = value;
+		}
+	});
+	return parsed;
+}
+
+function applyEnvFromServerDir(serverDir: string): void {
+	const envFiles = [
+		path.join(serverDir, '.env.codex'),
+		path.join(serverDir, '.env.production'),
+		path.join(serverDir, '.env')
+	];
+	envFiles.forEach((filePath) => {
+		const values = loadDotEnvFile(filePath);
+		Object.keys(values).forEach((key) => {
+			if (!process.env[key]) {
+				process.env[key] = values[key];
+			}
+		});
+	});
+}
+
+function addDaysUtc(date: Date, days: number): Date {
+	return new Date(Date.UTC(
+		date.getUTCFullYear(),
+		date.getUTCMonth(),
+		date.getUTCDate() + days,
+		date.getUTCHours(),
+		date.getUTCMinutes(),
+		date.getUTCSeconds(),
+		date.getUTCMilliseconds()
+	));
+}
+
+function normalizePrompt(prompt: string): string {
+	return String(prompt || '')
+		.replace(/\s+/g, ' ')
+		.trim();
+}
+
+function promptKey(prompt: string): string {
+	return normalizePrompt(prompt).toLowerCase();
+}
+
+function isUsefulPrompt(promptRaw: string): boolean {
+	const prompt = normalizePrompt(promptRaw);
+	if (!prompt || prompt.length < 8 || prompt.length > 320) {
+		return false;
+	}
+	if (!/[a-z]/i.test(prompt)) {
+		return false;
+	}
+	const lowered = prompt.toLowerCase();
+	if (['yes', 'no', 'ok', 'thanks', 'thank you'].includes(lowered)) {
+		return false;
+	}
+	if (/^\/[a-z0-9/_-]+$/i.test(prompt)) {
+		return false;
+	}
+	if (/^https?:\/\//i.test(prompt)) {
+		return false;
+	}
+	const wordCount = prompt.split(/\s+/g).filter(Boolean).length;
+	return wordCount >= 3;
+}
+
+function ensureAccumulator(map: Map<string, PromptAccumulator>, promptRaw: string): PromptAccumulator {
+	const prompt = normalizePrompt(promptRaw);
+	const key = promptKey(prompt);
+	let entry = map.get(key);
+	if (!entry) {
+		entry = {
+			prompt,
+			key,
+			score: 0,
+			seenCount: 0,
+			issueCount: 0,
+			sources: new Set<string>(),
+			conversationIds: new Set<string>(),
+			issueReasons: new Set<string>(),
+			issueExpected: new Set<string>()
+		};
+		map.set(key, entry);
+	}
+	return entry;
+}
+
+function applyRecencyScore(lastSeenAt: Date | undefined): number {
+	if (!lastSeenAt) {
+		return 0;
+	}
+	const ageMs = Date.now() - lastSeenAt.getTime();
+	const dayMs = 24 * 60 * 60 * 1000;
+	if (ageMs <= 7 * dayMs) {
+		return 20;
+	}
+	if (ageMs <= 30 * dayMs) {
+		return 12;
+	}
+	if (ageMs <= 90 * dayMs) {
+		return 6;
+	}
+	return 2;
+}
+
+async function run(): Promise<void> {
+	const repoRoot = process.cwd();
+	const defaultServerDir = path.resolve(repoRoot, '../resolveio-all/geochem/server');
+	const serverDir = normalizeOptionalString(process.env.AI_ASSISTANT_CORPUS_SERVER_DIR) || defaultServerDir;
+	const settingsPath = path.join(serverDir, normalizeOptionalString(process.env.AI_ASSISTANT_CORPUS_SETTINGS) || 'settings.local.json');
+	const appId = normalizeOptionalString(process.env.AI_ASSISTANT_CORPUS_APP_ID) || path.basename(path.dirname(serverDir));
+	const lookbackDays = parseInteger(process.env.AI_ASSISTANT_CORPUS_LOOKBACK_DAYS, 45, 1, 365);
+	const maxPrompts = parseInteger(process.env.AI_ASSISTANT_CORPUS_MAX_PROMPTS, 80, 10, 1000);
+	const maxRecentMessages = parseInteger(process.env.AI_ASSISTANT_CORPUS_MAX_MESSAGES, 5000, 200, 50000);
+	const dryRun = parseBoolean(process.env.AI_ASSISTANT_CORPUS_DRY_RUN);
+	const outputPath = path.join(repoRoot, normalizeOptionalString(process.env.AI_ASSISTANT_CORPUS_OUTPUT) || 'tmp/ai-assistant-query-corpus.json');
+
+	if (!fs.existsSync(settingsPath)) {
+		throw new Error(`Settings file not found: ${settingsPath}`);
+	}
+
+	if (dryRun) {
+		console.log(JSON.stringify({
+			mode: 'dry-run',
+			serverDir,
+			settingsPath,
+			appId,
+			lookbackDays,
+			maxPrompts,
+			maxRecentMessages,
+			outputPath
+		}, null, 2));
+		return;
+	}
+
+	applyEnvFromServerDir(serverDir);
+	process.env.AI_ASSISTANT_WORKSPACE_ROOT = process.env.AI_ASSISTANT_WORKSPACE_ROOT || path.resolve(serverDir, '../..');
+
+	const runtimeTmpDir = path.join(serverDir, 'tmp');
+	const runtimeSrcDir = path.join(serverDir, 'src');
+	const runtimeDir = fs.existsSync(path.join(runtimeTmpDir, 'server-app.js')) ? runtimeTmpDir : runtimeSrcDir;
+	const clientRoutesPath = path.join(runtimeDir, 'client-routes');
+	if (!fs.existsSync(clientRoutesPath) && !fs.existsSync(`${clientRoutesPath}.js`)) {
+		throw new Error(`client-routes module not found under runtime dir: ${runtimeDir}`);
+	}
+	const { CLIENT_ROUTES } = require(clientRoutesPath);
+	const serverConfig = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+	const envDatabase = normalizeOptionalString(process.env.DATABASE);
+	const envMongoUrl = normalizeOptionalString(process.env.MONGO_URL);
+	const envOplogUrl = normalizeOptionalString(process.env.OPLOG_URL);
+	if (envDatabase) {
+		serverConfig.DATABASE = envDatabase;
+	}
+	if (envMongoUrl) {
+		serverConfig.MONGO_URL = envMongoUrl;
+	}
+	if (envOplogUrl) {
+		serverConfig.OPLOG_URL = envOplogUrl;
+	}
+
+	process.env.IS_WORKERS_ENABLED = process.env.IS_WORKERS_ENABLED || 'false';
+	process.env.IS_WORKER_INSTANCE = process.env.IS_WORKER_INSTANCE || 'false';
+	process.env.WORKER_INDEX = process.env.WORKER_INDEX || '';
+	process.env.NODE_APP_INSTANCE = process.env.NODE_APP_INSTANCE || '8';
+
+	await ResolveIOServer.create(serverConfig, CLIENT_ROUTES(), appId.toUpperCase(), runtimeDir, false, false);
+	const mainServer = ResolveIOServer.getMainServer();
+	const methodManager = mainServer?.getMethodManager();
+	if (!methodManager) {
+		throw new Error('MethodManager unavailable after ResolveIOServer initialization.');
+	}
+	await methodManager.waitUntilReady(120000);
+
+	const dbName = normalizeOptionalString(serverConfig.DATABASE) || 'resolveio';
+	const db = ResolveIOServer.getMongoConnection().db(dbName);
+	const now = new Date();
+	const since = addDaysUtc(now, -lookbackDays);
+	const idUser = normalizeOptionalString(process.env.AI_ASSISTANT_CORPUS_USER_ID);
+
+	const promptMap = new Map<string, PromptAccumulator>();
+
+	SEED_PROMPTS.forEach((seedPrompt) => {
+		if (!isUsefulPrompt(seedPrompt)) {
+			return;
+		}
+		const entry = ensureAccumulator(promptMap, seedPrompt);
+		entry.sources.add('seed');
+		entry.score += 20;
+	});
+
+	const recentUserMessages = await db.collection('ai-terminal-messages')
+		.find(
+			{
+				role: 'user',
+				createdAt: { $gte: since }
+			},
+			{
+				projection: {
+					content: 1,
+					id_conversation: 1,
+					createdAt: 1
+				},
+				sort: { createdAt: -1 },
+				limit: maxRecentMessages
+			}
+		)
+		.toArray();
+
+	recentUserMessages.forEach((entryDoc: any) => {
+		const prompt = normalizePrompt(entryDoc?.content);
+		if (!isUsefulPrompt(prompt)) {
+			return;
+		}
+		const entry = ensureAccumulator(promptMap, prompt);
+		entry.sources.add('recent_messages');
+		entry.seenCount += 1;
+		entry.score += 3;
+		const conversationId = normalizeOptionalString(entryDoc?.id_conversation);
+		if (conversationId) {
+			entry.conversationIds.add(conversationId);
+		}
+		const createdAt = entryDoc?.createdAt ? new Date(entryDoc.createdAt) : null;
+		if (createdAt && Number.isFinite(createdAt.getTime())) {
+			if (!entry.lastSeenAt || createdAt > entry.lastSeenAt) {
+				entry.lastSeenAt = createdAt;
+			}
+		}
+	});
+
+	let issueReportCount = 0;
+	const hasIssueCollection = await db.listCollections({ name: 'ai-terminal-issue-reports' }).hasNext();
+	if (hasIssueCollection) {
+		const issueReports = await db.collection('ai-terminal-issue-reports')
+			.find(
+				{
+					createdAt: { $gte: since }
+				},
+				{
+					projection: {
+						user_prompt: 1,
+						reason: 1,
+						expected_outcome: 1,
+						id_conversation: 1,
+						createdAt: 1
+					},
+					sort: { createdAt: -1 },
+					limit: maxRecentMessages
+				}
+			)
+			.toArray();
+		issueReportCount = issueReports.length;
+		issueReports.forEach((issue: any) => {
+			const prompt = normalizePrompt(issue?.user_prompt);
+			if (!isUsefulPrompt(prompt)) {
+				return;
+			}
+			const entry = ensureAccumulator(promptMap, prompt);
+			entry.sources.add('issue_reports');
+			entry.issueCount += 1;
+			entry.score += 15;
+			const reason = normalizePrompt(issue?.reason);
+			const expected = normalizePrompt(issue?.expected_outcome);
+			if (reason) {
+				entry.issueReasons.add(reason);
+			}
+			if (expected) {
+				entry.issueExpected.add(expected);
+			}
+			const conversationId = normalizeOptionalString(issue?.id_conversation);
+			if (conversationId) {
+				entry.conversationIds.add(conversationId);
+			}
+			const createdAt = issue?.createdAt ? new Date(issue.createdAt) : null;
+			if (createdAt && Number.isFinite(createdAt.getTime())) {
+				if (!entry.lastSeenAt || createdAt > entry.lastSeenAt) {
+					entry.lastSeenAt = createdAt;
+				}
+			}
+		});
+	}
+
+	promptMap.forEach((entry) => {
+		entry.score += Math.min(entry.seenCount, 20);
+		entry.score += Math.min(entry.issueCount * 5, 40);
+		entry.score += applyRecencyScore(entry.lastSeenAt);
+	});
+
+	const ranked = Array.from(promptMap.values())
+		.sort((a, b) => {
+			if (b.score !== a.score) {
+				return b.score - a.score;
+			}
+			if (b.issueCount !== a.issueCount) {
+				return b.issueCount - a.issueCount;
+			}
+			if (b.seenCount !== a.seenCount) {
+				return b.seenCount - a.seenCount;
+			}
+			const aTime = a.lastSeenAt ? a.lastSeenAt.getTime() : 0;
+			const bTime = b.lastSeenAt ? b.lastSeenAt.getTime() : 0;
+			if (bTime !== aTime) {
+				return bTime - aTime;
+			}
+			return a.prompt.localeCompare(b.prompt);
+		})
+		.slice(0, maxPrompts);
+
+	const prompts: CorpusPrompt[] = ranked.map((entry, index) => ({
+		id: `corpus_${String(index + 1).padStart(3, '0')}`,
+		prompt: entry.prompt,
+		score: entry.score,
+		sources: Array.from(entry.sources.values()).sort(),
+		seenCount: entry.seenCount,
+		issueCount: entry.issueCount,
+		lastSeenAt: entry.lastSeenAt ? entry.lastSeenAt.toISOString() : undefined,
+		conversationIds: Array.from(entry.conversationIds.values()).slice(0, 5),
+		issueReasons: Array.from(entry.issueReasons.values()).slice(0, 3),
+		issueExpected: Array.from(entry.issueExpected.values()).slice(0, 3)
+	}));
+
+	const output = {
+		generatedAt: now.toISOString(),
+		serverDir,
+		settingsPath,
+		appId,
+		database: dbName,
+		...(idUser ? { idUser } : {}),
+		lookbackDays,
+		maxPrompts,
+		sources: {
+			seedPrompts: SEED_PROMPTS.length,
+			recentUserMessages: recentUserMessages.length,
+			issueReports: issueReportCount
+		},
+		totalPrompts: prompts.length,
+		prompts
+	};
+
+	fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+	fs.writeFileSync(outputPath, JSON.stringify(output, null, 2));
+	console.log(`ai assistant corpus build: ${prompts.length} prompts`);
+	console.log(`wrote ${outputPath}`);
+}
+
+run()
+	.then(() => {
+		process.exit(process.exitCode ?? 0);
+	})
+	.catch((error) => {
+		console.error(error);
+		process.exit(1);
+	});