@agentuity/cli 1.0.21 → 1.0.23

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

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createScheduleAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const ScheduleListResponseSchema = z.object({
+	schedules: z.array(
+		z.object({
+			id: z.string(),
+			created_at: z.string(),
+			updated_at: z.string(),
+			created_by: z.string(),
+			name: z.string(),
+			description: z.string().nullable(),
+			expression: z.string(),
+			due_date: z.string(),
+		})
+	),
+	total: z.number(),
+});
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List schedules',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, region: true },
+	optional: { project: true },
+	idempotent: true,
+	examples: [
+		{ command: getCommand('cloud schedule list'), description: 'List schedules' },
+		{ command: getCommand('cloud schedule list --limit 20'), description: 'List 20 schedules' },
+	],
+	schema: {
+		options: z.object({
+			limit: z.coerce.number().min(0).optional().describe('Maximum number of schedules'),
+			offset: z.coerce.number().min(0).optional().describe('Pagination offset'),
+		}),
+		response: ScheduleListResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { opts, options } = ctx;
+		const schedule = createScheduleAdapter(ctx);
+		const result = await schedule.list({ limit: opts.limit, offset: opts.offset });
+
+		if (!options.json) {
+			if (result.schedules.length === 0) {
+				tui.info('No schedules found');
+			} else {
+				tui.table(
+					result.schedules.map((item: {
+						id: string;
+						created_at: string;
+						updated_at: string;
+						created_by: string;
+						name: string;
+						description: string | null;
+						expression: string;
+						due_date: string;
+					}) => ({
+						Name: item.name,
+						ID: item.id,
+						Expression: item.expression,
+						'Next Due': item.due_date,
+						Created: new Date(item.created_at).toLocaleString(),
+					})),
+					['Name', 'ID', 'Expression', 'Next Due', 'Created']
+				);
+			}
+		}
+
+		return result;
+	},
+});
+
+export default listSubcommand;

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

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createScheduleAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const ScheduleUpdateResponseSchema = z.object({
+	schedule: z.object({
+		id: z.string(),
+		created_at: z.string(),
+		updated_at: z.string(),
+		created_by: z.string(),
+		name: z.string(),
+		description: z.string().nullable(),
+		expression: z.string(),
+		due_date: z.string(),
+	}),
+});
+
+export const updateSubcommand = createCommand({
+	name: 'update',
+	description: 'Update a schedule',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true, region: true },
+	optional: { project: true },
+	examples: [
+		{
+			command: getCommand("cloud schedule update sched_abc123 --expression '*/5 * * * *'"),
+			description: 'Update schedule expression',
+		},
+	],
+	schema: {
+		args: z.object({
+			schedule_id: z.string().min(1).describe('Schedule ID'),
+		}),
+		options: z.object({
+			name: z.string().optional().describe('Schedule name'),
+			expression: z.string().optional().describe('Cron expression'),
+			description: z.string().optional().describe('Schedule description'),
+		}),
+		response: ScheduleUpdateResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const schedule = createScheduleAdapter(ctx);
+		const result = await schedule.update(args.schedule_id, {
+			name: opts.name,
+			expression: opts.expression,
+			description: opts.description,
+		});
+
+		if (!options.json) {
+			tui.success(`Updated schedule: ${result.schedule.name}`);
+			tui.table(
+				[
+					{
+						Name: result.schedule.name,
+						ID: result.schedule.id,
+						Expression: result.schedule.expression,
+						Description: result.schedule.description ?? '-',
+						Updated: new Date(result.schedule.updated_at).toLocaleString(),
+					},
+				],
+				undefined,
+				{ layout: 'vertical' }
+			);
+		}
+
+		return result;
+	},
+});
+
+export default updateSubcommand;

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

