@agentuity/cli 0.0.60 → 0.0.62

package/src/cmd/cloud/thread/get.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { threadGet, APIError } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { getCatalystAPIClient } from '../../../config';
+
+const ThreadGetResponseSchema = z.object({
+	id: z.string().describe('Thread ID'),
+	created_at: z.string().describe('Creation timestamp'),
+	updated_at: z.string().describe('Update timestamp'),
+	deleted: z.boolean().describe('Deleted status'),
+	deleted_at: z.string().nullable().describe('Deletion timestamp'),
+	deleted_by: z.string().nullable().describe('Deleted by'),
+	org_id: z.string().describe('Organization ID'),
+	project_id: z.string().describe('Project ID'),
+	user_data: z.string().nullable().optional().describe('User data as JSON'),
+});
+
+export const getSubcommand = createSubcommand({
+	name: 'get',
+	description: 'Get details about a specific thread',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	examples: [
+		{
+			command: getCommand('cloud thread get thrd_abc123xyz'),
+			description: 'Get a thread by ID',
+		},
+	],
+	requires: { auth: true },
+	idempotent: true,
+	schema: {
+		args: z.object({
+			thread_id: z.string().describe('Thread ID'),
+		}),
+		response: ThreadGetResponseSchema,
+	},
+	async handler(ctx) {
+		const { config, logger, auth, args, options } = ctx;
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+
+		try {
+			const thread = await threadGet(catalystClient, { id: args.thread_id });
+
+			const result = {
+				id: thread.id,
+				created_at: thread.created_at,
+				updated_at: thread.updated_at,
+				deleted: thread.deleted,
+				deleted_at: thread.deleted_at,
+				deleted_by: thread.deleted_by,
+				org_id: thread.org_id,
+				project_id: thread.project_id,
+				user_data: thread.user_data,
+			};
+
+			if (options.json) {
+				return result;
+			}
+
+			console.log(tui.bold('ID:          ') + thread.id);
+			console.log(tui.bold('Project:     ') + thread.project_id);
+			console.log(tui.bold('Created:     ') + new Date(thread.created_at).toLocaleString());
+			console.log(tui.bold('Updated:     ') + new Date(thread.updated_at).toLocaleString());
+			console.log(tui.bold('Deleted:     ') + (thread.deleted ? 'Yes' : 'No'));
+			if (thread.deleted_at) {
+				console.log(tui.bold('Deleted At:  ') + new Date(thread.deleted_at).toLocaleString());
+			}
+			if (thread.deleted_by) {
+				console.log(tui.bold('Deleted By:  ') + thread.deleted_by);
+			}
+			if (thread.user_data) {
+				console.log(tui.bold('User Data:   ') + thread.user_data);
+			}
+
+			return result;
+		} catch (ex) {
+			if (ex instanceof APIError && ex.status === 404) {
+				tui.fatal(`Thread ${args.thread_id} not found`, ErrorCode.RESOURCE_NOT_FOUND);
+			}
+			tui.fatal(
+				`Failed to get thread: ${ex instanceof Error ? ex.message : String(ex)}`,
+				ErrorCode.API_ERROR
+			);
+		}
+	},
+});

package/src/cmd/cloud/thread/index.ts

@@ -0,0 +1,17 @@
+import { createCommand } from '../../../types';
+import { getSubcommand } from './get';
+import { listSubcommand } from './list';
+import { deleteSubcommand } from './delete';
+import { getCommand } from '../../../command-prefix';
+
+export const threadCommand = createCommand({
+	name: 'thread',
+	description: 'Manage threads',
+	tags: ['requires-auth'],
+	examples: [
+		{ command: getCommand('cloud thread list'), description: 'List all threads' },
+		{ command: getCommand('cloud thread get <id>'), description: 'Get thread details' },
+		{ command: getCommand('cloud thread delete <id>'), description: 'Delete a thread' },
+	],
+	subcommands: [getSubcommand, listSubcommand, deleteSubcommand],
+});

