@agentuity/cli 1.0.22 → 1.0.24

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

@@ -0,0 +1,35 @@
+import { createCommand } from '../../../types';
+import { getSubcommand } from './get';
+import { createSubcommand } from './create';
+import { updateSubcommand } from './update';
+import { listSubcommand } from './list';
+import { statsSubcommand } from './stats';
+import { getCommand } from '../../../command-prefix';
+
+export const taskCommand = createCommand({
+	name: 'task',
+	description: 'Manage tasks for your projects',
+	tags: ['requires-auth', 'slow'],
+	examples: [
+		{
+			command: getCommand('cloud task get task_abc123'),
+			description: 'Get task details',
+		},
+		{
+			command: getCommand('cloud task create "Fix bug" --type bug --created-id agent_001'),
+			description: 'Create a new bug task',
+		},
+		{
+			command: getCommand('cloud task list --status open'),
+			description: 'List open tasks',
+		},
+		{
+			command: getCommand('cloud task update task_abc123 --status in_progress'),
+			description: 'Update task status',
+		},
+	],
+	subcommands: [getSubcommand, createSubcommand, updateSubcommand, listSubcommand, statsSubcommand],
+	requires: { auth: true },
+});
+
+export default taskCommand;

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

@@ -0,0 +1,190 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+import type { TaskPriority, TaskStatus, TaskType, Task } from '@agentuity/core';
+
+const TaskListResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	tasks: z.array(
+		z.object({
+			id: z.string(),
+			title: z.string(),
+			type: z.string(),
+			status: z.string(),
+			priority: z.string(),
+			assigned_id: z.string().optional(),
+			created_at: z.string(),
+			updated_at: z.string(),
+		})
+	),
+	total: z.number().describe('Total number of matching tasks'),
+	limit: z.number().describe('Page size'),
+	offset: z.number().describe('Page offset'),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+});
+
+const PRIORITY_COLORS: Record<string, (s: string) => string> = {
+	high: tui.colorError,
+	medium: tui.colorWarning,
+	low: tui.colorInfo,
+	none: tui.muted,
+};
+
+const STATUS_COLORS: Record<string, (s: string) => string> = {
+	open: tui.colorSuccess,
+	in_progress: tui.colorWarning,
+	closed: tui.muted,
+};
+
+function formatPriority(p: string): string {
+	const colorFn = PRIORITY_COLORS[p] ?? tui.muted;
+	return colorFn(p);
+}
+
+function formatStatus(s: string): string {
+	const colorFn = STATUS_COLORS[s] ?? tui.muted;
+	return colorFn(s);
+}
+
+function truncate(s: string, max: number): string {
+	if (s.length <= max) return s;
+	return `${s.slice(0, max - 1)}…`;
+}
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List tasks with optional filtering and sorting',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	requires: { auth: true },
+	idempotent: true,
+	pagination: {
+		supported: true,
+		defaultLimit: 50,
+		maxLimit: 100,
+		parameters: { limit: 'limit', offset: 'offset' },
+	},
+	examples: [
+		{
+			command: getCommand('cloud task list'),
+			description: 'List all tasks',
+		},
+		{
+			command: getCommand('cloud task list --status open --priority high'),
+			description: 'List open high-priority tasks',
+		},
+		{
+			command: getCommand('cloud task list --type bug --sort created_at --order asc'),
+			description: 'List bugs sorted by oldest first',
+		},
+		{
+			command: getCommand('cloud task list --assigned-id agent_001 --limit 10'),
+			description: 'List first 10 tasks assigned to an agent',
+		},
+	],
+	schema: {
+		options: z.object({
+			status: z.enum(['open', 'in_progress', 'closed']).optional().describe('filter by status'),
+			type: z
+				.enum(['epic', 'feature', 'enhancement', 'bug', 'task'])
+				.optional()
+				.describe('filter by type'),
+			priority: z
+				.enum(['high', 'medium', 'low', 'none'])
+				.optional()
+				.describe('filter by priority'),
+			assignedId: z.string().optional().describe('filter by assigned agent or user ID'),
+			parentId: z.string().optional().describe('filter by parent task ID'),
+			sort: z
+				.enum([
+					'created_at',
+					'updated_at',
+					'priority',
+					'status',
+					'title',
+					'type',
+					'open_date',
+					'in_progress_date',
+					'closed_date',
+				])
+				.optional()
+				.describe('field to sort by (default: created_at)'),
+			order: z.enum(['asc', 'desc']).optional().describe('sort order (default: desc)'),
+			limit: z.coerce.number().optional().describe('max results to return (default: 50)'),
+			offset: z.coerce.number().optional().describe('offset for pagination'),
+		}),
+		response: TaskListResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { opts, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		const result = await storage.list({
+			status: opts.status as TaskStatus | undefined,
+			type: opts.type as TaskType | undefined,
+			priority: opts.priority as TaskPriority | undefined,
+			assigned_id: opts.assignedId,
+			parent_id: opts.parentId,
+			sort: opts.sort,
+			order: opts.order,
+			limit: opts.limit,
+			offset: opts.offset,
+		});
+
+		const durationMs = Date.now() - started;
+
+		if (!options.json) {
+			if (result.tasks.length === 0) {
+				tui.info('No tasks found');
+			} else {
+				const tableData = result.tasks.map((task: Task) => ({
+					ID: tui.muted(truncate(task.id, 28)),
+					Title: truncate(task.title, 40),
+					Type: task.type,
+					Status: formatStatus(task.status),
+					Priority: formatPriority(task.priority),
+					Assigned: task.assigned_id ?? tui.muted('—'),
+					Updated: new Date(task.updated_at).toLocaleDateString(),
+				}));
+
+				tui.table(tableData, [
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Title', alignment: 'left' },
+					{ name: 'Type', alignment: 'left' },
+					{ name: 'Status', alignment: 'left' },
+					{ name: 'Priority', alignment: 'left' },
+					{ name: 'Assigned', alignment: 'left' },
+					{ name: 'Updated', alignment: 'left' },
+				]);
+
+				tui.info(
+					`Showing ${result.tasks.length} of ${result.total} ${tui.plural(result.total, 'task', 'tasks')} (${durationMs.toFixed(1)}ms)`
+				);
+			}
+		}
+
+		return {
+			success: true,
+			tasks: result.tasks.map((task: Task) => ({
+				id: task.id,
+				title: task.title,
+				type: task.type,
+				status: task.status,
+				priority: task.priority,
+				assigned_id: task.assigned_id,
+				created_at: task.created_at,
+				updated_at: task.updated_at,
+			})),
+			total: result.total,
+			limit: result.limit,
+			offset: result.offset,
+			durationMs,
+		};
+	},
+});
+
+export default listSubcommand;

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

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getGlobalCatalystAPIClient } from '../../../config';
+import { getCommand } from '../../../command-prefix';
+import { getServiceStats, type ServiceStatsData } from '@agentuity/server';
+
+function formatNumber(n: number): string {
+	if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+	if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
+	return String(n);
+}
+
+function displayStats(data: ServiceStatsData): void {
+	const svc = data.services.task;
+	if (!svc) {
+		tui.info('No task data found.');
+		return;
+	}
+	tui.header('Task Statistics');
+	tui.newline();
+	console.log(`  ${tui.muted('Total:')}           ${formatNumber(svc.total)}`);
+	console.log(`  ${tui.muted('Open:')}            ${formatNumber(svc.open)}`);
+	console.log(
+		`  ${tui.muted('In Progress:')}     ${formatNumber(svc.inProgress)}`
+	);
+	console.log(`  ${tui.muted('Closed:')}          ${formatNumber(svc.closed)}`);
+}
+
+export const statsSubcommand = createCommand({
+	name: 'stats',
+	description: 'View task statistics',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud task stats'),
+			description: 'View task statistics',
+		},
+	],
+	schema: {
+		options: z.object({
+			start: z.string().optional().describe('Start time (ISO 8601)'),
+			end: z.string().optional().describe('End time (ISO 8601)'),
+		}),
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { opts, options } = ctx;
+		const client = await getGlobalCatalystAPIClient(ctx.logger, ctx.auth, ctx.config?.name);
+		const orgId = ctx.orgId ?? ctx.options.orgId ?? ctx.config?.preferences?.orgId;
+
+		if (!orgId) {
+			ctx.logger.fatal('Organization ID is required. Use --org-id or set a preferred org.');
+			return;
+		}
+
+		const data = await getServiceStats(client, orgId, {
+			service: 'task',
+			start: opts.start,
+			end: opts.end,
+			orgIdHeader: orgId,
+		});
+
+		if (!options.json) {
+			displayStats(data);
+		}
+
+		return data;
+	},
+});
+
+export default statsSubcommand;