@@ -0,0 +1,34 @@
+import { ScheduleService, type Logger } from '@agentuity/core';
+import { createServerFetchAdapter } from '@agentuity/server';
+import type { AuthData, Config, GlobalOptions, ProjectConfig } from '../../../types';
+import { getCatalystUrl } from '../../../catalyst';
+import * as tui from '../../../tui';
+
+export function createScheduleAdapter(
+	ctx: {
+		logger: Logger;
+		auth: AuthData;
+		region: string;
+		project?: ProjectConfig;
+		config: Config | null;
+		options: GlobalOptions;
+	},
+	explicitOrgId?: string
+) {
+	const orgId =
+		explicitOrgId ??
+		ctx.project?.orgId ??
+		ctx.options.orgId ??
+		(process.env.AGENTUITY_CLOUD_ORG_ID || ctx.config?.preferences?.orgId);
+	if (!orgId) {
+		tui.fatal(
+			'Organization ID is required. Either run from a project directory or use --org-id flag.'
+		);
+	}
+	const adapter = createServerFetchAdapter(
+		{ headers: { Authorization: `Bearer ${ctx.auth.apiKey}`, 'x-agentuity-orgid': orgId } },
+		ctx.logger
+	);
+	const baseUrl = getCatalystUrl(ctx.region);
+	return new ScheduleService(baseUrl, adapter);
+}

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

@@ -0,0 +1,124 @@
+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 TaskCreateResponseSchema = 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'),
+		created_at: z.string().describe('Creation timestamp'),
+	}),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+});
+
+export const createSubcommand = createCommand({
+	name: 'create',
+	aliases: ['new', 'add'],
+	description: 'Create a new task',
+	tags: ['mutating', 'slow', 'requires-auth'],
+	requires: { auth: true },
+	optional: { project: true },
+	examples: [
+		{
+			command: getCommand('cloud task create "Fix login bug" --type bug --created-id agent_001'),
+			description: 'Create a bug task',
+		},
+		{
+			command: getCommand(
+				'cloud task create "Add dark mode" --type feature --created-id agent_001 --priority high --description "Implement dark mode toggle"'
+			),
+			description: 'Create a feature with priority and description',
+		},
+		{
+			command: getCommand(
+				'cloud task create "Q1 Planning" --type epic --created-id agent_001 --metadata \'{"team":"engineering"}\''
+			),
+			description: 'Create an epic with metadata',
+		},
+	],
+	schema: {
+		args: z.object({
+			title: z.string().min(1).describe('the task title'),
+		}),
+		options: z.object({
+			type: z.enum(['epic', 'feature', 'enhancement', 'bug', 'task']).describe('the task type'),
+			createdId: z.string().min(1).describe('the ID of the creator (agent or user)'),
+			description: z.string().optional().describe('task description'),
+			priority: z
+				.enum(['high', 'medium', 'low', 'none'])
+				.optional()
+				.describe('task priority (default: none)'),
+			status: z
+				.enum(['open', 'in_progress', 'closed'])
+				.optional()
+				.describe('initial task status (default: open)'),
+			parentId: z.string().optional().describe('parent task ID for subtasks'),
+			assignedId: z.string().optional().describe('ID of the assigned agent or user'),
+			metadata: z.string().optional().describe('JSON metadata object'),
+		}),
+		response: TaskCreateResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		const metadata = parseMetadataFlag(opts.metadata);
+
+		const task = await storage.create({
+			title: args.title,
+			type: opts.type as TaskType,
+			created_id: opts.createdId,
+			description: opts.description,
+			priority: opts.priority as TaskPriority,
+			status: opts.status as TaskStatus,
+			parent_id: opts.parentId,
+			assigned_id: opts.assignedId,
+			metadata,
+		});
+
+		const durationMs = Date.now() - started;
+		await cacheTaskId(ctx, task.id);
+
+		if (!options.json) {
+			tui.success(`Task created: ${tui.bold(task.id)}`);
+
+			const tableData: Record<string, string> = {
+				Title: task.title,
+				Type: task.type,
+				Status: task.status,
+				Priority: task.priority,
+				Created: new Date(task.created_at).toLocaleString(),
+			};
+
+			if (task.description) {
+				tableData['Description'] = task.description;
+			}
+
+			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,
+				created_at: task.created_at,
+			},
+			durationMs,
+		};
+	},
+});
+
+export default createSubcommand;

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

