@agentuity/cli 2.0.6 → 2.0.7

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

@@ -0,0 +1,319 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter, resolveMeId, parseDuration, truncate } from './util';
+import { getCommand } from '../../../command-prefix';
+import { isDryRunMode, outputDryRun } from '../../../explain';
+import type { TaskPriority, TaskStatus, TaskType, BatchClosedTask } from '@agentuity/core';
+
+const TaskCloseResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	closed: z
+		.array(
+			z.object({
+				id: z.string().describe('Closed task ID'),
+				title: z.string().describe('Closed task title'),
+				status: z.string().describe('Task status'),
+				closed_date: z.string().optional().describe('ISO 8601 closed date'),
+			})
+		)
+		.describe('List of closed tasks'),
+	count: z.number().describe('Number of tasks closed'),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+	dryRun: z.boolean().optional().describe('Whether this was a dry run'),
+	message: z.string().optional().describe('Status message'),
+});
+
+export const closeSubcommand = createCommand({
+	name: 'close',
+	aliases: ['done', 'complete'],
+	description: 'Close a task by ID or batch-close tasks by filter',
+	tags: ['mutating', 'slow', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud task close task_abc123'),
+			description: 'Close a single task by ID',
+		},
+		{
+			command: getCommand('cloud task close --status in_progress --older-than 7d'),
+			description: 'Close in-progress tasks older than 7 days',
+		},
+		{
+			command: getCommand('cloud task close --status open --limit 10 --dry-run'),
+			description: 'Preview which open tasks would be closed (dry run)',
+		},
+		{
+			command: getCommand('cloud task close --created-id me --confirm'),
+			description: 'Close all tasks created by me without confirmation prompt',
+		},
+	],
+	schema: {
+		args: z.object({
+			id: z.string().optional().describe('Task ID to close (for single close)'),
+		}),
+		options: z.object({
+			status: z
+				.enum(['open', 'in_progress', 'started', 'done', 'completed', 'closed', 'cancelled'])
+				.optional()
+				.describe('filter batch close by status'),
+			type: z
+				.enum(['epic', 'feature', 'enhancement', 'bug', 'task'])
+				.optional()
+				.describe('filter batch close by type'),
+			priority: z
+				.enum(['high', 'medium', 'low', 'none'])
+				.optional()
+				.describe('filter batch close by priority'),
+			olderThan: z
+				.string()
+				.optional()
+				.describe('filter batch close by age (e.g. 30s, 7d, 24h, 2w)'),
+			parentId: z.string().optional().describe('filter batch close by parent task ID'),
+			createdId: z
+				.string()
+				.optional()
+				.describe('filter batch close by creator ID (use "me" for current user)'),
+			assignedId: z.string().optional().describe('filter batch close by assigned user ID'),
+			projectId: z.string().optional().describe('filter batch close by project ID'),
+			tagId: z.string().optional().describe('filter batch close by tag ID'),
+			idsFile: z.string().optional().describe('path to JSON file containing task IDs to close'),
+			orgId: z.string().optional().describe('organization ID (uses default if not specified)'),
+			dryRun: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe('preview changes without executing'),
+			limit: z.coerce
+				.number()
+				.int()
+				.min(1)
+				.max(200)
+				.default(50)
+				.describe('max tasks to close in batch mode (default: 50, max: 200)'),
+			confirm: z.boolean().optional().default(false).describe('skip confirmation prompt'),
+		}),
+		response: TaskCloseResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		const isSingleClose = !!args.id;
+		const hasFilters =
+			opts.status ||
+			opts.type ||
+			opts.priority ||
+			opts.olderThan ||
+			opts.parentId ||
+			opts.createdId ||
+			opts.assignedId ||
+			opts.projectId ||
+			opts.tagId ||
+			opts.idsFile;
+
+		if (!isSingleClose && !hasFilters) {
+			tui.fatal(
+				'Provide a task ID for single close, or use --status, --type, --priority, --older-than, --parent-id, --created-id, --assigned-id, --project-id, --tag-id, or --ids-file for batch close.'
+			);
+		}
+
+		if (isSingleClose && hasFilters) {
+			tui.fatal(
+				'Cannot combine task ID with filter options. Use either single close (by ID) or batch close (by filters).'
+			);
+		}
+
+		if (isSingleClose) {
+			if (isDryRunMode(options)) {
+				outputDryRun(`Would close task: ${args.id}`, options);
+				return {
+					success: true,
+					closed: [{ id: args.id!, title: '(dry run)', status: 'done' }],
+					count: 1,
+					durationMs: Date.now() - started,
+					dryRun: true,
+					message: 'Dry run — no tasks were closed',
+				};
+			}
+
+			if (!opts.confirm) {
+				const confirmed = await tui.confirm(`Close task "${args.id}"?`, false);
+				if (!confirmed) {
+					if (!options.json) tui.info('Cancelled');
+					return {
+						success: false,
+						closed: [],
+						count: 0,
+						durationMs: Date.now() - started,
+						message: 'Cancelled',
+					};
+				}
+			}
+
+			const task = await storage.close(args.id!);
+			const durationMs = Date.now() - started;
+
+			if (!options.json) {
+				tui.success(`Closed task ${tui.bold(task.id)} (${task.title}) in ${durationMs}ms`);
+			}
+
+			return {
+				success: true,
+				closed: [
+					{
+						id: task.id,
+						title: task.title,
+						status: task.status,
+						closed_date: task.closed_date,
+					},
+				],
+				count: 1,
+				durationMs,
+			};
+		}
+
+		// Batch close mode
+		if (opts.olderThan) {
+			parseDuration(opts.olderThan);
+		}
+
+		const createdId = resolveMeId(opts.createdId, ctx);
+		const assignedId = resolveMeId(opts.assignedId, ctx);
+
+		// Handle IDs file
+		let explicitIds: string[] | undefined;
+		if (opts.idsFile) {
+			const file = Bun.file(opts.idsFile);
+			if (!(await file.exists())) {
+				tui.fatal(`IDs file not found: ${opts.idsFile}`);
+			}
+			try {
+				const content = await file.json();
+				if (Array.isArray(content)) {
+					explicitIds = content.map((id) => String(id));
+				} else if (content && Array.isArray((content as { ids?: string[] }).ids)) {
+					explicitIds = (content as { ids: string[] }).ids;
+				} else {
+					tui.fatal(`Invalid IDs file format. Expected array of IDs or { ids: [...] }`);
+				}
+			} catch (err) {
+				tui.fatal(`Failed to parse IDs file: ${err}`);
+			}
+		}
+
+		const batchParams = {
+			status: opts.status as TaskStatus | undefined,
+			type: opts.type as TaskType | undefined,
+			priority: opts.priority as TaskPriority | undefined,
+			parent_id: opts.parentId,
+			created_id: createdId,
+			assigned_id: assignedId,
+			project_id: opts.projectId,
+			tag_id: opts.tagId,
+			older_than: opts.olderThan,
+			ids: explicitIds,
+			limit: opts.limit,
+			closed_id: ctx.auth.userId,
+			dry_run: isDryRunMode(options),
+		};
+
+		// For confirmation, run a dry-run first to preview
+		if (!isDryRunMode(options) && !opts.confirm) {
+			const preview = await storage.batchClose({ ...batchParams, dry_run: true });
+
+			if (preview.count === 0) {
+				if (!options.json) tui.info('No tasks match the given filters');
+				return {
+					success: true,
+					closed: [],
+					count: 0,
+					durationMs: Date.now() - started,
+					message: 'No matching tasks found',
+				};
+			}
+
+			if (!options.json) {
+				tui.warning(
+					`Found ${preview.count} ${tui.plural(preview.count, 'task', 'tasks')} to close:`
+				);
+				tui.newline();
+
+				const tableData = preview.closed.map((task: BatchClosedTask) => ({
+					ID: tui.muted(truncate(task.id, 28)),
+					Title: truncate(task.title, 40),
+					Status: task.status,
+				}));
+
+				tui.table(tableData, [
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Title', alignment: 'left' },
+					{ name: 'Status', alignment: 'left' },
+				]);
+				tui.newline();
+			}
+
+			const confirmed = await tui.confirm(
+				`Close ${preview.count} ${tui.plural(preview.count, 'task', 'tasks')}?`,
+				false
+			);
+			if (!confirmed) {
+				if (!options.json) tui.info('Cancelled');
+				return {
+					success: false,
+					closed: [],
+					count: 0,
+					durationMs: Date.now() - started,
+					message: 'Cancelled',
+				};
+			}
+		}
+
+		// Execute batch close
+		const result = await storage.batchClose(batchParams);
+		const durationMs = Date.now() - started;
+
+		if (!options.json) {
+			if (result.dry_run) {
+				if (result.count > 0) {
+					tui.info(
+						`Dry run: would close ${result.count} ${tui.plural(result.count, 'task', 'tasks')}`
+					);
+				} else {
+					tui.info('No tasks match the given filters');
+				}
+			} else if (result.count > 0) {
+				tui.success(
+					`Closed ${result.count} ${tui.plural(result.count, 'task', 'tasks')} in ${durationMs}ms`
+				);
+
+				// Show which tasks were closed
+				if (result.closed.length > 0) {
+					tui.newline();
+					const closedTable = result.closed.map((task) => ({
+						ID: tui.muted(truncate(task.id, 28)),
+						Title: truncate(task.title, 40),
+					}));
+					tui.table(closedTable, [
+						{ name: 'ID', alignment: 'left' },
+						{ name: 'Title', alignment: 'left' },
+					]);
+				}
+			} else {
+				tui.info('No tasks matched the given filters');
+			}
+		}
+
+		return {
+			success: true,
+			closed: result.closed,
+			count: result.count,
+			durationMs,
+			dryRun: result.dry_run,
+		};
+	},
+});
+
+export default closeSubcommand;

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