package/src/cmd/cloud/task/update.ts

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter, parseMetadataFlag, cacheTaskId } from './util';
+import { getCommand } from '../../../command-prefix';
+import type { TaskPriority, TaskStatus, TaskType } from '@agentuity/core';
+
+const TaskUpdateResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	task: z.object({
+		id: z.string().describe('Task ID'),
+		title: z.string().describe('Task title'),
+		type: z.string().describe('Task type'),
+		status: z.string().describe('Task status'),
+		priority: z.string().describe('Task priority'),
+		updated_at: z.string().describe('Last update timestamp'),
+	}),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+});
+
+export const updateSubcommand = createCommand({
+	name: 'update',
+	aliases: ['edit'],
+	description: 'Update an existing task',
+	tags: ['mutating', 'slow', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud task update task_abc123 --status in_progress'),
+			description: 'Move task to in-progress',
+		},
+		{
+			command: getCommand(
+				'cloud task update task_abc123 --title "Updated title" --priority high'
+			),
+			description: 'Update title and priority',
+		},
+		{
+			command: getCommand('cloud task update task_abc123 --assigned-id agent_002'),
+			description: 'Reassign a task',
+		},
+	],
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('the task ID to update'),
+		}),
+		options: z.object({
+			title: z.string().optional().describe('new task title'),
+			description: z.string().optional().describe('new task description'),
+			priority: z
+				.enum(['high', 'medium', 'low', 'none'])
+				.optional()
+				.describe('new task priority'),
+			type: z
+				.enum(['epic', 'feature', 'enhancement', 'bug', 'task'])
+				.optional()
+				.describe('new task type'),
+			status: z.enum(['open', 'in_progress', 'closed']).optional().describe('new task status'),
+			assignedId: z.string().optional().describe('new assigned agent or user ID'),
+			parentId: z.string().optional().describe('new parent task ID'),
+			closedId: z.string().optional().describe('ID of the closer (agent or user)'),
+			metadata: z.string().optional().describe('JSON metadata object'),
+		}),
+		response: TaskUpdateResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		const metadata = parseMetadataFlag(opts.metadata);
+
+		const params: Record<string, unknown> = {};
+		if (opts.title !== undefined) params.title = opts.title;
+		if (opts.description !== undefined) params.description = opts.description;
+		if (opts.priority !== undefined) params.priority = opts.priority as TaskPriority;
+		if (opts.type !== undefined) params.type = opts.type as TaskType;
+		if (opts.status !== undefined) params.status = opts.status as TaskStatus;
+		if (opts.assignedId !== undefined) params.assigned_id = opts.assignedId;
+		if (opts.parentId !== undefined) params.parent_id = opts.parentId;
+		if (opts.closedId !== undefined) params.closed_id = opts.closedId;
+		if (metadata !== undefined) params.metadata = metadata;
+
+		if (Object.keys(params).length === 0) {
+			tui.fatal('No update fields provided. Use --title, --status, --priority, etc.');
+		}
+
+		const task = await storage.update(args.id, params);
+		const durationMs = Date.now() - started;
+		await cacheTaskId(ctx, task.id);
+
+		if (!options.json) {
+			tui.success(`Task updated: ${tui.bold(task.id)}`);
+
+			const tableData: Record<string, string> = {
+				Title: task.title,
+				Type: task.type,
+				Status: task.status,
+				Priority: task.priority,
+				Updated: new Date(task.updated_at).toLocaleString(),
+			};
+
+			tui.table([tableData], Object.keys(tableData), { layout: 'vertical', padStart: '  ' });
+		}
+
+		return {
+			success: true,
+			task: {
+				id: task.id,
+				title: task.title,
+				type: task.type,
+				status: task.status,
+				priority: task.priority,
+				updated_at: task.updated_at,
+			},
+			durationMs,
+		};
+	},
+});
+
+export default updateSubcommand;

