@roj-ai/cli 0.0.2

package/src/commands/debug.ts

@@ -0,0 +1,347 @@
+import type { DomainEvent, LLMCallLogEntry, SessionId } from '@roj-ai/sdk'
+import type { GetAgentDetailResponse, ProjectionEvent } from '@roj-ai/shared'
+import {
+	type AgentDetailProjectionState,
+	AgentId,
+	type AgentRegistryState,
+	type AgentTreeProjectionState,
+	applyEventToAgentDetail,
+	applyEventToAgentRegistry,
+	applyEventToAgentTree,
+	applyEventToMailbox,
+	applyEventToMetrics,
+	applyEventToTimeline,
+	buildAgentTreeFromProjection,
+	createAgentDetailProjectionState,
+	createAgentRegistryState,
+	createAgentTreeProjectionState,
+	createMailboxState,
+	createMetricsState,
+	createTimelineState,
+	getAgentDetail,
+	getMailboxMessages,
+	getTimelineItems,
+	isDomainEvent,
+	metricsStateToResponse,
+} from '@roj-ai/shared'
+import type { RpcClient, RpcOutput } from '@roj-ai/shared/rpc'
+import { formatTable } from '../repl/formatter.js'
+import { unwrap } from '../unwrap.js'
+import {
+	formatAgentDetail,
+	formatAgentTree,
+	formatEventRow,
+	formatLLMCallDetail,
+	formatMailboxMessage,
+	formatMetrics,
+	formatTimelineItem,
+	truncate,
+} from './debug-format.js'
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+function isLLMCallLogEntry(data: unknown): data is LLMCallLogEntry {
+	return typeof data === 'object' && data !== null && 'id' in data && 'status' in data && 'request' in data
+}
+
+interface LoadedProjections {
+	registry: AgentRegistryState
+	agentTree: AgentTreeProjectionState
+	agentDetail: AgentDetailProjectionState
+	events: DomainEvent[]
+}
+
+async function loadProjections(client: RpcClient, sessionId: string): Promise<LoadedProjections> {
+	const { events: rawEvents } = unwrap(await client.call('sessions.getEvents', { sessionId, limit: 10000 }))
+	const events = rawEvents.filter(isDomainEvent)
+
+	let registry = createAgentRegistryState()
+	let agentTree = createAgentTreeProjectionState()
+	let agentDetail = createAgentDetailProjectionState()
+
+	for (const event of events) {
+		const e = event as ProjectionEvent
+		registry = applyEventToAgentRegistry(registry, e)
+		agentTree = applyEventToAgentTree(agentTree, e)
+		agentDetail = applyEventToAgentDetail(agentDetail, e)
+	}
+
+	return { registry, agentTree, agentDetail, events }
+}
+
+// ============================================================================
+// Direct RPC Commands
+// ============================================================================
+
+export async function eventsCommand(
+	client: RpcClient,
+	sessionId: string,
+	flags: Record<string, string | true>,
+	json: boolean,
+): Promise<void> {
+	const limit = typeof flags.limit === 'string' ? parseInt(flags.limit, 10) : undefined
+	const type = typeof flags.type === 'string' ? flags.type : undefined
+	const agentId = typeof flags.agent === 'string' ? flags.agent : undefined
+
+	const { events: rawEvents, total } = unwrap(await client.call('sessions.getEvents', { sessionId, limit, type, agentId }))
+	const events = rawEvents.filter(isDomainEvent)
+
+	if (json) {
+		console.log(JSON.stringify({ events, total }, null, 2))
+		return
+	}
+
+	if (events.length === 0) {
+		console.log('No events found.')
+		return
+	}
+
+	console.log(formatTable(
+		['#', 'Type', 'Agent', 'Time'],
+		events.map((e, i) => formatEventRow(e, i)),
+	))
+	console.log(`\nTotal: ${total} events`)
+}
+
+export async function llmCallsCommand(
+	client: RpcClient,
+	sessionId: string,
+	flags: Record<string, string | true>,
+	json: boolean,
+): Promise<void> {
+	const limit = typeof flags.limit === 'string' ? parseInt(flags.limit, 10) : undefined
+
+	const { calls, total } = unwrap(await client.call('llm.getCalls', { sessionId, limit }))
+
+	if (json) {
+		console.log(JSON.stringify({ calls, total }, null, 2))
+		return
+	}
+
+	if (calls.length === 0) {
+		console.log('No LLM calls found.')
+		return
+	}
+
+	const typedCalls = calls.filter(isLLMCallLogEntry)
+	console.log(formatTable(
+		['Time', 'Status', 'Model', 'Duration', 'Tokens', 'Cost', 'Agent'],
+		typedCalls.map((c) => {
+			const time = new Date(c.createdAt).toLocaleTimeString()
+			const duration = c.durationMs !== undefined ? `${(c.durationMs / 1000).toFixed(1)}s` : '-'
+			const tokens = c.metrics ? `${c.metrics.promptTokens}/${c.metrics.completionTokens}` : '-'
+			const cost = c.metrics?.cost !== undefined ? `$${c.metrics.cost.toFixed(4)}` : '-'
+			return [time, c.status, c.request.model, duration, tokens, cost, String(c.agentId)]
+		}),
+	))
+	console.log(`\nTotal: ${total} calls`)
+}
+
+export async function llmCallCommand(
+	client: RpcClient,
+	sessionId: string,
+	callId: string,
+	json: boolean,
+): Promise<void> {
+	const callData = unwrap(await client.call('llm.getCall', { sessionId, callId }))
+
+	if (json) {
+		console.log(JSON.stringify(callData, null, 2))
+		return
+	}
+
+	if (!isLLMCallLogEntry(callData)) {
+		console.error('Invalid LLM call data.')
+		return
+	}
+
+	console.log(formatLLMCallDetail(callData))
+}
+
+export async function presetAgentsCommand(
+	client: RpcClient,
+	sessionId: SessionId,
+	json: boolean,
+): Promise<void> {
+	const result = unwrap(await client.call('presets.getAgents', { sessionId }))
+	const agents = result.agents
+
+	if (json) {
+		console.log(JSON.stringify(agents, null, 2))
+		return
+	}
+
+	if (agents.length === 0) {
+		console.log('No agent definitions found.')
+		return
+	}
+
+	type PresetAgent = RpcOutput<'presets.getAgents'>['agents'][number]
+	console.log(formatTable(
+		['Name', 'Spawnable By', 'Has Input Schema'],
+		agents.map((a: PresetAgent) => [a.name, a.spawnableBy.join(', '), a.hasInputSchema ? 'yes' : 'no']),
+	))
+}
+
+export async function debugSendCommand(
+	client: RpcClient,
+	sessionId: string,
+	agentId: string,
+	content: string,
+	flags: Record<string, string | true>,
+	json: boolean,
+): Promise<void> {
+	const { messageId } = unwrap(await client.call('user-chat.sendMessage', { sessionId, agentId: AgentId(agentId), content }))
+
+	if (json) {
+		console.log(JSON.stringify({ messageId }))
+		return
+	}
+
+	console.log(`Message sent: ${messageId}`)
+}
+
+export async function spawnAgentCommand(
+	client: RpcClient,
+	sessionId: string,
+	definitionName: string,
+	parentId: string,
+	flags: Record<string, string | true>,
+	json: boolean,
+): Promise<void> {
+	const message = typeof flags.message === 'string' ? flags.message : undefined
+	const { agentId } = unwrap(await client.call('agents.spawn', { sessionId, definitionName, parentId: AgentId(parentId), message }))
+
+	if (json) {
+		console.log(JSON.stringify({ agentId }))
+		return
+	}
+
+	console.log(`Agent spawned: ${agentId}`)
+}
+
+// ============================================================================
+// Event-sourced Projection Commands
+// ============================================================================
+
+export async function agentsCommand(
+	client: RpcClient,
+	sessionId: string,
+	json: boolean,
+): Promise<void> {
+	const { agentTree: agentTreeState } = await loadProjections(client, sessionId)
+	const tree = buildAgentTreeFromProjection(agentTreeState)
+
+	if (json) {
+		console.log(JSON.stringify(tree, null, 2))
+		return
+	}
+
+	if (tree.length === 0) {
+		console.log('No agents.')
+		return
+	}
+
+	console.log(formatAgentTree(tree))
+}
+
+export async function agentCommand(
+	client: RpcClient,
+	sessionId: string,
+	agentId: string,
+	json: boolean,
+): Promise<void> {
+	const { agentDetail: agentDetailState } = await loadProjections(client, sessionId)
+	const detail = getAgentDetail(agentDetailState, AgentId(agentId))
+
+	if (!detail) {
+		console.error(`Agent not found: ${agentId}`)
+		process.exit(1)
+	}
+
+	if (json) {
+		console.log(JSON.stringify(detail, null, 2))
+		return
+	}
+
+	console.log(formatAgentDetail(detail))
+}
+
+export async function mailboxCommand(
+	client: RpcClient,
+	sessionId: string,
+	json: boolean,
+): Promise<void> {
+	const { registry, events } = await loadProjections(client, sessionId)
+
+	let mailboxState = createMailboxState()
+	for (const event of events) {
+		mailboxState = applyEventToMailbox(mailboxState, event as ProjectionEvent, registry)
+	}
+	const messages = getMailboxMessages(mailboxState)
+
+	if (json) {
+		console.log(JSON.stringify(messages, null, 2))
+		return
+	}
+
+	if (messages.length === 0) {
+		console.log('No mailbox messages.')
+		return
+	}
+
+	for (const msg of messages) {
+		console.log(formatMailboxMessage(msg))
+	}
+}
+
+export async function timelineCommand(
+	client: RpcClient,
+	sessionId: string,
+	json: boolean,
+): Promise<void> {
+	const { registry, events } = await loadProjections(client, sessionId)
+
+	let timelineState = createTimelineState()
+	for (const event of events) {
+		timelineState = applyEventToTimeline(timelineState, event as ProjectionEvent, registry)
+	}
+	const items = getTimelineItems(timelineState, registry)
+
+	if (json) {
+		console.log(JSON.stringify(items, null, 2))
+		return
+	}
+
+	if (items.length === 0) {
+		console.log('No timeline items.')
+		return
+	}
+
+	for (const item of items) {
+		console.log(formatTimelineItem(item))
+	}
+}
+
+export async function metricsCommand(
+	client: RpcClient,
+	sessionId: string,
+	json: boolean,
+): Promise<void> {
+	const { registry, events } = await loadProjections(client, sessionId)
+
+	let metricsState = createMetricsState()
+	for (const event of events) {
+		metricsState = applyEventToMetrics(metricsState, event as ProjectionEvent)
+	}
+	const metrics = metricsStateToResponse(metricsState, registry.count)
+
+	if (json) {
+		console.log(JSON.stringify(metrics, null, 2))
+		return
+	}
+
+	console.log(formatMetrics(metrics))
+}