@@ -1,46 +1,13 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createStorageAdapter } from './util';
+import { createStorageAdapter, resolveMeId, parseDuration, truncate } from './util';
 import { getCommand } from '../../../command-prefix';
 import { isDryRunMode, outputDryRun } from '../../../explain';
 import type { TaskPriority, TaskStatus, TaskType, BatchDeletedTask } from '@agentuity/core';
 
-const DURATION_UNITS: Record<string, number> = {
-	s: 1000,
-	m: 60 * 1000,
-	h: 60 * 60 * 1000,
-	d: 24 * 60 * 60 * 1000,
-	w: 7 * 24 * 60 * 60 * 1000,
-};
-
-/**
- * Parse a human-friendly duration string (e.g. "30s", "7d", "24h", "30m", "2w")
- * into milliseconds. Exported for testing.
- */
-export function parseDuration(duration: string): number {
-	const match = duration.match(/^(\d+)([smhdw])$/);
-	if (!match) {
-		tui.fatal(
-			`Invalid duration format: "${duration}". Use a number followed by s (seconds), m (minutes), h (hours), d (days), or w (weeks). Examples: 30s, 30m, 24h, 7d, 2w`
-		);
-		// tui.fatal exits, but TypeScript doesn't know that
-		throw new Error('unreachable');
-	}
-	const value = parseInt(match[1]!, 10);
-	const unit = match[2]!;
-	const ms = DURATION_UNITS[unit];
-	if (!ms) {
-		tui.fatal(`Unknown duration unit: "${unit}"`);
-		throw new Error('unreachable');
-	}
-	return value * ms;
-}
-
-function truncate(s: string, max: number): string {
-	if (s.length <= max) return s;
-	return `${s.slice(0, max - 1)}…`;
-}
+// Re-export for testing
+export { parseDuration } from './util';
 
 const TaskDeleteResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