package/src/cmd/cloud/thread/list.ts

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { threadList, type Thread } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { getCatalystAPIClient } from '../../../config';
+
+const ThreadListResponseSchema = z.array(
+	z.object({
+		id: z.string().describe('Thread ID'),
+		created_at: z.string().describe('Creation timestamp'),
+		updated_at: z.string().describe('Update timestamp'),
+		project_id: z.string().describe('Project ID'),
+		user_data: z.string().nullable().optional().describe('User data as JSON'),
+	})
+);
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	description: 'List recent threads',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	examples: [
+		{ command: getCommand('cloud thread list'), description: 'List 10 most recent threads' },
+		{
+			command: getCommand('cloud thread list --count=25'),
+			description: 'List 25 most recent threads',
+		},
+		{
+			command: getCommand('cloud thread list --project-id=proj_*'),
+			description: 'Filter by project',
+		},
+		{
+			command: getCommand('cloud thread list --org-id=org_*'),
+			description: 'Filter by organization',
+		},
+	],
+	aliases: ['ls'],
+	requires: { auth: true },
+	optional: { project: true },
+	idempotent: true,
+	pagination: {
+		supported: true,
+		defaultLimit: 10,
+		maxLimit: 100,
+		parameters: {
+			limit: 'count',
+		},
+	},
+	schema: {
+		options: z.object({
+			count: z.coerce
+				.number()
+				.int()
+				.min(1)
+				.max(100)
+				.default(10)
+				.describe('Number of threads to list (1–100)'),
+			orgId: z.string().optional().describe('Filter by organization ID'),
+			projectId: z.string().optional().describe('Filter by project ID'),
+		}),
+		response: ThreadListResponseSchema,
+	},
+	async handler(ctx) {
+		const { config, logger, auth, project, opts, options } = ctx;
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+
+		const projectId = opts.projectId || project?.projectId;
+		const orgId = opts.orgId;
+
+		try {
+			const threads = await threadList(catalystClient, {
+				count: opts.count,
+				orgId,
+				projectId,
+			});
+
+			const result = threads.map((t: Thread) => ({
+				id: t.id,
+				created_at: t.created_at,
+				updated_at: t.updated_at,
+				project_id: t.project_id,
+				user_data: t.user_data,
+			}));
+
+			if (options.json) {
+				return result;
+			}
+
+			if (threads.length === 0) {
+				tui.info('No threads found.');
+				return [];
+			}
+
+			const tableData = threads.map((t: Thread) => {
+				return {
+					ID: t.id,
+					Project: t.project_id,
+					Created: new Date(t.created_at).toLocaleString(),
+					Updated: new Date(t.updated_at).toLocaleString(),
+					'User Data': t.user_data
+						? t.user_data.length > 50
+							? t.user_data.substring(0, 47) + '...'
+							: t.user_data
+						: '-',
+				};
+			});
+
+			tui.table(tableData, [
+				{ name: 'ID', alignment: 'left' },
+				{ name: 'Project', alignment: 'left' },
+				{ name: 'Created', alignment: 'left' },
+				{ name: 'Updated', alignment: 'left' },
+				{ name: 'User Data', alignment: 'left' },
+			]);
+
+			return result;
+		} catch (ex) {
+			tui.fatal(
+				`Failed to list threads: ${ex instanceof Error ? ex.message : String(ex)}`,
+				ErrorCode.API_ERROR
+			);
+		}
+	},
+});

package/src/cmd/cloud/vector/delete.ts

@@ -4,7 +4,6 @@ import { ErrorCode } from '../../../errors';
 import * as tui from '../../../tui';
 import { createStorageAdapter } from './util';
 import { getCommand } from '../../../command-prefix';
-
 const VectorDeleteResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
 	namespace: z.string().describe('Namespace name'),
