@agentuity/cli 0.0.100 → 0.0.102

package/src/cmd/cloud/deploy.ts

@@ -6,13 +6,15 @@ import { tmpdir } from 'node:os';
 import { StructuredError } from '@agentuity/core';
 import { isRunningFromExecutable } from '../upgrade';
 import { createSubcommand } from '../../types';
+import { getUserAgent } from '../../api';
 import * as tui from '../../tui';
-import { saveProjectDir, getDefaultConfigDir } from '../../config';
+import { saveProjectDir, getDefaultConfigDir, loadProjectSDKKey } from '../../config';
 import {
 	runSteps,
 	stepSuccess,
 	stepSkipped,
 	stepError,
+	pauseStepUI,
 	type Step,
 	type StepContext,
 } from '../../steps';
@@ -40,7 +42,7 @@ import {
 import { zipDir } from '../../utils/zip';
 import { encryptFIPSKEMDEMStream } from '../../crypto/box';
 import { getCommand } from '../../command-prefix';
-import { checkCustomDomainForDNS } from './domain';
+import * as domain from '../../domain';
 import { DeployOptionsSchema } from '../../schemas/deploy';
 import { ErrorCode } from '../../errors';
 
@@ -106,6 +108,40 @@ export const deploySubcommand = createSubcommand({
 		let statusResult: DeploymentStatusResult | undefined;
 		const logs: string[] = [];
 
+		// Check for pre-created deployment from CI/Nova
+		const deploymentEnv = process.env.AGENTUITY_DEPLOYMENT;
+		let useExistingDeployment = false;
+		if (deploymentEnv) {
+			const ExistingDeploymentSchema = z.object({
+				id: z.string(),
+				orgId: z.string(),
+				publicKey: z.string(),
+			});
+			try {
+				const parsed = JSON.parse(deploymentEnv);
+				const result = ExistingDeploymentSchema.safeParse(parsed);
+				if (result.success) {
+					deployment = result.data;
+					useExistingDeployment = true;
+					logger.info(`Using existing deployment: ${result.data.id}`);
+				} else {
+					const errors = result.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join(', ');
+					logger.warn(`Invalid AGENTUITY_DEPLOYMENT schema: ${errors}`);
+				}
+			} catch (err) {
+				logger.warn(`Failed to parse AGENTUITY_DEPLOYMENT: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		}
+
+		const sdkKey = await loadProjectSDKKey(ctx.logger, ctx.projectDir);
+
+		// Ensure SDK key is present before proceeding
+		if (!sdkKey) {
+			ctx.logger.fatal(
+				'SDK key not found. Run "agentuity auth login" to authenticate or set AGENTUITY_SDK_KEY environment variable.'
+			);
+		}
+
 		try {
 			await saveProjectDir(projectDir);
 
@@ -114,24 +150,20 @@ export const deploySubcommand = createSubcommand({
 					!project.deployment?.domains?.length
 						? null
 						: {
-								label: `Validate Custom Domain${project.deployment.domains.length > 1 ? `s: ${project.deployment.domains.join(', ')}` : `: ${project.deployment.domains[0]}`}`,
+								label: `Validate Custom ${tui.plural(project.deployment.domains.length, 'Domain', 'Domains')}`,
 								run: async () => {
 									if (project.deployment?.domains?.length) {
-										const result = await checkCustomDomainForDNS(
-											project.projectId,
-											project.deployment.domains,
-											config
-										);
-										for (const r of result) {
-											if (r.success) {
-												continue;
-											}
-											if (r.message) {
-												return stepError(r.message);
-											}
-											return stepError('unknown dns error'); // shouldn't get here
+										try {
+											await domain.promptForDNS(
+												project.projectId,
+												project.deployment.domains,
+												config!,
+												() => pauseStepUI(true)
+											);
+											return stepSuccess();
+										} catch (ex) {
+											return stepError(String(ex), ex as Error);
 										}
-										return stepSuccess();
 									}
 									return stepSkipped();
 								},
@@ -176,6 +208,9 @@ export const deploySubcommand = createSubcommand({
 					{
 						label: 'Create Deployment',
 						run: async () => {
+							if (useExistingDeployment && deployment) {
+								return stepSkipped('using existing deployment');
+							}
 							try {
 								deployment = await projectDeploymentCreate(
 									apiClient,
@@ -241,10 +276,6 @@ export const deploySubcommand = createSubcommand({
 							const deploymentZip = join(tmpdir(), `${deployment.id}.zip`);
 							await zipDir(join(projectDir, '.agentuity'), deploymentZip, {
 								filter: (_filename: string, relative: string) => {
-									// Exclude Vite-specific build artifacts
-									if (relative.endsWith('.generated.ts')) {
-										return false;
-									}
 									if (relative.startsWith('.vite/')) {
 										return false;
 									}
@@ -328,6 +359,7 @@ export const deploySubcommand = createSubcommand({
 							}
 
 							progress(80);
+							let bytes = 0;
 							if (build?.assets) {
 								ctx.logger.trace(`Uploading ${build.assets.length} assets`);
 								if (!instructions.assets) {
@@ -337,9 +369,9 @@ export const deploySubcommand = createSubcommand({
 								}
 
 								// Workaround for Bun crash in compiled executables (https://github.com/agentuity/sdk/issues/191)
-								// Use limited concurrency (2 at a time) for executables to avoid parallel fetch crash
+								// Use limited concurrency (1 at a time) for executables to avoid parallel fetch crash
 								const isExecutable = isRunningFromExecutable();
-								const concurrency = isExecutable ? 2 : build.assets.length;
+								const concurrency = isExecutable ? 1 : Math.min(4, build.assets.length);
 
 								if (isExecutable) {
 									ctx.logger.trace(
@@ -361,15 +393,34 @@ export const deploySubcommand = createSubcommand({
 										}
 
 										// Asset filename already includes the subdirectory (e.g., "client/assets/main-abc123.js")
-										const file = Bun.file(join(projectDir, '.agentuity', asset.filename));
+										const filePath = join(projectDir, '.agentuity', asset.filename);
+
+										const headers: Record<string, string> = {
+											'Content-Type': asset.contentType,
+										};
+
+										bytes += asset.size;
+
+										let body: Uint8Array | Blob;
+										if (asset.contentEncoding === 'gzip') {
+											const file = Bun.file(filePath);
+											const ab = await file.arrayBuffer();
+											const gzipped = Bun.gzipSync(new Uint8Array(ab));
+											headers['Content-Encoding'] = 'gzip';
+											body = gzipped;
+											ctx.logger.trace(
+												`Compressing ${asset.filename} (${asset.size} -> ${gzipped.byteLength} bytes)`
+											);
+										} else {
+											body = Bun.file(filePath);
+										}
+
 										promises.push(
 											fetch(assetUrl, {
 												method: 'PUT',
 												duplex: 'half',
-												headers: {
-													'Content-Type': asset.contentType,
-												},
-												body: file,
+												headers,
+												body,
 											})
 										);
 									}
@@ -386,7 +437,14 @@ export const deploySubcommand = createSubcommand({
 							}
 
 							progress(100);
-							return stepSuccess();
+							const output = build?.assets.length
+								? [
+										tui.muted(
+											`✓ Uploaded ${build.assets.length} ${tui.plural(build.assets.length, 'asset', 'assets')} (${tui.formatBytes(bytes)}) to CDN`
+										),
+									]
+								: undefined;
+							return stepSuccess(output);
 						},
 					},
 					{
@@ -400,7 +458,7 @@ export const deploySubcommand = createSubcommand({
 						},
 					},
 				].filter(Boolean) as Step[],
-				options.logLevel
+				useExistingDeployment ? 'debug' : options.logLevel
 			);
 
 			if (!deployment) {
@@ -444,6 +502,10 @@ export const deploySubcommand = createSubcommand({
 										logger.debug('fetching stream: %s/%s', streamsUrl, streamId);
 										const resp = await fetch(`${streamsUrl}/${streamId}`, {
 											signal: logStreamController.signal,
+											headers: {
+												Authorization: `Bearer ${sdkKey}`,
+												'User-Agent': getUserAgent(),
+											},
 										});
 										if (!resp.ok || !resp.body) {
 											ctx.logger.trace(
@@ -607,20 +669,36 @@ export const deploySubcommand = createSubcommand({
 
 			// Show deployment URLs
 			if (complete?.publicUrls) {
+				const lines: string[] = [];
 				if (complete.publicUrls.custom?.length) {
 					for (const url of complete.publicUrls.custom) {
-						tui.arrow(tui.bold(tui.padRight('Deployment URL:', 17)) + tui.link(url));
+						lines.push(
+							`${tui.ICONS.arrow} ${tui.bold(tui.padRight('Deployment:', 12)) + tui.link(url)}`
+						);
 					}
 				} else {
-					tui.arrow(
-						tui.bold(tui.padRight('Deployment URL:', 17)) +
+					lines.push(
+						`${tui.ICONS.arrow} ${
+							tui.bold(tui.padRight('Deployment:', 12)) +
 							tui.link(complete.publicUrls.deployment)
+						}`
 					);
-					tui.arrow(
-						tui.bold(tui.padRight('Project URL:', 17)) + tui.link(complete.publicUrls.latest)
+					lines.push(
+						`${tui.ICONS.arrow} ${
+							tui.bold(tui.padRight('Project:', 12)) + tui.link(complete.publicUrls.latest)
+						}`
 					);
-					tui.arrow(tui.bold(tui.padRight('Dashboard URL:', 17)) + tui.link(dashboard));
 				}
+				lines.push(
+					`${tui.ICONS.arrow} ${
+						tui.bold(tui.padRight('Dashboard:', 12)) + tui.link(dashboard)
+					}`
+				);
+				tui.banner(`Deployment: ${tui.colorPrimary(deployment.id)}`, lines.join('\n'), {
+					centerTitle: false,
+					topSpacer: false,
+					bottomSpacer: false,
+				});
 			}
 
 			return {

package/src/cmd/cloud/keyvalue/create-namespace.ts

@@ -37,7 +37,9 @@ export const createNamespaceSubcommand = createCommand({
 		const kv = await createStorageAdapter(ctx);
 
 		await kv.createNamespace(args.name);
-		tui.success(`Namespace ${tui.bold(args.name)} created`);
+		if (!ctx.options.json) {
+			tui.success(`Namespace ${tui.bold(args.name)} created`);
+		}
 
 		return {
 			success: true,

package/src/cmd/cloud/keyvalue/delete-namespace.ts

@@ -68,7 +68,9 @@ export const deleteNamespaceSubcommand = createCommand({
 		}
 
 		await kv.deleteNamespace(args.name);
-		tui.success(`Namespace ${tui.bold(args.name)} deleted`);
+		if (!ctx.options.json) {
+			tui.success(`Namespace ${tui.bold(args.name)} deleted`);
+		}
 
 		return {
 			success: true,

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

@@ -39,7 +39,9 @@ export const deleteSubcommand = createCommand({
 		const storage = await createStorageAdapter(ctx);
 		await storage.delete(args.namespace, args.key);
 		const durationMs = Date.now() - started;
-		tui.success(`deleted in ${durationMs.toFixed(1)}ms`);
+		if (!ctx.options.json) {
+			tui.success(`deleted in ${durationMs.toFixed(1)}ms`);
+		}
 
 		return {
 			success: true,

package/src/cmd/cloud/keyvalue/set.ts

@@ -47,7 +47,7 @@ export const setSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args } = ctx;
+		const { args, options } = ctx;
 		const started = Date.now();
 		const storage = await createStorageAdapter(ctx);
 		const contentType = isPossiblyJSON(args.value) ? 'application/json' : 'text/plain';
@@ -57,7 +57,9 @@ export const setSubcommand = createCommand({
 			ttl,
 		});
 		const durationMs = Date.now() - started;
-		tui.success(`saved in ${durationMs.toFixed(1)}ms (${contentType})`);
+		if (!options.json) {
+			tui.success(`saved in ${durationMs.toFixed(1)}ms (${contentType})`);
+		}
 
 		return {
 			success: true,

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

@@ -3,13 +3,6 @@ import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
 import { createStorageAdapter } from './util';
 import { getCommand } from '../../../command-prefix';
-function formatBytes(bytes: number): string {
-	if (bytes === 0) return '0 B';
-	if (bytes < 1024) return `${bytes} B`;
-	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
-	if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-	return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
-}
 
 const GetStreamResponseSchema = z.object({
 	id: z.string().describe('Stream ID'),
@@ -70,7 +63,7 @@ export const getSubcommand = createCommand({
 				const durationMs = Date.now() - started;
 				const stats = await Bun.file(opts.output).stat();
 				tui.success(
-					`downloaded ${formatBytes(stats.size)} to ${opts.output} in ${durationMs.toFixed(1)}ms`
+					`downloaded ${tui.formatBytes(stats.size)} to ${opts.output} in ${durationMs.toFixed(1)}ms`
 				);
 
 				// Fetch stream metadata to populate the response
@@ -100,7 +93,7 @@ export const getSubcommand = createCommand({
 
 			console.log(`Name:     ${tui.bold(stream.name ?? 'unknown')}`);
 			console.log(`ID:       ${stream.id}`);
-			console.log(`Size:     ${formatBytes(sizeBytes)}`);
+			console.log(`Size:     ${tui.formatBytes(sizeBytes)}`);
 			console.log(`URL:      ${tui.link(stream.url ?? 'unknown')}`);
 			if (stream.metadata && Object.keys(stream.metadata).length > 0) {
 				console.log(`Metadata:`);

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

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import { ErrorCode } from '../../../errors';
+import * as tui from '../../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+export const deleteNamespaceSubcommand = createCommand({
+	name: 'delete-namespace',
+	aliases: ['rm-namespace'],
+	description: 'Delete a vector namespace and all its vectors',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, project: true },
+	examples: [
+		{
+			command: getCommand('vector delete-namespace staging'),
+			description: 'Delete staging namespace (interactive)',
+		},
+		{
+			command: getCommand('vector rm-namespace cache --confirm'),
+			description: 'Delete cache without confirmation',
+		},
+		{
+			command: getCommand('vector delete-namespace old-data --confirm'),
+			description: 'Force delete old-data namespace',
+		},
+	],
+	schema: {
+		args: z.object({
+			name: z.string().min(1).describe('the namespace name to delete'),
+		}),
+		options: z.object({
+			confirm: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe('if true will not prompt for confirmation'),
+		}),
+		response: z.object({
+			success: z.boolean().describe('Whether the deletion succeeded'),
+			namespace: z.string().describe('Deleted namespace name'),
+			message: z.string().optional().describe('Confirmation message'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, opts } = ctx;
+		const storage = await createStorageAdapter(ctx);
+
+		if (!opts.confirm) {
+			if (!process.stdin.isTTY) {
+				tui.fatal(
+					'No TTY and --confirm is not set. Refusing to delete',
+					ErrorCode.VALIDATION_FAILED
+				);
+			}
+			tui.warning(
+				`This will delete namespace ${tui.bold(args.name)} and ALL its vectors permanently.`
+			);
+			const confirm = await new Promise<boolean>((resolve) => {
+				process.stdout.write('Are you sure? (yes/no): ');
+				process.stdin.once('data', (data) => {
+					const answer = data.toString().trim().toLowerCase();
+					resolve(answer === 'yes' || answer === 'y');
+				});
+			});
+
+			if (!confirm) {
+				tui.info('Cancelled');
+				return { success: false, namespace: args.name, message: 'Cancelled' };
+			}
+		}
+
+		await storage.deleteNamespace(args.name);
+
+		if (!ctx.options.json) {
+			tui.success(`Namespace ${tui.bold(args.name)} deleted`);
+		}
+
+		return {
+			success: true,
+			namespace: args.name,
+			message: `Namespace ${args.name} deleted`,
+		};
+	},
+});
+
+export default deleteNamespaceSubcommand;

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

@@ -1,22 +1,39 @@
 import { createCommand } from '../../../types';
 import { deleteSubcommand } from './delete';
+import { deleteNamespaceSubcommand } from './delete-namespace';
 import { getSubcommand } from './get';
+import { listNamespacesSubcommand } from './list-namespaces';
 import { searchSubcommand } from './search';
+import { statsSubcommand } from './stats';
+import { upsertSubcommand } from './upsert';
 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'],
+	tags: ['requires-auth', 'slow'],
 	examples: [
 		{
-			command: getCommand('cloud vector search "query text"'),
+			command: getCommand('cloud vector search products "query text"'),
 			description: 'Search vector storage',
 		},
-		{ command: getCommand('cloud vec get <id>'), description: 'Get vector by ID' },
+		{
+			command: getCommand('cloud vec upsert products doc1 --document "text"'),
+			description: 'Upsert a vector',
+		},
+		{ command: getCommand('cloud vec get products doc1'), description: 'Get vector by key' },
+		{ command: getCommand('cloud vec stats'), description: 'Show namespace statistics' },
+	],
+	subcommands: [
+		upsertSubcommand,
+		searchSubcommand,
+		getSubcommand,
+		deleteSubcommand,
+		statsSubcommand,
+		listNamespacesSubcommand,
+		deleteNamespaceSubcommand,
 	],
-	subcommands: [searchSubcommand, getSubcommand, deleteSubcommand],
 	requires: { auth: true, project: true },
 });
 

package/src/cmd/cloud/vector/list-namespaces.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const NamespaceListResponseSchema = z.array(z.string().describe('Namespace name'));
+
+export const listNamespacesSubcommand = createCommand({
+	name: 'list-namespaces',
+	aliases: ['namespaces', 'ns'],
+	description: 'List all vector namespaces',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, project: true },
+	examples: [
+		{ command: getCommand('vector list-namespaces'), description: 'List all namespaces' },
+		{ command: getCommand('vector namespaces'), description: 'List namespaces (using alias)' },
+		{ command: getCommand('vector ns'), description: 'List namespaces (short alias)' },
+	],
+	schema: {
+		response: NamespaceListResponseSchema,
+	},
+	webUrl: '/services/vector',
+	idempotent: true,
+
+	async handler(ctx) {
+		const { options } = ctx;
+		const storage = await createStorageAdapter(ctx);
+		const namespaces = await storage.getNamespaces();
+
+		if (!options.json) {
+			if (namespaces.length === 0) {
+				tui.info('No vector namespaces found');
+			} else {
+				tui.info(`Found ${namespaces.length} namespace(s):`);
+				for (const name of namespaces) {
+					tui.arrow(name);
+				}
+			}
+		}
+
+		return namespaces;
+	},
+});
+
+export default listNamespacesSubcommand;

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

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const VectorItemStatsSchema = z.object({
+	embedding: z.array(z.number()).optional().describe('The embedding vector'),
+	document: z.string().optional().describe('Original document text'),
+	size: z.number().describe('Size in bytes'),
+	metadata: z.record(z.string(), z.unknown()).optional().describe('Metadata'),
+	firstUsed: z.number().describe('First access timestamp (ms)'),
+	lastUsed: z.number().describe('Last access timestamp (ms)'),
+	count: z.number().optional().describe('Access count (only available in cloud storage)'),
+});
+
+const VectorNamespaceStatsSchema = z.object({
+	sum: z.number().describe('Total size in bytes'),
+	count: z.number().describe('Number of vectors'),
+	createdAt: z.number().optional().describe('Creation timestamp (ms)'),
+	lastUsed: z.number().optional().describe('Last used timestamp (ms)'),
+});
+
+const VectorStatsResponseSchema = z.union([
+	VectorNamespaceStatsSchema.extend({
+		namespace: z.string().describe('Namespace name'),
+		sampledResults: z.record(z.string(), VectorItemStatsSchema).optional(),
+	}),
+	z.record(z.string(), VectorNamespaceStatsSchema),
+]);
+
+export const statsSubcommand = createCommand({
+	name: 'stats',
+	description: 'Get statistics for vector storage',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, project: true },
+	idempotent: true,
+	examples: [
+		{ command: getCommand('vector stats'), description: 'Show stats for all namespaces' },
+		{
+			command: getCommand('vector stats products'),
+			description: 'Show detailed stats for products namespace',
+		},
+		{ command: getCommand('vector stats embeddings'), description: 'Show stats for embeddings' },
+	],
+	schema: {
+		args: z.object({
+			name: z.string().optional().describe('the vector namespace (optional)'),
+		}),
+		response: VectorStatsResponseSchema,
+	},
+	webUrl: (ctx) =>
+		ctx.args.name ? `/services/vector/${encodeURIComponent(ctx.args.name)}` : '/services/vector',
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const storage = await createStorageAdapter(ctx);
+
+		if (args.name) {
+			const stats = await storage.getStats(args.name);
+
+			if (!options.json) {
+				if (stats.count === 0 && stats.sum === 0) {
+					tui.info(`Namespace ${tui.bold(args.name)} is empty or does not exist`);
+				} else {
+					tui.info(`Statistics for ${tui.bold(args.name)}:`);
+					tui.info(`  Vectors: ${stats.count}`);
+					const sizeDisplay =
+						stats.sum < 1024 * 1024
+							? `${stats.sum.toLocaleString()} bytes`
+							: `${(stats.sum / (1024 * 1024)).toFixed(2)} MB`;
+					tui.info(`  Total size: ${sizeDisplay}`);
+
+					if (stats.createdAt) {
+						tui.info(`  Created: ${new Date(stats.createdAt).toLocaleString()}`);
+					}
+					if (stats.lastUsed) {
+						tui.info(`  Last used: ${new Date(stats.lastUsed).toLocaleString()}`);
+					}
+
+					if (stats.sampledResults && Object.keys(stats.sampledResults).length > 0) {
+						tui.info('');
+						tui.info(`  Sample vectors (${Object.keys(stats.sampledResults).length}):`);
+
+						const tableData = Object.entries(stats.sampledResults).map(([key, item]) => {
+							const docPreview = item.document
+								? item.document.length > 30
+									? item.document.substring(0, 27) + '...'
+									: item.document
+								: '-';
+							return {
+								Key: key,
+								Size: `${item.size} bytes`,
+								Accesses: item.count ?? '-',
+								'Last Used': new Date(item.lastUsed).toLocaleDateString(),
+								Document: docPreview,
+							};
+						});
+
+						tui.table(tableData, [
+							{ name: 'Key', alignment: 'left' },
+							{ name: 'Size', alignment: 'right' },
+							{ name: 'Accesses', alignment: 'right' },
+							{ name: 'Last Used', alignment: 'left' },
+							{ name: 'Document', alignment: 'left' },
+						]);
+					}
+				}
+			}
+
+			return {
+				namespace: args.name,
+				...stats,
+			};
+		} else {
+			const allStats = await storage.getAllStats();
+			const entries = Object.entries(allStats);
+
+			if (!options.json) {
+				if (entries.length === 0) {
+					tui.info('No vector namespaces found');
+				} else {
+					tui.info(
+						`Found ${entries.length} ${tui.plural(entries.length, 'namespace', 'namespaces')}:`
+					);
+
+					const tableData = entries.map(([name, stats]) => {
+						const sizeDisplay =
+							stats.sum < 1024 * 1024
+								? `${stats.sum.toLocaleString()} bytes`
+								: `${(stats.sum / (1024 * 1024)).toFixed(2)} MB`;
+						return {
+							Namespace: name,
+							Vectors: stats.count,
+							Size: sizeDisplay,
+							Created: stats.createdAt
+								? new Date(stats.createdAt).toLocaleDateString()
+								: '-',
+							'Last Used': stats.lastUsed
+								? new Date(stats.lastUsed).toLocaleDateString()
+								: '-',
+						};
+					});
+
+					tui.table(tableData, [
+						{ name: 'Namespace', alignment: 'left' },
+						{ name: 'Vectors', alignment: 'right' },
+						{ name: 'Size', alignment: 'right' },
+						{ name: 'Created', alignment: 'left' },
+						{ name: 'Last Used', alignment: 'left' },
+					]);
+				}
+			}
+
+			return allStats;
+		}
+	},
+});
+
+export default statsSubcommand;