@agentuity/cli 0.0.56 → 0.0.57

package/src/cmd/build/ast.ts

@@ -3,6 +3,11 @@ import { basename, dirname, relative } from 'node:path';
 import { generate } from 'astring';
 import type { BuildMetadata } from '../../types';
 import { createLogger } from '@agentuity/server';
+import * as ts from 'typescript';
+import type { WorkbenchConfig } from '@agentuity/core';
+import type { LogLevel } from '../../types';
+
+const logger = createLogger((process.env.AGENTUITY_LOG_LEVEL || 'info') as LogLevel);
 
 interface ASTNode {
 	type: string;
@@ -925,14 +930,6 @@ export async function parseRoute(
 	return routes;
 }
 
-/**
- * Configuration extracted from createWorkbench call
- */
-export interface WorkbenchConfig {
-	route: string;
-	headers?: Record<string, string>;
-}
-
 /**
  * Result of workbench analysis
  */
@@ -949,15 +946,14 @@ export interface WorkbenchAnalysis {
  * @param functionName - The function name to check for (e.g., 'createWorkbench')
  * @returns true if the function is both imported and called
  */
-export async function checkFunctionUsage(content: string, functionName: string): Promise<boolean> {
+export function checkFunctionUsage(content: string, functionName: string): boolean {
 	try {
-		const ts = await import('typescript');
 		const sourceFile = ts.createSourceFile('temp.ts', content, ts.ScriptTarget.Latest, true);
 
 		let hasImport = false;
 		let hasUsage = false;
 
-		function visitNode(node: import('typescript').Node): void {
+		function visitNode(node: ts.Node): void {
 			// Check for import declarations with the function
 			if (ts.isImportDeclaration(node) && node.importClause?.namedBindings) {
 				if (ts.isNamedImports(node.importClause.namedBindings)) {
@@ -983,7 +979,7 @@ export async function checkFunctionUsage(content: string, functionName: string):
 		return hasImport && hasUsage;
 	} catch (error) {
 		// Fallback to string check if AST parsing fails
-		console.warn(`AST parsing failed for ${functionName}, falling back to string check:`, error);
+		logger.warn(`AST parsing failed for ${functionName}, falling back to string check:`, error);
 		return content.includes(functionName);
 	}
 }
@@ -991,17 +987,13 @@ export async function checkFunctionUsage(content: string, functionName: string):
 /**
  * Check if app.ts contains conflicting routes for a given endpoint
  */
-export async function checkRouteConflicts(
-	content: string,
-	workbenchEndpoint: string
-): Promise<boolean> {
+export function checkRouteConflicts(content: string, workbenchEndpoint: string): boolean {
 	try {
-		const ts = await import('typescript');
 		const sourceFile = ts.createSourceFile('app.ts', content, ts.ScriptTarget.Latest, true);
 
 		let hasConflict = false;
 
-		function visitNode(node: import('typescript').Node): void {
+		function visitNode(node: ts.Node): void {
 			// Check for router.get calls
 			if (
 				ts.isCallExpression(node) &&
@@ -1033,16 +1025,15 @@ export async function checkRouteConflicts(
  * @param content - The TypeScript source code
  * @returns workbench analysis including usage and config
  */
-export async function analyzeWorkbench(content: string): Promise<WorkbenchAnalysis> {
+export function analyzeWorkbench(content: string): WorkbenchAnalysis {
 	try {
-		const ts = await import('typescript');
 		const sourceFile = ts.createSourceFile('app.ts', content, ts.ScriptTarget.Latest, true);
 
 		let hasImport = false;
 		let hasUsage = false;
 		let config: WorkbenchConfig | null = null;
 
-		function visitNode(node: import('typescript').Node): void {
+		function visitNode(node: ts.Node): void {
 			// Check for import declarations with createWorkbench
 			if (ts.isImportDeclaration(node) && node.importClause?.namedBindings) {
 				if (ts.isNamedImports(node.importClause.namedBindings)) {
@@ -1062,7 +1053,7 @@ export async function analyzeWorkbench(content: string): Promise<WorkbenchAnalys
 					// Extract configuration from the first argument (if any)
 					if (node.arguments.length > 0) {
 						const configArg = node.arguments[0];
-						config = parseConfigObject(configArg, ts);
+						config = parseConfigObject(configArg);
 					} else {
 						// Default config if no arguments provided
 						config = { route: '/workbench' };
@@ -1087,7 +1078,7 @@ export async function analyzeWorkbench(content: string): Promise<WorkbenchAnalys
 		};
 	} catch (error) {
 		// Fallback to simple check if AST parsing fails
-		console.warn('Workbench AST parsing failed, falling back to string check:', error);
+		logger.warn('Workbench AST parsing failed, falling back to string check:', error);
 		const hasWorkbench = content.includes('createWorkbench');
 		return {
 			hasWorkbench,
@@ -1099,10 +1090,7 @@ export async function analyzeWorkbench(content: string): Promise<WorkbenchAnalys
 /**
  * Parse a TypeScript object literal to extract configuration
  */
-function parseConfigObject(
-	node: import('typescript').Node,
-	ts: typeof import('typescript')
-): WorkbenchConfig | null {
+function parseConfigObject(node: ts.Node): WorkbenchConfig | null {
 	if (!ts.isObjectLiteralExpression(node)) {
 		return { route: '/workbench' }; // Default config
 	}

package/src/cmd/build/bundler.ts

@@ -1,6 +1,6 @@
 import { $ } from 'bun';
+import { z } from 'zod';
 import { join, relative, resolve, dirname } from 'node:path';
-import { createRequire } from 'node:module';
 import { cpSync, existsSync, mkdirSync, rmSync } from 'node:fs';
 import gitParseUrl from 'git-url-parse';
 import AgentuityBundler, { getBuildMetadata } from './plugin';
@@ -10,8 +10,37 @@ import type { Project } from '../../types';
 import { fixDuplicateExportsInDirectory } from './fix-duplicate-exports';
 import { createLogger } from '@agentuity/server';
 import type { LogLevel } from '../../types';
+import { generateWorkbenchMainTsx, generateWorkbenchIndexHtml } from './workbench-templates';
+import { analyzeWorkbench } from './ast';
+import { encodeWorkbenchConfig } from '@agentuity/core';
 
-export interface BundleOptions {
+export const DeployOptionsSchema = z.object({
+	tag: z
+		.array(z.string())
+		.default(['latest'])
+		.optional()
+		.describe('One or more tags to add to the deployment'),
+	logsUrl: z.url().optional().describe('The url to the CI build logs'),
+	trigger: z
+		.enum(['cli', 'workflow', 'webhook'])
+		.default('cli')
+		.optional()
+		.describe('The trigger that caused the build'),
+	commitUrl: z.url().optional().describe('The url to the CI commit'),
+	provider: z.string().optional().describe('The CI provider name (attempts to autodetect)'),
+	event: z
+		.enum(['pull_request', 'push', 'manual', 'workflow'])
+		.default('manual')
+		.optional()
+		.describe('The event that triggered the deployment'),
+	pullRequestNumber: z.number().optional().describe('the pull request number'),
+	pullRequestCommentId: z.string().optional().describe('the pull request comment id'),
+	pullRequestURL: z.url().optional().describe('the pull request url'),
+});
+
+type DeployOptions = z.infer<typeof DeployOptionsSchema>;
+
+export interface BundleOptions extends DeployOptions {
 	rootDir: string;
 	dev?: boolean;
 	env?: Map<string, string>;
@@ -30,6 +59,15 @@ export async function bundle({
 	rootDir,
 	project,
 	port,
+	tag,
+	logsUrl,
+	commitUrl,
+	provider,
+	trigger,
+	event,
+	pullRequestNumber,
+	pullRequestCommentId,
+	pullRequestURL,
 }: BundleOptions) {
 	const appFile = join(rootDir, 'app.ts');
 	if (!existsSync(appFile)) {
@@ -254,14 +292,12 @@ export async function bundle({
 	}
 
 	// Bundle workbench app if detected via setupWorkbench
-	const { analyzeWorkbench } = await import('./ast');
 	if (existsSync(appFile)) {
 		const appContent = await Bun.file(appFile).text();
-		const analysis = await analyzeWorkbench(appContent);
+		const analysis = analyzeWorkbench(appContent);
 
 		if (analysis.hasWorkbench) {
 			// Encode workbench config for environment variable
-			const { encodeWorkbenchConfig } = await import('@agentuity/core');
 			const config = analysis.config || { route: '/workbench', headers: {} };
 			// Add port to config (defaults to 3500 if not provided)
 			const configWithPort = { ...config, port: port || 3500 };
@@ -272,41 +308,55 @@ export async function bundle({
 			};
 			const logger = createLogger((process.env.AGENTUITY_LOG_LEVEL as LogLevel) || 'info');
 			try {
-				const projectRequire = createRequire(resolve(rootDir, 'package.json'));
-				const workbenchPkgPath = projectRequire.resolve('@agentuity/workbench/package.json');
-				const workbenchAppDir = join(dirname(workbenchPkgPath), 'src', 'app');
+				// Generate workbench files on the fly instead of using files from package
+				const tempWorkbenchDir = join(outDir, 'temp-workbench');
+				mkdirSync(tempWorkbenchDir, { recursive: true });
 
-				if (existsSync(workbenchAppDir)) {
-					const workbenchIndexFile = join(workbenchAppDir, 'index.html');
-					if (existsSync(workbenchIndexFile)) {
-						// Bundle workbench using same config as main web app
-						const workbenchBuildConfig: Bun.BuildConfig = {
-							entrypoints: [workbenchIndexFile],
-							root: workbenchAppDir,
-							outdir: join(outDir, 'workbench'),
-							define: workbenchDefine,
-							sourcemap: dev ? 'inline' : 'linked',
-							plugins: [AgentuityBundler],
-							target: 'browser',
-							format: 'esm',
-							banner: `// Generated file. DO NOT EDIT`,
-							minify: true,
-							splitting: true,
-							packages: 'bundle',
-							naming: {
-								entry: '[dir]/[name].[ext]',
-								chunk: 'workbench/chunk/[name]-[hash].[ext]',
-								asset: 'workbench/asset/[name]-[hash].[ext]',
-							},
-						};
+				// Generate files using templates
+				await Bun.write(join(tempWorkbenchDir, 'main.tsx'), generateWorkbenchMainTsx(config));
+				const workbenchIndexFile = join(tempWorkbenchDir, 'index.html');
+				await Bun.write(workbenchIndexFile, generateWorkbenchIndexHtml());
 
-						const workbenchResult = await Bun.build(workbenchBuildConfig);
-						if (workbenchResult.success) {
-							logger.debug('Workbench bundled successfully');
-						} else {
-							logger.error('Workbench bundling failed:', workbenchResult.logs.join('\n'));
-						}
+				// Bundle workbench using generated files
+				const workbenchBuildConfig: Bun.BuildConfig = {
+					entrypoints: [workbenchIndexFile],
+					root: tempWorkbenchDir,
+					outdir: join(outDir, 'workbench'),
+					define: workbenchDefine,
+					sourcemap: dev ? 'inline' : 'linked',
+					plugins: [AgentuityBundler],
+					target: 'browser',
+					format: 'esm',
+					banner: `// Generated file. DO NOT EDIT`,
+					minify: true,
+					splitting: true,
+					packages: 'bundle',
+					naming: {
+						entry: '[dir]/[name].[ext]',
+						chunk: 'workbench/chunk/[name]-[hash].[ext]',
+						asset: 'workbench/asset/[name]-[hash].[ext]',
+					},
+				};
+
+				const workbenchResult = await Bun.build(workbenchBuildConfig);
+				if (workbenchResult.success) {
+					logger.debug('Workbench bundled successfully');
+					// Clean up temp directory
+					rmSync(tempWorkbenchDir, { recursive: true, force: true });
+				} else {
+					logger.error('Workbench bundling failed. Logs:', workbenchResult.logs);
+					if (workbenchResult.logs.length === 0) {
+						logger.error('No build logs available. Checking generated files...');
+						logger.error('Temp dir exists:', await Bun.file(tempWorkbenchDir).exists());
+						logger.error('Index file exists:', await Bun.file(workbenchIndexFile).exists());
+						logger.error(
+							'Main.tsx exists:',
+							await Bun.file(join(tempWorkbenchDir, 'main.tsx')).exists()
+						);
 					}
+					// Clean up temp directory even on failure
+					rmSync(tempWorkbenchDir, { recursive: true, force: true });
+					process.exit(1);
 				}
 			} catch (error) {
 				logger.error('Failed to bundle workbench:', error);
@@ -339,7 +389,14 @@ export async function bundle({
 			repo: process.env.GITHUB_REPOSITORY
 				? gitParseUrl(process.env.GITHUB_REPOSITORY).toString('https')
 				: '',
+			provider: 'git',
 		};
+		if (process.env.GITHUB_REPOSITORY) {
+			buildmetadata.deployment.git.provider = 'github';
+		}
+		if (process.env.CI && !trigger) {
+			buildmetadata.deployment.git.trigger = 'ci';
+		}
 		// pull out the git information if we have it
 		try {
 			let gitDir = join(rootDir, '.git');
@@ -396,6 +453,61 @@ export async function bundle({
 		}
 	}
 
+	// if in gitlab CI, set defaults before user overrides
+	if (process.env.GITLAB_CI && buildmetadata?.deployment) {
+		buildmetadata.deployment.git ??= {};
+		buildmetadata.deployment.git.provider ??= 'gitlab';
+		buildmetadata.deployment.git.branch ??= process.env.CI_COMMIT_REF_NAME;
+		buildmetadata.deployment.git.commit ??= process.env.CI_COMMIT_SHA;
+		buildmetadata.deployment.git.buildUrl ??=
+			process.env.CI_JOB_URL ?? process.env.CI_PIPELINE_URL;
+	}
+
+	// configure any overrides or any that aren't detected automatically
+	if (buildmetadata?.deployment) {
+		buildmetadata.deployment.git ??= {};
+
+		// build tags: start with existing discovered tags, add defaults, then merge explicit tags
+		const tags = new Set(buildmetadata.deployment.git.tags ?? []);
+		tags.add('latest');
+		if (buildmetadata.deployment.git.branch) {
+			tags.add(buildmetadata.deployment.git.branch);
+		}
+		if (buildmetadata.deployment.git.commit) {
+			tags.add(buildmetadata.deployment.git.commit.substring(0, 7));
+		}
+		if (tag?.length && !(tag.length === 1 && tag[0] === 'latest')) {
+			for (const t of tag) {
+				tags.add(t);
+			}
+			tags.delete('latest'); // if you specify explicit tags we remove latest
+		}
+		buildmetadata.deployment.git.tags = Array.from(tags);
+
+		if (provider) {
+			buildmetadata.deployment.git.provider = provider;
+		}
+		if (logsUrl) {
+			buildmetadata.deployment.git.buildUrl = logsUrl;
+		}
+		if (commitUrl) {
+			buildmetadata.deployment.git.url = commitUrl;
+		}
+		if (trigger) {
+			buildmetadata.deployment.git.trigger = trigger;
+		}
+		if (event) {
+			buildmetadata.deployment.git.event = event;
+		}
+		if (pullRequestNumber) {
+			buildmetadata.deployment.git.pull_request = {
+				number: pullRequestNumber,
+				url: pullRequestURL,
+				commentId: pullRequestCommentId,
+			};
+		}
+	}
+
 	await Bun.write(
 		`${outDir}/package.json`,
 		JSON.stringify({ name: pkgContents.name, version: pkgContents.version }, null, 2)

package/src/cmd/build/plugin.ts

@@ -8,8 +8,8 @@ import {
 	parseEvalMetadata,
 	analyzeWorkbench,
 	checkRouteConflicts,
-	type WorkbenchConfig,
 } from './ast';
+import type { WorkbenchConfig } from '@agentuity/core';
 import { applyPatch, generatePatches } from './patch';
 import { detectSubagent } from '../../utils/detectSubagent';
 import { createLogger } from '@agentuity/server';
@@ -35,18 +35,18 @@ async function setupWorkbench(srcDir: string): Promise<WorkbenchConfig | null> {
 	const srcAppFile = join(srcDir, 'app.ts');
 
 	let appFile = '';
-	if (existsSync(rootAppFile)) {
+	if (await Bun.file(rootAppFile).exists()) {
 		appFile = rootAppFile;
-	} else if (existsSync(srcAppFile)) {
+	} else if (await Bun.file(srcAppFile).exists()) {
 		appFile = srcAppFile;
 	}
 
-	if (!appFile || !existsSync(appFile)) {
+	if (!appFile || !(await Bun.file(appFile).exists())) {
 		return null;
 	}
 
 	const appContent = await Bun.file(appFile).text();
-	const analysis = await analyzeWorkbench(appContent);
+	const analysis = analyzeWorkbench(appContent);
 
 	if (!analysis.hasWorkbench) {
 		return null;
@@ -56,7 +56,7 @@ async function setupWorkbench(srcDir: string): Promise<WorkbenchConfig | null> {
 
 	// Check for route conflicts if workbench is being used
 	if (workbenchConfig?.route) {
-		const hasConflict = await checkRouteConflicts(appContent, workbenchConfig.route);
+		const hasConflict = checkRouteConflicts(appContent, workbenchConfig.route);
 		if (hasConflict) {
 			const logger = createLogger((process.env.AGENTUITY_LOG_LEVEL as LogLevel) || 'info');
 			logger.error(`🚨 Route conflict detected!\n`);
@@ -573,8 +573,8 @@ const AgentuityBundler: BunPlugin = {
 		// Use the workbench config determined at build time
 		const route = ${JSON.stringify(workbenchConfig?.route || '/workbench')};
 
-// If using custom route, update HTML to point to absolute /workbench/ paths
-if (route !== '/workbench') {
+		// If using custom route, update HTML to point to absolute /workbench/ paths
+		if (route !== '/workbench') {
 			workbenchIndex = workbenchIndex.replace(new RegExp('src="\\\\.\\\\/workbench\\\\/', 'g'), 'src="/workbench/');
 		}
 		

package/src/cmd/build/workbench-templates.ts

@@ -0,0 +1,52 @@
+import type { WorkbenchConfig } from '@agentuity/core';
+
+export function generateWorkbenchMainTsx(config: WorkbenchConfig): string {
+	const configString = JSON.stringify(config);
+
+	return `// Generated workbench entry point
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { AgentuityProvider } from '@agentuity/react';
+import { createWorkbench, Workbench } from '@agentuity/workbench';
+import '@agentuity/workbench/styles';
+
+// Root element
+const rootElement = document.getElementById('root');
+if (!rootElement) {
+	throw new Error('Root element not found');
+}
+
+// Create workbench instance with config from bundler
+const workbenchConfig = ${configString};
+const workbench = createWorkbench(workbenchConfig);
+
+function App() {
+	return (
+		<AgentuityProvider baseUrl={window.location.origin}>
+			<div className="min-h-screen bg-background text-foreground">
+				<Workbench workbench={workbench} />
+			</div>
+		</AgentuityProvider>
+	);
+}
+
+// Render the app
+const root = createRoot(rootElement);
+root.render(<App />);
+`;
+}
+
+export function generateWorkbenchIndexHtml(): string {
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>Agentuity Workbench</title>
+</head>
+<body>
+	<div id="root"></div>
+	<script type="module" src="./main.tsx"></script>
+</body>
+</html>`;
+}

package/src/cmd/cloud/deploy.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import { join, resolve } from 'node:path';
 import { createPublicKey } from 'node:crypto';
 import { createReadStream, createWriteStream } from 'node:fs';
@@ -26,9 +27,9 @@ import {
 } from '../../env-util';
 import { zipDir } from '../../utils/zip';
 import { encryptFIPSKEMDEMStream } from '../../crypto/box';
-import { checkCustomDomainForDNS } from './domain';
+import { DeployOptionsSchema } from '../build/bundler';
 import { getCommand } from '../../command-prefix';
-import { z } from 'zod';
+import { checkCustomDomainForDNS } from './domain';
 
 const DeployResponseSchema = z.object({
 	success: z.boolean().describe('Whether deployment succeeded'),
@@ -58,17 +59,19 @@ export const deploySubcommand = createSubcommand({
 	examples: [
 		`${getCommand('cloud deploy')}                    # Deploy current project`,
 		`${getCommand('cloud deploy')} --log-level=debug  # Deploy with verbose output`,
+		`${getCommand('cloud deploy')} --tag a --tag b    # Deploy with specific tags`,
 	],
 	toplevel: true,
 	idempotent: false,
 	requires: { auth: true, project: true, apiClient: true },
 	prerequisites: ['auth login'],
 	schema: {
+		options: DeployOptionsSchema,
 		response: DeployResponseSchema,
 	},
 
 	async handler(ctx) {
-		const { project, apiClient, projectDir, config, options } = ctx;
+		const { project, apiClient, projectDir, config, options, opts } = ctx;
 
 		let deployment: Deployment | undefined;
 		let build: BuildMetadata | undefined;
@@ -171,6 +174,11 @@ export const deploySubcommand = createSubcommand({
 									orgId: deployment.orgId,
 									projectId: project.projectId,
 									project,
+									commitUrl: opts?.commitUrl,
+									logsUrl: opts?.logsUrl,
+									provider: opts?.provider,
+									trigger: opts?.trigger,
+									tag: opts?.tag,
 								});
 								build = await loadBuildMetadata(join(projectDir, '.agentuity'));
 								instructions = await projectDeploymentUpdate(

package/src/cmd/cloud/deployment/show.ts

@@ -15,7 +15,39 @@ const DeploymentShowResponseSchema = z.object({
 	tags: z.array(z.string()).describe('Deployment tags'),
 	customDomains: z.array(z.string()).optional().describe('Custom domains'),
 	cloudRegion: z.string().optional().describe('Cloud region'),
-	metadata: z.any().optional().describe('Deployment metadata'),
+	metadata: z
+		.object({
+			git: z
+				.object({
+					repo: z.string().optional(),
+					commit: z.string().optional(),
+					message: z.string().optional(),
+					branch: z.string().optional(),
+					url: z.string().optional(),
+					trigger: z.string().optional(),
+					provider: z.string().optional(),
+					event: z.string().optional(),
+					buildUrl: z.string().optional(),
+					pull_request: z
+						.object({
+							number: z.number(),
+							url: z.string().optional(),
+							commentId: z.string().optional(),
+						})
+						.optional(),
+				})
+				.optional(),
+			build: z
+				.object({
+					agentuity: z.string().optional(),
+					bun: z.string().optional(),
+					platform: z.string().optional(),
+					arch: z.string().optional(),
+				})
+				.optional(),
+		})
+		.optional()
+		.describe('Deployment metadata'),
 });
 
 export const showSubcommand = createSubcommand({
@@ -49,8 +81,6 @@ export const showSubcommand = createSubcommand({
 
 			// Skip TUI output in JSON mode
 			if (!options.json) {
-				tui.banner(`Deployment ${deployment.id}`, `State: ${deployment.state || 'unknown'}`);
-
 				console.log(tui.bold('ID:       ') + deployment.id);
 				console.log(tui.bold('Project:  ') + projectId);
 				console.log(tui.bold('State:    ') + (deployment.state || 'unknown'));
@@ -74,22 +104,35 @@ export const showSubcommand = createSubcommand({
 					console.log(tui.bold('Region:   ') + deployment.cloudRegion);
 				}
 
-				// Metadata
-				const origin = deployment.metadata?.origin;
-				if (origin?.commit) {
+				// Git metadata
+				const git = deployment.metadata?.git;
+				if (git) {
 					tui.newline();
-					tui.info('Origin Information');
-					if (origin.trigger) console.log(`  Trigger:  ${origin.trigger}`);
-					if (origin.provider) console.log(`  Provider: ${origin.provider}`);
-					if (origin.event) console.log(`  Event:    ${origin.event}`);
-					if (origin.branch) console.log(`  Branch:   ${origin.branch}`);
-
-					if (origin.commit) {
-						console.log(`  Commit:   ${origin.commit.hash}`);
-						if (origin.commit.message) console.log(`  Message:  ${origin.commit.message}`);
-						if (origin.commit.author?.name)
-							console.log(`  Author:   ${origin.commit.author.name}`);
+					tui.info('Git Information');
+					if (git.repo) console.log(`  Repo:     ${git.repo}`);
+					if (git.branch) console.log(`  Branch:   ${git.branch}`);
+					if (git.commit) console.log(`  Commit:   ${git.commit}`);
+					if (git.message) console.log(`  Message:  ${git.message}`);
+					if (git.url) console.log(`  URL:      ${git.url}`);
+					if (git.trigger) console.log(`  Trigger:  ${git.trigger}`);
+					if (git.provider) console.log(`  Provider: ${git.provider}`);
+					if (git.event) console.log(`  Event:    ${git.event}`);
+					if (git.pull_request) {
+						console.log(`  PR:       #${git.pull_request.number}`);
+						if (git.pull_request.url) console.log(`  PR URL:   ${git.pull_request.url}`);
 					}
+					if (git.buildUrl) console.log(`  Build:    ${git.buildUrl}`);
+				}
+
+				// Build metadata
+				const build = deployment.metadata?.build;
+				if (build) {
+					tui.newline();
+					tui.info('Build Information');
+					if (build.agentuity) console.log(`  Agentuity: ${build.agentuity}`);
+					if (build.bun) console.log(`  Bun:       ${build.bun}`);
+					if (build.platform) console.log(`  Platform:  ${build.platform}`);
+					if (build.arch) console.log(`  Arch:      ${build.arch}`);
 				}
 			}
 

package/src/cmd/index.ts

@@ -38,6 +38,8 @@ export async function discoverCommands(): Promise<CommandDefinition[]> {
 									prerequisites: (subcommand as any).prerequisites,
 									// eslint-disable-next-line @typescript-eslint/no-explicit-any
 									tags: (subcommand as any).tags,
+									// eslint-disable-next-line @typescript-eslint/no-explicit-any
+									examples: (subcommand as any).examples,
 								};
 								commands.push(alias as CommandDefinition);
 							}

package/src/schema-generator.ts

@@ -13,7 +13,7 @@ export interface SchemaArgument {
 
 export interface SchemaOption {
 	name: string;
-	type: 'string' | 'number' | 'boolean';
+	type: 'string' | 'number' | 'boolean' | 'array';
 	required: boolean;
 	default?: unknown;
 	description?: string;