From 552c22d74e5df915088d9e9ff4a286c96c2a54d6 Mon Sep 17 00:00:00 2001 From: Adam Malczewski Date: Fri, 5 Jun 2026 21:20:34 +0900 Subject: feat(cli): one-shot terminal client (models, chat, --text/--file/--cwd/--conversation) HTTP client of transport-contract; pure-core arg/render/ndjson + injected fetch/fs shell. Docs: GLOSSARY (credential/key/model name/model catalog), tasks.md milestone, ORCHESTRATOR geography. --- packages/cli/src/args.test.ts | 140 +++++++++++++++++++++++++++++++++ packages/cli/src/args.ts | 108 ++++++++++++++++++++++++++ packages/cli/src/catalog.test.ts | 18 +++++ packages/cli/src/catalog.ts | 11 +++ packages/cli/src/http.test.ts | 164 +++++++++++++++++++++++++++++++++++++++ packages/cli/src/http.ts | 86 ++++++++++++++++++++ packages/cli/src/index.ts | 12 +++ packages/cli/src/main.ts | 74 ++++++++++++++++++ packages/cli/src/message.test.ts | 81 +++++++++++++++++++ packages/cli/src/message.ts | 55 +++++++++++++ packages/cli/src/ndjson.test.ts | 48 ++++++++++++ packages/cli/src/ndjson.ts | 18 +++++ packages/cli/src/render.test.ts | 147 +++++++++++++++++++++++++++++++++++ packages/cli/src/render.ts | 45 +++++++++++ 14 files changed, 1007 insertions(+) create mode 100644 packages/cli/src/args.test.ts create mode 100644 packages/cli/src/args.ts create mode 100644 packages/cli/src/catalog.test.ts create mode 100644 packages/cli/src/catalog.ts create mode 100644 packages/cli/src/http.test.ts create mode 100644 packages/cli/src/http.ts create mode 100644 packages/cli/src/index.ts create mode 100644 packages/cli/src/main.ts create mode 100644 packages/cli/src/message.test.ts create mode 100644 packages/cli/src/message.ts create mode 100644 packages/cli/src/ndjson.test.ts create mode 100644 packages/cli/src/ndjson.ts create mode 100644 packages/cli/src/render.test.ts create mode 100644 packages/cli/src/render.ts (limited to 'packages/cli/src') diff --git a/packages/cli/src/args.test.ts b/packages/cli/src/args.test.ts new file mode 100644 index 0000000..02b9e9b --- /dev/null +++ b/packages/cli/src/args.test.ts @@ -0,0 +1,140 @@ +import { describe, expect, it } from "vitest"; +import { parseArgs } from "./args.js"; + +const defaultServer = "http://localhost:24203"; + +describe("parseArgs", () => { + it("returns help for empty argv", () => { + expect(parseArgs([], { defaultServer })).toEqual({ kind: "help" }); + }); + + it("returns help for --help", () => { + expect(parseArgs(["--help"], { defaultServer })).toEqual({ kind: "help" }); + }); + + it("returns help for -h", () => { + expect(parseArgs(["-h"], { defaultServer })).toEqual({ kind: "help" }); + }); + + describe("models", () => { + it("parses 'models' with default server", () => { + expect(parseArgs(["models"], { defaultServer })).toEqual({ + kind: "models", + server: "http://localhost:24203", + }); + }); + + it("parses 'models --server '", () => { + expect(parseArgs(["models", "--server", "http://example.com"], { defaultServer })).toEqual({ + kind: "models", + server: "http://example.com", + }); + }); + + it("errors on unknown argument for models", () => { + const result = parseArgs(["models", "--foo"], { defaultServer }); + expect(result.kind).toBe("error"); + if (result.kind === "error") expect(result.message).toContain("Unknown argument"); + }); + }); + + describe("chat", () => { + it("parses a chat with --text", () => { + const result = parseArgs(["my-model", "--text", "hello"], { defaultServer }); + expect(result).toEqual({ + kind: "chat", + server: "http://localhost:24203", + modelName: "my-model", + text: "hello", + file: undefined, + cwd: undefined, + conversationId: undefined, + showReasoning: false, + }); + }); + + it("parses a chat with --file", () => { + const result = parseArgs(["my-model", "--file", "foo.txt"], { defaultServer }); + expect(result).toEqual({ + kind: "chat", + server: "http://localhost:24203", + modelName: "my-model", + text: undefined, + file: "foo.txt", + cwd: undefined, + conversationId: undefined, + showReasoning: false, + }); + }); + + it("parses a chat with both --text and --file", () => { + const result = parseArgs(["m", "--text", "hi", "--file", "f.txt"], { defaultServer }); + expect(result).toMatchObject({ kind: "chat", text: "hi", file: "f.txt" }); + }); + + it("parses --cwd, --conversation, --server, --show-reasoning", () => { + const result = parseArgs( + [ + "m", + "--text", + "x", + "--cwd", + "/tmp", + "--conversation", + "abc", + "--server", + "http://s", + "--show-reasoning", + ], + { defaultServer }, + ); + expect(result).toEqual({ + kind: "chat", + server: "http://s", + modelName: "m", + text: "x", + file: undefined, + cwd: "/tmp", + conversationId: "abc", + showReasoning: true, + }); + }); + + it("errors when text and file are both missing", () => { + const result = parseArgs(["my-model"], { defaultServer }); + expect(result.kind).toBe("error"); + if (result.kind === "error") expect(result.message).toContain("--text or --file"); + }); + + it("errors on unknown flag", () => { + const result = parseArgs(["my-model", "--text", "hi", "--bogus"], { defaultServer }); + expect(result.kind).toBe("error"); + if (result.kind === "error") expect(result.message).toContain("Unknown flag"); + }); + + it("errors when --text has no value", () => { + const result = parseArgs(["m", "--text"], { defaultServer }); + expect(result.kind).toBe("error"); + }); + + it("errors when --file has no value", () => { + const result = parseArgs(["m", "--file"], { defaultServer }); + expect(result.kind).toBe("error"); + }); + + it("errors when --server has no value", () => { + const result = parseArgs(["models", "--server"], { defaultServer }); + expect(result.kind).toBe("error"); + }); + + it("errors when --cwd has no value", () => { + const result = parseArgs(["m", "--text", "x", "--cwd"], { defaultServer }); + expect(result.kind).toBe("error"); + }); + + it("errors when --conversation has no value", () => { + const result = parseArgs(["m", "--text", "x", "--conversation"], { defaultServer }); + expect(result.kind).toBe("error"); + }); + }); +}); diff --git a/packages/cli/src/args.ts b/packages/cli/src/args.ts new file mode 100644 index 0000000..2c554e8 --- /dev/null +++ b/packages/cli/src/args.ts @@ -0,0 +1,108 @@ +/** + * Pure argument parser — zero I/O, zero ambient state. + * + * Parses process.argv-style strings into a discriminated command union. + * Validates required flags and reports unknown flags as errors. + */ + +export type ParsedCommand = + | { readonly kind: "models"; readonly server: string } + | { + readonly kind: "chat"; + readonly server: string; + readonly modelName: string; + readonly text?: string | undefined; + readonly file?: string | undefined; + readonly cwd?: string | undefined; + readonly conversationId?: string | undefined; + readonly showReasoning: boolean; + } + | { readonly kind: "help" } + | { readonly kind: "error"; readonly message: string }; + +interface ParseOpts { + readonly defaultServer: string; +} + +export function parseArgs(argv: readonly string[], opts: ParseOpts): ParsedCommand { + if (argv.length === 0) { + return { kind: "help" }; + } + + const first = argv[0] as string; + + if (first === "--help" || first === "-h") { + return { kind: "help" }; + } + + if (first === "models") { + let server = opts.defaultServer; + for (let i = 1; i < argv.length; i++) { + if (argv[i] === "--server" && i + 1 < argv.length) { + server = argv[++i] as string; + } else { + return { kind: "error", message: `Unknown argument for 'models': ${argv[i]}` }; + } + } + return { kind: "models", server }; + } + + // Chat mode: first arg is the model name + const modelName = first; + let text: string | undefined; + let file: string | undefined; + let cwd: string | undefined; + let conversationId: string | undefined; + let showReasoning = false; + let server = opts.defaultServer; + + for (let i = 1; i < argv.length; i++) { + const arg = argv[i] as string; + switch (arg) { + case "--text": + if (i + 1 >= argv.length) return { kind: "error", message: "--text requires a value" }; + text = argv[++i]; + break; + case "--file": + if (i + 1 >= argv.length) return { kind: "error", message: "--file requires a value" }; + file = argv[++i]; + break; + case "--cwd": + if (i + 1 >= argv.length) return { kind: "error", message: "--cwd requires a value" }; + cwd = argv[++i]; + break; + case "--conversation": + if (i + 1 >= argv.length) + return { kind: "error", message: "--conversation requires a value" }; + conversationId = argv[++i]; + break; + case "--server": + if (i + 1 >= argv.length) return { kind: "error", message: "--server requires a value" }; + server = argv[++i] as string; + break; + case "--show-reasoning": + showReasoning = true; + break; + default: + return { kind: "error", message: `Unknown flag: ${arg}` }; + } + } + + if (!text && !file) { + return { + kind: "error", + message: "At least one of --text or --file is required for a chat command", + }; + } + + return { + kind: "chat", + server, + modelName, + text, + file, + cwd, + conversationId, + showReasoning, + }; +} diff --git a/packages/cli/src/catalog.test.ts b/packages/cli/src/catalog.test.ts new file mode 100644 index 0000000..3b32efc --- /dev/null +++ b/packages/cli/src/catalog.test.ts @@ -0,0 +1,18 @@ +import { describe, expect, it } from "vitest"; +import { formatCatalog } from "./catalog.js"; + +describe("formatCatalog", () => { + it("formats a single model", () => { + expect(formatCatalog({ models: ["openai/gpt-4"] })).toBe("openai/gpt-4"); + }); + + it("formats multiple models one per line", () => { + expect(formatCatalog({ models: ["openai/gpt-4", "anthropic/claude-3", "local/llama"] })).toBe( + "openai/gpt-4\nanthropic/claude-3\nlocal/llama", + ); + }); + + it("returns empty string for empty models", () => { + expect(formatCatalog({ models: [] })).toBe(""); + }); +}); diff --git a/packages/cli/src/catalog.ts b/packages/cli/src/catalog.ts new file mode 100644 index 0000000..a2b0780 --- /dev/null +++ b/packages/cli/src/catalog.ts @@ -0,0 +1,11 @@ +/** + * Pure catalog formatter — zero I/O. + * + * Formats a ModelsResponse into one model name per line. + */ + +import type { ModelsResponse } from "@dispatch/transport-contract"; + +export function formatCatalog(r: ModelsResponse): string { + return r.models.join("\n"); +} diff --git a/packages/cli/src/http.test.ts b/packages/cli/src/http.test.ts new file mode 100644 index 0000000..becfdbb --- /dev/null +++ b/packages/cli/src/http.test.ts @@ -0,0 +1,164 @@ +import type { AgentEvent } from "@dispatch/transport-contract"; +import { describe, expect, it } from "vitest"; +import { fetchModels, streamChat } from "./http.js"; + +function ndjsonLines(...events: AgentEvent[]): string { + return `${events.map((e) => JSON.stringify(e)).join("\n")}\n`; +} + +function makeFakeFetch(responseBody: string, headers?: Record) { + const fn = async (_url: string | URL | Request, _init?: RequestInit): Promise => { + const encoder = new TextEncoder(); + const chunks = responseBody.split("|||"); + let i = 0; + const stream = new ReadableStream({ + pull(controller) { + if (i < chunks.length) { + const chunk = chunks[i]; + if (chunk !== undefined) controller.enqueue(encoder.encode(chunk)); + i++; + } else { + controller.close(); + } + }, + }); + return new Response(stream, { + status: 200, + headers: headers ?? {}, + }); + }; + return fn as unknown as typeof fetch; +} + +describe("streamChat", () => { + it("parses NDJSON events and returns conversationId", async () => { + const event1: AgentEvent = { + type: "text-delta", + conversationId: "c1", + turnId: "t1", + delta: "Hello", + }; + const event2: AgentEvent = { + type: "done", + conversationId: "c1", + turnId: "t1", + reason: "completed", + }; + + const body = ndjsonLines(event1, event2); + const fakeFetch = makeFakeFetch(body, { "X-Conversation-Id": "c1" }); + + const { conversationId, events } = await streamChat( + { fetchImpl: fakeFetch }, + { + server: "http://localhost:24203", + request: { message: "hi", model: "openai/gpt-4" }, + }, + ); + + expect(conversationId).toBe("c1"); + + const collected: AgentEvent[] = []; + for await (const e of events) { + collected.push(e); + } + + expect(collected).toEqual([event1, event2]); + }); + + it("handles NDJSON split across chunks", async () => { + const event1: AgentEvent = { + type: "text-delta", + conversationId: "c", + turnId: "t", + delta: "Hi", + }; + const event2: AgentEvent = { + type: "usage", + conversationId: "c", + turnId: "t", + usage: { inputTokens: 10, outputTokens: 5 }, + }; + + const fullNdjson = ndjsonLines(event1, event2); + // Split mid-line: after 20 chars + const mid = 20; + const chunk1 = fullNdjson.slice(0, mid); + const chunk2 = fullNdjson.slice(mid); + + const fakeFetch = makeFakeFetch(`${chunk1}|||${chunk2}`, { + "X-Conversation-Id": "c", + }); + + const { events } = await streamChat( + { fetchImpl: fakeFetch }, + { + server: "http://localhost:24203", + request: { message: "hi" }, + }, + ); + + const collected: AgentEvent[] = []; + for await (const e of events) { + collected.push(e); + } + + expect(collected).toEqual([event1, event2]); + }); + + it("throws on non-OK status", async () => { + const fakeFetch = (async (): Promise => + new Response("not found", { status: 404 })) as unknown as typeof fetch; + + await expect( + streamChat( + { fetchImpl: fakeFetch }, + { + server: "http://localhost:24203", + request: { message: "hi" }, + }, + ), + ).rejects.toThrow("POST /chat failed with status 404"); + }); + + it("throws when response has no body", async () => { + const fakeFetch = (async (): Promise => + new Response(null, { status: 200 })) as unknown as typeof fetch; + + await expect( + streamChat( + { fetchImpl: fakeFetch }, + { + server: "http://localhost:24203", + request: { message: "hi" }, + }, + ), + ).rejects.toThrow("no body"); + }); +}); + +describe("fetchModels", () => { + it("returns ModelsResponse on success", async () => { + const models = { models: ["openai/gpt-4", "anthropic/claude-3"] }; + const fakeFetch = (async (): Promise => + new Response(JSON.stringify(models), { + status: 200, + headers: { "Content-Type": "application/json" }, + })) as unknown as typeof fetch; + + const result = await fetchModels( + { fetchImpl: fakeFetch }, + { server: "http://localhost:24203" }, + ); + expect(result).toEqual(models); + }); + + it("throws on non-OK status", async () => { + const fakeFetch = (async (): Promise => + new Response("server error", { status: 500 })) as unknown as typeof fetch; + + await expect( + fetchModels({ fetchImpl: fakeFetch }, { server: "http://localhost:24203" }), + ).rejects.toThrow("GET /models failed with status 500"); + }); +}); diff --git a/packages/cli/src/http.ts b/packages/cli/src/http.ts new file mode 100644 index 0000000..5e61afb --- /dev/null +++ b/packages/cli/src/http.ts @@ -0,0 +1,86 @@ +/** + * Shell — HTTP transport layer (effects injected at the edges). + * + * streamChat: POST /chat, returns an async iterable of AgentEvents. + * fetchModels: GET /models, returns the ModelsResponse. + * + * The fetchImpl dependency is injected (outermost edge mock allowed). + */ + +import type { AgentEvent, ChatRequest, ModelsResponse } from "@dispatch/transport-contract"; +import { splitNdjsonLines } from "./ndjson.js"; + +interface FetchDeps { + readonly fetchImpl: typeof fetch; +} + +interface StreamChatOpts { + readonly server: string; + readonly request: ChatRequest; +} + +export async function streamChat( + deps: FetchDeps, + opts: StreamChatOpts, +): Promise<{ conversationId: string | null; events: AsyncIterable }> { + const url = `${opts.server}/chat`; + const res = await deps.fetchImpl(url, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify(opts.request), + }); + + if (!res.ok) { + const body = await res.text(); + throw new Error(`POST /chat failed with status ${res.status}: ${body}`); + } + + const conversationId = res.headers.get("X-Conversation-Id"); + + if (!res.body) { + throw new Error("POST /chat returned no body"); + } + + const events = readNdjsonStream(res.body); + return { conversationId, events }; +} + +async function* readNdjsonStream(body: ReadableStream): AsyncIterable { + const reader = body.getReader(); + const decoder = new TextDecoder(); + let buffer = ""; + + try { + while (true) { + const { done, value } = await reader.read(); + if (done) break; + buffer += decoder.decode(value, { stream: true }); + const { lines, rest } = splitNdjsonLines(buffer); + buffer = rest; + for (const line of lines) { + yield JSON.parse(line) as AgentEvent; + } + } + if (buffer.length > 0) { + yield JSON.parse(buffer) as AgentEvent; + } + } finally { + reader.releaseLock(); + } +} + +interface FetchModelsOpts { + readonly server: string; +} + +export async function fetchModels(deps: FetchDeps, opts: FetchModelsOpts): Promise { + const url = `${opts.server}/models`; + const res = await deps.fetchImpl(url); + + if (!res.ok) { + const body = await res.text(); + throw new Error(`GET /models failed with status ${res.status}: ${body}`); + } + + return (await res.json()) as ModelsResponse; +} diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts new file mode 100644 index 0000000..82e0b21 --- /dev/null +++ b/packages/cli/src/index.ts @@ -0,0 +1,12 @@ +/** + * Barrel export — the public surface of @dispatch/cli. + * + * Pure functions + http functions for consumers and tests. + */ + +export { type ParsedCommand, parseArgs } from "./args.js"; +export { formatCatalog } from "./catalog.js"; +export { fetchModels, streamChat } from "./http.js"; +export { buildChatRequest, composeMessage } from "./message.js"; +export { type SplitResult, splitNdjsonLines } from "./ndjson.js"; +export { renderEvent } from "./render.js"; diff --git a/packages/cli/src/main.ts b/packages/cli/src/main.ts new file mode 100644 index 0000000..fc70c0c --- /dev/null +++ b/packages/cli/src/main.ts @@ -0,0 +1,74 @@ +/** + * Composition root — the thin, untested shell that wires everything together. + * + * Reads process.argv, reads files, writes to stdout/stderr. + * This is the ONLY file that touches I/O. + */ + +import { readFile } from "node:fs/promises"; +import { parseArgs } from "./args.js"; +import { formatCatalog } from "./catalog.js"; +import { fetchModels, streamChat } from "./http.js"; +import { buildChatRequest, composeMessage } from "./message.js"; +import { renderEvent } from "./render.js"; + +const USAGE = `Usage: + dispatch models [--server ] + dispatch --text "..." [--file ] [--cwd ] [--conversation ] [--server ] [--show-reasoning] + dispatch --help`; + +async function main(): Promise { + const defaultServer = `http://localhost:${process.env.BACKEND_PORT ?? "24203"}`; + const parsed = parseArgs(process.argv.slice(2), { defaultServer }); + + switch (parsed.kind) { + case "help": + process.stdout.write(`${USAGE}\n`); + process.exit(0); + break; + case "error": + process.stderr.write(`Error: ${parsed.message}\n`); + process.exit(1); + break; + case "models": { + const result = await fetchModels({ fetchImpl: globalThis.fetch }, { server: parsed.server }); + process.stdout.write(`${formatCatalog(result)}\n`); + break; + } + case "chat": { + let fileContent: string | undefined; + if (parsed.file) { + fileContent = await readFile(parsed.file, "utf-8"); + } + + const cwd = parsed.cwd ?? process.cwd(); + const message = composeMessage({ + ...(parsed.text !== undefined && { text: parsed.text }), + ...(parsed.file !== undefined && { file: parsed.file }), + ...(fileContent !== undefined && { fileContent }), + }); + const request = buildChatRequest(parsed, { cwd, message }); + + const { conversationId, events } = await streamChat( + { fetchImpl: globalThis.fetch }, + { server: parsed.server, request }, + ); + + for await (const event of events) { + const rendered = renderEvent(event, { showReasoning: parsed.showReasoning }); + if (rendered?.stdout) process.stdout.write(rendered.stdout); + if (rendered?.stderr) process.stderr.write(rendered.stderr); + } + + if (conversationId) { + process.stdout.write(`\n[conversation] ${conversationId}\n`); + } + break; + } + } +} + +main().catch((err: unknown) => { + process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}\n`); + process.exit(1); +}); diff --git a/packages/cli/src/message.test.ts b/packages/cli/src/message.test.ts new file mode 100644 index 0000000..8d6d9e1 --- /dev/null +++ b/packages/cli/src/message.test.ts @@ -0,0 +1,81 @@ +import { describe, expect, it } from "vitest"; +import { buildChatRequest, composeMessage } from "./message.js"; + +describe("composeMessage", () => { + it("returns text only", () => { + expect(composeMessage({ text: "hello" })).toBe("hello"); + }); + + it("returns file only with neutral label", () => { + expect(composeMessage({ file: "foo.txt", fileContent: "contents" })).toBe( + "Attached file (foo.txt):\ncontents", + ); + }); + + it("returns text + labeled file block", () => { + expect(composeMessage({ text: "check this", file: "a.ts", fileContent: "const x = 1;" })).toBe( + "check this\n\nAttached file (a.ts):\nconst x = 1;", + ); + }); + + it("handles missing fileContent gracefully", () => { + expect(composeMessage({ file: "f.txt" })).toBe("Attached file (f.txt):\n"); + }); + + it("uses basename for absolute paths", () => { + expect(composeMessage({ file: "/tmp/opencode/demo/note.txt", fileContent: "hello" })).toBe( + "Attached file (note.txt):\nhello", + ); + }); + + it("handles empty input", () => { + expect(composeMessage({})).toBe(""); + }); +}); + +describe("buildChatRequest", () => { + it("maps fields correctly", () => { + const req = buildChatRequest( + { + modelName: "cred/model", + text: "hi", + showReasoning: false, + }, + { cwd: "/work", message: "hi" }, + ); + expect(req).toEqual({ + message: "hi", + model: "cred/model", + cwd: "/work", + }); + }); + + it("includes conversationId when provided", () => { + const req = buildChatRequest( + { + modelName: "m", + text: "x", + conversationId: "conv-123", + showReasoning: false, + }, + { cwd: "/work", message: "x" }, + ); + expect(req.conversationId).toBe("conv-123"); + }); + + it("omits conversationId when not provided", () => { + const req = buildChatRequest( + { modelName: "m", text: "x", showReasoning: false }, + { cwd: "/work", message: "x" }, + ); + expect(req).not.toHaveProperty("conversationId"); + }); + + it("uses explicit cwd over context cwd", () => { + const req = buildChatRequest( + { modelName: "m", text: "x", cwd: "/explicit", showReasoning: false }, + { cwd: "/default", message: "x" }, + ); + expect(req.cwd).toBe("/explicit"); + }); +}); diff --git a/packages/cli/src/message.ts b/packages/cli/src/message.ts new file mode 100644 index 0000000..0c3f538 --- /dev/null +++ b/packages/cli/src/message.ts @@ -0,0 +1,55 @@ +/** + * Pure message composition — zero I/O. + * + * Combines text and file content into a single message string, + * and builds a ChatRequest from a parsed command. + */ + +import type { ChatRequest } from "@dispatch/transport-contract"; + +interface ComposeInput { + readonly text?: string; + readonly file?: string; + readonly fileContent?: string; +} + +function basename(filePath: string): string { + const segments = filePath.split("/"); + return segments[segments.length - 1] ?? filePath; +} + +export function composeMessage(input: ComposeInput): string { + const { text, fileContent } = input; + const file = input.file; + + if (text && file) { + return `${text}\n\nAttached file (${basename(file)}):\n${fileContent ?? ""}`; + } + if (file) { + return `Attached file (${basename(file)}):\n${fileContent ?? ""}`; + } + return text ?? ""; +} + +interface ChatCmd { + readonly modelName: string; + readonly text?: string | undefined; + readonly file?: string | undefined; + readonly cwd?: string | undefined; + readonly conversationId?: string | undefined; + readonly showReasoning: boolean; +} + +interface BuildCtx { + readonly cwd: string; + readonly message: string; +} + +export function buildChatRequest(cmd: ChatCmd, ctx: BuildCtx): ChatRequest { + return { + message: ctx.message, + model: cmd.modelName, + ...(cmd.conversationId !== undefined && { conversationId: cmd.conversationId }), + ...(cmd.cwd !== undefined ? { cwd: cmd.cwd } : { cwd: ctx.cwd }), + }; +} diff --git a/packages/cli/src/ndjson.test.ts b/packages/cli/src/ndjson.test.ts new file mode 100644 index 0000000..8ed3bff --- /dev/null +++ b/packages/cli/src/ndjson.test.ts @@ -0,0 +1,48 @@ +import { describe, expect, it } from "vitest"; +import { splitNdjsonLines } from "./ndjson.js"; + +describe("splitNdjsonLines", () => { + it("splits complete lines", () => { + const result = splitNdjsonLines('{"a":1}\n{"b":2}\n'); + expect(result.lines).toEqual(['{"a":1}', '{"b":2}']); + expect(result.rest).toBe(""); + }); + + it("keeps incomplete trailing line in rest", () => { + const result = splitNdjsonLines('{"a":1}\n{"b":2'); + expect(result.lines).toEqual(['{"a":1}']); + expect(result.rest).toBe('{"b":2'); + }); + + it("returns empty lines array for single incomplete line", () => { + const result = splitNdjsonLines('{"a":1'); + expect(result.lines).toEqual([]); + expect(result.rest).toBe('{"a":1'); + }); + + it("filters out empty lines", () => { + const result = splitNdjsonLines('{"a":1}\n\n{"b":2}\n'); + expect(result.lines).toEqual(['{"a":1}', '{"b":2}']); + expect(result.rest).toBe(""); + }); + + it("handles a line split across two buffers", () => { + const buf1 = '{"a":1}\n{"b":'; + const buf2 = '2}\n{"c":3}\n'; + + const r1 = splitNdjsonLines(buf1); + expect(r1.lines).toEqual(['{"a":1}']); + expect(r1.rest).toBe('{"b":'); + + const combined = r1.rest + buf2; + const r2 = splitNdjsonLines(combined); + expect(r2.lines).toEqual(['{"b":2}', '{"c":3}']); + expect(r2.rest).toBe(""); + }); + + it("handles empty buffer", () => { + const result = splitNdjsonLines(""); + expect(result.lines).toEqual([]); + expect(result.rest).toBe(""); + }); +}); diff --git a/packages/cli/src/ndjson.ts b/packages/cli/src/ndjson.ts new file mode 100644 index 0000000..57093c1 --- /dev/null +++ b/packages/cli/src/ndjson.ts @@ -0,0 +1,18 @@ +/** + * Pure NDJSON line splitter — zero I/O. + * + * Splits a buffer on newlines, keeping an incomplete trailing line in `rest`. + * Does NOT parse JSON — that is the caller's job. + */ + +export interface SplitResult { + readonly lines: readonly string[]; + readonly rest: string; +} + +export function splitNdjsonLines(buffer: string): SplitResult { + const parts = buffer.split("\n"); + const rest = parts[parts.length - 1] ?? ""; + const lines = parts.slice(0, -1).filter((l) => l.length > 0); + return { lines, rest }; +} diff --git a/packages/cli/src/render.test.ts b/packages/cli/src/render.test.ts new file mode 100644 index 0000000..bfdb791 --- /dev/null +++ b/packages/cli/src/render.test.ts @@ -0,0 +1,147 @@ +import type { AgentEvent } from "@dispatch/transport-contract"; +import { describe, expect, it } from "vitest"; +import { renderEvent } from "./render.js"; + +describe("renderEvent", () => { + const opts = { showReasoning: false }; + const optsReasoning = { showReasoning: true }; + + it("renders text-delta as stdout", () => { + const e: AgentEvent = { + type: "text-delta", + conversationId: "c", + turnId: "t", + delta: "hello", + }; + expect(renderEvent(e, opts)).toEqual({ stdout: "hello" }); + }); + + it("hides reasoning-delta by default", () => { + const e: AgentEvent = { + type: "reasoning-delta", + conversationId: "c", + turnId: "t", + delta: "thinking...", + }; + expect(renderEvent(e, opts)).toBeUndefined(); + }); + + it("shows reasoning-delta when showReasoning is true", () => { + const e: AgentEvent = { + type: "reasoning-delta", + conversationId: "c", + turnId: "t", + delta: "thinking...", + }; + expect(renderEvent(e, optsReasoning)).toEqual({ stdout: "thinking..." }); + }); + + it("renders tool-call with name and JSON input", () => { + const e: AgentEvent = { + type: "tool-call", + conversationId: "c", + turnId: "t", + toolCallId: "tc1", + toolName: "read_file", + input: { path: "/foo" }, + }; + const result = renderEvent(e, opts); + expect(result?.stdout).toContain("[tool] read_file"); + expect(result?.stdout).toContain('"/foo"'); + }); + + it("renders tool-output data as stdout", () => { + const e: AgentEvent = { + type: "tool-output", + conversationId: "c", + turnId: "t", + toolCallId: "tc1", + data: "some output", + stream: "stdout", + }; + expect(renderEvent(e, opts)).toEqual({ stdout: "some output" }); + }); + + it("renders tool-result without error", () => { + const e: AgentEvent = { + type: "tool-result", + conversationId: "c", + turnId: "t", + toolCallId: "tc1", + toolName: "read_file", + content: "file contents", + isError: false, + }; + expect(renderEvent(e, opts)).toEqual({ + stdout: "[tool:read_file] file contents\n", + }); + }); + + it("renders tool-result with error flag", () => { + const e: AgentEvent = { + type: "tool-result", + conversationId: "c", + turnId: "t", + toolCallId: "tc1", + toolName: "read_file", + content: "not found", + isError: true, + }; + expect(renderEvent(e, opts)).toEqual({ + stdout: "[tool:read_file] ERROR not found\n", + }); + }); + + it("renders usage event", () => { + const e: AgentEvent = { + type: "usage", + conversationId: "c", + turnId: "t", + usage: { inputTokens: 100, outputTokens: 50 }, + }; + expect(renderEvent(e, opts)).toEqual({ + stdout: "\n[usage] in=100 out=50\n", + }); + }); + + it("renders error event to stderr", () => { + const e: AgentEvent = { + type: "error", + conversationId: "c", + turnId: "t", + message: "something went wrong", + }; + expect(renderEvent(e, opts)).toEqual({ + stderr: "[error] something went wrong\n", + }); + }); + + it("returns undefined for status", () => { + const e: AgentEvent = { + type: "status", + conversationId: "c", + status: "running", + }; + expect(renderEvent(e, opts)).toBeUndefined(); + }); + + it("returns undefined for turn-start", () => { + const e: AgentEvent = { type: "turn-start", conversationId: "c", turnId: "t" }; + expect(renderEvent(e, opts)).toBeUndefined(); + }); + + it("returns undefined for turn-sealed", () => { + const e: AgentEvent = { type: "turn-sealed", conversationId: "c", turnId: "t" }; + expect(renderEvent(e, opts)).toBeUndefined(); + }); + + it("returns undefined for done", () => { + const e: AgentEvent = { + type: "done", + conversationId: "c", + turnId: "t", + reason: "completed", + }; + expect(renderEvent(e, opts)).toBeUndefined(); + }); +}); diff --git a/packages/cli/src/render.ts b/packages/cli/src/render.ts new file mode 100644 index 0000000..1853963 --- /dev/null +++ b/packages/cli/src/render.ts @@ -0,0 +1,45 @@ +/** + * Pure event renderer — zero I/O. + * + * Maps an AgentEvent to optional stdout/stderr strings. + * Consumers write these to process.stdout / process.stderr. + */ + +import type { AgentEvent } from "@dispatch/transport-contract"; + +interface RenderOpts { + readonly showReasoning: boolean; +} + +interface RenderOutput { + readonly stdout?: string; + readonly stderr?: string; +} + +export function renderEvent(e: AgentEvent, opts: RenderOpts): RenderOutput | undefined { + switch (e.type) { + case "text-delta": + return { stdout: e.delta }; + case "reasoning-delta": + return opts.showReasoning ? { stdout: e.delta } : undefined; + case "tool-call": + return { stdout: `\n[tool] ${e.toolName} ${JSON.stringify(e.input)}\n` }; + case "tool-output": + return { stdout: e.data }; + case "tool-result": + return { + stdout: `[tool:${e.toolName}]${e.isError ? " ERROR" : ""} ${e.content}\n`, + }; + case "usage": + return { + stdout: `\n[usage] in=${e.usage.inputTokens} out=${e.usage.outputTokens}\n`, + }; + case "error": + return { stderr: `[error] ${e.message}\n` }; + case "status": + case "turn-start": + case "turn-sealed": + case "done": + return undefined; + } +} -- cgit v1.2.3