@@ -0,0 +1,138 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter, cacheTaskId } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const TaskGetResponseSchema = 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'),
+		description: z.string().optional().describe('Task description'),
+		type: z.string().describe('Task type'),
+		status: z.string().describe('Task status'),
+		priority: z.string().describe('Task priority'),
+		parent_id: z.string().optional().describe('Parent task ID'),
+		assigned_id: z.string().optional().describe('Assigned agent or user ID'),
+		created_id: z.string().describe('Creator ID'),
+		closed_id: z.string().optional().describe('Closer ID'),
+		metadata: z.record(z.string(), z.unknown()).optional().describe('Task metadata'),
+		created_at: z.string().describe('Creation timestamp'),
+		updated_at: z.string().describe('Last update timestamp'),
+		open_date: z.string().optional().describe('Date task was opened'),
+		in_progress_date: z.string().optional().describe('Date task moved to in-progress'),
+		closed_date: z.string().optional().describe('Date task was closed'),
+	}),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+});
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	aliases: ['show', 'info'],
+	description: 'Get details of a task by ID',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true },
+	optional: { project: true },
+	examples: [
+		{
+			command: getCommand('cloud task get task_abc123'),
+			description: 'Get task details',
+		},
+		{
+			command: getCommand('cloud task get task_abc123 --json'),
+			description: 'Get task details as JSON',
+		},
+	],
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('the task ID to get'),
+		}),
+		response: TaskGetResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		const task = await storage.get(args.id);
+		const durationMs = Date.now() - started;
+
+		if (!task) {
+			tui.fatal(`Task not found: ${args.id}`);
+		}
+
+		await cacheTaskId(ctx, task.id);
+
+		if (!options.json) {
+			const tableData: Record<string, string> = {
+				ID: task.id,
+				Title: task.title,
+				Type: task.type,
+				Status: task.status,
+				Priority: task.priority,
+			};
+
+			if (task.description) {
+				tableData['Description'] = task.description;
+			}
+
+			tableData['Creator'] = task.created_id;
+
+			if (task.assigned_id) {
+				tableData['Assigned'] = task.assigned_id;
+			}
+			if (task.parent_id) {
+				tableData['Parent'] = task.parent_id;
+			}
+			if (task.closed_id) {
+				tableData['Closed By'] = task.closed_id;
+			}
+
+			tableData['Created'] = new Date(task.created_at).toLocaleString();
+			tableData['Updated'] = new Date(task.updated_at).toLocaleString();
+
+			if (task.open_date) {
+				tableData['Opened'] = new Date(task.open_date).toLocaleString();
+			}
+			if (task.in_progress_date) {
+				tableData['In Progress'] = new Date(task.in_progress_date).toLocaleString();
+			}
+			if (task.closed_date) {
+				tableData['Closed'] = new Date(task.closed_date).toLocaleString();
+			}
+			if (task.metadata && Object.keys(task.metadata).length > 0) {
+				tableData['Metadata'] = JSON.stringify(task.metadata);
+			}
+
+			tui.table([tableData], Object.keys(tableData), { layout: 'vertical', padStart: '  ' });
+		}
+
+		return {
+			success: true,
+			task: {
+				id: task.id,
+				title: task.title,
+				description: task.description,
+				type: task.type,
+				status: task.status,
+				priority: task.priority,
+				parent_id: task.parent_id,
+				assigned_id: task.assigned_id,
+				created_id: task.created_id,
+				closed_id: task.closed_id,
+				metadata: task.metadata,
+				created_at: task.created_at,
+				updated_at: task.updated_at,
+				open_date: task.open_date,
+				in_progress_date: task.in_progress_date,
+				closed_date: task.closed_date,
+			},
+			durationMs,
+		};
+	},
+});
+
+export default getSubcommand;

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

@@ -0,0 +1,34 @@
+import { createCommand } from '../../../types';
+import { getSubcommand } from './get';
+import { createSubcommand } from './create';
+import { updateSubcommand } from './update';
+import { listSubcommand } from './list';
+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],
+	requires: { auth: true },
+});
+
+export default taskCommand;

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

@@ -0,0 +1,191 @@
+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 },
+	optional: { project: 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(
+					`\nShowing ${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;