@iinm/plain-agent 1.8.4 → 1.8.6

package/src/cliFormatter.mjs

@@ -0,0 +1,518 @@
+/**
+ * @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 { execFile } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { styleText } from "node:util";
+import { noThrow } from "./utils/noThrow.mjs";
+
+/** 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
+ * @param {{ createDiff?: (oldContent: string, newContent: string) => Promise<string | null> }} [options]
+ * @returns {Promise<string>}
+ */
+export async function formatToolUse(toolUse, options = {}) {
+  const { createDiff = tryGitDiff } = options;
+  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 = await Promise.all(
+      diffs.map(async ({ search, replace }) => {
+        const gitDiffOutput = await createDiff(search, replace);
+        if (gitDiffOutput) {
+          return `${gitDiffOutput}\n-------\n${replace}`;
+        }
+        return [
+          `${styleText("yellow", "(git diff unavailable, showing plain diff)")}`,
+          "--- old",
+          `${search}`,
+          "+++ new",
+          `${replace}`,
+        ].join("\n");
+      }),
+    );
+
+    return [
+      `tool: ${toolName}`,
+      `path: ${patchFileInput.filePath}`,
+      `diff:\n${highlightedDiff.join("\n\n")}`,
+    ].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
+ * @returns {Promise<void>}
+ */
+export async function printMessage(message) {
+  switch (message.role) {
+    case "assistant": {
+      // console.log(styleText("bold", "\nAgent:"));
+      // Pre-format all tool_use parts in parallel to avoid sequential awaits
+      const toolUseParts = message.content.filter(
+        (part) => part.type === "tool_use",
+      );
+      const formattedToolUses = await Promise.all(
+        toolUseParts.map((part) => formatToolUse(part)),
+      );
+      let toolUseIndex = 0;
+      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(formattedToolUses[toolUseIndex++]);
+            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));
+    }
+  }
+}
+
+/**
+ * Generate a colored unified diff using `git diff --color`.
+ * Falls back to `null` if git is unavailable or if any step fails
+ * (temp directory creation, file writing, git execution, or cleanup).
+ * @param {string} oldContent
+ * @param {string} newContent
+ * @returns {Promise<string | null>}
+ */
+async function tryGitDiff(oldContent, newContent) {
+  const tmpDir = await noThrow(() =>
+    mkdtemp(path.join(os.tmpdir(), "git-diff-")),
+  );
+  if (tmpDir instanceof Error) {
+    console.error(
+      styleText("yellow", `git diff: mkdtemp failed: ${tmpDir.message}`),
+    );
+    return null;
+  }
+
+  const oldPath = path.join(tmpDir, "old");
+  const newPath = path.join(tmpDir, "new");
+
+  try {
+    const w1 = await noThrow(() => writeFile(oldPath, oldContent, "utf8"));
+    if (w1 instanceof Error) {
+      console.error(
+        styleText("yellow", `git diff: writeFile(old) failed: ${w1.message}`),
+      );
+      return null;
+    }
+
+    const w2 = await noThrow(() => writeFile(newPath, newContent, "utf8"));
+    if (w2 instanceof Error) {
+      console.error(
+        styleText("yellow", `git diff: writeFile(new) failed: ${w2.message}`),
+      );
+      return null;
+    }
+
+    const diffResult = await noThrow(() => execGitDiff(oldPath, newPath));
+    if (diffResult instanceof Error) {
+      console.error(
+        styleText("yellow", `git diff: exec failed: ${diffResult.message}`),
+      );
+      return null;
+    }
+
+    return diffResult;
+  } finally {
+    const cleanup = await noThrow(() =>
+      rm(tmpDir, { recursive: true, force: true }),
+    );
+    if (cleanup instanceof Error) {
+      console.error(
+        styleText("yellow", `git diff: cleanup failed: ${cleanup.message}`),
+      );
+    }
+  }
+}
+
+/**
+ * Execute git diff accepting exit code 1 as success (differences found).
+ * @param {string} oldPath
+ * @param {string} newPath
+ * @returns {Promise<string>}
+ */
+function execGitDiff(oldPath, newPath) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      "git",
+      ["--no-pager", "diff", "--color", "--no-index", "--", oldPath, newPath],
+      { encoding: "utf8", maxBuffer: 10 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        if (stderr) {
+          console.error(styleText("yellow", `git diff stderr: ${stderr}`));
+        }
+        // git diff returns exit code 1 when there are differences, which is expected
+        if (error && error.code !== 1) {
+          reject(error);
+        } else {
+          resolve(stdout);
+        }
+      },
+    );
+  });
+}