@iinm/plain-agent 1.8.4 → 1.8.5

package/src/cliFormatter.mjs

@@ -0,0 +1,413 @@
+/**
+ * @import { Message, MessageContentToolUse, MessageContentToolResult, ProviderTokenUsage } from "./model"
+ * @import { CompactContextInput } from "./tools/compactContext"
+ * @import { ExecCommandInput } from "./tools/execCommand"
+ * @import { PatchFileInput } from "./tools/patchFile"
+ * @import { WriteFileInput } from "./tools/writeFile"
+ * @import { TmuxCommandInput } from "./tools/tmuxCommand"
+ * @import { SwitchToSubagentInput } from "./tools/switchToSubagent"
+ */
+
+import { styleText } from "node:util";
+import { createPatch } from "diff";
+
+/** Length above which a single-line arg forces block-form rendering. */
+const ARG_BLOCK_LENGTH_THRESHOLD = 60;
+
+/**
+ * Format an args array for display.
+ * Uses compact JSON for short single-line args; switches to a YAML-style
+ * block form when any arg contains newlines or exceeds
+ * {@link ARG_BLOCK_LENGTH_THRESHOLD} characters so that long scripts passed
+ * to `bash -c`, `python -c`, `node -e`, etc. stay readable.
+ * @param {unknown} args
+ * @returns {string}
+ */
+export function formatArgs(args) {
+  if (!Array.isArray(args) || args.length === 0) {
+    return `args: ${JSON.stringify(args ?? [])}`;
+  }
+
+  const needsBlock = args.some(
+    (a) =>
+      typeof a === "string" &&
+      (a.includes("\n") || a.length > ARG_BLOCK_LENGTH_THRESHOLD),
+  );
+  if (!needsBlock) {
+    return `args: ${JSON.stringify(args)}`;
+  }
+
+  const lines = ["args:"];
+  for (const arg of args) {
+    if (
+      typeof arg === "string" &&
+      (arg.includes("\n") || arg.length > ARG_BLOCK_LENGTH_THRESHOLD)
+    ) {
+      lines.push("  - |");
+      for (const line of arg.split("\n")) {
+        lines.push(`      ${line}`);
+      }
+    } else {
+      lines.push(`  - ${JSON.stringify(arg)}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Format tool use for display.
+ * @param {MessageContentToolUse} toolUse
+ * @returns {string}
+ */
+export function formatToolUse(toolUse) {
+  const { toolName, input } = toolUse;
+
+  if (toolName === "exec_command") {
+    /** @type {Partial<ExecCommandInput>} */
+    const execCommandInput = input;
+    return [
+      `tool: ${toolName}`,
+      `command: ${JSON.stringify(execCommandInput.command)}`,
+      formatArgs(execCommandInput.args),
+    ].join("\n");
+  }
+
+  if (toolName === "write_file") {
+    /** @type {Partial<WriteFileInput>} */
+    const writeFileInput = input;
+    return [
+      `tool: ${toolName}`,
+      `filePath: ${writeFileInput.filePath}`,
+      `content:\n${writeFileInput.content}`,
+    ].join("\n");
+  }
+
+  if (toolName === "patch_file") {
+    /** @type {Partial<PatchFileInput>} */
+    const patchFileInput = input;
+    const diff = patchFileInput.diff || "";
+
+    /** @type {{search:string; replace:string}[]} */
+    const diffs = [];
+    const matches = Array.from(
+      diff.matchAll(
+        /<<< [0-9a-z]{3} <<< SEARCH\n(.*?)\n=== [0-9a-z]{3} ===\n(.*?)\n?>>> [0-9a-z]{3} >>> REPLACE/gs,
+      ),
+    );
+    for (const match of matches) {
+      const [_, search, replace] = match;
+      diffs.push({ search, replace });
+    }
+
+    const highlightedDiff = diffs
+      .map(
+        ({ search, replace }) =>
+          `${createPatch(patchFileInput.filePath || "", search, replace)
+            .replace(/^-.+$/gm, (match) => styleText("red", match))
+            .replace(/^\+.+$/gm, (match) => styleText("green", match))
+            .replace(/^@@.+$/gm, (match) => styleText("gray", match))
+            .replace(/^\$/gm, (match) =>
+              styleText("gray", match),
+            )}\n-------\n${replace}`,
+      )
+      .join("\n\n");
+
+    return [
+      `tool: ${toolName}`,
+      `path: ${patchFileInput.filePath}`,
+      `diff:\n${highlightedDiff}`,
+    ].join("\n");
+  }
+
+  if (toolName === "tmux_command") {
+    /** @type {Partial<TmuxCommandInput>} */
+    const tmuxCommandInput = input;
+    return [
+      `tool: ${toolName}`,
+      `command: ${tmuxCommandInput.command}`,
+      formatArgs(tmuxCommandInput.args),
+    ].join("\n");
+  }
+
+  if (toolName === "switch_to_subagent") {
+    /** @type {Partial<SwitchToSubagentInput>} */
+    const switchToSubagentInput = input;
+    return [
+      `tool: ${toolName}`,
+      `name: ${switchToSubagentInput.name}`,
+      `goal: ${switchToSubagentInput.goal}`,
+    ].join("\n");
+  }
+
+  if (toolName === "compact_context") {
+    /** @type {Partial<CompactContextInput>} */
+    const compactContextInput = input;
+    return [
+      `tool: ${toolName}`,
+      `memoryPath: ${compactContextInput.memoryPath}`,
+      `reason: ${compactContextInput.reason}`,
+    ].join("\n");
+  }
+
+  if (toolName === "switch_to_main_agent") {
+    /** @type {Partial<import("./tools/switchToMainAgent").SwitchToMainAgentInput>} */
+    const switchToMainAgentInput = input;
+    return [
+      `tool: ${toolName}`,
+      `memoryPath: ${switchToMainAgentInput.memoryPath}`,
+    ].join("\n");
+  }
+
+  if (toolName === "ask_web") {
+    /** @type {Partial<import("./tools/askWeb.mjs").AskWebInput>} */
+    const askWebInput = input;
+    return [`tool: ${toolName}`, `question: ${askWebInput.question}`].join(
+      "\n",
+    );
+  }
+
+  if (toolName === "ask_url") {
+    /** @type {Partial<import("./tools/askURL.mjs").AskURLInput>} */
+    const askURLInput = input;
+    return [`tool: ${toolName}`, `question: ${askURLInput.question}`].join(
+      "\n",
+    );
+  }
+
+  const { provider: _, ...filteredToolUse } = toolUse;
+
+  return JSON.stringify(filteredToolUse, null, 2);
+}
+
+/** Maximum length of output to display */
+const MAX_DISPLAY_OUTPUT_LENGTH = 1024;
+
+/**
+ * Format tool result for display.
+ * @param {MessageContentToolResult} toolResult
+ * @returns {string}
+ */
+export function formatToolResult(toolResult) {
+  const { content, isError } = toolResult;
+
+  /** @type {string[]} */
+  const contentStringParts = [];
+  for (const part of content) {
+    switch (part.type) {
+      case "text":
+        contentStringParts.push(part.text);
+        break;
+      case "image":
+        contentStringParts.push(
+          `data:${part.mimeType};base64,${part.data.slice(0, 20)}...`,
+        );
+        break;
+      default:
+        console.log(`Unsupported content part: ${JSON.stringify(part)}`);
+        break;
+    }
+  }
+
+  const contentString = contentStringParts.join("\n\n");
+
+  if (isError) {
+    return styleText("red", contentString);
+  }
+
+  if (toolResult.toolName === "exec_command") {
+    return contentString
+      .replace(/(^<stdout>|<\/stdout>$)/gm, styleText("blue", "$1"))
+      .replace(
+        /(<truncated_output.+?>|<\/truncated_output>)/g,
+        styleText("yellow", "$1"),
+      )
+      .replace(/(^<stderr>|<\/stderr>$)/gm, styleText("magenta", "$1"))
+      .replace(/(^<error>|<\/error>$)/gm, styleText("red", "$1"));
+  }
+
+  if (toolResult.toolName === "tmux_command") {
+    return contentString
+      .replace(/(^<stdout>|<\/stdout>$)/gm, styleText("blue", "$1"))
+      .replace(/(^<stderr>|<\/stderr>$)/gm, styleText("magenta", "$1"))
+      .replace(/(^<error>|<\/error>$)/gm, styleText("red", "$1"))
+      .replace(/(^<tmux:.*?>|<\/tmux:.*?>$)/gm, styleText("green", "$1"));
+  }
+
+  if (contentString.length > MAX_DISPLAY_OUTPUT_LENGTH) {
+    return [
+      contentString.slice(0, MAX_DISPLAY_OUTPUT_LENGTH),
+      styleText("yellow", "... (Output truncated for display)"),
+      "\n",
+    ].join("");
+  }
+
+  return contentString;
+}
+
+/**
+ * Format provider token usage for display.
+ * @param {ProviderTokenUsage} usage
+ * @returns {string}
+ */
+export function formatProviderTokenUsage(usage) {
+  /** @type {string[]} */
+  const lines = [];
+  /** @type {string[]} */
+  const header = [];
+  for (const [key, value] of Object.entries(usage)) {
+    if (typeof value === "number") {
+      header.push(`${key}: ${value}`);
+    } else if (typeof value === "string") {
+      header.push(`${key}: ${value}`);
+    } else if (value) {
+      lines.push(
+        `(${key}) ${Object.entries(value)
+          .filter(
+            ([k]) =>
+              ![
+                // OpenAI
+                "audio_tokens",
+                "accepted_prediction_tokens",
+                "rejected_prediction_tokens",
+              ].includes(k),
+          )
+          .map(([k, v]) => `${k}: ${JSON.stringify(v)}`)
+          .join(", ")}`,
+      );
+    }
+  }
+
+  const outputLines = [`\n${header.join(", ")}`];
+
+  if (lines.length) {
+    outputLines.push(lines.join(" / "));
+  }
+
+  return styleText("gray", outputLines.join("\n"));
+}
+
+/**
+ * Format cost summary for interactive display
+ * @param {import("./costTracker.mjs").CostSummary} summary
+ * @returns {string}
+ */
+export function formatCostSummary(summary) {
+  if (!summary || Object.keys(summary.breakdown).length === 0) {
+    return styleText("gray", "No token usage recorded yet.");
+  }
+
+  const lines = [];
+
+  if (summary.totalCost !== undefined) {
+    lines.push(
+      styleText(
+        "bold",
+        `\nTotal: ${summary.totalCost.toFixed(4)} ${summary.currency}`,
+      ),
+    );
+  } else {
+    lines.push(styleText("yellow", "Total: N/A (no cost configuration)"));
+  }
+
+  lines.push(styleText("bold", "\nTokens:"));
+  for (const [key, { tokens, cost }] of Object.entries(summary.breakdown)) {
+    const tokenStr = `${key}: ${tokens.toLocaleString()}`;
+
+    if (cost !== undefined) {
+      const costStr = `${cost.toFixed(4)} ${summary.currency}`;
+      lines.push(`  ${tokenStr.padEnd(30)} ${styleText("cyan", costStr)}`);
+    } else {
+      lines.push(`  ${tokenStr.padEnd(30)} ${styleText("gray", "N/A")}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Format cost for batch mode JSON output
+ * @param {import("./costTracker.mjs").CostSummary} summary
+ */
+export function formatCostForBatch(summary) {
+  if (!summary || Object.keys(summary.breakdown).length === 0) {
+    return undefined;
+  }
+
+  return {
+    total: summary.totalCost,
+    currency: summary.currency,
+    unit: summary.unit,
+    breakdown: Object.fromEntries(
+      Object.entries(summary.breakdown).map(([key, { tokens, cost }]) => [
+        key,
+        { tokens, cost },
+      ]),
+    ),
+  };
+}
+
+/**
+ * Print a message to the console.
+ * @param {Message} message
+ */
+export function printMessage(message) {
+  switch (message.role) {
+    case "assistant": {
+      // console.log(styleText("bold", "\nAgent:"));
+      for (const part of message.content) {
+        switch (part.type) {
+          // Note: Streamで表示するためここでは表示しない
+          // case "thinking":
+          //   console.log(
+          //     [
+          //       styleText("blue", "<thinking>"),
+          //       part.thinking,
+          //       styleText("blue", "</thinking>\n"),
+          //     ].join("\n"),
+          //   );
+          //   break;
+          // case "text":
+          //   console.log(part.text);
+          //   break;
+          case "tool_use":
+            console.log(styleText("bold", "\nTool call:"));
+            console.log(formatToolUse(part));
+            break;
+        }
+      }
+      break;
+    }
+    case "user": {
+      for (const part of message.content) {
+        switch (part.type) {
+          case "tool_result": {
+            console.log(styleText("bold", "\nTool result:"));
+            console.log(formatToolResult(part));
+            break;
+          }
+          case "text": {
+            console.log(styleText("bold", "\nUser:"));
+            const highlighted = part.text.replace(
+              /^(<context.+?>|<\/context>)/gm,
+              styleText("green", "$1"),
+            );
+            console.log(highlighted);
+            break;
+          }
+          case "image": {
+            break;
+          }
+          default: {
+            console.log(styleText("bold", "\nUnknown Message Format:"));
+            console.log(JSON.stringify(part, null, 2));
+          }
+        }
+      }
+      break;
+    }
+    default: {
+      console.log(styleText("bold", "\nUnknown Message Format:"));
+      console.log(JSON.stringify(message, null, 2));
+    }
+  }
+}