@@ -22,9 +21,18 @@ export const deleteSubcommand = createCommand({
 	requires: { auth: true, project: true },
 	idempotent: true,
 	examples: [
-		`${getCommand('vector delete products chair-001')} - Delete a single vector (interactive)`,
-		`${getCommand('vector rm knowledge-base doc-123 doc-456 --confirm')} - Delete multiple vectors without confirmation`,
-		`${getCommand('vector del embeddings old-profile-1 old-profile-2 --confirm')} - Bulk delete without confirmation`,
+		{
+			command: getCommand('vector delete products chair-001'),
+			description: 'Delete a single vector (interactive)',
+		},
+		{
+			command: getCommand('vector rm knowledge-base doc-123 doc-456 --confirm'),
+			description: 'Delete multiple vectors without confirmation',
+		},
+		{
+			command: getCommand('vector del embeddings old-profile-1 old-profile-2 --confirm'),
+			description: 'Bulk delete without confirmation',
+		},
 	],
 	schema: {
 		args: z.object({
@@ -51,8 +59,11 @@ export const deleteSubcommand = createCommand({
 					ErrorCode.VALIDATION_FAILED
 				);
 			}
-			const keyList = args.keys.length > 3 ? `${args.keys.slice(0, 3).join(', ')}...` : args.keys.join(', ');
-			tui.warning(`This will delete ${args.keys.length} vector(s) from ${tui.bold(args.namespace)}: ${keyList}`);
+			const keyList =
+				args.keys.length > 3 ? `${args.keys.slice(0, 3).join(', ')}...` : args.keys.join(', ');
+			tui.warning(
+				`This will delete ${args.keys.length} vector(s) from ${tui.bold(args.namespace)}: ${keyList}`
+			);
 			const confirm = await new Promise<boolean>((resolve) => {
 				process.stdout.write('Are you sure? (yes/no): ');
 				process.stdin.once('data', (data) => {

package/src/cmd/cloud/vector/get.ts

@@ -3,7 +3,6 @@ import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
 import { createStorageAdapter } from './util';
 import { getCommand } from '../../../command-prefix';
-
 const VectorGetResponseSchema = z.object({
 	exists: z.boolean().describe('Whether the vector exists'),
 	key: z.string().optional().describe('Vector key'),
@@ -20,9 +19,18 @@ export const getSubcommand = createCommand({
 	requires: { auth: true, project: true },
 	idempotent: true,
 	examples: [
-		`${getCommand('vector get products chair-001')} - Get a specific product vector`,
-		`${getCommand('vector get knowledge-base doc-123')} - Get a document from knowledge base`,
-		`${getCommand('vector get embeddings user-profile-456')} - Get user profile embedding`,
+		{
+			command: getCommand('vector get products chair-001'),
+			description: 'Get a specific product vector',
+		},
+		{
+			command: getCommand('vector get knowledge-base doc-123'),
+			description: 'Get a document from knowledge base',
+		},
+		{
+			command: getCommand('vector get embeddings user-profile-456'),
+			description: 'Get user profile embedding',
+		},
 	],
 	schema: {
 		args: z.object({

package/src/cmd/cloud/vector/index.ts

@@ -2,12 +2,20 @@ import { createCommand } from '../../../types';
 import { deleteSubcommand } from './delete';
 import { getSubcommand } from './get';
 import { searchSubcommand } from './search';
+import { getCommand } from '../../../command-prefix';
 
 export const vectorCommand = createCommand({
 	name: 'vector',
 	aliases: ['vec'],
 	description: 'Manage vector storage for your projects',
 	tags: ['requires-auth', 'destructive', 'deletes-resource', 'slow'],
+	examples: [
+		{
+			command: getCommand('cloud vector search "query text"'),
+			description: 'Search vector storage',
+		},
+		{ command: getCommand('cloud vec get <id>'), description: 'Get vector by ID' },
+	],
 	subcommands: [searchSubcommand, getSubcommand, deleteSubcommand],
 	requires: { auth: true, project: true },
 });

package/src/cmd/cloud/vector/search.ts

@@ -3,7 +3,6 @@ import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
 import { createStorageAdapter } from './util';
 import { getCommand } from '../../../command-prefix';
-
 const VectorSearchResultSchema = z.object({
 	id: z.string().describe('Vector ID'),
 	key: z.string().describe('Vector key'),
@@ -26,11 +25,26 @@ export const searchSubcommand = createCommand({
 	requires: { auth: true, project: true },
 	idempotent: true,
 	examples: [
-		`${getCommand('vector search products "comfortable office chair"')} - Search for similar products`,
-		`${getCommand('vector list knowledge-base "machine learning"')} - Search knowledge base`,
-		`${getCommand('vector search docs "API documentation" --limit 5')} - Limit results`,
-		`${getCommand('vector search products "ergonomic" --similarity 0.8')} - Set minimum similarity`,
-		`${getCommand('vector ls embeddings "neural networks" --metadata category=ai')} - Filter by metadata`,
+		{
+			command: getCommand('vector search products "comfortable office chair"'),
+			description: 'Search for similar products',
+		},
+		{
+			command: getCommand('vector list knowledge-base "machine learning"'),
+			description: 'Search knowledge base',
+		},
+		{
+			command: getCommand('vector search docs "API documentation" --limit 5'),
+			description: 'Limit results',
+		},
+		{
+			command: getCommand('vector search products "ergonomic" --similarity 0.8'),
+			description: 'Set minimum similarity',
+		},
+		{
+			command: getCommand('vector ls embeddings "neural networks" --metadata category=ai'),
+			description: 'Filter by metadata',
+		},
 	],
 	schema: {
 		args: z.object({

package/src/cmd/dev/agents.ts

@@ -3,6 +3,7 @@ import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { APIResponseSchema } from '@agentuity/server';
 import { abbreviate, abbreviateDescription } from '../../utils/format';
+import { getCommand } from '../../command-prefix';
 
 const AgentSchema = z.object({
 	id: z.string(),
@@ -35,6 +36,10 @@ const AgentsResponseSchema = APIResponseSchema(z.array(AgentSchema));
 export const agentsSubcommand = createSubcommand({
 	name: 'agents',
 	description: 'Show devmode agent results',
+	examples: [
+		{ command: getCommand('dev agents'), description: 'Show all development mode agents' },
+		{ command: getCommand('dev agents --verbose'), description: 'Show agents with full details' },
+	],
 	requires: { auth: true, apiClient: true, project: true },
 	schema: {
 		options: z.object({
@@ -88,7 +93,7 @@ export const agentsSubcommand = createSubcommand({
 			if (agents.length === 0) {
 				tui.muted('No agents found');
 			} else {
-				console.table(
+				tui.table(
 					agents.map((agent) => ({
 						name: agent.name,
 						id: verbose ? agent.id : abbreviate(agent.id, 20),
@@ -107,7 +112,7 @@ export const agentsSubcommand = createSubcommand({
 				for (const agent of agents) {
 					if (agent.evals.length > 0) {
 						console.log(`\n  Evals for ${agent.name}:`);
-						console.table(
+						tui.table(
 							agent.evals.map((evalItem) => ({
 								name: evalItem.name,
 								id: verbose ? evalItem.id : abbreviate(evalItem.id, 20),

package/src/cmd/dev/api.ts

@@ -1,6 +1,7 @@
 import { APIResponseSchema } from '@agentuity/server';
 import { z } from 'zod';
 import type { APIClient } from '../../api';
+import { StructuredError } from '@agentuity/core';
 
 const DevmodeRequestSchema = z.object({
 	hostname: z.string().optional().describe('the hostname for the endpoint'),
@@ -17,6 +18,8 @@ export type DevmodeResponse = z.infer<typeof DevmodeResponseSchema>;
 const DevmodeResponseAPISchema = APIResponseSchema(DevmodeResponseSchema);
 type DevmodeResponseAPI = z.infer<typeof DevmodeResponseAPISchema>;
 
+const DevmodeEndpointError = StructuredError('DevmodeEndpointError');
+
 /**
  * Generate an Endpoint ID and Hostname
  *
@@ -39,7 +42,7 @@ export async function generateEndpoint(
 	);
 
 	if (!resp.success) {
-		throw new Error(resp.message);
+		throw new DevmodeEndpointError({ message: resp.message });
 	}
 
 	return resp.data;

package/src/cmd/dev/index.ts

@@ -22,20 +22,28 @@ import { getDevmodeDeploymentId } from '../build/ast';
 import { BuildMetadata } from '@agentuity/server';
 import { getCommand } from '../../command-prefix';
 
+const shouldDisableInteractive = (interactive?: boolean) => {
+	if (!interactive) {
+		return true;
+	}
+	return process.env.TERM_PROGRAM === 'vscode';
+};
+
 export const command = createCommand({
 	name: 'dev',
 	description: 'Build and run the development server',
 	tags: ['mutating', 'slow', 'requires-project'],
 	idempotent: true,
 	examples: [
-		getCommand('dev'),
-		getCommand('dev --port 8080'),
-		getCommand('dev --local'),
-		getCommand('dev --no-public'),
+		{ command: getCommand('dev'), description: 'Start development server' },
+		{ command: getCommand('dev --port 8080'), description: 'Specify custom port' },
+		{ command: getCommand('dev --local'), description: 'Run in local mode' },
+		{ command: getCommand('dev --no-public'), description: 'Disable public URL' },
 	],
 	schema: {
 		options: z.object({
 			local: z.boolean().optional().describe('Turn on local services (instead of cloud)'),
+			interactive: z.boolean().default(true).optional().describe('Turn on interactive mode'),
 			public: z
 				.boolean()
 				.optional()
@@ -66,6 +74,8 @@ export const command = createCommand({
 		const mustHaves = [join(rootDir, 'package.json'), appTs, srcDir];
 		const missing: string[] = [];
 
+		const interactive = !shouldDisableInteractive(opts.interactive);
+
 		for (const filename of mustHaves) {
 			if (!existsSync(filename)) {
 				missing.push(filename);
@@ -137,7 +147,8 @@ export const command = createCommand({
 			}
 		}
 
-		const canDoInput = !!(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI);
+		const canDoInput =
+			interactive && !!(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI);
 
 		const devmodebody =
 			tui.muted(tui.padRight('Local:', 10)) +

package/src/cmd/help/index.ts

@@ -0,0 +1,40 @@
+import { createCommand } from '../../types';
+import { getCommand } from '../../command-prefix';
+
+export const command = createCommand({
+	name: 'help',
+	description: 'Display help information',
+	hidden: true,
+	tags: ['read-only', 'fast'],
+	examples: [
+		{ command: getCommand('help'), description: 'Run help command' },
+		{ command: getCommand('--help'), description: 'Show help information' },
+	],
+	idempotent: true,
+
+	async handler() {
+		// Spawn the CLI with no arguments to show help
+		let spawnArgs: string[];
+
+		if (process.env.AGENTUITY_CLI_VERSION) {
+			// Compiled binary: spawn only the binary executable with no additional args
+			spawnArgs = [process.argv[0]];
+		} else {
+			// Script mode: spawn runtime and script, omitting the 'help' argument
+			spawnArgs = [process.argv[0], ...(process.argv.length > 1 ? [process.argv[1]] : [])];
+		}
+
+		const proc = Bun.spawn(spawnArgs, {
+			stdio: ['inherit', 'inherit', 'inherit'],
+			env: process.env,
+		});
+
+		const exitCode = await proc.exited;
+
+		if (exitCode !== 0) {
+			throw new Error(`Help command exited with code ${exitCode}`);
+		}
+
+		return undefined;
+	},
+});

package/src/cmd/index.ts

@@ -8,6 +8,7 @@ export async function discoverCommands(): Promise<CommandDefinition[]> {
 		import('./build').then((m) => m.command),
 		import('./cloud').then((m) => m.command),
 		import('./dev').then((m) => m.command),
+		import('./help').then((m) => m.command),
 		import('./profile').then((m) => m.command),
 		import('./project').then((m) => m.command),
 		import('./repl').then((m) => m.command),

package/src/cmd/profile/create.ts

@@ -24,9 +24,9 @@ export const createCommand = createSubcommand({
 	aliases: ['new'],
 	idempotent: false,
 	examples: [
-		getCommand('profile create production'),
-		getCommand('profile create staging --switch'),
-		getCommand('profile create development'),
+		{ command: getCommand('profile create production'), description: 'Create new item' },
+		{ command: getCommand('profile create staging --switch'), description: 'Use switch option' },
+		{ command: getCommand('profile create development'), description: 'Create new item' },
 	],
 	schema: {
 		args: z

package/src/cmd/profile/delete.ts

@@ -13,9 +13,12 @@ export const deleteCommand = createSubcommand({
 	idempotent: false,
 	aliases: ['remove', 'rm', 'del'],
 	examples: [
-		getCommand('profile delete staging'),
-		getCommand('profile delete old-dev --confirm'),
-		getCommand('profile delete'),
+		{ command: getCommand('profile delete staging'), description: 'Delete item' },
+		{
+			command: getCommand('profile delete old-dev --confirm'),
+			description: 'Use confirm option',
+		},
+		{ command: getCommand('profile delete'), description: 'Delete item' },
 	],
 	schema: {
 		args: z.object({

package/src/cmd/profile/index.ts

@@ -4,11 +4,19 @@ import { useCommand } from './use';
 import { listCommand } from './list';
 import { showCommand } from './show';
 import { deleteCommand } from './delete';
+import { getCommand } from '../../command-prefix';
 
 export const command = createCommand({
 	name: 'profile',
 	description: 'Manage configuration profiles',
 	tags: ['read-only', 'fast'],
 	hidden: true,
+	examples: [
+		{ command: getCommand('profile list'), description: 'List all profiles' },
+		{
+			command: getCommand('profile use production'),
+			description: 'Switch to production profile',
+		},
+	],
 	subcommands: [createProfileCmd, useCommand, listCommand, showCommand, deleteCommand],
 });

package/src/cmd/profile/list.ts

@@ -19,7 +19,10 @@ export const listCommand = createSubcommand({
 	tags: ['read-only', 'fast'],
 	idempotent: true,
 	aliases: ['ls'],
-	examples: [getCommand('profile list'), getCommand('profile ls')],
+	examples: [
+		{ command: getCommand('profile list'), description: 'List items' },
+		{ command: getCommand('profile ls'), description: 'List items' },
+	],
 	schema: {
 		response: ProfileListResponseSchema,
 	},

package/src/cmd/profile/show.ts

@@ -14,9 +14,12 @@ export const showCommand = createSubcommand({
 	tags: ['read-only', 'fast'],
 	aliases: ['current'],
 	examples: [
-		getCommand('profile show'),
-		getCommand('profile show production'),
-		getCommand('profile show staging --json'),
+		{ command: getCommand('profile show'), description: 'Show details' },
+		{ command: getCommand('profile show production'), description: 'Show details' },
+		{
+			command: getCommand('profile show staging --json'),
+			description: 'Show output in JSON format',
+		},
 	],
 	schema: {
 		args: z

package/src/cmd/profile/use.ts

@@ -11,9 +11,18 @@ export const useCommand = createSubcommand({
 	aliases: ['switch'],
 	idempotent: true,
 	examples: [
-		getCommand('profile use production'),
-		getCommand('profile switch staging'),
-		getCommand('profile use'),
+		{
+			command: getCommand('profile use production'),
+			description: 'Switch to the "production" profile',
+		},
+		{
+			command: getCommand('profile switch staging'),
+			description: 'Switch to the "staging" profile',
+		},
+		{
+			command: getCommand('profile use'),
+			description: 'Show interactive profile selection menu',
+		},
 	],
 	schema: {
 		args: z.object({

package/src/cmd/project/create.ts

@@ -24,11 +24,17 @@ export const createProjectSubcommand = createSubcommand({
 	optional: { auth: true, org: true, region: true },
 	requires: { apiClient: true },
 	examples: [
-		getCommand('project create'),
-		getCommand('project create --name my-ai-agent'),
-		getCommand('project create --name customer-service-bot --dir ~/projects/agent'),
-		getCommand('project create --template basic --no-install'),
-		getCommand('project new --no-register'),
+		{ command: getCommand('project create'), description: 'Create new item' },
+		{ command: getCommand('project create --name my-ai-agent'), description: 'Create new item' },
+		{
+			command: getCommand('project create --name customer-service-bot --dir ~/projects/agent'),
+			description: 'Create new item',
+		},
+		{
+			command: getCommand('project create --template basic --no-install'),
+			description: 'Use no install option',
+		},
+		{ command: getCommand('project new --no-register'), description: 'Use no register option' },
 	],
 	schema: {
 		options: z.object({