package/src/commands/messages.ts

@@ -0,0 +1,92 @@
+import type { ChatMessage } from '@roj-ai/sdk'
+import { AgentId } from '@roj-ai/shared'
+import type { RpcClient } from '@roj-ai/shared/rpc'
+import { connectWebSocket } from '../client.js'
+import { formatChatMessage } from '../repl/formatter.js'
+import { unwrap } from '../unwrap.js'
+
+function isChatMessage(msg: unknown): msg is ChatMessage {
+	return typeof msg === 'object' && msg !== null && 'type' in msg && 'timestamp' in msg
+}
+
+export async function messagesCommand(client: RpcClient, sessionId: string, json: boolean): Promise<void> {
+	const { messages: rawMessages } = unwrap(await client.call('user-chat.getMessages', { sessionId }))
+	const messages = rawMessages.filter(isChatMessage)
+
+	if (json) {
+		console.log(JSON.stringify(messages, null, 2))
+		return
+	}
+
+	if (messages.length === 0) {
+		console.log('No messages.')
+		return
+	}
+
+	for (const msg of messages) {
+		console.log(formatChatMessage(msg))
+		console.log()
+	}
+}
+
+export async function sendCommand(
+	client: RpcClient,
+	baseUrl: string,
+	sessionId: string,
+	content: string,
+	wait: boolean,
+	json: boolean,
+): Promise<void> {
+	const session = unwrap(await client.call('sessions.get', { sessionId }))
+	if (!session.entryAgentId) {
+		console.error('No entry agent found for session.')
+		process.exit(1)
+	}
+	const { messageId } = unwrap(await client.call('user-chat.sendMessage', { sessionId, agentId: AgentId(session.entryAgentId), content }))
+
+	if (!wait) {
+		if (json) {
+			console.log(JSON.stringify({ messageId }))
+		} else {
+			console.log(`Message sent: ${messageId}`)
+		}
+		return
+	}
+
+	// Wait for agent response via WebSocket
+	const responsePromise = new Promise<string>((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			connection.disconnect()
+			reject(new Error('Timeout waiting for agent response'))
+		}, 120_000)
+
+		const connection = connectWebSocket(baseUrl, sessionId, {
+			agentMessage: (payload) => {
+				if (typeof payload !== 'object' || payload === null) return
+				const input = payload as Record<string, unknown>
+				if (typeof input.content !== 'string') return
+				clearTimeout(timeout)
+				connection.disconnect()
+				resolve(input.content)
+			},
+			error: (payload) => {
+				if (typeof payload !== 'object' || payload === null) return
+				const input = payload as Record<string, unknown>
+				if (typeof input.message !== 'string') return
+				clearTimeout(timeout)
+				connection.disconnect()
+				reject(new Error(input.message))
+			},
+		})
+
+		connection.connect().catch(reject)
+	})
+
+	const response = await responsePromise
+
+	if (json) {
+		console.log(JSON.stringify({ messageId, response }))
+	} else {
+		console.log(response)
+	}
+}

