@agentuity/cli 2.0.6 → 2.0.8

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,

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

@@ -11,11 +11,14 @@ export interface TaskContext {
 	auth: AuthData;
 	config: Config | null;
 	options: GlobalOptions;
+	project?: {
+		projectId: string;
+		orgId: string;
+	};
 }
 
 export async function createStorageAdapter(ctx: TaskContext) {
-	const orgId =
-		ctx.options.orgId ?? (process.env.AGENTUITY_CLOUD_ORG_ID || ctx.config?.preferences?.orgId);
+	const orgId = resolveOrgId(ctx);
 	if (!orgId) {
 		tui.fatal('Organization ID is required. Use --org-id flag or set AGENTUITY_CLOUD_ORG_ID.');
 	}
@@ -37,8 +40,7 @@ export async function createStorageAdapter(ctx: TaskContext) {
 }
 
 export async function createStorageAdapterOptionalOrg(ctx: TaskContext) {
-	const orgId =
-		ctx.options.orgId ?? (process.env.AGENTUITY_CLOUD_ORG_ID || ctx.config?.preferences?.orgId);
+	const orgId = resolveOrgId(ctx);
 
 	const headers: Record<string, string> = {
 		Authorization: `Bearer ${ctx.auth.apiKey}`,
@@ -54,17 +56,30 @@ export async function createStorageAdapterOptionalOrg(ctx: TaskContext) {
 	return new TaskStorageService(baseUrl, adapter);
 }
 
+function resolveOrgId(ctx: TaskContext): string | undefined {
+	return (
+		ctx.options.orgId ??
+		process.env.AGENTUITY_CLOUD_ORG_ID ??
+		ctx.project?.orgId ??
+		ctx.config?.preferences?.orgId
+	);
+}
+
 export async function cacheTaskId(
 	ctx: {
 		config: Config | null;
 		options: GlobalOptions;
+		project?: { orgId: string };
 	},
 	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);
+		ctx.options.orgId ??
+		process.env.AGENTUITY_CLOUD_ORG_ID ??
+		ctx.project?.orgId ??
+		ctx.config?.preferences?.orgId;
 	await setResourceInfo('task', profileName, taskId, region, orgId);
 }
 
@@ -76,3 +91,42 @@ export function parseMetadataFlag(raw: string | undefined): Record<string, unkno
 		tui.fatal('Invalid JSON for --metadata flag');
 	}
 }
+
+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,
+};
+
+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`
+		);
+		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;
+}
+
+export function truncate(s: string, max: number): string {
+	if (s.length <= max) return s;
+	return `${s.slice(0, max - 1)}…`;
+}
+
+export function resolveMeId(id: string | undefined, ctx: TaskContext): string | undefined {
+	if (!id) return undefined;
+	if (id === 'me') {
+		return ctx.auth.userId;
+	}
+	return id;
+}

package/src/cmd/coder/archive.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { CoderClient } from '@agentuity/core/coder';
+import { ValidationOutputError } from '@agentuity/core';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
+import { ErrorCode } from '../../errors';
+
+export const archiveSubcommand = createSubcommand({
+	name: 'archive',
+	description: 'Archive a Coder Hub session',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder archive codesess_abc123'),
+			description: 'Archive a session',
+		},
+		{
+			command: getCommand('coder archive codesess_abc123 --json'),
+			description: 'Archive a session and return JSON output',
+		},
+	],
+	schema: {
+		args: z.object({
+			sessionId: z.string().describe('Session ID to archive'),
+		}),
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+		}),
+	},
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		try {
+			const session = await client.archiveSession(args.sessionId);
+			const result = session ?? { archived: true, sessionId: args.sessionId };
+
+			if (options.json) {
+				return result;
+			}
+
+			tui.success(`Session ${args.sessionId} archived.`);
+			return result;
+		} catch (err) {
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to archive session ${args.sessionId}: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+	},
+});