package/src/cmd/cloud/task/util.ts

@@ -0,0 +1,62 @@
+import { TaskStorageService, type Logger } from '@agentuity/core';
+import { createServerFetchAdapter } from '@agentuity/server';
+import type { AuthData, Config, GlobalOptions } from '../../../types';
+import { getCatalystUrl } from '../../../catalyst';
+import { setResourceInfo } from '../../../cache';
+import { defaultProfileName, getDefaultRegion } from '../../../config';
+import * as tui from '../../../tui';
+
+export interface TaskContext {
+	logger: Logger;
+	auth: AuthData;
+	config: Config | null;
+	options: GlobalOptions;
+}
+
+export async function createStorageAdapter(ctx: TaskContext) {
+	const orgId =
+		ctx.options.orgId ??
+		(process.env.AGENTUITY_CLOUD_ORG_ID || ctx.config?.preferences?.orgId);
+	if (!orgId) {
+		tui.fatal('Organization ID is required. Use --org-id flag or set AGENTUITY_CLOUD_ORG_ID.');
+	}
+
+	const adapter = createServerFetchAdapter(
+		{
+			headers: {
+				Authorization: `Bearer ${ctx.auth.apiKey}`,
+				'x-agentuity-orgid': orgId,
+			},
+		},
+		ctx.logger
+	);
+
+	// Task tenant DB is not regional — any Catalyst can serve the request.
+	const region = await getDefaultRegion(ctx.config?.name ?? defaultProfileName, ctx.config);
+	const baseUrl = getCatalystUrl(region);
+	return new TaskStorageService(baseUrl, adapter);
+}
+
+export async function cacheTaskId(
+	ctx: {
+		config: Config | null;
+		options: GlobalOptions;
+	},
+	taskId: string
+) {
+	const profileName = ctx.config?.name ?? defaultProfileName;
+	const region = await getDefaultRegion(profileName, ctx.config);
+	const orgId =
+		ctx.options.orgId ??
+		(process.env.AGENTUITY_CLOUD_ORG_ID || ctx.config?.preferences?.orgId);
+	await setResourceInfo('task', profileName, taskId, region, orgId);
+}
+
+export function parseMetadataFlag(raw: string | undefined): Record<string, unknown> | undefined {
+	if (!raw) return undefined;
+	try {
+		return JSON.parse(raw) as Record<string, unknown>;
+	} catch {
+		tui.fatal('Invalid JSON for --metadata flag');
+	}
+}

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

