@harms-haus/pi-subagents 0.1.0

package/src/format-tool-call.ts

@@ -0,0 +1,597 @@
+/**
+ * Tool Call Formatting & Path/Bash Utilities
+ *
+ * Functions for formatting tool call previews and shortening paths/collapsing
+ * cd commands in sub-agent output.
+ */
+
+import { homedir } from "node:os";
+import { relative } from "node:path";
+
+const HOME = homedir();
+
+const TRUNCATION_SUFFIX_LENGTH = 3;
+const BASH_PREFIX_WIDTH = 12;
+const BASH_CONT_PREFIX_WIDTH = 5;
+
+// ── Path Shortening ──────────────────────────────────────────────────────
+
+/**
+ * Shortens a single absolute file path relative to the given cwd.
+ * - Replaces home directory prefix with `~`
+ * - Uses relative path from cwd if shorter
+ */
+export function shortenPath(absolutePath: string, cwd: string): string {
+  if (absolutePath === cwd) {
+    return ".";
+  }
+
+  let displayPath = absolutePath;
+  if (absolutePath.startsWith(`${HOME}/`)) {
+    displayPath = `~${absolutePath.slice(HOME.length)}`;
+  }
+
+  const rel = relative(cwd, absolutePath);
+
+  if (rel !== "" && rel !== "." && rel.length < displayPath.length) {
+    // For ascending paths (..), only use if significantly shorter to avoid confusing output
+    if (rel.startsWith("..")) {
+      const savings = displayPath.length - rel.length;
+      if (savings < 10) {
+        return displayPath;
+      }
+    }
+    return rel;
+  }
+
+  return displayPath;
+}
+
+/** Regex to match candidate absolute paths (at least 2 segments, starting with /) */
+const ABSOLUTE_PATH_REGEX = /(?:^|[^:\w/])((?:\/[a-zA-Z0-9._-]+){2,})/g;
+
+/**
+ * Finds absolute paths in arbitrary text and shortens them.
+ * Excludes URLs (preceded by `://`).
+ */
+export function shortenPathsInText(text: string, cwd: string): string {
+  const matches: Array<{ match: string; index: number }> = [];
+  ABSOLUTE_PATH_REGEX.lastIndex = 0;
+  let m: RegExpExecArray | null = ABSOLUTE_PATH_REGEX.exec(text);
+  while (m !== null) {
+    if (m[1]) {
+      matches.push({ match: m[1], index: m.index + (m[0].length - m[1].length) });
+    }
+    m = ABSOLUTE_PATH_REGEX.exec(text);
+  }
+
+  if (matches.length === 0) {
+    return text;
+  }
+
+  // Build result by replacing each match
+  let result = "";
+  let lastEnd = 0;
+
+  for (const { match, index } of matches) {
+    result += text.slice(lastEnd, index);
+    result += shortenPath(match, cwd);
+    lastEnd = index + match.length;
+  }
+  result += text.slice(lastEnd);
+  return result;
+}
+
+/**
+ * Handles the common pattern where the cwd appears in cd commands.
+ * - `cd <cwd> && ...` → strips the `cd <cwd> &&` prefix
+ * - `cd <cwd>` exactly → returns `.`
+ * - `cd <cwd> &&` with nothing after → returns empty string
+ */
+let _cdCwd = "";
+let _cdPattern: RegExp | null = null;
+
+function getCdPattern(cwd: string): RegExp {
+  if (cwd !== _cdCwd) {
+    _cdCwd = cwd;
+    const escapedCwd = cwd.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    _cdPattern = new RegExp(`^cd\\s+${escapedCwd}(\\s+&&\\s*(.*))?$`);
+  }
+  return _cdPattern as RegExp;
+}
+
+export function collapseCdDot(command: string, cwd: string): string {
+  const match = command.match(getCdPattern(cwd));
+
+  if (!match) {
+    return command;
+  }
+
+  if (!command.includes("&&")) {
+    // Exact match: `cd <cwd>` with nothing after → return "."
+    return ".";
+  }
+
+  // Has `&&` part — match[2] is the text after `&&\s*`, which may be empty
+  const after = match[2];
+  if (!after || after.trim() === "") {
+    // `cd <cwd> &&` with nothing after → return empty string
+    return "";
+  }
+
+  // `cd <cwd> && ...` → strip prefix, return the rest
+  return after.trimStart();
+}
+
+// ── Bash Command Formatting ────────────────────────────────────────
+
+function flushTruncatedSegment(
+  seg: string,
+  budget: number,
+  isLast: boolean,
+  isFirstLine: boolean,
+  lines: string[],
+  contPrefix: string,
+): { isFirstLine: boolean } {
+  const truncated = `${seg.slice(0, budget - TRUNCATION_SUFFIX_LENGTH)}...`;
+  const prefix = isFirstLine ? "" : contPrefix;
+  const suffix = isLast ? "" : " &&";
+  lines.push(`${prefix}${truncated}${suffix}`);
+  return { isFirstLine: false };
+}
+
+function formatBashSegments(
+  segments: string[],
+  firstLineBudget: number,
+  contLineBudget: number,
+  contPrefix: string,
+  separator: string,
+): string {
+  const lines: string[] = [];
+  let currentLine = "";
+  let isFirstLine = true;
+
+  for (let i = 0; i < segments.length; i++) {
+    const budget = isFirstLine && currentLine.length === 0 ? firstLineBudget : contLineBudget;
+    const seg = segments[i];
+    if (!seg) continue;
+    const isLast = i === segments.length - 1;
+
+    if (currentLine.length === 0) {
+      if (seg.length <= budget) {
+        currentLine = `${isFirstLine ? "" : contPrefix}${seg}`;
+      } else {
+        const result = flushTruncatedSegment(seg, budget, isLast, isFirstLine, lines, contPrefix);
+        isFirstLine = result.isFirstLine;
+        currentLine = "";
+      }
+    } else {
+      const withSeg = `${currentLine} && ${seg}`;
+      if (withSeg.length <= budget) {
+        currentLine = withSeg;
+      } else {
+        lines.push(`${currentLine}${separator}`);
+        isFirstLine = false;
+
+        if (seg.length <= contLineBudget) {
+          currentLine = `${contPrefix}${seg}`;
+        } else {
+          const result = flushTruncatedSegment(
+            seg,
+            contLineBudget,
+            isLast,
+            false,
+            lines,
+            contPrefix,
+          );
+          isFirstLine = result.isFirstLine;
+          currentLine = "";
+        }
+      }
+    }
+  }
+
+  if (currentLine.length > 0) {
+    lines.push(currentLine);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Format a bash command with smart && splitting for display.
+ *
+ * Splits on ` && ` boundaries, greedily fits segments into the width budget.
+ * When the next segment won't fit in the remaining width, starts a new line.
+ * When a single segment is too long, truncates with `...`.
+ * Continuation lines are prefixed with `│ ` for visual grouping.
+ *
+ * @param cmd - The bash command string (already collapsed/stripped of cd prefix)
+ * @param firstLineBudget - Maximum characters for the first line of command content
+ * @param contBudget - Maximum characters for continuation lines (command text only,
+ *   excluding the `│ ` prefix). Defaults to `firstLineBudget`.
+ * @returns Formatted multi-line string (continuation lines include `│ ` prefix)
+ */
+export function formatBashCommand(
+  cmd: string,
+  firstLineBudget: number,
+  contBudget?: number,
+): string {
+  const contLineBudget = contBudget ?? firstLineBudget;
+
+  if (cmd.length <= firstLineBudget) {
+    return cmd;
+  }
+
+  // Split on " && " boundaries
+  const segments = cmd.split(" && ");
+
+  if (segments.length === 1) {
+    // Single segment, just truncate
+    return `${cmd.slice(0, firstLineBudget - TRUNCATION_SUFFIX_LENGTH)}...`;
+  }
+
+  const separator = " &&"; // goes at end of line when wrapping
+  const contPrefix = "\u2502 "; // \u2502 = │ prefix for continuation lines
+
+  return formatBashSegments(segments, firstLineBudget, contLineBudget, contPrefix, separator);
+}
+
+// ── Tool Call Formatting ────────────────────────────────────────────
+
+/**
+ * Count non-empty lines in a text without allocating intermediate arrays.
+ */
+export function countNonEmptyLines(text: string): number {
+  let count = 0;
+  let lineStart = 0;
+  for (let i = 0; i <= text.length; i++) {
+    if (i === text.length || text.charCodeAt(i) === 10) {
+      // newline
+      let empty = true;
+      for (let j = lineStart; j < i; j++) {
+        const c = text.charCodeAt(j);
+        if (c !== 32 && c !== 9 && c !== 13) {
+          // not space/tab/CR
+          empty = false;
+          break;
+        }
+      }
+      if (!empty) {
+        count++;
+      }
+      lineStart = i + 1;
+    }
+  }
+  return count;
+}
+
+function countOutputEntries(text: string): number {
+  let count = 0;
+  let lineStart = 0;
+  for (let i = 0; i <= text.length; i++) {
+    if (i === text.length || text.charCodeAt(i) === 10) {
+      if (i > lineStart && text.charCodeAt(lineStart) !== 91) count++;
+      lineStart = i + 1;
+    }
+  }
+  return count;
+}
+
+function countDirsInOutput(text: string): number {
+  let dirs = 0;
+  let lineStart = 0;
+  for (let i = 0; i <= text.length; i++) {
+    if (i === text.length || text.charCodeAt(i) === 10) {
+      if (i > lineStart && text.charCodeAt(lineStart) !== 91 && text.charCodeAt(i - 1) === 47) {
+        dirs++;
+      }
+      lineStart = i + 1;
+    }
+  }
+  return dirs;
+}
+
+function isEmptyLsOutput(text: string): boolean {
+  return !text || text === "(empty directory)" || text === "(empty directory)\n";
+}
+
+function formatLsResultText(
+  text: string,
+  details?: { entryLimitReached?: number },
+  inline?: boolean,
+): string {
+  const prefix = inline ? "" : "  ";
+  if (isEmptyLsOutput(text)) {
+    return `${prefix}(empty)`;
+  }
+  const dirs = countDirsInOutput(text);
+  const total = countOutputEntries(text);
+  const files = total - dirs;
+  if (dirs === 0 && files === 0) {
+    return `${prefix}(empty)`;
+  }
+  const parts: string[] = [];
+  if (files > 0) parts.push(`${files} file${files !== 1 ? "s" : ""}`);
+  if (dirs > 0) parts.push(`${dirs} dir${dirs !== 1 ? "s" : ""}`);
+  const truncationIndicator = details?.entryLimitReached ? "+" : "";
+  return `${prefix}${parts.join(", ")}${truncationIndicator}`;
+}
+
+function formatFindResultText(
+  text: string,
+  details?: { resultLimitReached?: number },
+  inline?: boolean,
+): string {
+  const prefix = inline ? "" : "  ";
+  if (
+    !text ||
+    text === "No files found matching pattern" ||
+    text === "No files found matching pattern\n"
+  ) {
+    return `${prefix}0 matches`;
+  }
+  const count = countOutputEntries(text);
+  const truncationIndicator = details?.resultLimitReached ? "+" : "";
+  return `${prefix}${count} match${count !== 1 ? "es" : ""}${truncationIndicator}`;
+}
+
+export function formatToolResult(
+  toolName: string,
+  resultText: string,
+  details?: Record<string, unknown>,
+): string | null {
+  if (toolName === "ls") {
+    return formatLsResultText(resultText, details);
+  }
+  if (toolName === "find") {
+    return formatFindResultText(resultText, details);
+  }
+  return null;
+}
+
+/**
+ * Like formatToolResult but returns the summary WITHOUT leading spaces.
+ * Returns null for unsupported tool names.
+ */
+export function formatToolResultInline(
+  toolName: string,
+  resultText: string,
+  details?: Record<string, unknown>,
+): string | null {
+  if (toolName === "ls") {
+    return formatLsResultText(resultText, details, true);
+  }
+  if (toolName === "find") {
+    return formatFindResultText(resultText, details, true);
+  }
+  return null;
+}
+
+// ── formatToolCall case helpers ────────────────────────────────────
+
+function formatEditCall(
+  a: Record<string, string>,
+  args: Record<string, unknown>,
+  cwd: string,
+): string {
+  const path = shortenPath(a.path || a.filePath || "...", cwd);
+  const edits = (args.edits as Array<{ oldText?: string; newText?: string }> | undefined) ?? [];
+  const count = edits.length;
+  const suffix = count ? ` (${count} edit${count > 1 ? "s" : ""})` : "";
+  let added = 0;
+  let removed = 0;
+  for (const edit of edits) {
+    removed += countNonEmptyLines(edit.oldText ?? "");
+    added += countNonEmptyLines(edit.newText ?? "");
+  }
+  const diffStats = count > 0 ? ` +${added}/-${removed}` : "";
+  return `edit → ${path}${suffix}${diffStats}`;
+}
+
+function formatWriteCall(a: Record<string, string>, cwd: string): string {
+  const path = shortenPath(a.path || a.filePath || "...", cwd);
+  const content = a.content || "";
+  const lines = countNonEmptyLines(content);
+  return `write → ${path} +${lines}`;
+}
+
+function formatGrepCall(a: Record<string, string>, cwd: string): string {
+  const pattern = a.pattern || "...";
+  if (a.glob) {
+    return `grep → /${pattern}/ → ${a.glob}`;
+  } else if (a.path) {
+    return `grep → /${pattern}/ → ${shortenPath(a.path, cwd)}`;
+  }
+  return `grep → /${pattern}/`;
+}
+
+function formatBashCall(a: Record<string, string>, cwd: string, widthBudget: number): string {
+  let cmd = (a.command || "...").split("\n")[0] ?? "...";
+  cmd = collapseCdDot(cmd, cwd);
+  if (cmd === "." || cmd === "") {
+    return `bash → cd .`;
+  }
+  cmd = shortenPathsInText(cmd, cwd);
+  return `bash → ${formatBashCommand(cmd, widthBudget - BASH_PREFIX_WIDTH, widthBudget - BASH_CONT_PREFIX_WIDTH)}`;
+}
+
+function formatReadCall(a: Record<string, string>, cwd: string): string {
+  const path = shortenPath(a.path || "...", cwd);
+  const parts = [path];
+  if (a.offset) {
+    parts.push(`:${a.offset}`);
+  }
+  if (a.limit) {
+    parts.push(`+${a.limit}`);
+  }
+  const lineCount = a.limit ? ` (${a.limit} lines)` : "";
+  return `read → ${parts.join("")}${lineCount}`;
+}
+
+function formatDelegateCall(a: Record<string, string>, args: Record<string, unknown>): string {
+  const tasks = (args.tasks || []) as { profile?: string }[];
+  const profiles = tasks.map((t) => t.profile).filter(Boolean);
+  const profileStr =
+    profiles.length > 0 ? ` [${profiles.join(", ")}]` : a.profile ? ` [${a.profile}]` : "";
+  return `delegate_to_subagents → ${tasks.length} task${tasks.length !== 1 ? "s" : ""}${profileStr}`;
+}
+
+function formatWriteTodosCall(args: Record<string, unknown>): string {
+  const n = (args.todos as unknown[] | undefined)?.length ?? 0;
+  return `write_todos → ${n} todos written`;
+}
+
+function formatLspRefactorSymbolCall(a: Record<string, string>, cwd: string): string {
+  const file = shortenPath(a.file || "...", cwd);
+  return `lsp_refactor_symbol → ${file}:${a.line}:${a.column} → ${a.newName || "..."}`;
+}
+
+function formatFetchRepoCall(a: Record<string, string>): string {
+  return `fetch_repo → ${a.url || "..."}`;
+}
+
+function formatSessionCall(toolName: string, args: Record<string, unknown>): string {
+  const sessionId = (args.sessionId as string) || "...";
+  return `${toolName} → ${sessionId}`;
+}
+
+function formatWorkflowStepCall(args: Record<string, unknown>): string {
+  const action = (args.action as string) || "?";
+  return `workflow_step → ${action}`;
+}
+
+function formatLsCall(a: Record<string, string>, cwd: string): string {
+  const path = a.path ? shortenPath(a.path, cwd) : ".";
+  return `ls → ${path}`;
+}
+
+function formatFindCall(a: Record<string, string>, cwd: string): string {
+  const pattern = a.pattern || "...";
+  if (a.path) {
+    return `find → ${pattern} in ${shortenPath(a.path, cwd)}`;
+  }
+  return `find → ${pattern}`;
+}
+
+function formatLspFindSymbolCall(a: Record<string, string>): string {
+  return `lsp_find_symbol → ${a.query || "..."}`;
+}
+
+function formatEditTodosCall(args: Record<string, unknown>): string {
+  const action = (args.action as string) || "?";
+  const indices = (args.indices as number[] | undefined) ?? [];
+  const todos = args.todos as Array<{ text?: string }> | undefined;
+  let desc: string;
+  if (todos && todos.length > 0) {
+    desc = todos.map((t) => t.text ?? "").join(", ");
+    if (desc.length > 48) {
+      desc = `${desc.slice(0, 45)}...`;
+    }
+  } else {
+    desc = `${action} [${indices.join(",")}]`;
+  }
+  return `edit_todos → ${desc}`;
+}
+
+function formatLspFileCall(toolName: string, a: Record<string, string>, cwd: string): string {
+  const file = shortenPath(a.file || "...", cwd);
+  return `${toolName} → ${file}`;
+}
+
+function formatLspPositionCall(toolName: string, a: Record<string, string>, cwd: string): string {
+  const file = shortenPath(a.file || "...", cwd);
+  return `${toolName} → ${file}:${a.line}:${a.column}`;
+}
+
+function formatLintFilesCall(args: Record<string, unknown>, cwd: string): string {
+  const files = args.files as string[] | undefined;
+  if (files && files.length > 0) {
+    const shortened = files.map((f) => shortenPath(f, cwd));
+    const preview =
+      shortened.length <= 3
+        ? shortened.join(", ")
+        : `${shortened.slice(0, 2).join(", ")}, ... +${shortened.length - 2} more`;
+    return `lint → ${preview}`;
+  }
+  return "lint → (all)";
+}
+
+function formatFetchCall(toolName: string, a: Record<string, string>, widthBudget: number): string {
+  const url = a.url || a.query || "...";
+  const urlBudget = widthBudget - toolName.length - 4;
+  const truncated = url.length > urlBudget ? `${url.slice(0, urlBudget - 3)}...` : url;
+  return `${toolName} → ${truncated}`;
+}
+
+function formatDefaultCall(
+  toolName: string,
+  args: Record<string, unknown>,
+  widthBudget: number,
+): string {
+  const argsStr = JSON.stringify(args);
+  const budget = widthBudget - toolName.length - 1;
+  if (argsStr === "{}") {
+    return toolName;
+  }
+  if (argsStr.length > budget) {
+    return `${toolName} ${argsStr.slice(0, Math.max(0, budget - 3))}...`;
+  }
+  return `${toolName} ${argsStr}`;
+}
+
+const TOOL_FORMATTERS: Partial<
+  Record<
+    string,
+    (
+      a: Record<string, string>,
+      args: Record<string, unknown>,
+      cwd: string,
+      widthBudget: number,
+    ) => string
+  >
+> = {
+  edit: (a, args, cwd) => formatEditCall(a, args, cwd),
+  write: (a, _args, cwd) => formatWriteCall(a, cwd),
+  grep: (a, _args, cwd) => formatGrepCall(a, cwd),
+  bash: (a, _args, cwd, widthBudget) => formatBashCall(a, cwd, widthBudget),
+  read: (a, _args, cwd) => formatReadCall(a, cwd),
+  delegate_to_subagents: (a, args) => formatDelegateCall(a, args),
+  write_todos: (_a, args) => formatWriteTodosCall(args),
+  edit_todos: (_a, args) => formatEditTodosCall(args),
+  list_todos: () => "list_todos",
+  lsp_diagnostics: (a, _args, cwd) => formatLspFileCall("lsp_diagnostics", a, cwd),
+  lsp_find_references: (a, _args, cwd) => formatLspPositionCall("lsp_find_references", a, cwd),
+  lsp_goto_definition: (a, _args, cwd) => formatLspPositionCall("lsp_goto_definition", a, cwd),
+  lsp_find_symbol: (a) => formatLspFindSymbolCall(a),
+  lsp_call_hierarchy: (a, _args, cwd) => formatLspPositionCall("lsp_call_hierarchy", a, cwd),
+  lsp_refactor_symbol: (a, _args, cwd) => formatLspRefactorSymbolCall(a, cwd),
+  lint_files: (_a, args, cwd) => formatLintFilesCall(args, cwd),
+  fetch_content: (a, _args, _cwd, widthBudget) => formatFetchCall("fetch_content", a, widthBudget),
+  web_search: (a, _args, _cwd, widthBudget) => formatFetchCall("web_search", a, widthBudget),
+  fetch_repo: (a) => formatFetchRepoCall(a),
+  get_subagent_output: (_a, args) => formatSessionCall("get_subagent_output", args),
+  get_subagent_session: (_a, args) => formatSessionCall("get_subagent_session", args),
+  list_subagent_profiles: () => "list_subagent_profiles",
+  workflow_step: (_a, args) => formatWorkflowStepCall(args),
+  ls: (a, _args, cwd) => formatLsCall(a, cwd),
+  find: (a, _args, cwd) => formatFindCall(a, cwd),
+};
+
+/**
+ * Format a tool call as a concise one-liner for the sub-agent rolling window.
+ * Avoids dumping full JSON arguments for common tools.
+ */
+export function formatToolCall(
+  toolName: string,
+  args: Record<string, unknown>,
+  cwd: string,
+  widthBudget: number,
+): string {
+  const a = args as Record<string, string>;
+  const formatter = TOOL_FORMATTERS[toolName];
+  if (formatter) {
+    return formatter(a, args, cwd, widthBudget);
+  }
+  return formatDefaultCall(toolName, args, widthBudget);
+}