/**

 * A tool call in one line, for the row that names it.

 *

 * A collapsed call took three rows: the tool's name, its arguments as raw

 * JSON, and its result. The middle row is the one nobody reads as JSON —

 * `{"args":["issue","view","212","-R","OpenAgentsInc/openagents.com"]}` is a

 * command line wearing a costume, and eight of them in a row is a screen of

 * punctuation with the answers pushed off the bottom.

 *

 * So the call joins the row that names it, in the shape a person would have

 * typed: `openagents issue view 212 -R OpenAgentsInc/openagents.com`. The raw

 * arguments are still there under `ctrl+o`, which is what expanding a call is

 * for.

 *

 * Nothing here invents a summary it cannot make. A tool whose arguments have no

 * obvious subject falls back to the JSON, clipped by the caller, which is what

 * the row showed before.

 * Formats tool calls and userFacingNames closely mirroring Claude Code's

 * UI conventions (e.g. `Bash(command)`, `Read(file_path)`, `Edit(file_path)`, `delegate(description)`).

 */

/** Fields worth showing whole, in the order a tool would mean them. */

const SUBJECTS = ["command", "path", "file", "pattern", "query", "name"] as const;

const SUBJECTS = ["command", "path", "file_path", "file", "pattern", "query", "name", "description"] as const;

