@ymdvsymd/tornado 0.5.0

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@ymdvsymd/tornado",
+  "version": "0.5.0",
+  "description": "Multi-agent development orchestrator with TUI",
+  "bin": {
+    "tornado": "bin/tornado.js"
+  },
+  "files": [
+    "bin/",
+    "sdk/"
+  ],
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mizchi/tornado"
+  },
+  "homepage": "https://github.com/mizchi/tornado",
+  "bugs": {
+    "url": "https://github.com/mizchi/tornado/issues"
+  },
+  "keywords": [
+    "moonbit",
+    "agent",
+    "orchestration",
+    "tui",
+    "cli"
+  ],
+  "author": "mizchi",
+  "license": "MIT",
+  "scripts": {
+    "build:sdk": "tsc -p tsconfig.sdk.json"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.49",
+    "@openai/codex-sdk": "^0.104.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.3"
+  }
+}

package/sdk/agent-adapter.mjs

@@ -0,0 +1 @@
+export {};

package/sdk/agent-adapter.mts

@@ -0,0 +1,31 @@
+export type RunnerOptions = {
+  prompt: string;
+  cwd?: string;
+  model?: string;
+  systemPrompt?: string;
+  sessionId?: string;
+  threadId?: string;
+};
+
+export type AdapterEmission = {
+  event?: unknown;
+  log?: string;
+};
+
+export type AdapterStartResult<RawEvent> = {
+  sessionId: string;
+  stream: AsyncIterable<RawEvent>;
+  initEvents?: readonly unknown[];
+  initLogs?: readonly string[];
+};
+
+export type AdapterIO = {
+  write(event: unknown): void;
+  log(line: string): void;
+};
+
+export interface AgentAdapter<RawEvent> {
+  readonly tag: string;
+  start(opts: RunnerOptions): Promise<AdapterStartResult<RawEvent>>;
+  emit(raw: RawEvent, sessionId: string): readonly AdapterEmission[];
+}

package/sdk/agent-runner.mjs

@@ -0,0 +1,39 @@
+import { createLogger, writeJsonl } from "./runner-io.mjs";
+export async function runAdapter(adapter, opts, io) {
+    const sink = io ?? createDefaultIO(adapter.tag);
+    const started = await adapter.start(opts);
+    for (const event of started.initEvents ?? []) {
+        sink.write(event);
+    }
+    for (const line of started.initLogs ?? []) {
+        sink.log(line);
+    }
+    for await (const raw of started.stream) {
+        const emissions = adapter.emit(raw, started.sessionId);
+        for (const emission of emissions) {
+            if (emission.event !== undefined) {
+                sink.write(emission.event);
+            }
+            if (emission.log) {
+                sink.log(emission.log);
+            }
+        }
+    }
+}
+export async function runAdapterFromArgv(adapter, argv = process.argv) {
+    const arg = argv[2];
+    if (!arg) {
+        throw new Error("Missing runner options JSON in argv[2]");
+    }
+    const opts = JSON.parse(arg);
+    await runAdapter(adapter, opts);
+}
+function createDefaultIO(tag) {
+    const log = createLogger(tag);
+    return {
+        write(event) {
+            writeJsonl(event);
+        },
+        log,
+    };
+}

package/sdk/agent-runner.mts

@@ -0,0 +1,56 @@
+import type {
+  AdapterIO,
+  AgentAdapter,
+  RunnerOptions,
+} from "./agent-adapter.mjs";
+import { createLogger, writeJsonl } from "./runner-io.mjs";
+
+export async function runAdapter<RawEvent>(
+  adapter: AgentAdapter<RawEvent>,
+  opts: RunnerOptions,
+  io?: AdapterIO,
+): Promise<void> {
+  const sink = io ?? createDefaultIO(adapter.tag);
+  const started = await adapter.start(opts);
+
+  for (const event of started.initEvents ?? []) {
+    sink.write(event);
+  }
+  for (const line of started.initLogs ?? []) {
+    sink.log(line);
+  }
+
+  for await (const raw of started.stream) {
+    const emissions = adapter.emit(raw, started.sessionId);
+    for (const emission of emissions) {
+      if (emission.event !== undefined) {
+        sink.write(emission.event);
+      }
+      if (emission.log) {
+        sink.log(emission.log);
+      }
+    }
+  }
+}
+
+export async function runAdapterFromArgv<RawEvent>(
+  adapter: AgentAdapter<RawEvent>,
+  argv: readonly string[] = process.argv,
+): Promise<void> {
+  const arg = argv[2];
+  if (!arg) {
+    throw new Error("Missing runner options JSON in argv[2]");
+  }
+  const opts = JSON.parse(arg) as RunnerOptions;
+  await runAdapter(adapter, opts);
+}
+
+function createDefaultIO(tag: string): AdapterIO {
+  const log = createLogger(tag);
+  return {
+    write(event) {
+      writeJsonl(event);
+    },
+    log,
+  };
+}

