tool parsing cleanup

Author: jonathanlab

src/renderer/features/logs/tools/BashOutputToolView.tsx

@@ -10,6 +10,7 @@ import type {
   ShellStatus,
 } from "@features/logs/tools/types";
 import { Box } from "@radix-ui/themes";
+import { parseShellStatusResult } from "@utils/tool-results";
 
 type BashOutputToolViewProps = BaseToolViewProps<
   BashOutputArgs,
@@ -19,20 +20,7 @@ type BashOutputToolViewProps = BaseToolViewProps<
 export function BashOutputToolView({ args, result }: BashOutputToolViewProps) {
   const { filter } = args;
 
-  // Parse result
-  let stdout = "";
-  let stderr = "";
-  let status: string | undefined;
-
-  if (result) {
-    if (typeof result === "string") {
-      stdout = result;
-    } else if (typeof result === "object") {
-      stdout = result.stdout || "";
-      stderr = result.stderr || "";
-      status = result.status;
-    }
-  }
+  const { stdout, stderr, status } = parseShellStatusResult(result);
 
   return (
     <Box>

src/renderer/features/logs/tools/BashToolView.tsx

@@ -11,26 +11,14 @@ import type {
   ShellResult,
 } from "@features/logs/tools/types";
 import { Box } from "@radix-ui/themes";
+import { parseShellResult } from "@utils/tool-results";
 
 type BashToolViewProps = BaseToolViewProps<BashArgs, string | ShellResult>;
 
 export function BashToolView({ args, result }: BashToolViewProps) {
   const { command, timeout, run_in_background } = args;
 
-  // Parse result
-  let stdout = "";
-  let stderr = "";
-  let exitCode: number | undefined;
-
-  if (result) {
-    if (typeof result === "string") {
-      stdout = result;
-    } else if (typeof result === "object") {
-      stdout = result.stdout || "";
-      stderr = result.stderr || "";
-      exitCode = result.exitCode;
-    }
-  }
+  const { stdout, stderr, exitCode } = parseShellResult(result);
 
   return (
     <Box>

src/renderer/features/logs/tools/GrepToolView.tsx

@@ -10,7 +10,7 @@ import type {
   GrepResult,
 } from "@features/logs/tools/types";
 import { Box, Code } from "@radix-ui/themes";
-import { parseStringListResult, truncateList } from "@utils/tool-results";
+import { parseGrepResult, truncateList } from "@utils/tool-results";
 
 type GrepToolViewProps = BaseToolViewProps<GrepArgs, string | GrepResult>;
 
@@ -22,18 +22,7 @@ export function GrepToolView({ args, result }: GrepToolViewProps) {
   const contextBefore = args["-B"];
   const contextAround = args["-C"];
 
-  // Parse result
-  let matches: string[] = [];
-  let count: number | undefined;
-
-  if (result) {
-    if (typeof result === "string") {
-      matches = parseStringListResult(result);
-    } else if (typeof result === "object") {
-      matches = result.matches || [];
-      count = result.count;
-    }
-  }
+  const { matches, count } = parseGrepResult(result);
 
   return (
     <Box>

src/renderer/features/logs/tools/KillShellToolView.tsx

@@ -5,25 +5,15 @@ import type {
   KillShellResult,
 } from "@features/logs/tools/types";
 import { Box } from "@radix-ui/themes";
+import { parseKillShellResult } from "@utils/tool-results";
 
 type KillShellToolViewProps = BaseToolViewProps<
   KillShellArgs,
   string | KillShellResult
 >;
 
 export function KillShellToolView({ result }: KillShellToolViewProps) {
-  let success = false;
-  let message = "";
-
-  if (result) {
-    if (typeof result === "string") {
-      message = result;
-      success = result.includes("killed") || result.includes("terminated");
-    } else if (typeof result === "object") {
-      success = result.success || false;
-      message = result.message || "";
-    }
-  }
+  const { success, message } = parseKillShellResult(result);
 
   return (
     <Box>

src/renderer/features/logs/tools/WebSearchToolView.tsx

@@ -7,6 +7,7 @@ import type {
   WebSearchResultItem,
 } from "@features/logs/tools/types";
 import { Box, Code } from "@radix-ui/themes";
+import { parseWebSearchResult } from "@utils/tool-results";
 
 type WebSearchToolViewProps = BaseToolViewProps<
   WebSearchArgs,
@@ -16,20 +17,7 @@ type WebSearchToolViewProps = BaseToolViewProps<
 export function WebSearchToolView({ args, result }: WebSearchToolViewProps) {
   const { allowed_domains, blocked_domains } = args;
 
-  // Parse result
-  let results: WebSearchResultItem[] = [];
-  if (result) {
-    if (typeof result === "string") {
-      try {
-        const parsed = JSON.parse(result);
-        results = parsed.results || [];
-      } catch {
-        // Result is just text
-      }
-    } else if (result && typeof result === "object" && "results" in result) {
-      results = result.results || [];
-    }
-  }
+  const results = parseWebSearchResult<WebSearchResultItem>(result);
 
   return (
     <Box>

src/renderer/utils/tool-results.ts

@@ -32,3 +32,90 @@ export function truncateList(
 
   return truncated.join(separator);
 }
+
+function parseToolResult<TResult>(
+  result: string | Partial<TResult> | undefined,
+  defaults: TResult,
+  stringParser?: (str: string) => Partial<TResult>,
+): TResult {
+  if (!result) {
+    return defaults;
+  }
+
+  if (typeof result === "string") {
+    const stringResult =
+      stringParser?.(result) ??
+      ({ stdout: result } as unknown as Partial<TResult>);
+    return { ...defaults, ...stringResult };
+  }
+
+  return { ...defaults, ...result };
+}
+
+export interface ShellResult {
+  stdout: string;
+  stderr: string;
+  exitCode?: number;
+}
+
+export function parseShellResult(
+  result: string | Partial<ShellResult> | undefined,
+): ShellResult {
+  return parseToolResult(result, { stdout: "", stderr: "" });
+}
+
+export interface ShellStatusResult {
+  stdout: string;
+  stderr: string;
+  status?: string;
+}
+
+export function parseShellStatusResult(
+  result: string | Partial<ShellStatusResult> | undefined,
+): ShellStatusResult {
+  return parseToolResult(result, { stdout: "", stderr: "" });
+}
+
+export interface KillShellResult {
+  success: boolean;
+  message: string;
+}
+
+export function parseKillShellResult(
+  result: string | Partial<KillShellResult> | undefined,
+): KillShellResult {
+  return parseToolResult(result, { success: false, message: "" }, (str) => ({
+    success: str.includes("killed") || str.includes("terminated"),
+    message: str,
+  }));
+}
+
+export interface GrepResultParsed {
+  matches: string[];
+  count?: number;
+}
+
+export function parseGrepResult(
+  result: string | Partial<GrepResultParsed> | undefined,
+): GrepResultParsed {
+  return parseToolResult(result, { matches: [] }, (str) => ({
+    matches: parseStringListResult(str),
+  }));
+}
+
+export function parseWebSearchResult<T>(
+  result: string | { results?: T[] } | undefined,
+): T[] {
+  if (!result) return [];
+
+  if (typeof result === "string") {
+    try {
+      const parsed = JSON.parse(result);
+      return parsed.results || [];
+    } catch {
+      return [];
+    }
+  }
+
+  return result.results || [];
+}