export const summarizeToolCall = (args: string): string => {

/**

 * Format a tool call with CC-aligned semantics:

 * If toolName is provided, produces `ToolName(summary)` or `ToolName` if empty.

 * If called with 1 argument for backwards compatibility, produces `summary`.

 */

export function formatToolUseHeader(toolName: string, args: string): string {

  const summary = summarizeToolCall(args, toolName);

  if (!summary) return toolName;

  return `${toolName}(${summary})`;

}

export const summarizeToolCall = (args: string, toolName?: string): string => {

  const trimmed = args.trim();

  if (trimmed.length === 0) return "";

  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return trimmed;

  const record = parsed as Record<string, unknown>;

  // Special case: openagents / delegate / bash / file tools

  if (toolName === "delegate" || record["prompt"] !== undefined) {

    if (typeof record["description"] === "string" && record["description"].length > 0) {

      return record["description"];

    }

  }

  // An argument vector, which is the case this exists for: the `openagents`

  // tool takes the command line as a list, and joining it back is the whole

  // translation.

                ? DIM

                : YELLOW;

      // A reply still arriving pulses; a finished one is solid. The dot is the

      // only thing in this column because it is the only thing the colour and

      // the styling do not already say.

      const glyph = entry.settled ? "●" : pulse ? "●" : "○";

      // Follow Claude Code message markers: ⏺ for settled assistant/user turns, pulse ⏺/○ when streaming.

      const glyph = entry.settled ? "⏺" : pulse ? "⏺" : "○";

      const head = `  ${color}${glyph}${RESET} `;

      const continuation = " ".repeat(GUTTER);

      const rows = entryRows(entry, width, tasks);

          : tool.status === "failed"

            ? `${RED}✗${RESET}`

            : `${GREEN}✓${RESET}`;

      // The call on the row that names it, in the shape a person would have

      // typed. It used to sit below as raw JSON, which cost a row per call and

      // read as punctuation; `ctrl+o` still shows the arguments whole.

      // Format tool header following Claude Code UI conventions: Tool(summary)

      const summary = clip(

        summarizeToolCall(tool.arguments),

        Math.max(8, width - tool.name.length - 4),

        summarizeToolCall(tool.arguments, tool.name),

        Math.max(8, width - tool.name.length - 6),

      );

      const rows = [

        `${mark} ${BOLD}${tool.name}${RESET}` +

          (summary.length === 0 ? "" : ` ${DIM}${summary}${RESET}`),

      ];

      const headerText = summary.length === 0 ? tool.name : `${tool.name}(${summary})`;

      const rows = [`${mark} ${BOLD}${headerText}${RESET}`];

      if (tool.name === "delegate" && tool.status === "running") {

        // Working children first when there are more than fit: a finished child

          // as one JSON document split over a blank line.

          const lines = tool.output.split("\n");

          for (const [index, line] of lines.entries()) {

            const marker = index === 0 ? `${DIM}→${RESET} ` : "  ";

            const marker = index === 0 ? `${DIM}⎿ ${RESET}` : "  ";

            rows.push(`${marker}${DIM}${truncate(line, Math.max(4, width - 2))}${RESET}`);

          }

        }

          tool.error !== undefined

            ? `${RED}${clip(tool.error, Math.max(8, width - 4))}${RESET}`

            : tool.output !== undefined

              ? `${DIM}→ ${clip(tool.output, Math.max(8, width - 6))}${RESET}`

              ? `${DIM}⎿ ${clip(tool.output, Math.max(8, width - 6))}${RESET}`

              : tool.status === "running" && tool.name !== "delegate"

                ? `${DIM}→ running…${RESET}`

                ? `${DIM}⎿ running…${RESET}`

                : "";

        if (outcome.length > 0) rows.push(outcome);

      }

import { describe, expect, it } from "vitest";

import { summarizeToolCall } from "../src/coder-tool-summary.js";

import { formatToolUseHeader, summarizeToolCall } from "../src/coder-tool-summary.js";

describe("a tool call in one line", () => {

  it("turns an argument vector back into the command line it was", () => {

    ).toBe("issue view 212 -R OpenAgentsInc/openagents.com");

  });

  it("formats tool headers in Claude Code style", () => {

    expect(

      formatToolUseHeader(

        "openagents",

        `{"args":["issue","view","212","-R","OpenAgentsInc/openagents.com"]}`,

      ),

    ).toBe("openagents(issue view 212 -R OpenAgentsInc/openagents.com)");

    expect(formatToolUseHeader("shell", `{"command":"git status"}`)).toBe("shell(git status)");

    expect(formatToolUseHeader("read", `{"file_path":"src/main.ts"}`)).toBe("read(src/main.ts)");

  });

  it("quotes an argument with a space, so it still reads as one", () => {

    expect(summarizeToolCall(`{"args":["issue","create","--title","two words"]}`)).toBe(

      `issue create --title "two words"`,

  });

  it("drops the punctuation when nothing is named", () => {

    // `delegate` has no single subject, and its fields are still what a reader

    // wants: how many children, and what they were asked for.

    expect(summarizeToolCall(`{"count":3,"description":"audit the providers"}`)).toBe(

      `count=3 description="audit the providers"`,

      "audit the providers",

    );

  });

    stdin.emit("data", "\x04");

    await running;

    const bullets = rows.filter((row) => row.trimStart().startsWith("\u25cf"));

    const bullets = rows.filter((row) => row.trimStart().startsWith("⏺"));

    expect(bullets.length).toBeGreaterThan(0);

    expect(bullets.every((row) => row.replace("\u25cf", "").trim().length > 0)).toBe(true);

    expect(bullets.every((row) => row.replace("⏺", "").trim().length > 0)).toBe(true);

  });

  it("shows the tool, its call, and its outcome, on two rows", async () => {

    // which cost a row per call and read as punctuation rather than as the

    // command it is.

    const named = rows.find((row) => row.includes("repo_grep")) ?? "";

    expect(named).toContain("repo_grep x");

    expect(named).toContain("repo_grep(x)");

    expect(named).not.toContain('{"pattern"');

    expect(rows.join("\n")).toContain('{"matches":[]}');

    ]);

    const named = rows.find((row) => row.includes("openagents")) ?? "";

    expect(named).toContain("openagents issue view 212 -R OpenAgentsInc/openagents.com");

    expect(named).toContain("openagents(issue view 212 -R OpenAgentsInc/openagents.com)");

  });

  it("renders assistant Markdown rather than its source", async () => {

    // Five words of chrome per turn — `you`, `think`, `coder`, `note`, `tool` —

    // said what the styling already said.

    expect(painted).toContain("● an answer");

    expect(painted).toContain("⏺ an answer");

    expect(painted).not.toMatch(/\bcoder\s+an answer/);

    expect(painted).not.toMatch(/^\s*you\s/m);

  });

    stdin.emit("data", "\x04");

    await running;

    expect(stdout.written).toContain("●");

    expect(stdout.written).toContain("⏺");

  });

  it("keeps the scroll marker in the same voice as the rest of the bar", async () => {