@roj-ai/cli 0.0.2

package/src/main.ts

@@ -0,0 +1,319 @@
+import { SessionId } from '@roj-ai/shared'
+import { RpcError } from '@roj-ai/shared/rpc'
+import { createCliClient } from './client.js'
+import { answerCommand } from './commands/answer.js'
+import {
+	agentCommand,
+	agentsCommand,
+	debugSendCommand,
+	eventsCommand,
+	llmCallCommand,
+	llmCallsCommand,
+	mailboxCommand,
+	metricsCommand,
+	presetAgentsCommand,
+	spawnAgentCommand,
+	timelineCommand,
+} from './commands/debug.js'
+import { messagesCommand, sendCommand } from './commands/messages.js'
+import { presetsCommand } from './commands/presets.js'
+import { sessionCloseCommand, sessionCreateCommand, sessionGetCommand, sessionsListCommand } from './commands/sessions.js'
+import { startRepl } from './repl/repl.js'
+
+const USAGE = `Usage:
+  roj-cli [options]                                  Start REPL
+  roj-cli <command> [args] [options]                  Non-interactive
+
+Options:
+  --url <url>     Server URL (default: http://localhost:2486, env: ROJ_URL)
+  --json          Output as JSON (non-interactive only)
+
+Commands:
+  presets                                                List available presets
+  sessions [--status active|closed|errored]              List sessions
+  session-create <presetId>                              Create new session
+  session-get <sessionId>                                Get session info
+  session-close <sessionId>                              Close session
+  messages <sessionId>                                   Get messages
+  send <sessionId> <message> [--wait]                    Send message
+  answer <sessionId> <questionId> <answer>               Answer agent question
+
+Debug commands:
+  events <sessionId> [--type <type>] [--agent <id>] [--limit N]   Show domain events
+  agents <sessionId>                                               Show agent tree
+  agent <sessionId> <agentId>                                      Show agent detail
+  mailbox <sessionId>                                              Show global mailbox
+  timeline <sessionId>                                             Show execution timeline
+  metrics <sessionId>                                              Show session metrics
+  llm-calls <sessionId> [--limit N]                                List LLM calls
+  llm-call <sessionId> <callId>                                    Show LLM call detail
+  preset-agents <sessionId>                                        Show spawnable agents
+  debug-send <sessionId> <agentId> <message> [--from <sender>]     Send debug message
+  spawn-agent <sessionId> <defName> <parentId> [--message <msg>]   Spawn agent manually`
+
+interface ParsedArgs {
+	url: string
+	json: boolean
+	command: string | null
+	positional: string[]
+	flags: Record<string, string | true>
+}
+
+function parseArgs(argv: string[]): ParsedArgs {
+	// Skip bun and script path
+	const args = argv.slice(2)
+
+	let url = process.env.ROJ_URL ?? 'http://localhost:2486'
+	let json = false
+	const positional: string[] = []
+	const flags: Record<string, string | true> = {}
+
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i]
+		if (arg === '--url') {
+			url = args[++i]
+		} else if (arg === '--json') {
+			json = true
+		} else if (arg === '--help' || arg === '-h') {
+			console.log(USAGE)
+			process.exit(0)
+		} else if (arg.startsWith('--')) {
+			const key = arg.slice(2)
+			const next = args[i + 1]
+			if (next && !next.startsWith('--')) {
+				flags[key] = next
+				i++
+			} else {
+				flags[key] = true
+			}
+		} else {
+			positional.push(arg)
+		}
+	}
+
+	return {
+		url,
+		json,
+		command: positional[0] ?? null,
+		positional: positional.slice(1),
+		flags,
+	}
+}
+
+async function main(): Promise<void> {
+	const parsed = parseArgs(process.argv)
+	const client = createCliClient(parsed.url)
+
+	// REPL mode if no command
+	if (!parsed.command) {
+		await startRepl(client, parsed.url)
+		return
+	}
+
+	switch (parsed.command) {
+		case 'presets':
+			await presetsCommand(client, parsed.json)
+			break
+
+		case 'sessions': {
+			const status = parsed.flags.status as 'active' | 'closed' | 'errored' | undefined
+			await sessionsListCommand(client, typeof status === 'string' ? status : undefined, parsed.json)
+			break
+		}
+
+		case 'session-create': {
+			const presetId = parsed.positional[0]
+			if (!presetId) {
+				console.error('Usage: session-create <presetId>')
+				process.exit(1)
+			}
+			await sessionCreateCommand(client, presetId, parsed.json)
+			break
+		}
+
+		case 'session-get': {
+			const sessionId = parsed.positional[0]
+			if (!sessionId) {
+				console.error('Usage: session-get <sessionId>')
+				process.exit(1)
+			}
+			await sessionGetCommand(client, sessionId, parsed.json)
+			break
+		}
+
+		case 'session-close': {
+			const sessionId = parsed.positional[0]
+			if (!sessionId) {
+				console.error('Usage: session-close <sessionId>')
+				process.exit(1)
+			}
+			await sessionCloseCommand(client, sessionId, parsed.json)
+			break
+		}
+
+		case 'messages': {
+			const sessionId = parsed.positional[0]
+			if (!sessionId) {
+				console.error('Usage: messages <sessionId>')
+				process.exit(1)
+			}
+			await messagesCommand(client, sessionId, parsed.json)
+			break
+		}
+
+		case 'send': {
+			const sessionId = parsed.positional[0]
+			const message = parsed.positional.slice(1).join(' ')
+			if (!sessionId || !message) {
+				console.error('Usage: send <sessionId> <message> [--wait]')
+				process.exit(1)
+			}
+			const wait = parsed.flags.wait === true
+			await sendCommand(client, parsed.url, sessionId, message, wait, parsed.json)
+			break
+		}
+
+		case 'answer': {
+			const sessionId = parsed.positional[0]
+			const questionId = parsed.positional[1]
+			const answer = parsed.positional.slice(2).join(' ')
+			if (!sessionId || !questionId || !answer) {
+				console.error('Usage: answer <sessionId> <questionId> <answer>')
+				process.exit(1)
+			}
+			await answerCommand(client, sessionId, questionId, answer, parsed.json)
+			break
+		}
+
+		// Debug commands
+		case 'events': {
+			const sessionId = parsed.positional[0]
+			if (!sessionId) {
+				console.error('Usage: events <sessionId> [--type <type>] [--agent <agentId>] [--limit N]')
+				process.exit(1)
+			}
+			await eventsCommand(client, sessionId, parsed.flags, parsed.json)
+			break
+		}
+
+		case 'agents': {
+			const sessionId = parsed.positional[0]
+			if (!sessionId) {
+				console.error('Usage: agents <sessionId>')
+				process.exit(1)
+			}
+			await agentsCommand(client, sessionId, parsed.json)
+			break
+		}
+
+		case 'agent': {
+			const sessionId = parsed.positional[0]
+			const agentId = parsed.positional[1]
+			if (!sessionId || !agentId) {
+				console.error('Usage: agent <sessionId> <agentId>')
+				process.exit(1)
+			}
+			await agentCommand(client, sessionId, agentId, parsed.json)
+			break
+		}
+
+		case 'mailbox': {
+			const sessionId = parsed.positional[0]
+			if (!sessionId) {
+				console.error('Usage: mailbox <sessionId>')
+				process.exit(1)
+			}
+			await mailboxCommand(client, sessionId, parsed.json)
+			break
+		}
+
+		case 'timeline': {
+			const sessionId = parsed.positional[0]
+			if (!sessionId) {
+				console.error('Usage: timeline <sessionId>')
+				process.exit(1)
+			}
+			await timelineCommand(client, sessionId, parsed.json)
+			break
+		}
+
+		case 'metrics': {
+			const sessionId = parsed.positional[0]
+			if (!sessionId) {
+				console.error('Usage: metrics <sessionId>')
+				process.exit(1)
+			}
+			await metricsCommand(client, sessionId, parsed.json)
+			break
+		}
+
+		case 'llm-calls': {
+			const sessionId = parsed.positional[0]
+			if (!sessionId) {
+				console.error('Usage: llm-calls <sessionId> [--limit N]')
+				process.exit(1)
+			}
+			await llmCallsCommand(client, sessionId, parsed.flags, parsed.json)
+			break
+		}
+
+		case 'llm-call': {
+			const sessionId = parsed.positional[0]
+			const callId = parsed.positional[1]
+			if (!sessionId || !callId) {
+				console.error('Usage: llm-call <sessionId> <callId>')
+				process.exit(1)
+			}
+			await llmCallCommand(client, sessionId, callId, parsed.json)
+			break
+		}
+
+		case 'preset-agents': {
+			const sessionId = parsed.positional[0]
+			if (!sessionId) {
+				console.error('Usage: preset-agents <sessionId>')
+				process.exit(1)
+			}
+			await presetAgentsCommand(client, SessionId(sessionId), parsed.json)
+			break
+		}
+
+		case 'debug-send': {
+			const sessionId = parsed.positional[0]
+			const agentId = parsed.positional[1]
+			const message = parsed.positional.slice(2).join(' ')
+			if (!sessionId || !agentId || !message) {
+				console.error('Usage: debug-send <sessionId> <agentId> <message> [--from <sender>]')
+				process.exit(1)
+			}
+			await debugSendCommand(client, sessionId, agentId, message, parsed.flags, parsed.json)
+			break
+		}
+
+		case 'spawn-agent': {
+			const sessionId = parsed.positional[0]
+			const definitionName = parsed.positional[1]
+			const parentId = parsed.positional[2]
+			if (!sessionId || !definitionName || !parentId) {
+				console.error('Usage: spawn-agent <sessionId> <definitionName> <parentId> [--message <msg>]')
+				process.exit(1)
+			}
+			await spawnAgentCommand(client, sessionId, definitionName, parentId, parsed.flags, parsed.json)
+			break
+		}
+
+		default:
+			console.error(`Unknown command: ${parsed.command}`)
+			console.error(USAGE)
+			process.exit(1)
+	}
+}
+
+main().catch((error) => {
+	if (error instanceof RpcError) {
+		console.error(`RPC Error [${error.error.type}]: ${error.error.message}`)
+	} else {
+		console.error(error instanceof Error ? error.message : String(error))
+	}
+	process.exit(1)
+})

