@agentuity/cli 0.0.6

package/src/cmd/bundle/bundler.ts

@@ -0,0 +1,88 @@
+import { join } from 'node:path';
+import { existsSync, rmSync } from 'node:fs';
+import AgentuityBundler from './plugin';
+import { getFilesRecursively } from './file';
+import { getVersion } from '../../version';
+
+export interface BundleOptions {
+	rootDir: string;
+	dev?: boolean;
+}
+
+export async function bundle({ dev = false, rootDir }: BundleOptions) {
+	const appFile = join(rootDir, 'app.ts');
+	if (!existsSync(appFile)) {
+		throw new Error(`App file not found at expected location: ${appFile}`);
+	}
+	const outDir = join(rootDir, '.agentuity');
+	const srcDir = join(rootDir, 'src');
+
+	const entrypoints: string[] = [];
+
+	for (const folder of ['apis', 'agents', 'web']) {
+		const dir = join(srcDir, folder);
+		if (!existsSync(dir)) {
+			if (folder === 'agents') {
+				throw new Error(`Expected directory not found: ${dir}`);
+			}
+			continue;
+		}
+		const files = await getFilesRecursively(dir);
+		for (const filename of files) {
+			if (/\.[jt]sx?$/.test(filename)) {
+				entrypoints.push(filename);
+			}
+		}
+	}
+
+	entrypoints.push(appFile);
+
+	if (existsSync(outDir)) {
+		rmSync(outDir, { recursive: true, force: true });
+	}
+
+	const pkgFile = Bun.file('./package.json');
+	const pkgContents = JSON.parse(await pkgFile.text());
+
+	const isProd = !dev;
+
+	const define = {
+		'process.env.AGENTUITY_CLOUD_SDK_VERSION': JSON.stringify(getVersion() ?? '1.0.0'),
+		'process.env.NODE_ENV': JSON.stringify(isProd ? 'production' : 'development'),
+	};
+
+	const config: Bun.BuildConfig = {
+		entrypoints,
+		root: rootDir,
+		outdir: outDir,
+		define,
+		sourcemap: dev ? 'inline' : 'external',
+		env: 'AGENTUITY_CLOUD_*',
+		plugins: [AgentuityBundler],
+		target: 'bun',
+		format: 'esm',
+		banner: `// Generated file. DO NOT EDIT`,
+		minify: isProd,
+		drop: isProd ? ['debugger'] : undefined,
+		naming: isProd
+			? {
+					entry: '[dir]/[name].js',
+					chunk: 'chunks/[name]-[hash].js',
+					asset: 'assets/[name]-[hash].[ext]',
+				}
+			: undefined,
+		conditions: [isProd ? 'production' : 'development', 'bun'],
+	};
+
+	await Bun.write(
+		`${outDir}/package.json`,
+		JSON.stringify({ name: pkgContents.name, version: pkgContents.version }, null, 2)
+	);
+
+	const agentuityYAML = Bun.file('./agentuity.yaml');
+	if (await agentuityYAML.exists()) {
+		await Bun.write(`${outDir}/agentuity.yaml`, agentuityYAML);
+	}
+
+	await Bun.build(config);
+}

package/src/cmd/bundle/file.ts

@@ -0,0 +1,16 @@
+import fs from 'node:fs';
+import { resolve } from 'node:path';
+import { promisify } from 'node:util';
+
+const readdir = promisify(fs.readdir);
+
+export async function getFilesRecursively(dir: string): Promise<string[]> {
+	const subdirs = await readdir(dir, { withFileTypes: true });
+	const files = await Promise.all(
+		subdirs.map(async (dirent: fs.Dirent) => {
+			const res = resolve(dir, dirent.name);
+			return dirent.isDirectory() ? getFilesRecursively(res) : res;
+		})
+	);
+	return files.flat();
+}

package/src/cmd/bundle/index.ts