@@ -58,31 +58,36 @@ export const getSubcommand = createCommand({
 				);
 
 				const data = result.data;
-				tui.info(`  ID: ${data.id}`);
-				tui.info(`  Key: ${data.key}`);
+				const details: Record<string, unknown> = {
+					ID: data.id,
+					Key: data.key,
+				};
 
 				if (data.similarity !== undefined) {
-					tui.info(`  Similarity: ${(data.similarity * 100).toFixed(1)}%`);
+					details.Similarity = `${(data.similarity * 100).toFixed(1)}%`;
 				}
 
 				if (data.document) {
-					const docPreview =
+					details.Document =
 						data.document.length > 200
 							? data.document.substring(0, 197) + '...'
 							: data.document;
-					tui.info(`  Document: ${docPreview}`);
-				}
-
-				if (data.metadata && Object.keys(data.metadata).length > 0) {
-					tui.info(`  Metadata: ${JSON.stringify(data.metadata, null, 2)}`);
 				}
 
 				if (data.embeddings) {
-					tui.info(`  Embeddings: [${data.embeddings.length} dimensions]`);
+					details.Embeddings = `[${data.embeddings.length} dimensions]`;
 				}
 
 				if (data.expiresAt) {
-					tui.info(`  Expires: ${new Date(data.expiresAt).toLocaleString()}`);
+					details.Expires = new Date(data.expiresAt).toLocaleString();
+				}
+
+				tui.table([details], undefined, { layout: 'vertical' });
+
+				if (data.metadata && Object.keys(data.metadata).length > 0) {
+					tui.newline();
+					tui.header('Metadata');
+					tui.json(data.metadata);
 				}
 			} else {
 				tui.warning(`Vector "${tui.bold(args.key)}" not found in ${tui.bold(args.namespace)}`);

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

@@ -85,24 +85,26 @@ export const statsSubcommand = createCommand({
 				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}`);
+					tui.header(`Statistics for ${tui.bold(args.name)}`);
 					const sizeDisplay =
 						stats.sum < 1024 * 1024
 							? `${stats.sum.toLocaleString()} bytes`
 							: `${(stats.sum / (1024 * 1024)).toFixed(2)} MB`;
-					tui.info(`  Total size: ${sizeDisplay}`);
-
+					const statsDetails: Record<string, unknown> = {
+						Vectors: stats.count,
+						'Total size': sizeDisplay,
+					};
 					if (stats.createdAt) {
-						tui.info(`  Created: ${new Date(stats.createdAt).toLocaleString()}`);
+						statsDetails.Created = new Date(stats.createdAt).toLocaleString();
 					}
 					if (stats.lastUsed) {
-						tui.info(`  Last used: ${new Date(stats.lastUsed).toLocaleString()}`);
+						statsDetails['Last used'] = new Date(stats.lastUsed).toLocaleString();
 					}
+					tui.table([statsDetails], undefined, { layout: 'vertical' });
 
 					if (stats.sampledResults && Object.keys(stats.sampledResults).length > 0) {
-						tui.info('');
-						tui.info(`  Sample vectors (${Object.keys(stats.sampledResults).length}):`);
+						tui.newline();
+						tui.header(`Sample vectors (${Object.keys(stats.sampledResults).length})`);
 
 						const tableData = Object.entries(stats.sampledResults).map(([key, item]) => {
 							const docPreview = item.document

package/src/cmd/cloud/webhook/create.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createWebhookAPIClient, getWebhookApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { createWebhook, WebhookSchema } from '@agentuity/server';
+
+const WebhookCreateResponseSchema = WebhookSchema.pick({ id: true, name: true, url: true, created_at: true });
+
+export const createSubcommand = createCommand({
+	name: 'create',
+	description: 'Create a new webhook',
+	tags: ['mutating', 'creates-resource', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud webhook create --name my-webhook'),
+			description: 'Create a webhook named my-webhook',
+		},
+		{
+			command: getCommand(
+				'cloud webhook create --name github-events --description "GitHub webhook"'
+			),
+			description: 'Create a webhook with a description',
+		},
+	],
+	schema: {
+		args: z.object({}),
+		options: z.object({
+			name: z.string().describe('Webhook name'),
+			description: z.string().optional().describe('Webhook description'),
+		}),
+		response: WebhookCreateResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { opts, options } = ctx;
+		const client = await createWebhookAPIClient(ctx);
+
+		const webhook = await createWebhook(
+			client,
+			{
+				name: opts.name,
+				description: opts.description,
+			},
+			getWebhookApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			tui.success(`Created webhook: ${webhook.name}`);
+			console.log(`  ID:  ${webhook.id}`);
+			if (webhook.url) {
+				console.log(`  URL: ${webhook.url}`);
+			}
+		}
+
+		return {
+			id: webhook.id,
+			name: webhook.name,
+			url: webhook.url,
+			created_at: webhook.created_at,
+		};
+	},
+});
+
+export default createSubcommand;

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

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createWebhookAPIClient, getWebhookApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { deleteWebhook } from '@agentuity/server';
+import { ErrorCode } from '../../../errors';
+
+const DeleteResponseSchema = z.object({
+	success: z.boolean(),
+	id: z.string(),
+});
+
+export const deleteSubcommand = createCommand({
+	name: 'delete',
+	aliases: ['rm'],
+	description: 'Delete a webhook by ID',
+	tags: ['mutating', 'deletes-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud webhook delete wh_abc123 --confirm'),
+			description: 'Delete a webhook (requires confirmation)',
+		},
+	],
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('Webhook ID'),
+		}),
+		options: z.object({
+			confirm: z.boolean().default(false).describe('Skip confirmation prompt'),
+		}),
+		response: DeleteResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+
+		if (!opts.confirm) {
+			tui.fatal('Use --confirm to confirm webhook deletion', ErrorCode.INVALID_ARGUMENT);
+		}
+
+		const client = await createWebhookAPIClient(ctx);
+		await deleteWebhook(client, args.id, getWebhookApiOptions(ctx));
+
+		if (!options.json) {
+			tui.success(`Deleted webhook: ${args.id}`);
+		}
+
+		return {
+			success: true,
+			id: args.id,
+		};
+	},
+});
+
+export default deleteSubcommand;