package/src/repl/formatter.ts

@@ -0,0 +1,84 @@
+import type { AskUserInputTypeSchema } from '@roj-ai/sdk'
+import type { ChatMessage } from '@roj-ai/shared/rpc'
+
+// ANSI color codes
+const RESET = '\x1b[0m'
+const BOLD = '\x1b[1m'
+const DIM = '\x1b[2m'
+const CYAN = '\x1b[36m'
+const GREEN = '\x1b[32m'
+const YELLOW = '\x1b[33m'
+const RED = '\x1b[31m'
+const MAGENTA = '\x1b[35m'
+
+export function formatAgentMessage(content: string): string {
+	return `${CYAN}${BOLD}Agent:${RESET} ${content}`
+}
+
+export function formatUserMessage(content: string): string {
+	return `${GREEN}${BOLD}You:${RESET} ${content}`
+}
+
+export function formatStatus(status: string): string {
+	return `${DIM}[${status}]${RESET}`
+}
+
+export function formatError(message: string): string {
+	return `${RED}Error: ${message}${RESET}`
+}
+
+export function formatQuestion(question: string, inputType: AskUserInputTypeSchema): string {
+	const lines = [`${YELLOW}${BOLD}Question:${RESET} ${question}`]
+
+	if (inputType.type === 'single_choice' || inputType.type === 'multi_choice') {
+		for (let i = 0; i < inputType.options.length; i++) {
+			const opt = inputType.options[i]
+			const desc = opt.description ? ` - ${opt.description}` : ''
+			lines.push(`  ${MAGENTA}${i + 1})${RESET} ${opt.label}${DIM}${desc}${RESET}`)
+		}
+		if (inputType.type === 'single_choice') {
+			lines.push(`${DIM}Enter number to select:${RESET}`)
+		} else {
+			lines.push(`${DIM}Enter numbers separated by commas:${RESET}`)
+		}
+	} else if (inputType.type === 'confirm') {
+		const confirmLabel = inputType.confirmLabel ?? 'yes'
+		const cancelLabel = inputType.cancelLabel ?? 'no'
+		lines.push(`${DIM}(${confirmLabel}/${cancelLabel}):${RESET}`)
+	} else if (inputType.type === 'rating') {
+		lines.push(`${DIM}Enter a number from ${inputType.min} to ${inputType.max}:${RESET}`)
+	}
+
+	return lines.join('\n')
+}
+
+export function formatChatMessage(msg: ChatMessage): string {
+	switch (msg.type) {
+		case 'user_message':
+			return formatUserMessage(msg.content)
+		case 'agent_message':
+			return formatAgentMessage(msg.content)
+		case 'ask_user': {
+			const answered = msg.answered ? `${DIM} (answered: ${JSON.stringify(msg.answer)})${RESET}` : ''
+			return formatQuestion(msg.question, msg.inputType) + answered
+		}
+	}
+}
+
+export function formatSessionInfo(session: { sessionId: string; presetId: string; status: string; createdAt: number }): string {
+	const date = new Date(session.createdAt).toLocaleString()
+	return `${BOLD}${session.sessionId}${RESET} ${DIM}[${session.presetId}]${RESET} ${session.status} ${DIM}${date}${RESET}`
+}
+
+export function formatTable(headers: string[], rows: string[][]): string {
+	const colWidths = headers.map((h, i) => {
+		const maxDataWidth = rows.reduce((max, row) => Math.max(max, (row[i] ?? '').length), 0)
+		return Math.max(h.length, maxDataWidth)
+	})
+
+	const headerLine = headers.map((h, i) => h.padEnd(colWidths[i])).join('  ')
+	const separator = colWidths.map(w => '─'.repeat(w)).join('──')
+	const dataLines = rows.map(row => row.map((cell, i) => (cell ?? '').padEnd(colWidths[i])).join('  '))
+
+	return [headerLine, separator, ...dataLines].join('\n')
+}