package/src/commands/presets.ts

@@ -0,0 +1,22 @@
+import type { RpcClient } from '@roj-ai/shared/rpc'
+import { formatTable } from '../repl/formatter.js'
+import { unwrap } from '../unwrap.js'
+
+export async function presetsCommand(client: RpcClient, json: boolean): Promise<void> {
+	const { presets } = unwrap(await client.call('presets.list', {}))
+
+	if (json) {
+		console.log(JSON.stringify(presets, null, 2))
+		return
+	}
+
+	if (presets.length === 0) {
+		console.log('No presets available.')
+		return
+	}
+
+	console.log(formatTable(
+		['ID', 'Name', 'Description'],
+		presets.map(p => [p.id, p.name, p.description ?? '']),
+	))
+}

package/src/commands/sessions.ts

@@ -0,0 +1,73 @@
+import type { SessionMetadata } from '@roj-ai/sdk'
+import type { RpcClient } from '@roj-ai/shared/rpc'
+import { formatSessionInfo, formatTable } from '../repl/formatter.js'
+import { unwrap } from '../unwrap.js'
+
+function isSessionMetadata(data: unknown): data is SessionMetadata {
+	return typeof data === 'object' && data !== null && 'sessionId' in data && 'presetId' in data
+}
+
+export async function sessionsListCommand(
+	client: RpcClient,
+	status: 'active' | 'closed' | 'errored' | undefined,
+	json: boolean,
+): Promise<void> {
+	const { sessions } = unwrap(await client.call('sessions.list', { status, limit: 50, order: 'desc' }))
+
+	if (json) {
+		console.log(JSON.stringify(sessions, null, 2))
+		return
+	}
+
+	if (sessions.length === 0) {
+		console.log('No sessions found.')
+		return
+	}
+
+	console.log(formatTable(
+		['Session ID', 'Preset', 'Status', 'Created'],
+		sessions.filter(isSessionMetadata).map(s => [
+			s.sessionId,
+			s.presetId,
+			s.status,
+			new Date(s.createdAt).toLocaleString(),
+		]),
+	))
+}
+
+export async function sessionCreateCommand(client: RpcClient, presetId: string, json: boolean): Promise<void> {
+	const { sessionId } = unwrap(await client.call('sessions.create', { presetId }))
+
+	if (json) {
+		console.log(JSON.stringify({ sessionId }))
+		return
+	}
+
+	console.log(`Session created: ${sessionId}`)
+}
+
+export async function sessionGetCommand(client: RpcClient, sessionId: string, json: boolean): Promise<void> {
+	const session = unwrap(await client.call('sessions.get', { sessionId }))
+
+	if (json) {
+		console.log(JSON.stringify(session, null, 2))
+		return
+	}
+
+	console.log(formatSessionInfo(session))
+	console.log(`  Agents: ${session.agentCount}`)
+	if (session.closedAt) {
+		console.log(`  Closed: ${new Date(session.closedAt).toLocaleString()}`)
+	}
+}
+
+export async function sessionCloseCommand(client: RpcClient, sessionId: string, json: boolean): Promise<void> {
+	const result = unwrap(await client.call('sessions.close', { sessionId }))
+
+	if (json) {
+		console.log(JSON.stringify(result))
+		return
+	}
+
+	console.log('Session closed.')
+}