@agentuity/cli 0.0.35 → 0.0.42

package/src/cmd/bundle/ast.ts

@@ -1,6 +1,7 @@
 import * as acornLoose from 'acorn-loose';
 import { basename, dirname, relative } from 'node:path';
 import { generate } from 'astring';
+import { BuildMetadata } from '../../types';
 
 interface ASTNode {
 	type: string;
@@ -12,9 +13,7 @@ interface ASTNodeIdentifier extends ASTNode {
 
 interface ASTCallExpression extends ASTNode {
 	arguments: unknown[];
-	callee: {
-		name: string;
-	};
+	callee: ASTMemberExpression;
 }
 
 interface ASTPropertyNode {
@@ -31,10 +30,22 @@ interface ASTObjectExpression extends ASTNode {
 	properties: ASTPropertyNode[];
 }
 
-interface ASTLiteral {
+interface ASTLiteral extends ASTNode {
 	value: string;
 }
 
+interface ASTMemberExpression extends ASTNode {
+	object: ASTNode;
+	property: ASTNode;
+	computed: boolean;
+	optional: boolean;
+	name?: string;
+}
+
+interface ASTExpressionStatement extends ASTNode {
+	expression: ASTCallExpression;
+}
+
 function parseObjectExpressionToMap(expr: ASTObjectExpression): Map<string, string> {
 	const result = new Map<string, string>();
 	for (const prop of expr.properties) {
@@ -98,6 +109,10 @@ function getAgentId(identifier: string): string {
 	return hash(projectId, identifier);
 }
 
+function generateRouteId(method: string, path: string): string {
+	return hash(projectId, method, path);
+}
+
 type AcornParseResultType = ReturnType<typeof acornLoose.parse>;
 
 function augmentAgentMetadataNode(
@@ -229,3 +244,153 @@ export function parseAgentMetadata(
 		`error parsing: ${filename}. could not find an proper createAgent defined in this file`
 	);
 }
+
+type RouteDefinition = BuildMetadata['routes'];
+
+export async function parseRoute(
+	rootDir: string,
+	filename: string
+): Promise<BuildMetadata['routes']> {
+	const contents = await Bun.file(filename).text();
+	const version = hash(contents);
+	const ast = acornLoose.parse(contents, { ecmaVersion: 'latest', sourceType: 'module' });
+	let exportName: string | undefined;
+	let variableName: string | undefined;
+	for (const body of ast.body) {
+		if (body.type === 'ExportDefaultDeclaration') {
+			const identifier = body.declaration as ASTNodeIdentifier;
+			exportName = identifier.name;
+			break;
+		}
+	}
+	if (!exportName) {
+		throw new Error(`could not find default export for ${filename} using ${rootDir}`);
+	}
+	for (const body of ast.body) {
+		if (body.type === 'VariableDeclaration') {
+			for (const vardecl of body.declarations) {
+				if (vardecl.type === 'VariableDeclarator' && vardecl.id.type === 'Identifier') {
+					const identifier = vardecl.id as ASTNodeIdentifier;
+					if (identifier.name === exportName) {
+						if (vardecl.init?.type === 'CallExpression') {
+							const call = vardecl.init as ASTCallExpression;
+							if (call.callee.name === 'createRouter') {
+								variableName = identifier.name;
+								break;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if (!variableName) {
+		throw new Error(
+			`error parsing: ${filename}. could not find an proper createRouter defined in this file`
+		);
+	}
+
+	const rel = relative(rootDir, filename);
+	const name = basename(dirname(filename));
+	const routes: RouteDefinition = [];
+	const routePrefix = filename.includes('src/agents') ? '/agent' : '/api';
+
+	for (const body of ast.body) {
+		if (body.type === 'ExpressionStatement') {
+			const statement = body as ASTExpressionStatement;
+			const callee = statement.expression.callee;
+			if (callee.object.type === 'Identifier') {
+				const identifier = callee.object as ASTNodeIdentifier;
+				if (identifier.name === variableName) {
+					let method = (callee.property as ASTNodeIdentifier).name;
+					let type = 'api';
+					const action = statement.expression.arguments[0];
+					let suffix = '';
+					let config: Record<string, unknown> | undefined;
+					switch (method) {
+						case 'get':
+						case 'put':
+						case 'post':
+						case 'patch':
+						case 'delete': {
+							const theaction = action as ASTLiteral;
+							if (theaction.type === 'Literal') {
+								suffix = theaction.value;
+								break;
+							}
+							break;
+						}
+						case 'stream':
+						case 'sse':
+						case 'websocket': {
+							type = method;
+							method = 'post';
+							const theaction = action as ASTLiteral;
+							if (theaction.type === 'Literal') {
+								suffix = theaction.value;
+								break;
+							}
+							break;
+						}
+						case 'sms': {
+							type = method;
+							method = 'post';
+							const theaction = action as ASTObjectExpression;
+							if (theaction.type === 'ObjectExpression') {
+								config = {};
+								theaction.properties.forEach((p) => {
+									if (p.value.type === 'Literal') {
+										const literal = p.value as ASTLiteral;
+										config![p.key.name] = literal.value;
+									}
+								});
+								const number = theaction.properties.find((p) => p.key.name === 'number');
+								if (number && number.value.type === 'Literal') {
+									const phoneNumber = number.value as ASTLiteral;
+									suffix = hash(phoneNumber.value);
+									break;
+								}
+							}
+							break;
+						}
+						case 'email': {
+							type = method;
+							method = 'post';
+							const theaction = action as ASTLiteral;
+							if (theaction.type === 'Literal') {
+								const email = theaction.value;
+								suffix = hash(email);
+								break;
+							}
+							break;
+						}
+						case 'cron': {
+							type = method;
+							method = 'post';
+							const theaction = action as ASTLiteral;
+							if (theaction.type === 'Literal') {
+								const number = theaction.value;
+								suffix = hash(number);
+								break;
+							}
+							break;
+						}
+					}
+					const thepath = `${routePrefix}/${name}/${suffix}`
+						.replaceAll(/\/{2,}/g, '/')
+						.replaceAll(/\/$/g, '');
+					routes.push({
+						id: generateRouteId(method, thepath),
+						method: method as 'get' | 'post' | 'put' | 'delete' | 'patch',
+						type: type as 'api' | 'sms' | 'email' | 'cron',
+						filename: rel,
+						path: thepath,
+						version,
+						config,
+					});
+				}
+			}
+		}
+	}
+	return routes;
+}

package/src/cmd/bundle/bundler.ts

@@ -7,6 +7,7 @@ import { getVersion } from '../../version';
 export interface BundleOptions {
 	rootDir: string;
 	dev?: boolean;
+	env?: Map<string, string>;
 }
 
 export async function bundle({ dev = false, rootDir }: BundleOptions) {

package/src/cmd/bundle/patch/index.ts

@@ -1,4 +1,5 @@
 import { generatePatches as aisdkGeneratePatches } from './aisdk';
+import { generatePatches as llmGeneratePatches } from './llm';
 import { type PatchModule, searchBackwards } from './_util';
 
 export function generatePatches(): Map<string, PatchModule> {
@@ -6,6 +7,9 @@ export function generatePatches(): Map<string, PatchModule> {
 	for (const [name, patch] of aisdkGeneratePatches()) {
 		patches.set(name, patch);
 	}
+	for (const [name, patch] of llmGeneratePatches()) {
+		patches.set(name, patch);
+	}
 	return patches;
 }
 

package/src/cmd/bundle/patch/llm.ts

@@ -0,0 +1,36 @@
+import { type PatchModule, generateEnvGuard, generateGatewayEnvGuard } from './_util';
+
+function registerLLMPatch(
+	patches: Map<string, PatchModule>,
+	module: string,
+	filename: string,
+	key: string,
+	baseurl: string,
+	name: string
+) {
+	patches.set(module, {
+		module,
+		filename,
+		body: {
+			before: generateEnvGuard(
+				key,
+				generateGatewayEnvGuard(key, 'process.env.AGENTUITY_SDK_KEY', baseurl, name)
+			),
+		},
+	});
+}
+
+export function generatePatches(): Map<string, PatchModule> {
+	const patches = new Map<string, PatchModule>();
+	registerLLMPatch(
+		patches,
+		'@anthropic-ai',
+		'index',
+		'ANTHROPIC_API_KEY',
+		'ANTHROPIC_BASE_URL',
+		'anthropic'
+	);
+	registerLLMPatch(patches, 'groq-sdk', 'index', 'GROQ_API_KEY', 'GROQ_BASE_URL', 'groq');
+	registerLLMPatch(patches, 'openai', 'index', 'OPENAI_API_KEY', 'OPENAI_BASE_URL', 'openai');
+	return patches;
+}

package/src/cmd/bundle/plugin.ts

@@ -1,7 +1,8 @@
 import type { BunPlugin } from 'bun';
 import { dirname, basename, join } from 'node:path';
 import { existsSync, writeFileSync } from 'node:fs';
-import { parseAgentMetadata } from './ast';
+import type { BuildMetadata } from '../../types';
+import { parseAgentMetadata, parseRoute } from './ast';
 import { applyPatch, generatePatches } from './patch';
 
 function toCamelCase(str: string): string {
@@ -115,6 +116,7 @@ const AgentuityBundler: BunPlugin = {
 			Map<string, string>
 		>();
 		const transpiler = new Bun.Transpiler({ loader: 'ts' });
+		let routeDefinitions: BuildMetadata['routes'] = [];
 
 		build.onResolve({ filter: /\/route\.ts$/, namespace: 'file' }, async (args) => {
 			if (args.path.startsWith(srcDir)) {
@@ -194,6 +196,9 @@ const AgentuityBundler: BunPlugin = {
 						.replace('/agents', '/agent')
 						.replace('./', '/');
 
+					const definitions = await parseRoute(rootDir, join(srcDir, route + '.ts'));
+					routeDefinitions = [...routeDefinitions, ...definitions];
+
 					let agentDetail: Record<string, string> = {};
 
 					if (hasAgent) {
@@ -264,6 +269,42 @@ const AgentuityBundler: BunPlugin = {
 					contents += `\n${inserts.join('\n')}`;
 				}
 
+				// generate the build metadata
+				const metadata: BuildMetadata = {
+					routes: routeDefinitions,
+					agents: [],
+				};
+				for (const [, v] of agentMetadata) {
+					if (!v.has('filename')) {
+						throw new Error('agent metadata is missing expected filename property');
+					}
+					if (!v.has('id')) {
+						throw new Error('agent metadata is missing expected id property');
+					}
+					if (!v.has('identifier')) {
+						throw new Error('agent metadata is missing expected identifier property');
+					}
+					if (!v.has('version')) {
+						throw new Error('agent metadata is missing expected version property');
+					}
+					if (!v.has('name')) {
+						throw new Error('agent metadata is missing expected name property');
+					}
+					metadata.agents.push({
+						filename: v.get('filename')!,
+						id: v.get('id')!,
+						identifier: v.get('identifier')!,
+						version: v.get('version')!,
+						name: v.get('name')!,
+						description: v.get('description') ?? '<no description provided>',
+					});
+				}
+
+				const metadataFilename = Bun.file(
+					join(build.config.outdir!, 'agentuity.metadata.json')
+				);
+				await metadataFilename.write(JSON.stringify(metadata));
+
 				return {
 					contents,
 					loader: 'ts',

package/src/cmd/dev/index.ts

@@ -3,6 +3,8 @@ import { z } from 'zod';
 import { resolve, join } from 'node:path';
 import { bundle } from '../bundle/bundler';
 import { existsSync, FSWatcher, watch } from 'node:fs';
+import { loadBuildMetadata } from '../../config';
+import type { BuildMetadata } from '../../types';
 import * as tui from '../../tui';
 
 export const command = createCommand({
@@ -38,6 +40,32 @@ export const command = createCommand({
 			process.exit(1);
 		}
 
+		const devmodebody =
+			tui.muted('Local: ') +
+			tui.link('http://127.0.0.1:3000') +
+			'\n\n' +
+			tui.muted('Press ') +
+			tui.bold('h') +
+			tui.muted(' for keyboard shortcuts');
+
+		function showBanner() {
+			tui.banner('⨺ Agentuity DevMode', devmodebody, {
+				padding: 2,
+				topSpacer: false,
+				bottomSpacer: false,
+				centerTitle: false,
+			});
+		}
+
+		showBanner();
+
+		const env = { ...process.env };
+		env.AGENTUITY_SDK_DEV_MODE = 'true';
+		env.AGENTUITY_ENV = 'development';
+		env.NODE_ENV = 'development';
+		env.PORT = '3000';
+		env.AGENTUITY_PORT = env.PORT;
+
 		const agentuityDir = resolve(rootDir, '.agentuity');
 		const appPath = resolve(agentuityDir, 'app.js');
 
@@ -54,6 +82,7 @@ export const command = createCommand({
 		let shuttingDownForRestart = false;
 		let pendingRestart = false;
 		let building = false;
+		let metadata: BuildMetadata | undefined;
 
 		// Track restart timestamps to detect restart loops
 		const restartTimestamps: number[] = [];
@@ -200,6 +229,10 @@ export const command = createCommand({
 					return;
 				}
 
+				metadata = await loadBuildMetadata(agentuityDir);
+
+				env.AGENTUITY_LOG_LEVEL = logger.level;
+
 				logger.trace('Starting dev server: %s', appPath);
 				// Use shell to run in a process group for proper cleanup
 				// The 'exec' ensures the shell is replaced by the actual process
@@ -207,7 +240,8 @@ export const command = createCommand({
 					cwd: rootDir,
 					stdout: 'inherit',
 					stderr: 'inherit',
-					stdin: 'inherit',
+					stdin: process.stdin.isTTY ? 'ignore' : 'inherit', // Don't inherit stdin, we handle it ourselves
+					env,
 				});
 
 				running = true;
@@ -286,6 +320,71 @@ export const command = createCommand({
 		await restart();
 		logger.trace('Initial restart completed, setting up watchers');
 
+		// Setup keyboard shortcuts (only if we have a TTY)
+		if (process.stdin.isTTY) {
+			logger.trace('Setting up keyboard shortcuts');
+			process.stdin.setRawMode(true);
+			process.stdin.resume();
+			process.stdin.setEncoding('utf8');
+
+			const showHelp = () => {
+				console.log('\n' + tui.bold('Keyboard Shortcuts:'));
+				console.log(tui.muted('  h') + ' - show this help');
+				console.log(tui.muted('  c') + ' - clear console');
+				console.log(tui.muted('  r') + ' - restart server');
+				console.log(tui.muted('  o') + ' - show routes');
+				console.log(tui.muted('  a') + ' - show agents');
+				console.log(tui.muted('  q') + ' - quit\n');
+			};
+
+			const showRoutes = () => {
+				tui.info('API Route Detail');
+				console.table(metadata?.routes, ['method', 'path', 'filename']);
+			};
+
+			const showAgents = () => {
+				tui.info('Agent Detail');
+				console.table(metadata?.agents, ['name', 'filename', 'description']);
+			};
+
+			process.stdin.on('data', (data) => {
+				const key = data.toString();
+
+				// Handle Ctrl+C
+				if (key === '\u0003') {
+					cleanup();
+					return;
+				}
+
+				// Handle other shortcuts
+				switch (key) {
+					case 'h':
+						showHelp();
+						break;
+					case 'c':
+						console.clear();
+						showBanner();
+						break;
+					case 'r':
+						tui.info('Manually restarting server...');
+						restart();
+						break;
+					case 'o':
+						showRoutes();
+						break;
+					case 'a':
+						showAgents();
+						break;
+					case 'q':
+						tui.info('Shutting down...');
+						cleanup();
+						break;
+				}
+			});
+
+			logger.trace('✓ Keyboard shortcuts enabled');
+		}
+
 		// Patterns to ignore (generated files that change during build)
 		const ignorePatterns = [
 			/\.generated\.(js|ts|d\.ts)$/,

package/src/cmd/example/optional-auth.ts

@@ -10,7 +10,7 @@ export const optionalAuthSubcommand: SubcommandDefinition = {
 
 		// Type guard to check if auth is present
 		const ctxWithAuth = ctx as CommandContext<true>;
-		if ('auth' in ctx && ctxWithAuth.auth) {
+		if (ctxWithAuth.auth) {
 			const auth = ctxWithAuth.auth as AuthData;
 			// User chose to authenticate
 			tui.success('You are authenticated!');

package/src/cmd/index.ts

@@ -28,6 +28,7 @@ export async function discoverCommands(): Promise<CommandDefinition[]> {
 									aliases: subcommand.aliases,
 									hidden: true,
 									requiresAuth: subcommand.requiresAuth,
+									optionalAuth: subcommand.optionalAuth,
 									schema: subcommand.schema,
 									handler: subcommand.handler,
 								};

package/src/cmd/profile/README.md

@@ -77,4 +77,4 @@ The `name` field is extracted using the regex: `/\bname:\s+["']?([\w-_]+)["']?/`
 - Profile files must have `.yaml` extension
 - Profile names must match: `^[\w-_]{3,}$` (3+ chars, alphanumeric, dashes, underscores)
 - The config loader (`loadConfig()`) automatically uses the active profile
-- If no profile is selected or the file doesn't exist, falls back to `config.yaml`
+- If no profile is selected or the file doesn't exist, falls back to `production.yaml`

package/src/cmd/project/create.ts

@@ -7,7 +7,7 @@ export const createProjectSubcommand = createSubcommand({
 	description: 'Create a new project',
 	aliases: ['new'],
 	toplevel: true,
-	requiresAuth: false,
+	optionalAuth: true,
 	schema: {
 		options: z.object({
 			name: z.string().optional().describe('Project name'),
@@ -32,11 +32,17 @@ export const createProjectSubcommand = createSubcommand({
 				.default(true)
 				.describe('Run bun run build after installing (use --no-build to skip)'),
 			confirm: z.boolean().optional().describe('Skip confirmation prompts'),
+			register: z
+				.boolean()
+				.default(true)
+				.optional()
+				.describe('Register the project, if authenticated (use --no-register to skip)'),
 		}),
 	},
 
 	async handler(ctx) {
-		const { logger, opts } = ctx;
+		const { logger, opts, auth, config } = ctx;
+
 		await runCreateFlow({
 			projectName: opts.name,
 			dir: opts.dir,
@@ -47,6 +53,8 @@ export const createProjectSubcommand = createSubcommand({
 			noBuild: opts.build === false,
 			skipPrompts: opts.confirm === true,
 			logger,
+			auth: opts.register === true ? auth : undefined,
+			config: config!,
 		});
 	},
 });

package/src/cmd/project/delete.ts

@@ -1,13 +1,54 @@
+import { z } from 'zod';
 import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectDelete } from '@agentuity/server';
+import { getAPIBaseURL, APIClient } from '../../api';
 
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',
 	description: 'Delete a project',
 	aliases: ['rm', 'del'],
 	requiresAuth: true,
+	schema: {
+		args: z.object({
+			id: z.string().describe('the project id'),
+		}),
+		options: z.object({
+			confirm: z.boolean().optional().describe('Skip confirmation prompts'),
+		}),
+	},
 
 	async handler(ctx) {
-		const { logger } = ctx;
-		logger.info('TODO: Implement project delete functionality');
+		const { args, opts, config } = ctx;
+
+		const apiUrl = getAPIBaseURL(config);
+		const client = new APIClient(apiUrl, config);
+
+		const skipConfirm = opts?.confirm === true;
+
+		if (!process.stdout.isTTY && !skipConfirm) {
+			tui.fatal('no TTY and --confirm is false');
+		}
+
+		if (!skipConfirm) {
+			const ok = await tui.confirm('Are you sure you want to delete', false);
+			if (!ok) {
+				return;
+			}
+		}
+
+		const deleted = await tui.spinner('Deleting project', async () => {
+			const val = await projectDelete(client!, args.id);
+			if (val.length === 1 && val[0] === args.id) {
+				return true;
+			}
+			return false;
+		});
+
+		if (deleted) {
+			tui.success(`Project ${args.id} deleted`);
+		} else {
+			tui.warning(`${args.id} not found`);
+		}
 	},
 });

package/src/cmd/project/download.ts

@@ -225,6 +225,23 @@ export async function setupProject(options: SetupOptions): Promise<void> {
 			clearOnSuccess: true,
 		});
 
+		// Configure git user in CI environments (where git config may not be set)
+		if (process.env.CI) {
+			await tui.runCommand({
+				command: 'git config user.email',
+				cwd: dest,
+				cmd: ['git', 'config', 'user.email', 'agentuity@example.com'],
+				clearOnSuccess: true,
+			});
+
+			await tui.runCommand({
+				command: 'git config user.name',
+				cwd: dest,
+				cmd: ['git', 'config', 'user.name', 'Agentuity'],
+				clearOnSuccess: true,
+			});
+		}
+
 		// Add all files
 		await tui.runCommand({
 			command: 'git add .',

package/src/cmd/project/list.ts

@@ -1,13 +1,44 @@
+import { z } from 'zod';
 import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectList } from '@agentuity/server';
+import { getAPIBaseURL, APIClient } from '../../api';
 
 export const listSubcommand = createSubcommand({
 	name: 'list',
 	description: 'List all projects',
 	aliases: ['ls'],
 	requiresAuth: true,
+	schema: {
+		options: z.object({
+			format: z
+				.enum(['json', 'table'])
+				.optional()
+				.describe('the output format: json, table (default)'),
+		}),
+	},
 
 	async handler(ctx) {
-		const { logger } = ctx;
-		logger.info('TODO: Implement project list functionality');
+		const { config, opts } = ctx;
+
+		const apiUrl = getAPIBaseURL(config);
+		const client = new APIClient(apiUrl, config);
+
+		const projects = await tui.spinner('Fetching projects', () => {
+			return projectList(client!);
+		});
+
+		// TODO: might want to sort by the last org_id we used
+		if (projects) {
+			projects.sort((a, b) => {
+				return a.name.localeCompare(b.name);
+			});
+		}
+
+		if (opts?.format === 'json') {
+			console.log(JSON.stringify(projects, null, 2));
+		} else {
+			console.table(projects, ['id', 'name', 'orgName']);
+		}
 	},
 });