@agentuity/cli 0.0.49 → 0.0.50

package/src/cmd/dev/sync.ts

@@ -0,0 +1,414 @@
+import { z } from 'zod';
+import type { Logger, BuildMetadata } from '../../types';
+import type { APIClient } from '../../api';
+
+interface AgentSyncPayload {
+	id: string;
+	name: string;
+	identifier: string;
+	agentId: string;
+	description?: string;
+	version: string;
+	filename: string;
+	projectId: string;
+	subagents?: Array<{
+		id: string;
+		name: string;
+		identifier: string;
+		agentId: string;
+		description?: string;
+		version: string;
+		filename: string;
+		projectId: string;
+	}>;
+}
+
+interface EvalSyncPayload {
+	id: string;
+	name: string;
+	identifier: string;
+	evalId: string;
+	description?: string;
+	version: string;
+	filename: string;
+	projectId: string;
+	agentIdentifier: string;
+}
+
+interface IDevmodeSyncService {
+	sync(
+		currentMetadata: BuildMetadata,
+		previousMetadata: BuildMetadata | undefined,
+		projectId: string,
+		deploymentId: string
+	): Promise<void>;
+}
+
+// Shared diff logic for agents
+function getAgentsToSync(
+	currentAgents: BuildMetadata['agents'],
+	previousAgentIds: Set<string>,
+	projectId: string,
+	logger: Logger
+): { create: AgentSyncPayload[]; delete: string[] } {
+	const agentsToCreate: AgentSyncPayload[] = [];
+	const currentAgentIds = new Set<string>();
+
+	for (const agent of currentAgents || []) {
+		currentAgentIds.add(agent.id);
+		// If ID is not in previous, add to create
+		if (!previousAgentIds.has(agent.id)) {
+			logger.debug(
+				'[CLI AGENT SYNC] Preparing to create: id="%s", name="%s"',
+				agent.id,
+				agent.name
+			);
+
+			// Add projectId to subagents if they exist
+			const subagents = agent.subagents?.map((subagent) => {
+				return {
+					id: subagent.id,
+					name: subagent.name,
+					identifier: subagent.identifier,
+					agentId: subagent.agentId,
+					description: subagent.description,
+					version: subagent.version,
+					filename: subagent.filename,
+					projectId,
+				};
+			});
+
+			agentsToCreate.push({
+				id: agent.id,
+				name: agent.name,
+				identifier: agent.identifier,
+				agentId: agent.agentId,
+				description: agent.description,
+				version: agent.version,
+				filename: agent.filename,
+				projectId,
+				...(subagents && { subagents }),
+			});
+		}
+	}
+
+	// If ID is in previous but not in current, add to delete
+	const agentsToDelete: string[] = [];
+	for (const previousId of previousAgentIds) {
+		if (!currentAgentIds.has(previousId)) {
+			logger.debug('[CLI AGENT SYNC] Preparing to delete: id="%s"', previousId);
+			agentsToDelete.push(previousId);
+		}
+	}
+
+	return { create: agentsToCreate, delete: agentsToDelete };
+}
+
+// Shared diff logic for evals
+function getEvalsToSync(
+	currentMetadata: BuildMetadata,
+	previousEvalIds: Set<string>,
+	projectId: string,
+	logger: Logger
+): { create: EvalSyncPayload[]; delete: string[] } {
+	const evalsToCreate: EvalSyncPayload[] = [];
+	const currentEvalIds = new Set<string>();
+
+	for (const agent of currentMetadata.agents || []) {
+		if (agent.evals) {
+			for (const evalItem of agent.evals) {
+				currentEvalIds.add(evalItem.id);
+				// If ID is not in previous, add to create
+				if (!previousEvalIds.has(evalItem.id)) {
+					logger.debug(
+						'[CLI EVAL SYNC] Preparing to create: id="%s", name="%s"',
+						evalItem.id,
+						evalItem.name
+					);
+
+					evalsToCreate.push({
+						...evalItem,
+						evalId: evalItem.evalId,
+						projectId,
+						agentIdentifier: agent.agentId,
+					});
+				}
+			}
+		}
+	}
+
+	// If ID is in previous but not in current, add to delete
+	const evalsToDelete: string[] = [];
+	for (const previousId of previousEvalIds) {
+		if (!currentEvalIds.has(previousId)) {
+			logger.debug('[CLI EVAL SYNC] Preparing to delete: id="%s"', previousId);
+			evalsToDelete.push(previousId);
+		}
+	}
+
+	return { create: evalsToCreate, delete: evalsToDelete };
+}
+
+class DevmodeSyncService implements IDevmodeSyncService {
+	constructor(
+		private logger: Logger,
+		private apiClient: APIClient
+	) {}
+
+	async sync(
+		currentMetadata: BuildMetadata,
+		previousMetadata: BuildMetadata | undefined,
+		projectId: string,
+		deploymentId: string
+	): Promise<void> {
+		// Build previous agent IDs set
+		const previousAgentIds = new Set<string>();
+		if (previousMetadata) {
+			this.logger.debug(
+				'Previous metadata found with %d agent(s)',
+				previousMetadata.agents?.length ?? 0
+			);
+			for (const agent of previousMetadata.agents || []) {
+				previousAgentIds.add(agent.id);
+			}
+		} else {
+			this.logger.debug('No previous metadata, all agents will be treated as new');
+		}
+
+		// Build previous eval IDs set
+		const previousEvalIds = new Set<string>();
+		if (previousMetadata) {
+			let prevEvalCount = 0;
+			for (const agent of previousMetadata.agents || []) {
+				if (agent.evals) {
+					for (const evalItem of agent.evals) {
+						previousEvalIds.add(evalItem.id);
+						prevEvalCount++;
+					}
+				}
+			}
+			this.logger.debug('Previous metadata found with %d eval(s)', prevEvalCount);
+		} else {
+			this.logger.debug('No previous metadata, all evals will be treated as new');
+		}
+
+		const currentAgents = currentMetadata.agents || [];
+		this.logger.debug('Processing %d current agent(s)', currentAgents.length);
+
+		let currentEvalCount = 0;
+		for (const agent of currentMetadata.agents || []) {
+			if (agent.evals) {
+				currentEvalCount += agent.evals.length;
+			}
+		}
+		this.logger.debug('Processing %d current eval(s)', currentEvalCount);
+
+		// Get agents and evals to sync using shared diff logic
+		const { create: agentsToCreate, delete: agentsToDelete } = getAgentsToSync(
+			currentAgents,
+			previousAgentIds,
+			projectId,
+			this.logger
+		);
+		const { create: evalsToCreate, delete: evalsToDelete } = getEvalsToSync(
+			currentMetadata,
+			previousEvalIds,
+			projectId,
+			this.logger
+		);
+
+		if (agentsToCreate.length > 0 || agentsToDelete.length > 0) {
+			this.logger.debug(
+				'Bulk syncing %d agent(s) to create, %d agent(s) to delete',
+				agentsToCreate.length,
+				agentsToDelete.length
+			);
+		}
+		if (evalsToCreate.length > 0 || evalsToDelete.length > 0) {
+			this.logger.debug(
+				'Bulk syncing %d eval(s) to create, %d eval(s) to delete',
+				evalsToCreate.length,
+				evalsToDelete.length
+			);
+		}
+
+		// Sync both in parallel
+		try {
+			await Promise.all([
+				this.syncAgents(agentsToCreate, agentsToDelete, deploymentId),
+				this.syncEvals(evalsToCreate, evalsToDelete, deploymentId),
+			]);
+
+			if (agentsToCreate.length > 0 || agentsToDelete.length > 0) {
+				this.logger.debug(
+					'Successfully bulk synced %d agent(s) to create, %d agent(s) to delete',
+					agentsToCreate.length,
+					agentsToDelete.length
+				);
+			}
+			if (evalsToCreate.length > 0 || evalsToDelete.length > 0) {
+				this.logger.debug(
+					'Successfully bulk synced %d eval(s) to create, %d eval(s) to delete',
+					evalsToCreate.length,
+					evalsToDelete.length
+				);
+			}
+		} catch (error) {
+			this.logger.error('Failed to bulk sync agents/evals: %s', error);
+			if (error instanceof Error) {
+				this.logger.error('Error details: %s', error.message);
+			}
+			throw error;
+		}
+	}
+
+	private async syncAgents(
+		agents: AgentSyncPayload[],
+		agentsToDelete: string[],
+		deploymentId: string
+	): Promise<void> {
+		if (agents.length === 0 && agentsToDelete.length === 0) {
+			return;
+		}
+
+		const payload = {
+			create: agents,
+			delete: agentsToDelete,
+			deploymentId,
+		};
+		this.logger.trace(
+			'[CLI AGENT SYNC] Sending payload to POST /cli/devmode/agent: %s',
+			JSON.stringify(payload, null, 2)
+		);
+
+		await this.apiClient.request(
+			'POST',
+			'/cli/devmode/agent',
+			z.object({ success: z.boolean() }),
+			payload
+		);
+	}
+
+	private async syncEvals(
+		evals: EvalSyncPayload[],
+		evalsToDelete: string[],
+		deploymentId: string
+	): Promise<void> {
+		if (evals.length === 0 && evalsToDelete.length === 0) {
+			return;
+		}
+
+		const payload = {
+			deploymentId,
+			create: evals,
+			delete: evalsToDelete,
+		};
+		this.logger.trace(
+			'[CLI EVAL SYNC] Sending payload to POST /cli/devmode/eval: %s',
+			JSON.stringify(payload, null, 2)
+		);
+
+		await this.apiClient.request(
+			'POST',
+			'/cli/devmode/eval',
+			z.object({ success: z.boolean() }),
+			payload
+		);
+	}
+}
+
+class MockDevmodeSyncService implements IDevmodeSyncService {
+	constructor(private logger: Logger) {}
+
+	async sync(
+		currentMetadata: BuildMetadata,
+		previousMetadata: BuildMetadata | undefined,
+		projectId: string,
+		deploymentId: string
+	): Promise<void> {
+		// Build previous agent IDs set
+		this.logger.debug('Mock syncing agents and evals for deploymentId: %s', deploymentId);
+		const previousAgentIds = new Set<string>();
+		if (previousMetadata) {
+			for (const agent of previousMetadata.agents || []) {
+				previousAgentIds.add(agent.id);
+			}
+		}
+
+		// Build previous eval IDs set
+		const previousEvalIds = new Set<string>();
+		if (previousMetadata) {
+			for (const agent of previousMetadata.agents || []) {
+				if (agent.evals) {
+					for (const evalItem of agent.evals) {
+						previousEvalIds.add(evalItem.id);
+					}
+				}
+			}
+		}
+
+		// Get agents and evals to sync using shared diff logic
+		const { create: agentsToCreate, delete: agentsToDelete } = getAgentsToSync(
+			currentMetadata.agents,
+			previousAgentIds,
+			projectId,
+			this.logger
+		);
+		const { create: evalsToCreate, delete: evalsToDelete } = getEvalsToSync(
+			currentMetadata,
+			previousEvalIds,
+			projectId,
+			this.logger
+		);
+
+		// Log the requests that would be made
+		if (agentsToCreate.length > 0 || agentsToDelete.length > 0) {
+			this.logger.info(
+				'[MOCK] Would make request: POST /cli/devmode/agent with %d agent(s) to create, %d agent(s) to delete',
+				agentsToCreate.length,
+				agentsToDelete.length
+			);
+			this.logger.info(
+				'[MOCK] Request payload: %s',
+				JSON.stringify({ create: agentsToCreate, delete: agentsToDelete }, null, 2)
+			);
+		}
+
+		if (evalsToCreate.length > 0 || evalsToDelete.length > 0) {
+			this.logger.info(
+				'[MOCK] Would make request: POST /cli/devmode/eval with %d eval(s) to create, %d eval(s) to delete',
+				evalsToCreate.length,
+				evalsToDelete.length
+			);
+			this.logger.info(
+				'[MOCK] Request payload: %s',
+				JSON.stringify({ create: evalsToCreate, delete: evalsToDelete }, null, 2)
+			);
+		}
+
+		if (
+			agentsToCreate.length === 0 &&
+			agentsToDelete.length === 0 &&
+			evalsToCreate.length === 0 &&
+			evalsToDelete.length === 0
+		) {
+			this.logger.info('[MOCK] No requests would be made (no changes detected)');
+		}
+	}
+}
+
+export function createDevmodeSyncService({
+	logger,
+	apiClient,
+	mock = false,
+}: {
+	logger: Logger;
+	apiClient: APIClient;
+	mock?: boolean;
+}): IDevmodeSyncService {
+	if (mock) {
+		return new MockDevmodeSyncService(logger);
+	}
+
+	return new DevmodeSyncService(logger, apiClient);
+}

