@agentuity/cli 0.0.47 → 0.0.49

package/src/cmd/env/set.ts

@@ -11,15 +11,29 @@ import {
 } from '../../env-util';
 import { getCommand } from '../../command-prefix';
 
+const EnvSetResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	key: z.string().describe('Environment variable key'),
+	path: z.string().describe('Local file path where env var was saved'),
+});
+
 export const setSubcommand = createSubcommand({
 	name: 'set',
 	description: 'Set an environment variable',
+	tags: ['mutating', 'updates-resource', 'slow', 'requires-auth', 'requires-project'],
+	idempotent: true,
 	requires: { auth: true, project: true, apiClient: true },
+	examples: [
+		getCommand('env set NODE_ENV production'),
+		getCommand('env set PORT 3000'),
+		getCommand('env set LOG_LEVEL debug'),
+	],
 	schema: {
 		args: z.object({
 			key: z.string().describe('the environment variable key'),
 			value: z.string().describe('the environment variable value'),
 		}),
+		response: EnvSetResponseSchema,
 	},
 
 	async handler(ctx) {
@@ -45,7 +59,11 @@ export const setSubcommand = createSubcommand({
 				tui.info(
 					`Cancelled. Use "${getCommand('secret set')}" to store this as a secret instead.`
 				);
-				return;
+				return {
+					success: false,
+					key: args.key,
+					path: '',
+				};
 			}
 		}
 
@@ -67,5 +85,11 @@ export const setSubcommand = createSubcommand({
 		await writeEnvFile(envFilePath, filteredEnv);
 
 		tui.success(`Environment variable '${args.key}' set successfully (cloud + ${envFilePath})`);
+
+		return {
+			success: true,
+			key: args.key,
+			path: envFilePath,
+		};
 	},
 });

package/src/cmd/index.ts

@@ -22,7 +22,8 @@ export async function discoverCommands(): Promise<CommandDefinition[]> {
 					if (cmd.subcommands) {
 						for (const subcommand of cmd.subcommands) {
 							if (subcommand.toplevel) {
-								const alias: CommandDefinition = {
+								// eslint-disable-next-line @typescript-eslint/no-explicit-any
+								const alias: any = {
 									name: subcommand.name,
 									description: subcommand.description,
 									aliases: subcommand.aliases,
@@ -31,8 +32,14 @@ export async function discoverCommands(): Promise<CommandDefinition[]> {
 									optional: subcommand.optional,
 									schema: subcommand.schema,
 									handler: subcommand.handler,
+									// eslint-disable-next-line @typescript-eslint/no-explicit-any
+									idempotent: (subcommand as any).idempotent,
+									// eslint-disable-next-line @typescript-eslint/no-explicit-any
+									prerequisites: (subcommand as any).prerequisites,
+									// eslint-disable-next-line @typescript-eslint/no-explicit-any
+									tags: (subcommand as any).tags,
 								};
-								commands.push(alias);
+								commands.push(alias as CommandDefinition);
 							}
 						}
 					}

package/src/cmd/kv/create-namespace.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { createCommand } from '../../types';
+import * as tui from '../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../command-prefix';
+
+export const createNamespaceSubcommand = createCommand({
+	name: 'create-namespace',
+	aliases: ['create'],
+	description: 'Create a new keyvalue namespace',
+	tags: ['mutating', 'creates-resource', 'slow', 'requires-auth'],
+	idempotent: false,
+	requires: { auth: true, project: true },
+	examples: [
+		`${getCommand('kv create-namespace production')} - Create production namespace`,
+		`${getCommand('kv create staging')} - Create staging namespace (using alias)`,
+		`${getCommand('kv create cache')} - Create cache namespace`,
+	],
+	schema: {
+		args: z.object({
+			name: z.string().min(1).max(64).describe('the namespace name'),
+		}),
+		response: z.object({
+			success: z.boolean().describe('Whether the operation succeeded'),
+			namespace: z.string().describe('Namespace name'),
+			message: z.string().optional().describe('Success message'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args } = ctx;
+		const kv = await createStorageAdapter(ctx);
+
+		await kv.createNamespace(args.name);
+		tui.success(`Namespace ${tui.bold(args.name)} created`);
+
+		return {
+			success: true,
+			namespace: args.name,
+			message: `Namespace ${args.name} created`,
+		};
+	},
+});
+
+export default createNamespaceSubcommand;

package/src/cmd/kv/delete-namespace.ts

@@ -0,0 +1,73 @@
+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 keyvalue namespace and all its keys',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth', 'requires-project'],
+	idempotent: true,
+	requires: { auth: true, project: true },
+	examples: [
+		`${getCommand('kv delete-namespace staging')} - Delete staging namespace (interactive)`,
+		`${getCommand('kv rm-namespace cache --confirm')} - Delete cache without confirmation`,
+		`${getCommand('kv delete-namespace production --confirm')} - Force delete production`,
+	],
+	schema: {
+		args: z.object({
+			name: z.string().min(1).max(64).describe('the namespace name'),
+			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 } = ctx;
+		const kv = await createStorageAdapter(ctx);
+
+		if (!args.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 keys.`);
+			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 kv.deleteNamespace(args.name);
+		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/kv/delete.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { createCommand } from '../../types';
+import * as tui from '../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../command-prefix';
+
+const KVDeleteResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	namespace: z.string().describe('Namespace name'),
+	key: z.string().describe('Key name'),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+});
+
+export const deleteSubcommand = createCommand({
+	name: 'delete',
+	aliases: ['del', 'rm', 'remove'],
+	description: 'Delete a key from the keyvalue storage',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, project: true },
+	examples: [
+		`${getCommand('kv delete production user:123')} - Delete user data`,
+		`${getCommand('kv delete cache session:abc')} - Delete cached session`,
+		`${getCommand('kv rm staging cache:homepage')} - Delete homepage cache (using alias)`,
+	],
+	schema: {
+		args: z.object({
+			namespace: z.string().min(1).describe('the namespace name'),
+			key: z.string().min(1).describe('the key name'),
+		}),
+		response: KVDeleteResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args } = ctx;
+		const started = Date.now();
+		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`);
+
+		return {
+			success: true,
+			namespace: args.namespace,
+			key: args.key,
+			durationMs,
+		};
+	},
+});
+
+export default deleteSubcommand;

package/src/cmd/kv/get.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { createCommand } from '../../types';
+import * as tui from '../../tui';
+import { tryParseJSON } from '../../json';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../command-prefix';
+
+const KVGetResponseSchema = z.object({
+	exists: z.boolean().describe('Whether the key exists'),
+	data: z.union([z.string(), z.any()]).optional().describe('Value data (string or binary)'),
+	contentType: z.string().optional().describe('Content type'),
+});
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	description: 'Get a value from the keyvalue storage',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, project: true },
+	examples: [
+		`${getCommand('kv get production user:123')} - Get user data`,
+		`${getCommand('kv get cache session:abc')} - Get cached session`,
+		`${getCommand('kv get staging cache:homepage')} - Get homepage cache`,
+	],
+	schema: {
+		args: z.object({
+			namespace: z.string().min(1).describe('the namespace name'),
+			key: z.string().min(1).describe('the key name'),
+		}),
+		response: KVGetResponseSchema,
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { args } = ctx;
+		const storage = await createStorageAdapter(ctx);
+		const started = Date.now();
+		const res = await storage.get(args.namespace, args.key);
+		if (res.exists) {
+			if (res.data) {
+				if (res.contentType?.includes('json')) {
+					const val = tryParseJSON(res.data as unknown as string);
+					tui.json(val);
+				} else if (res.contentType?.includes('text')) {
+					console.log(String(res.data));
+				} else {
+					const b = res.data as ArrayBuffer;
+					tui.info(`Read ${b.byteLength} bytes (${res.contentType})`);
+				}
+				tui.success(`retrieved in ${(Date.now() - started).toFixed(1)}ms (${res.contentType})`);
+			} else {
+				tui.warning(`${args.key} returned empty data for ${args.namespace}`);
+			}
+		} else {
+			tui.warning(`${args.key} does not exist in ${args.namespace}`);
+		}
+
+		return {
+			exists: res.exists,
+			data: res.data,
+			contentType: res.exists ? res.contentType : undefined,
+		};
+	},
+});
+
+export default getSubcommand;

package/src/cmd/kv/index.ts

@@ -0,0 +1,31 @@
+import { createCommand } from '../../types';
+import { createNamespaceSubcommand } from './create-namespace';
+import { deleteSubcommand } from './delete';
+import { deleteNamespaceSubcommand } from './delete-namespace';
+import { getSubcommand } from './get';
+import { keysSubcommand } from './keys';
+import { listNamespacesSubcommand } from './list-namespaces';
+import { replSubcommand } from './repl';
+import { searchSubcommand } from './search';
+import { setSubcommand } from './set';
+import { statsSubcommand } from './stats';
+
+export const command = createCommand({
+	name: 'keyvalue',
+	aliases: ['kv'],
+	description: 'Manage keyvalue storage for your projects',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	subcommands: [
+		replSubcommand,
+		getSubcommand,
+		setSubcommand,
+		deleteSubcommand,
+		statsSubcommand,
+		searchSubcommand,
+		keysSubcommand,
+		listNamespacesSubcommand,
+		createNamespaceSubcommand,
+		deleteNamespaceSubcommand,
+	],
+	requires: { auth: true, project: true },
+});

package/src/cmd/kv/keys.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { createCommand } from '../../types';
+import * as tui from '../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../command-prefix';
+
+const KVKeysResponseSchema = z.object({
+	namespace: z.string().describe('Namespace name'),
+	keys: z.array(z.string()).describe('List of keys in the namespace'),
+});
+
+export const keysSubcommand = createCommand({
+	name: 'keys',
+	aliases: ['ls', 'list'],
+	description: 'List all keys in a keyvalue namespace',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	requires: { auth: true, project: true },
+	idempotent: true,
+	examples: [
+		`${getCommand('kv keys production')} - List all keys in production`,
+		`${getCommand('kv ls cache')} - List all cached keys (using alias)`,
+		`${getCommand('kv list staging')} - List all staging keys`,
+	],
+	schema: {
+		args: z.object({
+			name: z.string().min(1).describe('the namespace name'),
+		}),
+		response: KVKeysResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args } = ctx;
+		const kv = await createStorageAdapter(ctx);
+
+		const keys = await kv.getKeys(args.name);
+
+		if (keys.length === 0) {
+			tui.info(`No keys found in namespace ${tui.bold(args.name)}`);
+			return {
+				namespace: args.name,
+				keys: [],
+			};
+		}
+
+		tui.info(`Found ${keys.length} key(s) in ${tui.bold(args.name)}:`);
+		for (const key of keys) {
+			tui.info(`  ${key}`);
+		}
+
+		return {
+			namespace: args.name,
+			keys,
+		};
+	},
+});
+
+export default keysSubcommand;

package/src/cmd/kv/list-namespaces.ts

@@ -0,0 +1,43 @@
+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 keyvalue namespaces',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, project: true },
+	examples: [
+		`${getCommand('kv list-namespaces')} - List all namespaces`,
+		`${getCommand('kv namespaces')} - List namespaces (using alias)`,
+		`${getCommand('kv ns')} - List namespaces (short alias)`,
+	],
+	schema: {
+		response: NamespaceListResponseSchema,
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const storage = await createStorageAdapter(ctx);
+		const namespaces = await storage.getNamespaces();
+
+		if (namespaces.length === 0) {
+			tui.info('No namespaces found');
+			return [];
+		}
+
+		tui.info(`Found ${namespaces.length} namespace(s):`);
+		for (const name of namespaces) {
+			tui.arrow(name);
+		}
+
+		return namespaces;
+	},
+});
+
+export default listNamespacesSubcommand;