package/sdk/agent-runner.test.mjs

@@ -0,0 +1,69 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { runAdapter } from './agent-runner.mjs';
+
+test('runAdapter emits init events and mapped stream events in order', async () => {
+  const events = [];
+  const logs = [];
+
+  const adapter = {
+    tag: 'Mock',
+    async start(opts) {
+      assert.equal(opts.prompt, 'hello');
+      return {
+        sessionId: 's-1',
+        initEvents: [{ type: 'system', subtype: 'init', session_id: 's-1' }],
+        initLogs: ['booted'],
+        stream: toAsync([{ kind: 'one' }, { kind: 'two' }]),
+      };
+    },
+    emit(raw, sessionId) {
+      return [{ event: { type: 'assistant', raw: raw.kind, session_id: sessionId }, log: `saw:${raw.kind}` }];
+    },
+  };
+
+  await runAdapter(adapter, { prompt: 'hello' }, {
+    write: (event) => events.push(event),
+    log: (line) => logs.push(line),
+  });
+
+  assert.deepEqual(events, [
+    { type: 'system', subtype: 'init', session_id: 's-1' },
+    { type: 'assistant', raw: 'one', session_id: 's-1' },
+    { type: 'assistant', raw: 'two', session_id: 's-1' },
+  ]);
+  assert.deepEqual(logs, ['booted', 'saw:one', 'saw:two']);
+});
+
+test('runAdapter supports log-only emissions', async () => {
+  const events = [];
+  const logs = [];
+
+  const adapter = {
+    tag: 'Mock',
+    async start() {
+      return {
+        sessionId: 's-2',
+        stream: toAsync([{ kind: 'tick' }]),
+      };
+    },
+    emit() {
+      return [{ log: 'only-log' }];
+    },
+  };
+
+  await runAdapter(adapter, { prompt: 'x' }, {
+    write: (event) => events.push(event),
+    log: (line) => logs.push(line),
+  });
+
+  assert.deepEqual(events, []);
+  assert.deepEqual(logs, ['only-log']);
+});
+
+async function* toAsync(values) {
+  for (const value of values) {
+    yield value;
+  }
+}

package/sdk/claude-adapter.mjs

@@ -0,0 +1,105 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+export function createClaudeAdapter() {
+    return {
+        tag: "Claude",
+        async start(opts) {
+            const queryOpts = buildQueryOptions(opts);
+            return {
+                sessionId: opts.sessionId || "",
+                stream: query({
+                    prompt: opts.prompt,
+                    options: queryOpts,
+                }),
+            };
+        },
+        emit(raw) {
+            const emissions = [{ event: raw }];
+            const logs = extractLogs(raw);
+            for (const line of logs) {
+                emissions.push({ log: line });
+            }
+            return emissions;
+        },
+    };
+}
+function buildQueryOptions(opts) {
+    const queryOptions = {
+        includePartialMessages: true,
+        permissionMode: "bypassPermissions",
+        allowDangerouslySkipPermissions: true,
+        cwd: opts.cwd || process.cwd(),
+    };
+    if (opts.sessionId)
+        queryOptions.resume = opts.sessionId;
+    if (opts.model)
+        queryOptions.model = opts.model;
+    if (opts.systemPrompt)
+        queryOptions.systemPrompt = opts.systemPrompt;
+    return queryOptions;
+}
+function extractLogs(message) {
+    switch (message.type) {
+        case "system":
+            return extractSystemLog(message);
+        case "stream_event":
+            return extractStreamEventLog(message);
+        case "assistant":
+            return extractToolUseLog(message);
+        case "result":
+            return [formatResultLog(message)];
+        default:
+            return [];
+    }
+}
+function extractSystemLog(message) {
+    if (message.subtype !== "init")
+        return [];
+    return [
+        `Session init: model=${message.model || "unknown"}, session=${message.session_id || "new"}`,
+    ];
+}
+function extractStreamEventLog(message) {
+    const event = message.event;
+    if (event?.type !== "content_block_start")
+        return [];
+    const block = event.content_block;
+    if (block?.type === "tool_use") {
+        return [`Tool: ${block.name}`];
+    }
+    if (block?.type === "thinking") {
+        return ["Thinking..."];
+    }
+    if (block?.type === "text") {
+        return ["Generating..."];
+    }
+    return [];
+}
+function extractToolUseLog(message) {
+    const logs = [];
+    const content = message.message?.content;
+    if (!Array.isArray(content))
+        return logs;
+    for (const block of content) {
+        if (block.type !== "tool_use")
+            continue;
+        const inputPreview = JSON.stringify(block.input).slice(0, 100);
+        logs.push(`${block.name}(${inputPreview})`);
+    }
+    return logs;
+}
+function formatResultLog(message) {
+    const parts = [`Result: ${message.subtype}`];
+    if (message.total_cost_usd) {
+        parts.push(`cost=$${message.total_cost_usd.toFixed(4)}`);
+    }
+    if (message.duration_ms) {
+        parts.push(`${(message.duration_ms / 1000).toFixed(1)}s`);
+    }
+    if (message.usage) {
+        const { input_tokens, output_tokens } = message.usage;
+        if (input_tokens || output_tokens) {
+            parts.push(`${input_tokens || 0}in/${output_tokens || 0}out`);
+        }
+    }
+    return parts.join(", ");
+}