package/src/cmd/project/list.ts

@@ -50,7 +50,7 @@ export const listSubcommand = createSubcommand({
 		if (options.json) {
 			console.log(JSON.stringify(projects, null, 2));
 		} else {
-			console.table(projects, ['id', 'name', 'orgName']);
+			tui.table(projects, ['id', 'name', 'orgName']);
 		}
 
 		return projects ?? [];

package/src/cmd/project/show.ts

@@ -45,7 +45,7 @@ export const showSubcommand = createSubcommand({
 		if (options.json) {
 			console.log(JSON.stringify(project, null, 2));
 		} else {
-			console.table([project], ['id', 'orgId']);
+			tui.table([project], ['id', 'orgId']);
 		}
 
 		return {

package/src/repl.ts

@@ -7,7 +7,6 @@ import { getDefaultConfigDir } from './config';
 import { join } from 'node:path';
 import { mkdir } from 'node:fs/promises';
 import { z } from 'zod';
-import { Table } from 'console-table-printer';
 import { colorize } from 'json-colorizer';
 
 /**
@@ -25,12 +24,7 @@ export interface ParsedCommand {
 /**
  * Table column definition
  */
-export interface TableColumn {
-	/** Column name */
-	name: string;
-	/** Column alignment */
-	alignment?: 'left' | 'right' | 'center';
-}
+export type TableColumn = tui.TableColumn;
 
 /**
  * Context provided to command handlers
@@ -522,12 +516,8 @@ export async function createRepl(config: ReplConfig): Promise<void> {
 			signal: abortController.signal,
 			exit: exitRepl,
 			table: (columns: TableColumn[], data: Record<string, unknown>[]) => {
-				const table = new Table({ columns });
-				for (const row of data) {
-					table.addRow(row);
-				}
 				// Capture table output to buffer instead of direct stdout
-				const tableOutput = table.render();
+				const tableOutput = tui.table(data, columns, { render: true }) || '';
 				outputBuffer.push(...tableOutput.split('\n'));
 			},
 			json: (value: unknown) => {

package/src/tui.ts

@@ -1364,3 +1364,97 @@ export function plural(count: number, singular: string, plural: string): string
 			return plural;
 	}
 }
+
+/**
+ * Table column definition
+ */
+export interface TableColumn {
+	/** Column name */
+	name: string;
+	/** Column alignment */
+	alignment?: 'left' | 'right' | 'center';
+}
+
+/**
+ * Display data in a formatted table using console-table-printer
+ *
+ * Supports two modes:
+ * 1. Simple mode: Pass data array and optional column names
+ * 2. Advanced mode: Pass column configurations with custom names and alignment
+ *
+ * @param data - Array of data objects to display
+ * @param columns - Column names or column configurations
+ * @param options - Additional options
+ * @returns If render=true, returns the table as a string, otherwise prints to stdout
+ */
+export function table<T extends Record<string, unknown>>(
+	data: T[],
+	columns?: (keyof T)[] | TableColumn[],
+	options?: { render?: boolean }
+): string | void {
+	// Dynamic import to avoid type errors (console-table-printer has poor typings)
+	// eslint-disable-next-line @typescript-eslint/no-require-imports
+	const { Table } = require('console-table-printer') as {
+		Table: new (options?: { columns?: Array<{ name: string; alignment: string }> }) => {
+			addRow(row: Record<string, unknown>): void;
+			printTable(): void;
+			render(): string;
+		};
+	};
+
+	if (!data || data.length === 0) {
+		return options?.render ? '' : undefined;
+	}
+
+	// Determine if we're using advanced column config or simple column names
+	const isAdvancedMode = columns && columns.length > 0 && typeof columns[0] === 'object';
+
+	let tableConfig: { columns: Array<{ name: string; alignment: string }> };
+
+	if (isAdvancedMode) {
+		// Advanced mode: use provided column configurations
+		tableConfig = {
+			columns: (columns as TableColumn[]).map((col) => ({
+				name: col.name,
+				alignment: col.alignment || 'left',
+			})),
+		};
+	} else {
+		// Simple mode: determine column names from data or columns parameter
+		const columnNames = columns
+			? (columns as (keyof T)[]).map((c) => String(c))
+			: data.length > 0
+				? Object.keys(data[0])
+				: [];
+
+		tableConfig = {
+			columns: columnNames.map((name) => ({
+				name,
+				alignment: 'left',
+			})),
+		};
+	}
+
+	const t = new Table(tableConfig);
+
+	// Add rows to table
+	for (const row of data) {
+		if (columns && !isAdvancedMode) {
+			// Simple mode with column filtering
+			const filtered: Record<string, unknown> = {};
+			for (const col of columns as (keyof T)[]) {
+				filtered[String(col)] = row[col];
+			}
+			t.addRow(filtered);
+		} else {
+			// Advanced mode or no column filtering
+			t.addRow(row);
+		}
+	}
+
+	if (options?.render) {
+		return t.render();
+	} else {
+		t.printTable();
+	}
+}

package/src/types.ts

@@ -413,21 +413,24 @@ const FileFields = {
 	identifier: zod.string().describe('the folder for the file'),
 };
 
+const EvalSchema = zod.object({
+	...FileFields,
+	id: zod.string().describe('the unique calculated id for the eval'),
+	evalId: zod.string().describe('the unique id for eval for the project across deployments'),
+	name: zod.string().describe('the name of the eval'),
+	description: zod.string().optional().describe('the eval description'),
+	agentIdentifier: zod.string().describe('the identifier of the agent'),
+	projectId: zod.string().describe('the project id'),
+});
+
 const BaseAgentFields = {
 	...FileFields,
 	id: zod.string().describe('the unique calculated id for the agent'),
+	agentId: zod.string().describe('the unique id for agent for the project across deployments'),
+	projectId: zod.string().describe('the project id'),
 	name: zod.string().describe('the name of the agent'),
 	description: zod.string().optional().describe('the agent description'),
-	evals: zod
-		.array(
-			zod.object({
-				...FileFields,
-				name: zod.string().describe('the name of the eval'),
-				description: zod.string().optional().describe('the eval description'),
-			})
-		)
-		.optional()
-		.describe('the evals for the agent'),
+	evals: zod.array(EvalSchema).optional().describe('the evals for the agent'),
 };
 
 const AgentSchema = zod.object({

package/src/utils/format.ts

@@ -0,0 +1,17 @@
+/**
+ * Abbreviate a string to a maximum length, adding ellipsis if truncated
+ */
+export function abbreviate(str: string | null | undefined, maxLength = 8): string {
+	if (!str) return 'N/A';
+	if (str.length <= maxLength) return str;
+	return str.slice(0, maxLength) + '...';
+}
+
+/**
+ * Abbreviate a description (longer default length)
+ */
+export function abbreviateDescription(str: string | null | undefined, maxLength = 40): string {
+	if (!str) return 'N/A';
+	if (str.length <= maxLength) return str;
+	return str.slice(0, maxLength) + '...';
+}