@@ -104,7 +71,16 @@ export const deleteSubcommand = createCommand({
 				.optional()
 				.describe('filter batch delete by age (e.g. 30s, 7d, 24h, 2w)'),
 			parentId: z.string().optional().describe('filter batch delete by parent task ID'),
-			createdId: z.string().optional().describe('filter batch delete by creator ID'),
+			createdId: z
+				.string()
+				.optional()
+				.describe('filter batch delete by creator ID (use "me" for current user)'),
+			orgId: z.string().optional().describe('organization ID (uses default if not specified)'),
+			dryRun: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe('preview changes without executing'),
 			limit: z.coerce
 				.number()
 				.int()
@@ -198,7 +174,7 @@ export const deleteSubcommand = createCommand({
 			type: opts.type as TaskType | undefined,
 			priority: opts.priority as TaskPriority | undefined,
 			parent_id: opts.parentId,
-			created_id: opts.createdId,
+			created_id: resolveMeId(opts.createdId, ctx),
 			older_than: opts.olderThan,
 			limit: opts.limit,
 		};
@@ -212,6 +188,7 @@ export const deleteSubcommand = createCommand({
 				type: batchParams.type,
 				priority: batchParams.priority,
 				parent_id: batchParams.parent_id,
+				created_id: batchParams.created_id,
 				limit: batchParams.limit,
 				sort: 'created_at',
 				order: 'asc',
@@ -219,11 +196,6 @@ export const deleteSubcommand = createCommand({
 
 			// Client-side filters for preview (server will apply these on actual delete)
 			let candidates = preview.tasks;
-			if (batchParams.created_id) {
-				candidates = candidates.filter(
-					(t: { created_id: string }) => t.created_id === batchParams.created_id
-				);
-			}
 			if (opts.olderThan) {
 				const durationMs = parseDuration(opts.olderThan);
 				const cutoff = new Date(Date.now() - durationMs);

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

@@ -4,6 +4,7 @@ import { createSubcommand } from './create';
 import { updateSubcommand } from './update';
 import { listSubcommand } from './list';
 import { deleteSubcommand } from './delete';
+import { closeSubcommand } from './close';
 import { statsSubcommand } from './stats';
 import { attachmentSubcommand } from './attachment';
 import { userSubcommand } from './user';
@@ -36,6 +37,14 @@ export const taskCommand = createCommand({
 			command: getCommand('cloud task delete task_abc123'),
 			description: 'Delete a task by ID',
 		},
+		{
+			command: getCommand('cloud task close task_abc123'),
+			description: 'Close a task by ID',
+		},
+		{
+			command: getCommand('cloud task close --status done --older-than 7d'),
+			description: 'Batch close done tasks older than 7 days',
+		},
 		{
 			command: getCommand('cloud task delete --status done --older-than 7d'),
 			description: 'Batch delete done tasks older than 7 days',
@@ -59,6 +68,7 @@ export const taskCommand = createCommand({
 		updateSubcommand,
 		listSubcommand,
 		deleteSubcommand,
+		closeSubcommand,
 		statsSubcommand,
 		attachmentSubcommand,
 		userSubcommand,

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createStorageAdapter } from './util';
+import { createStorageAdapter, resolveMeId } from './util';
 import { getCommand } from '../../../command-prefix';
-import type { TaskPriority, TaskStatus, TaskType, Task } from '@agentuity/core';
+import type { TaskPriority, TaskStatus, TaskType, Task, TaskIncludeField } from '@agentuity/core';
 
 const TaskListResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
@@ -14,6 +14,12 @@ const TaskListResponseSchema = z.object({
 			type: z.string(),
 			status: z.string(),
 			priority: z.string(),
+			description: z.string().optional(),
+			metadata: z.record(z.string(), z.unknown()).optional(),
+			tags: z.array(z.object({ id: z.string(), name: z.string() })).optional(),
+			subtask_count: z.number().optional(),
+			created_id: z.string().optional(),
+			deleted: z.boolean().optional(),
 			creator: z
 				.object({
 					id: z.string(),
@@ -73,6 +79,38 @@ function truncate(s: string, max: number): string {
 	return `${s.slice(0, max - 1)}…`;
 }
 
+const VALID_INCLUDE_FIELDS = new Set<TaskIncludeField>([
+	'description',
+	'metadata',
+	'tags',
+	'subtask_count',
+	'created_id',
+	'deleted',
+]);
+
+function parseIncludeParam(include: string | undefined): TaskIncludeField[] | undefined {
+	if (!include) return undefined;
+	const fields: TaskIncludeField[] = [];
+	for (const f of include.split(',')) {
+		const trimmed = f.trim() as TaskIncludeField;
+		if (VALID_INCLUDE_FIELDS.has(trimmed)) {
+			fields.push(trimmed);
+		} else {
+			tui.fatal(
+				`Invalid include field: "${trimmed}". Valid fields are: ${[...VALID_INCLUDE_FIELDS].join(', ')}`
+			);
+		}
+	}
+	return fields.length > 0 ? fields : undefined;
+}
+
+function hasIncludeField(
+	include: TaskIncludeField[] | undefined,
+	field: TaskIncludeField
+): boolean {
+	return include?.includes(field) ?? false;
+}
+
 export const listSubcommand = createCommand({
 	name: 'list',
 	aliases: ['ls'],
@@ -103,6 +141,14 @@ export const listSubcommand = createCommand({
 			command: getCommand('cloud task list --assigned-id agent_001 --limit 10'),
 			description: 'List first 10 tasks assigned to an agent',
 		},
+		{
+			command: getCommand('cloud task list --created-id me --include description,metadata,tags'),
+			description: 'List tasks created by me with full details',
+		},
+		{
+			command: getCommand('cloud task list --project-id proj_abc123'),
+			description: 'List tasks for a specific project',
+		},
 	],
 	schema: {
 		options: z.object({
@@ -118,8 +164,24 @@ export const listSubcommand = createCommand({
 				.enum(['high', 'medium', 'low', 'none'])
 				.optional()
 				.describe('filter by priority'),
-			assignedId: z.string().optional().describe('filter by assigned agent or user ID'),
+			assignedId: z
+				.string()
+				.optional()
+				.describe('filter by assigned agent or user ID (use "me" for current user)'),
+			createdId: z
+				.string()
+				.optional()
+				.describe('filter by creator ID (use "me" for current user)'),
 			parentId: z.string().optional().describe('filter by parent task ID'),
+			projectId: z.string().optional().describe('filter by project ID'),
+			tagId: z.string().optional().describe('filter by tag ID'),
+			deleted: z.boolean().optional().describe('include soft-deleted tasks'),
+			include: z
+				.string()
+				.optional()
+				.describe(
+					'comma-separated fields to include: description,metadata,tags,subtask_count,created_id,deleted'
+				),
 			sort: z
 				.enum(['created_at', 'updated_at', 'priority'])
 				.optional()
@@ -127,6 +189,7 @@ export const listSubcommand = createCommand({
 			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'),
+			orgId: z.string().optional().describe('organization ID (uses default if not specified)'),
 		}),
 		response: TaskListResponseSchema,
 	},
@@ -136,12 +199,22 @@ export const listSubcommand = createCommand({
 		const started = Date.now();
 		const storage = await createStorageAdapter(ctx);
 
+		const createdId = resolveMeId(opts.createdId, ctx);
+		const assignedId = resolveMeId(opts.assignedId, ctx);
+
+		const includeFields = parseIncludeParam(opts.include);
+
 		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,
+			assigned_id: assignedId,
+			created_id: createdId,
 			parent_id: opts.parentId,
+			project_id: opts.projectId,
+			tag_id: opts.tagId,
+			deleted: opts.deleted,
+			include: includeFields,
 			sort: opts.sort,
 			order: opts.order,
 			limit: opts.limit,
@@ -154,6 +227,10 @@ export const listSubcommand = createCommand({
 			if (result.tasks.length === 0) {
 				tui.info('No tasks found');
 			} else {
+				const showDescription = hasIncludeField(includeFields, 'description');
+				const showTags = hasIncludeField(includeFields, 'tags');
+				const showMetadata = hasIncludeField(includeFields, 'metadata');
+
 				const tableData = result.tasks.map((task: Task) => ({
 					ID: tui.muted(truncate(task.id, 28)),
 					Title: truncate(task.title, 40),
@@ -176,6 +253,30 @@ export const listSubcommand = createCommand({
 					{ name: 'Updated', alignment: 'left' },
 				]);
 
+				// Show extra details for each task if included
+				if (showDescription || showTags || showMetadata) {
+					for (const task of result.tasks) {
+						const extras: string[] = [];
+						if (showDescription && task.description) {
+							extras.push(`${tui.muted('Desc:')} ${truncate(task.description, 80)}`);
+						}
+						if (showTags && task.tags && task.tags.length > 0) {
+							const tagList = task.tags.map((t) => t.name).join(', ');
+							extras.push(`${tui.muted('Tags:')} ${tagList}`);
+						}
+						if (showMetadata && task.metadata) {
+							const metaStr =
+								typeof task.metadata === 'object'
+									? JSON.stringify(task.metadata)
+									: String(task.metadata);
+							extras.push(`${tui.muted('Meta:')} ${truncate(metaStr, 80)}`);
+						}
+						if (extras.length > 0) {
+							tui.output(`  ${tui.muted(truncate(task.id, 28))} → ${extras.join(' | ')}`);
+						}
+					}
+				}
+
 				tui.info(
 					`Showing ${result.tasks.length} of ${result.total} ${tui.plural(result.total, 'task', 'tasks')} (${durationMs.toFixed(1)}ms)`
 				);
@@ -190,6 +291,12 @@ export const listSubcommand = createCommand({
 				type: task.type,
 				status: task.status,
 				priority: task.priority,
+				description: task.description,
+				metadata: task.metadata,
+				tags: task.tags,
+				subtask_count: task.subtask_count,
+				created_id: task.created_id,
+				deleted: task.deleted,
 				creator: task.creator,
 				assignee: task.assignee,
 				project: task.project,