package/sdk/claude-adapter.mts

@@ -0,0 +1,143 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import type {
+  AdapterEmission,
+  AdapterStartResult,
+  AgentAdapter,
+  RunnerOptions,
+} from "./agent-adapter.mjs";
+
+type ClaudeMessage = {
+  type?: string;
+  subtype?: string;
+  model?: string;
+  session_id?: string;
+  event?: {
+    type?: string;
+    content_block?: { type?: string; name?: string };
+  };
+  message?: {
+    content?: Array<{
+      type?: string;
+      name?: string;
+      input?: unknown;
+    }>;
+  };
+  total_cost_usd?: number;
+  duration_ms?: number;
+  usage?: {
+    input_tokens?: number;
+    output_tokens?: number;
+  };
+  [key: string]: unknown;
+};
+
+export function createClaudeAdapter(): AgentAdapter<ClaudeMessage> {
+  return {
+    tag: "Claude",
+    async start(opts: RunnerOptions): Promise<AdapterStartResult<ClaudeMessage>> {
+      const queryOpts = buildQueryOptions(opts);
+      return {
+        sessionId: opts.sessionId || "",
+        stream: query({
+          prompt: opts.prompt,
+          options: queryOpts,
+        }) as AsyncIterable<ClaudeMessage>,
+      };
+    },
+    emit(raw: ClaudeMessage): readonly AdapterEmission[] {
+      const emissions: AdapterEmission[] = [{ event: raw }];
+      const logs = extractLogs(raw);
+      for (const line of logs) {
+        emissions.push({ log: line });
+      }
+      return emissions;
+    },
+  };
+}
+
+function buildQueryOptions(opts: RunnerOptions): Record<string, unknown> {
+  const queryOptions: Record<string, unknown> = {
+    includePartialMessages: true,
+    permissionMode: "bypassPermissions",
+    allowDangerouslySkipPermissions: true,
+    cwd: opts.cwd || process.cwd(),
+  };
+
+  if (opts.sessionId) queryOptions.resume = opts.sessionId;
+  if (opts.model) queryOptions.model = opts.model;
+  if (opts.systemPrompt) queryOptions.systemPrompt = opts.systemPrompt;
+
+  return queryOptions;
+}
+
+function extractLogs(message: ClaudeMessage): string[] {
+  switch (message.type) {
+    case "system":
+      return extractSystemLog(message);
+    case "stream_event":
+      return extractStreamEventLog(message);
+    case "assistant":
+      return extractToolUseLog(message);
+    case "result":
+      return [formatResultLog(message)];
+    default:
+      return [];
+  }
+}
+
+function extractSystemLog(message: ClaudeMessage): string[] {
+  if (message.subtype !== "init") return [];
+  return [
+    `Session init: model=${message.model || "unknown"}, session=${message.session_id || "new"}`,
+  ];
+}
+
+function extractStreamEventLog(message: ClaudeMessage): string[] {
+  const event = message.event;
+  if (event?.type !== "content_block_start") return [];
+
+  const block = event.content_block;
+  if (block?.type === "tool_use") {
+    return [`Tool: ${block.name}`];
+  }
+  if (block?.type === "thinking") {
+    return ["Thinking..."];
+  }
+  if (block?.type === "text") {
+    return ["Generating..."];
+  }
+  return [];
+}
+
+function extractToolUseLog(message: ClaudeMessage): string[] {
+  const logs: string[] = [];
+  const content = message.message?.content;
+  if (!Array.isArray(content)) return logs;
+
+  for (const block of content) {
+    if (block.type !== "tool_use") continue;
+    const inputPreview = JSON.stringify(block.input).slice(0, 100);
+    logs.push(`${block.name}(${inputPreview})`);
+  }
+
+  return logs;
+}
+
+function formatResultLog(message: ClaudeMessage): string {
+  const parts = [`Result: ${message.subtype}`];
+
+  if (message.total_cost_usd) {
+    parts.push(`cost=$${message.total_cost_usd.toFixed(4)}`);
+  }
+  if (message.duration_ms) {
+    parts.push(`${(message.duration_ms / 1000).toFixed(1)}s`);
+  }
+  if (message.usage) {
+    const { input_tokens, output_tokens } = message.usage;
+    if (input_tokens || output_tokens) {
+      parts.push(`${input_tokens || 0}in/${output_tokens || 0}out`);
+    }
+  }
+
+  return parts.join(", ");
+}