package/src/repl/repl.ts

@@ -0,0 +1,246 @@
+import type { ChatMessage, SessionId } from '@roj-ai/sdk'
+import type { AskUserInputTypeSchema } from '@roj-ai/sdk'
+import { AgentId, ChatMessageId } from '@roj-ai/shared'
+
+function isChatMessage(msg: unknown): msg is ChatMessage {
+	return typeof msg === 'object' && msg !== null && 'type' in msg && 'timestamp' in msg
+}
+import type { RpcClient } from '@roj-ai/shared/rpc'
+import * as readline from 'node:readline'
+import { connectWebSocket, type NotificationHandlers, type WsConnection } from '../client.js'
+import { unwrap } from '../unwrap.js'
+import { formatAgentMessage, formatChatMessage, formatError, formatQuestion, formatStatus } from './formatter.js'
+import { createNewSession, pickSession } from './session-picker.js'
+
+const DIM = '\x1b[2m'
+const RESET = '\x1b[0m'
+
+export async function startRepl(client: RpcClient, baseUrl: string): Promise<void> {
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout,
+	})
+
+	console.log(`${DIM}Connected to ${baseUrl}${RESET}`)
+	console.log(`${DIM}Commands: /quit, /sessions, /new, /messages, /help${RESET}`)
+
+	let sessionId = await pickSession(client, rl)
+	let entryAgentId = await resolveEntryAgentId(client, sessionId)
+	await loadAndDisplayMessages(client, sessionId)
+
+	let pendingQuestion: { questionId: string; inputType: AskUserInputTypeSchema } | null = null
+
+	const handlers: NotificationHandlers = {
+		agentMessage: (payload) => {
+			if (typeof payload !== 'object' || payload === null) return
+			const input = payload as Record<string, unknown>
+			if (typeof input.content !== 'string') return
+			readline.clearLine(process.stdout, 0)
+			readline.cursorTo(process.stdout, 0)
+			console.log(formatAgentMessage(input.content))
+			rl.prompt()
+		},
+		askUser: (payload) => {
+			if (typeof payload !== 'object' || payload === null) return
+			const input = payload as Record<string, unknown>
+			if (typeof input.questionId !== 'string' || typeof input.question !== 'string') return
+			readline.clearLine(process.stdout, 0)
+			readline.cursorTo(process.stdout, 0)
+			console.log(formatQuestion(input.question, input.inputType as AskUserInputTypeSchema))
+			pendingQuestion = { questionId: input.questionId, inputType: input.inputType as AskUserInputTypeSchema }
+			rl.prompt()
+		},
+		agentStatus: (payload) => {
+			if (typeof payload !== 'object' || payload === null) return
+			const input = payload as Record<string, unknown>
+			if (typeof input.status !== 'string') return
+			const statusLabels: Record<string, string> = {
+				idle: 'Agent idle',
+				thinking: 'Agent thinking...',
+				responding: 'Agent responding...',
+				waiting_for_user: 'Waiting for your input',
+				error: 'Agent error',
+			}
+			readline.clearLine(process.stdout, 0)
+			readline.cursorTo(process.stdout, 0)
+			console.log(formatStatus(statusLabels[input.status] ?? input.status))
+			rl.prompt()
+		},
+		error: (payload) => {
+			if (typeof payload !== 'object' || payload === null) return
+			const input = payload as Record<string, unknown>
+			if (typeof input.message !== 'string') return
+			readline.clearLine(process.stdout, 0)
+			readline.cursorTo(process.stdout, 0)
+			console.log(formatError(input.message))
+			rl.prompt()
+		},
+	}
+
+	let connection = connectWebSocket(baseUrl, sessionId, handlers)
+	await connection.connect()
+
+	rl.setPrompt('> ')
+	rl.prompt()
+
+	rl.on('line', async (line) => {
+		const input = line.trim()
+		if (!input) {
+			rl.prompt()
+			return
+		}
+
+		if (input.startsWith('/')) {
+			const handled = await handleSlashCommand(input, client, baseUrl, rl, sessionId, connection)
+			if (handled === 'quit') {
+				await connection.disconnect()
+				rl.close()
+				return
+			}
+			if (handled !== false) {
+				// Session switch
+				await connection.disconnect()
+				sessionId = handled
+				entryAgentId = await resolveEntryAgentId(client, sessionId)
+				connection = connectWebSocket(baseUrl, sessionId, handlers)
+				await connection.connect()
+				await loadAndDisplayMessages(client, sessionId)
+			}
+			rl.prompt()
+			return
+		}
+
+		// Handle pending question answer
+		if (pendingQuestion && entryAgentId) {
+			const answer = parseAnswer(input, pendingQuestion.inputType)
+			unwrap(
+				await client.call('user-chat.answerQuestion', {
+					sessionId,
+					agentId: AgentId(entryAgentId),
+					questionId: ChatMessageId(pendingQuestion.questionId),
+					answer,
+				}),
+			)
+			pendingQuestion = null
+			rl.prompt()
+			return
+		}
+
+		// Send message
+		if (entryAgentId) {
+			unwrap(await client.call('user-chat.sendMessage', { sessionId, agentId: AgentId(entryAgentId), content: input }))
+		}
+		rl.prompt()
+	})
+
+	rl.on('close', async () => {
+		await connection.disconnect()
+		process.exit(0)
+	})
+}
+
+async function resolveEntryAgentId(client: RpcClient, sessionId: SessionId): Promise<string | null> {
+	const session = unwrap(await client.call('sessions.get', { sessionId }))
+	return session.entryAgentId
+}
+
+async function loadAndDisplayMessages(client: RpcClient, sessionId: SessionId): Promise<void> {
+	const { messages: rawMessages } = unwrap(await client.call('user-chat.getMessages', { sessionId }))
+	const messages = rawMessages.filter(isChatMessage)
+	if (messages.length > 0) {
+		console.log()
+		console.log(`${DIM}--- Message history ---${RESET}`)
+		for (const msg of messages) {
+			console.log(formatChatMessage(msg))
+			console.log()
+		}
+		console.log(`${DIM}--- End of history ---${RESET}`)
+		console.log()
+	}
+}
+
+type SlashResult = 'quit' | SessionId | false
+
+async function handleSlashCommand(
+	input: string,
+	client: RpcClient,
+	_baseUrl: string,
+	rl: readline.Interface,
+	currentSessionId: SessionId,
+	_connection: WsConnection,
+): Promise<SlashResult> {
+	const [cmd] = input.split(/\s+/)
+
+	switch (cmd) {
+		case '/quit':
+		case '/exit':
+		case '/q':
+			return 'quit'
+
+		case '/sessions': {
+			const newSessionId = await pickSession(client, rl)
+			if (newSessionId !== currentSessionId) {
+				return newSessionId
+			}
+			return false
+		}
+
+		case '/new': {
+			const newSessionId = await createNewSession(client, rl)
+			return newSessionId
+		}
+
+		case '/messages': {
+			await loadAndDisplayMessages(client, currentSessionId)
+			return false
+		}
+
+		case '/help':
+			console.log(`${DIM}Commands:${RESET}`)
+			console.log(`  /quit, /exit, /q  - Exit the REPL`)
+			console.log(`  /sessions         - Switch to another session`)
+			console.log(`  /new              - Create a new session`)
+			console.log(`  /messages         - Show message history`)
+			console.log(`  /help             - Show this help`)
+			return false
+
+		default:
+			console.log(`Unknown command: ${cmd}. Type /help for available commands.`)
+			return false
+	}
+}
+
+function parseAnswer(input: string, inputType: AskUserInputTypeSchema): unknown {
+	switch (inputType.type) {
+		case 'text':
+			return input
+
+		case 'single_choice': {
+			const index = parseInt(input, 10) - 1
+			if (index >= 0 && index < inputType.options.length) {
+				return inputType.options[index].value
+			}
+			return input
+		}
+
+		case 'multi_choice': {
+			const indices = input.split(',').map(s => parseInt(s.trim(), 10) - 1)
+			return indices
+				.filter(i => i >= 0 && i < inputType.options.length)
+				.map(i => inputType.options[i].value)
+		}
+
+		case 'confirm': {
+			const lower = input.toLowerCase()
+			return lower === 'y' || lower === 'yes' || lower === '1' || lower === 'true'
+		}
+
+		case 'rating': {
+			const num = parseInt(input, 10)
+			if (num >= inputType.min && num <= inputType.max) {
+				return num
+			}
+			return parseInt(input, 10)
+		}
+	}
+}