@@ -0,0 +1,38 @@
+import { createSubcommand } from '@/types';
+import { z } from 'zod';
+import { resolve } from 'node:path';
+import { bundle } from './bundler';
+
+export const command = createSubcommand({
+	name: 'bundle',
+	description: 'Bundle Agentuity application for deployment',
+	aliases: ['build'],
+	schema: {
+		options: z.object({
+			dir: z.string().optional().describe('Root directory of the project'),
+			dev: z.boolean().optional().describe('Enable development mode'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, opts } = ctx;
+		const rootDir = resolve(opts.dir || process.cwd());
+
+		try {
+			logger.info(`Bundling project at: ${rootDir}`);
+
+			await bundle({
+				rootDir,
+				dev: opts.dev || false,
+			});
+
+			logger.info('✓ Bundle complete');
+		} catch (error) {
+			if (error instanceof Error) {
+				logger.fatal(`Bundle failed: ${error.message}`);
+			} else {
+				logger.fatal('Bundle failed');
+			}
+		}
+	},
+});

package/src/cmd/bundle/plugin.ts

@@ -0,0 +1,259 @@
+import type { BunPlugin } from 'bun';
+import { dirname, basename, join } from 'node:path';
+import { existsSync, writeFileSync } from 'node:fs';
+import { parseAgentMetadata } from './ast';
+
+function toCamelCase(str: string): string {
+	return str
+		.replace(/[-_\s]+(.)?/g, (_, char) => (char ? char.toUpperCase() : ''))
+		.replace(/^(.)/, (char) => char.toLowerCase());
+}
+
+function toPascalCase(str: string): string {
+	const camel = toCamelCase(str);
+	return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+
+function generateAgentRegistry(srcDir: string, agentInfo: Array<Record<string, string>>) {
+	const imports = agentInfo
+		.map(({ name, path }) => {
+			const camelName = toCamelCase(name);
+			const relativePath = path.replace(/^\.\/agents\//, './');
+			return `import ${camelName}Agent from '${relativePath}';`;
+		})
+		.join('\n');
+
+	const registry = agentInfo
+		.map(({ name }) => {
+			const camelName = toCamelCase(name);
+			return `  ${camelName}: ${camelName}Agent,`;
+		})
+		.join('\n');
+
+	const typeExports = agentInfo
+		.map(({ name }) => {
+			const camelName = toCamelCase(name);
+			const pascalName = toPascalCase(name);
+			return `export type ${pascalName}AgentRunner = AgentRunner<typeof ${camelName}Agent['inputSchema'], typeof ${camelName}Agent['outputSchema'], typeof ${camelName}Agent['stream'] extends true ? true : false>;`;
+		})
+		.join('\n');
+
+	const generatedContent = `// Auto-generated by Agentuity - do not edit manually
+${imports}
+import type { AgentRunner, Logger } from '@agentuity/runtime';
+import type { KeyValueStorage, ObjectStorage, StreamStorage, VectorStorage } from '@agentuity/core';
+
+export const agentRegistry = {
+${registry}
+} as const;
+
+export type AgentName = keyof typeof agentRegistry;
+export type AgentRegistry = typeof agentRegistry;
+
+// Typed runners for each agent
+${typeExports}
+
+// Augment Context to provide strongly-typed agents
+declare module "hono" {
+	interface Context {
+	   agentName: AgentName;
+	   agent: {
+	     [K in AgentName]: AgentRunner<AgentRegistry[K]['inputSchema'], AgentRegistry[K]['outputSchema'], AgentRegistry[K]['stream'] extends true ? true : false>;
+	   };
+	   waitUntil: (promise: Promise<void> | (() => void | Promise<void>)) => void;
+	   logger: Logger;
+	   kv: KeyValueStorage;
+	   objectstore: ObjectStorage;
+	   stream: StreamStorage;
+	   vector: VectorStorage;
+  }
+}
+`;
+
+	const agentsDir = join(srcDir, 'agents');
+	const registryPath = join(agentsDir, 'registry.generated.ts');
+
+	writeFileSync(registryPath, generatedContent, 'utf-8');
+
+	const clientTypesContent = `// Auto-generated by Agentuity - do not edit manually
+// This file augments @agentuity/react with your project's agent types
+${agentInfo
+	.map(({ name, path }) => {
+		const camelName = toCamelCase(name);
+		const relativePath = path.replace(/^\.\/agents\//, './');
+		return `import type ${camelName}Agent from '${relativePath}';`;
+	})
+	.join('\n')}
+import type { Agent } from '@agentuity/react';
+
+declare module '@agentuity/react' {
+	interface AgentRegistry {
+${agentInfo
+	.map(({ name }) => {
+		const camelName = toCamelCase(name);
+		return `		'${name}': Agent<typeof ${camelName}Agent['inputSchema'], typeof ${camelName}Agent['outputSchema']>;`;
+	})
+	.join('\n')}
+	}
+}
+`;
+
+	const clientTypesPath = join(agentsDir, 'types.generated.d.ts');
+	writeFileSync(clientTypesPath, clientTypesContent, 'utf-8');
+}
+
+const AgentuityBundler: BunPlugin = {
+	name: 'Agentuity Bundler',
+	setup(build) {
+		const rootDir = build.config.root ?? '.';
+		const srcDir = join(rootDir, 'src');
+		const routes: Set<string> = new Set();
+		const agentInfo: Array<Record<string, string>> = [];
+		const agentMetadata: Map<string, Map<string, string>> = new Map<
+			string,
+			Map<string, string>
+		>();
+		const transpiler = new Bun.Transpiler({ loader: 'ts' });
+
+		build.onResolve({ filter: /\/route\.ts$/, namespace: 'file' }, async (args) => {
+			if (args.path.startsWith(srcDir)) {
+				const importPath = args.path
+					.replace(rootDir, '')
+					.replace('.ts', '')
+					.replace('/src/', './');
+				routes.add(importPath);
+			}
+			return args;
+		});
+
+		build.onLoad({ filter: /\/agent\.ts$/, namespace: 'file' }, async (args) => {
+			let newsource = await Bun.file(args.path).text();
+			if (args.path.startsWith(srcDir)) {
+				const contents = transpiler.transformSync(newsource);
+				const [ns, md] = parseAgentMetadata(rootDir, args.path, contents);
+				newsource = ns;
+				agentMetadata.set(md.get('identifier')!, md);
+			}
+			return {
+				contents: newsource,
+				loader: 'ts',
+			};
+		});
+
+		build.onLoad(
+			{
+				filter: new RegExp(join(rootDir, 'app.ts')),
+				namespace: 'file',
+			},
+			async (args) => {
+				await args.defer();
+
+				const inserts: string[] = [];
+
+				for (const route of routes) {
+					const name = basename(dirname(route));
+					const agent = route.replace(/\/route$/, '/agent');
+					const hasAgent = existsSync(join(srcDir, agent + '.ts'));
+					const agentPath = route
+						.replace(/\/route$/, '/*')
+						.replace('/agents', '/agent')
+						.replace('./', '/');
+					const routePath = route
+						.replace(/\/route$/, '')
+						.replace('/apis/', '/api/')
+						.replace('/apis', '/api')
+						.replace('/agents', '/agent')
+						.replace('/agents', '/agent')
+						.replace('./', '/');
+
+					let agentDetail: Record<string, string> = {};
+
+					if (hasAgent) {
+						const md = agentMetadata.get(name);
+						if (!md) {
+							throw new Error(`Couldn't find agent metadata for ${route}`);
+						}
+						agentDetail = {
+							name,
+							path: `.${agent}`,
+							filename: md.get('filename')!,
+							identifier: md.get('identifier')!,
+							description: md.get('description') ?? '',
+						};
+						agentInfo.push(agentDetail);
+					}
+
+					let buffer = `await (async() => {
+    const { createAgentMiddleware, getApp, registerAgent } = await import('@agentuity/runtime');
+    const app = getApp()!;
+    const route = require('./src/${route}').default;`;
+					if (hasAgent) {
+						buffer += `
+    const agent = require('./src/${agent}').default;
+    app.all("${agentPath}", createAgentMiddleware('${name}'));
+    registerAgent("${name}", agent);`;
+					}
+					buffer += `
+    app.route("${routePath}", route);
+})();`;
+					inserts.push(buffer);
+				}
+
+				const indexFile = join(srcDir, 'web', 'app.tsx');
+
+				if (existsSync(indexFile)) {
+					const uniqid = Math.random().toString(36);
+					const clientjscode = `
+import React from "react";
+import { createRoot } from "react-dom/client";
+import { App } from "./app";
+
+const root = createRoot(document.getElementById("root"));
+root.render(<App />);
+`;
+					const clientFile = join(srcDir, 'web', 'client.generated.js');
+					writeFileSync(clientFile, clientjscode);
+
+					inserts.unshift(`await (async () => {
+    const { renderToString } = require('react-dom/server');
+    const { serveStatic } = require('hono/bun');
+    const { getApp } = await import('@agentuity/runtime');
+    const app = getApp()!;
+    const routehtml = renderToString(require("./src/web/app").default);
+    app.get("/", (c) => c.html(\`<html><body><div id="root">\${routehtml}</div><script src="/web/${uniqid}/client.js" type="module"></script></body></html>\`));
+    app.get("/web/${uniqid}/client.js", (c) => new Response(Bun.file('./src/web/client.generated.js'), { type: 'text/javascript', headers: { 'Cache-Control': 'public, max-age=31536000, immutable' } }));
+    app.get('/public/*', serveStatic({ root: './src/web' }));
+})();`);
+				}
+
+				generateAgentRegistry(srcDir, agentInfo);
+
+				const file = Bun.file(args.path);
+				let contents = await file.text();
+				let inserted = false;
+				const index = contents.indexOf(' createApp(');
+				if (index > 0) {
+					const endSemi = contents.indexOf(');', index);
+					if (endSemi > 0) {
+						contents =
+							contents.slice(0, endSemi + 2) +
+							'\n\n' +
+							inserts.join('\n') +
+							contents.slice(endSemi + 2);
+						inserted = true;
+					}
+				}
+				if (!inserted) {
+					contents += `\n${inserts.join('\n')}`;
+				}
+
+				return {
+					contents,
+					loader: 'ts',
+				};
+			}
+		);
+	},
+};
+
+export default AgentuityBundler;

package/src/cmd/dev/index.ts

@@ -0,0 +1,83 @@
+import { createCommand } from '@/types';
+import { z } from 'zod';
+import { resolve } from 'node:path';
+import { bundle } from '../bundle/bundler';
+import { existsSync } from 'node:fs';
+import * as tui from '@/tui';
+
+export const command = createCommand({
+	name: 'dev',
+	description: 'Build and run the development server',
+	schema: {
+		options: z.object({
+			dir: z.string().optional().describe('Root directory of the project'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { opts } = ctx;
+		const rootDir = resolve(opts.dir || process.cwd());
+		const agentuityDir = resolve(rootDir, '.agentuity');
+		const appPath = resolve(agentuityDir, 'app.js');
+
+		try {
+			await tui.spinner('Building project...', async () => {
+				await bundle({
+					rootDir,
+					dev: true,
+				});
+			});
+
+			tui.success('Build complete');
+
+			if (!existsSync(appPath)) {
+				tui.error(`App file not found: ${appPath}`);
+				process.exit(1);
+			}
+
+			tui.newline();
+			tui.info('Starting development server...');
+			tui.newline();
+
+			// Use shell to run in a process group for proper cleanup
+			// The 'exec' ensures the shell is replaced by the actual process
+			const devServer = Bun.spawn(['sh', '-c', `exec bun run "${appPath}"`], {
+				cwd: rootDir,
+				stdout: 'inherit',
+				stderr: 'inherit',
+				stdin: 'inherit',
+			});
+
+			// Handle signals to ensure entire process tree is killed
+			const cleanup = () => {
+				if (devServer.pid) {
+					try {
+						// Kill the process group (negative PID kills entire group)
+						process.kill(-devServer.pid, 'SIGTERM');
+					} catch {
+						// Fallback: kill the direct process
+						try {
+							devServer.kill();
+						} catch {
+							// Ignore if already dead
+						}
+					}
+				}
+				process.exit(0);
+			};
+
+			process.on('SIGINT', cleanup);
+			process.on('SIGTERM', cleanup);
+
+			const exitCode = await devServer.exited;
+			process.exit(exitCode);
+		} catch (error) {
+			if (error instanceof Error) {
+				tui.error(`Dev server failed: ${error.message}`);
+			} else {
+				tui.error('Dev server failed');
+			}
+			process.exit(1);
+		}
+	},
+});

package/src/cmd/example/create-user.ts

@@ -0,0 +1,38 @@
+import { createSubcommand } from '@/types';
+import { z } from 'zod';
+
+export const createUserSubcommand = createSubcommand({
+	name: 'create-user',
+	description: 'Example: Create a user with validation (requires authentication)',
+	requiresAuth: true,
+	schema: {
+		args: z.object({
+			username: z.string().min(3).max(20).describe('Username for the new user'),
+		}),
+		options: z.object({
+			email: z.string().email().optional().describe('Email address'),
+			admin: z.boolean().optional().describe('Grant admin privileges'),
+			age: z.number().int().positive().optional().describe('User age'),
+		}),
+	},
+
+	async handler(ctx) {
+		// ctx.args and ctx.opts are fully typed - NO CASTING NEEDED!
+		const { logger, auth, args, opts } = ctx;
+
+		logger.info(`Creating user: ${args.username}`);
+		logger.debug(`Authenticated as: ${auth.userId}`);
+
+		if (opts.email) {
+			logger.info(`Email: ${opts.email}`);
+		}
+		if (opts.admin) {
+			logger.info('Admin privileges: enabled');
+		}
+		if (opts.age) {
+			logger.info(`Age: ${opts.age}`);
+		}
+
+		logger.info('User created successfully!');
+	},
+});

package/src/cmd/example/create.ts

@@ -0,0 +1,31 @@
+import { createSubcommand } from '@/types';
+import { z } from 'zod';
+
+export const createCommand = createSubcommand({
+	name: 'create',
+	description: 'Create a new example',
+	schema: {
+		args: z.object({
+			name: z.string().describe('Name of the example'),
+		}),
+		options: z.object({
+			type: z.string().optional().describe('Example type'),
+			force: z.boolean().optional().describe('Force creation'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, args, opts } = ctx;
+
+		logger.trace('Starting create command...');
+		logger.debug(`Type: ${opts.type || 'default'}`);
+		logger.debug(`Force: ${opts.force || false}`);
+		logger.info(`Creating example: ${args.name}`);
+
+		if (opts.force) {
+			logger.warn('Force mode enabled');
+		}
+
+		logger.info('Example created successfully!');
+	},
+});

package/src/cmd/example/deploy.ts

@@ -0,0 +1,36 @@
+import { createSubcommand } from '@/types';
+import { z } from 'zod';
+
+export const deploySubcommand = createSubcommand({
+	name: 'deploy',
+	description: 'Example: Deploy to an environment (requires authentication)',
+	requiresAuth: true,
+	schema: {
+		args: z.object({
+			environment: z.string().describe('Target environment (dev/staging/prod)'),
+		}),
+		options: z.object({
+			force: z.boolean().optional().describe('Force deployment without confirmation'),
+			dryRun: z.boolean().optional().describe('Preview changes without deploying'),
+		}),
+	},
+
+	async handler(ctx) {
+		// ctx.args and ctx.opts are fully typed - NO CASTING NEEDED!
+		const { logger, auth, args, opts } = ctx;
+
+		logger.info(`Deploying to: ${args.environment}`);
+		logger.debug(`Using API key: ${auth.apiKey.substring(0, 8)}...`);
+
+		if (opts.dryRun) {
+			logger.info('Dry run mode - no changes made');
+			return;
+		}
+
+		if (opts.force) {
+			logger.info('Force deployment enabled');
+		}
+
+		logger.info('Deployment complete');
+	},
+});

package/src/cmd/example/index.ts

@@ -0,0 +1,27 @@
+import { createCommand } from '@/types';
+import { createCommand as createSubCmd } from './create';
+import { listSubcommand } from './list';
+import { stepsSubcommand } from './steps';
+import { spinnerSubcommand } from './spinner';
+import { deploySubcommand } from './deploy';
+import { versionSubcommand } from './version';
+import { createUserSubcommand } from './create-user';
+import { runCommandSubcommand } from './run-command';
+import { soundSubcommand } from './sound';
+
+export const command = createCommand({
+	name: 'example',
+	description: 'Example command with subcommands',
+	hidden: true,
+	subcommands: [
+		createSubCmd,
+		listSubcommand,
+		stepsSubcommand,
+		spinnerSubcommand,
+		deploySubcommand,
+		versionSubcommand,
+		createUserSubcommand,
+		runCommandSubcommand,
+		soundSubcommand,
+	],
+});

package/src/cmd/example/list.ts

@@ -0,0 +1,32 @@
+import { createSubcommand } from '@/types';
+import { z } from 'zod';
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	description: 'List examples',
+	schema: {
+		options: z.object({
+			all: z.boolean().optional().describe('Show all examples'),
+			json: z.boolean().optional().describe('Output as JSON'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, opts } = ctx;
+
+		logger.trace('Starting list command...');
+		logger.debug(`All: ${opts.all || false}`);
+		logger.debug(`JSON: ${opts.json || false}`);
+
+		const examples = ['example1', 'example2', 'example3'];
+
+		if (opts.json) {
+			console.log(JSON.stringify(examples));
+		} else {
+			logger.info('Examples:');
+			for (const example of examples) {
+				logger.info(`  - ${example}`);
+			}
+		}
+	},
+});

package/src/cmd/example/run-command.ts

@@ -0,0 +1,45 @@
+import { createSubcommand } from '@/types';
+import * as tui from '@/tui';
+
+export const runCommandSubcommand = createSubcommand({
+	name: 'run-command',
+	description: 'Demo of runCommand TUI component',
+
+	async handler() {
+		tui.info('Example 1: Running a successful command\n');
+		await tui.runCommand({
+			command: 'echo "Hello, World!"',
+			cmd: ['echo', 'Hello, World!'],
+		});
+
+		tui.newline();
+		tui.info('Example 2: Command with multiple output lines\n');
+		await tui.runCommand({
+			command: 'ls -la',
+			cmd: ['ls', '-la'],
+			cwd: process.cwd(),
+		});
+
+		tui.newline();
+		tui.info('Example 3: Long running command\n');
+		await tui.runCommand({
+			command: 'for i in {1..100}; do echo "Line $i"; sleep 0.01; done',
+			cmd: ['sh', '-c', 'for i in {1..100}; do echo "Line $i"; sleep 0.01; done'],
+		});
+
+		tui.newline();
+		tui.info('Example 4: Failing command\n');
+		const exitCode = await tui.runCommand({
+			command: 'exit 1',
+			cmd: ['sh', '-c', 'echo "This will fail"; exit 1'],
+		});
+		tui.info(`Exit code: ${exitCode}`);
+
+		tui.newline();
+		tui.info('Example 5: Tree\n');
+		await tui.runCommand({
+			command: 'tree',
+			cmd: ['tree'],
+		});
+	},
+});