package/sdk/claude-runner.mjs

@@ -0,0 +1,3 @@
+import { runAdapterFromArgv } from "./agent-runner.mjs";
+import { createClaudeAdapter } from "./claude-adapter.mjs";
+await runAdapterFromArgv(createClaudeAdapter());

package/sdk/claude-runner.mts

@@ -0,0 +1,4 @@
+import { runAdapterFromArgv } from "./agent-runner.mjs";
+import { createClaudeAdapter } from "./claude-adapter.mjs";
+
+await runAdapterFromArgv(createClaudeAdapter());

package/sdk/codex-adapter.mjs

@@ -0,0 +1,77 @@
+import { Codex } from "@openai/codex-sdk";
+import { formatTurnCompletedLog, formatTurnFailedLog, normalizeItemComplete, normalizeItemStart, normalizeTurnCompleted, normalizeTurnFailed, } from "./codex-normalizer.mjs";
+export function createCodexAdapter(client = new Codex()) {
+    return {
+        tag: "Codex",
+        async start(opts) {
+            const threadOpts = {
+                model: opts.model || undefined,
+                workingDirectory: opts.cwd || process.cwd(),
+                approvalPolicy: "never",
+            };
+            const logs = [];
+            const thread = opts.threadId
+                ? resumeThread(client, opts.threadId, threadOpts, logs)
+                : startThread(client, threadOpts, logs);
+            logs.push(`Thread: ${thread.id}`);
+            const run = await thread.runStreamed(opts.prompt);
+            return {
+                sessionId: thread.id,
+                initEvents: [
+                    {
+                        type: "system",
+                        subtype: "init",
+                        session_id: thread.id,
+                        model: opts.model || "default",
+                    },
+                ],
+                initLogs: logs,
+                stream: run.events,
+            };
+        },
+        emit(raw, sessionId) {
+            switch (raw.type) {
+                case "item.started":
+                    return emitItemStart(raw.item);
+                case "item.completed":
+                    return emitItemComplete(raw.item);
+                case "turn.completed": {
+                    const resultEvent = normalizeTurnCompleted(raw, sessionId);
+                    return [{ event: resultEvent, log: formatTurnCompletedLog(raw) }];
+                }
+                case "turn.failed": {
+                    const errorEvent = normalizeTurnFailed(raw, sessionId);
+                    return [{ event: errorEvent, log: formatTurnFailedLog(raw) }];
+                }
+                default:
+                    return [];
+            }
+        },
+    };
+}
+function resumeThread(client, threadId, opts, logs) {
+    logs.push(`Resuming thread: ${threadId}`);
+    return client.resumeThread(threadId, opts);
+}
+function startThread(client, opts, logs) {
+    logs.push("Starting new thread");
+    return client.startThread(opts);
+}
+function emitItemStart(item) {
+    const normalized = normalizeItemStart(item || {});
+    if (!normalized)
+        return [];
+    const display = typeof normalized._display === "string"
+        ? normalized._display
+        : item?.type || "item.started";
+    return [{ event: normalized, log: display }];
+}
+function emitItemComplete(item) {
+    const normalized = normalizeItemComplete(item || {});
+    if (!normalized)
+        return [];
+    const display = typeof normalized._display === "string"
+        ? normalized._display
+        : item?.type || "item.completed";
+    return [{ event: normalized, log: `Done: ${display}` }];
+}