refactor

Author: Frank

agents/claude-code.ts

@@ -20,50 +20,32 @@ function sessionKey(cwd: string, model: string): string {
   return `${cwd}::${model}`;
 }
 
-function formatCommand(command: string, args: string[]): string {
-  if (args.length === 0) {
-    return command;
-  }
-
-  const rendered = args.map((arg) =>
-    /[\s"']/.test(arg) ? JSON.stringify(arg) : arg,
-  );
-
-  return `${command} ${rendered.join(" ")}`;
-}
-
-function writeLog(
-  output: NodeJS.WriteStream,
-  message: string,
-  logger?: Logger.Instance,
-): void {
-  output.write(`${logger?.format(message) ?? message}\n`);
-}
-
 function logJson(value: unknown, options: Agent.RunOptions): void {
+  let message: string;
   try {
-    writeLog(process.stdout, JSON.stringify(value), options.logger);
+    message = JSON.stringify(value);
   } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    writeLog(
-      process.stdout,
-      JSON.stringify({ error: "serialization_failed", reason }),
-      options.logger,
-    );
+    message = JSON.stringify({
+      error: "serialization_failed",
+      reason: error instanceof Error ? error.message : String(error),
+    });
   }
+
+  process.stdout.write(`${options.logger.format(message)}\n`);
 }
 
 function logError(value: unknown, options: Agent.RunOptions): void {
+  let message: string;
   try {
-    writeLog(process.stderr, JSON.stringify(value), options.logger);
+    message = JSON.stringify(value);
   } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    writeLog(
-      process.stderr,
-      JSON.stringify({ error: "serialization_failed", reason }),
-      options.logger,
-    );
+    message = JSON.stringify({
+      error: "serialization_failed",
+      reason: error instanceof Error ? error.message : String(error),
+    });
   }
+
+  process.stderr.write(`${options.logger.format(message)}\n`);
 }
 
 function serializeError(error: unknown): Record<string, unknown> {
@@ -79,18 +61,7 @@ function serializeError(error: unknown): Record<string, unknown> {
 
 const claudeCodeAgent: Agent.Definition = {
   async run(model, prompt, cwd, options) {
-    assert(
-      typeof prompt === "string",
-      "Claude Code agent requires a prompt string.",
-    );
-
-    const displayCommand = formatCommand("claude-agent-sdk", [
-      "--model",
-      model,
-      prompt,
-    ]);
-
-    options.logger.log(displayCommand);
+    options.logger.log(`claude-agent-sdk --model ${model} ${prompt}`);
 
     const cacheKey = sessionKey(cwd, model);
     const existingSessionID = sessionCache.get(cacheKey);
@@ -142,7 +113,7 @@ const claudeCodeAgent: Agent.Definition = {
       throw error;
     }
 
-    return { command: displayCommand, actions, usage };
+    return { actions, usage };
   },
 };
 

agents/codex.ts

@@ -4,14 +4,12 @@ import process from "node:process";
 import {
   Codex,
   Usage,
-  type CommandExecutionItem,
   type SandboxMode,
   type Thread,
   type ThreadItem,
 } from "@openai/codex-sdk";
 
 import type { Agent } from "~/agents/index.js";
-import { Logger } from "~/lib/logger.js";
 
 const DEFAULT_SANDBOX: SandboxMode = "workspace-write";
 
@@ -30,46 +28,23 @@ function sessionKey(cwd: string, model: string): string {
   return `${cwd}::${model}`;
 }
 
-function formatCommand(command: string, args: string[]): string {
-  if (args.length === 0) {
-    return command;
-  }
-
-  const renderedArgs = args.map((arg) =>
-    /[\s"']/.test(arg) ? JSON.stringify(arg) : arg,
-  );
-
-  return `${command} ${renderedArgs.join(" ")}`;
-}
-
-function writeLog(
-  output: NodeJS.WriteStream,
-  message: string,
-  logger?: Logger.Instance,
-): void {
-  output.write(`${logger?.format(message) ?? message}\n`);
-}
-
-function isCommandExecutionItem(
-  item: ThreadItem,
-): item is CommandExecutionItem {
-  return item.type === "command_execution";
-}
-
 function logTurnItems(items: ThreadItem[], options: Agent.RunOptions): void {
   for (const item of items) {
     try {
-      writeLog(process.stdout, JSON.stringify(item), options.logger);
+      process.stdout.write(`${options.logger.format(JSON.stringify(item))}\n`);
     } catch (error) {
-      const sanitizedItem = isCommandExecutionItem(item)
-        ? { ...item, aggregated_output: "<omitted>" }
-        : item;
-      writeLog(process.stdout, JSON.stringify(sanitizedItem), options.logger);
+      const sanitizedItem =
+        item.type === "command_execution"
+          ? { ...item, aggregated_output: "<omitted>" }
+          : item;
+      process.stdout.write(
+        `${options.logger.format(JSON.stringify(sanitizedItem))}\n`,
+      );
       if (error instanceof Error) {
-        writeLog(
-          process.stderr,
-          `Failed to serialize Codex item: ${error.message}`,
-          options.logger,
+        process.stderr.write(
+          `${options.logger.format(
+            `Failed to serialize Codex item: ${error.message}`,
+          )}\n`,
         );
       }
     }
@@ -94,17 +69,9 @@ function getOrCreateThread(model: string, cwd: string): Thread {
 
 const codexAgent: Agent.Definition<(typeof models)[number]> = {
   async run(model, prompt, cwd, options) {
-    assert(typeof prompt === "string", "Codex agent requires a prompt string.");
-
-    const displayCommand = formatCommand("codex-sdk", [
-      "--model",
-      model,
-      "--sandbox",
-      DEFAULT_SANDBOX,
-      prompt,
-    ]);
-
-    options.logger.log(displayCommand);
+    options.logger.log(
+      `codex-sdk --model ${model} --sandbox ${DEFAULT_SANDBOX} ${prompt}`,
+    );
 
     const key = sessionKey(model, cwd);
     const thread = getOrCreateThread(model, cwd);
@@ -136,7 +103,6 @@ const codexAgent: Agent.Definition<(typeof models)[number]> = {
     }
 
     return {
-      command: displayCommand,
       actions,
       usage: {
         input: usage.input_tokens,

agents/index.ts

@@ -31,7 +31,6 @@ export namespace Agent {
   }
 
   export interface RunResult {
-    command: string;
     actions: string[];
     usage: {
       input: number;