@kirosnn/mosaic 0.0.91 → 0.73.0

package/src/utils/toolFormatting.ts

@@ -9,15 +9,34 @@ const TOOL_DISPLAY_NAMES: Record<string, string> = {
   write: 'Write',
   edit: 'Edit',
   list: 'List',
-  create_directory: 'Mkdir',
   glob: 'Glob',
   grep: 'Grep',
   bash: 'Command',
   question: 'Question',
   explore: 'Explore',
+  fetch: 'Fetch',
+  plan: 'Plan',
 };
 
+function parseMcpSafeId(toolName: string): { serverId: string; tool: string } | null {
+  if (!toolName.startsWith('mcp__')) return null;
+  const parts = toolName.slice(5).split('__');
+  if (parts.length < 2) return null;
+  const tool = parts.pop()!;
+  const serverId = parts.join('__');
+  return { serverId, tool };
+}
+
+function getMcpToolDisplayName(tool: string): string {
+  const words = tool.replace(/[-_]+/g, ' ').replace(/([a-z])([A-Z])/g, '$1 $2');
+  return words.split(' ').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+}
+
 function getToolDisplayName(toolName: string): string {
+  const mcp = parseMcpSafeId(toolName);
+  if (mcp) {
+    return getMcpToolDisplayName(mcp.tool);
+  }
   return TOOL_DISPLAY_NAMES[toolName] || toolName;
 }
 
@@ -42,17 +61,65 @@ export function formatToolResult(result: unknown): string {
   }
 }
 
+function getMcpHeaderInfo(_tool: string, args: Record<string, unknown>): string {
+  const query = args.query ?? args.search ?? args.prompt ?? args.input ?? args.text ?? args.q;
+  if (typeof query === 'string' && query.trim()) {
+    const clean = query.replace(/[\r\n]+/g, ' ').trim();
+    return clean.length > 50 ? clean.slice(0, 50) + '...' : clean;
+  }
+
+  const url = args.url ?? args.uri ?? args.href;
+  if (typeof url === 'string' && url.trim()) {
+    try {
+      const u = new URL(url);
+      return u.hostname + (u.pathname !== '/' ? u.pathname : '');
+    } catch {
+      return url.length > 50 ? url.slice(0, 50) + '...' : url;
+    }
+  }
+
+  const urls = args.urls;
+  if (Array.isArray(urls) && urls.length > 0) {
+    const first = typeof urls[0] === 'string' ? urls[0] : '';
+    if (urls.length === 1) {
+      try {
+        return new URL(first).hostname;
+      } catch {
+        return first.length > 40 ? first.slice(0, 40) + '...' : first;
+      }
+    }
+    return `${urls.length} URLs`;
+  }
+
+  const path = args.path ?? args.file ?? args.filename ?? args.filepath ?? args.name;
+  if (typeof path === 'string' && path.trim()) {
+    return path.length > 50 ? path.slice(0, 50) + '...' : path;
+  }
+
+  const command = args.command ?? args.cmd;
+  if (typeof command === 'string' && command.trim()) {
+    const clean = command.replace(/[\r\n]+/g, ' ').trim();
+    return clean.length > 50 ? clean.slice(0, 50) + '...' : clean;
+  }
+
+  return '';
+}
+
 function formatKnownToolArgs(toolName: string, args: Record<string, unknown>): string | null {
   switch (toolName) {
     case 'read':
     case 'write':
     case 'edit':
     case 'list':
-    case 'create_directory':
     case 'glob':
     case 'grep':
     case 'bash':
-    case 'explore': {
+    case 'explore':
+    case 'fetch': {
+      return null;
+    }
+
+    case 'plan': {
       return null;
     }
 
@@ -62,6 +129,9 @@ function formatKnownToolArgs(toolName: string, args: Record<string, unknown>): s
     }
 
     default: {
+      if (toolName.startsWith('mcp__')) {
+        return null;
+      }
       const keys = Object.keys(args);
       if (keys.length === 0) return null;
       try {
@@ -89,35 +159,86 @@ export function isToolSuccess(result: unknown): boolean {
 
 function formatToolHeader(toolName: string, args: Record<string, unknown>): string {
   const displayName = getToolDisplayName(toolName);
-  const path = typeof args.path === 'string' ? args.path : '';
 
   switch (toolName) {
     case 'read':
+      const readPath = typeof args.path === 'string' ? args.path : '';
+      return readPath ? `${displayName} (${readPath})` : displayName;
     case 'write':
+      const writePath = typeof args.path === 'string' ? args.path : '';
+      return writePath ? `${displayName} (${writePath})` : displayName;
     case 'edit':
+      const editPath = typeof args.path === 'string' ? args.path : '';
+      return editPath ? `${displayName} (${editPath})` : displayName;
     case 'list':
-    case 'create_directory':
-      return path ? `${displayName} (${path})` : displayName;
+      const listPath = typeof args.path === 'string' ? args.path : '';
+      return listPath ? `${displayName} (${listPath})` : displayName;
     case 'glob': {
       const pattern = typeof args.pattern === 'string' ? args.pattern : '';
       return pattern ? `${displayName} (${pattern})` : displayName;
     }
     case 'grep': {
-      const pattern = typeof args.file_pattern === 'string' ? args.file_pattern : '';
-      return pattern ? `${displayName} (pattern: ${pattern})` : displayName;
+      const query = typeof args.query === 'string' ? args.query : '';
+      const fileType = typeof args.file_type === 'string' ? args.file_type : '';
+      const pattern = typeof args.pattern === 'string' ? args.pattern : '';
+      const info = fileType ? `*.${fileType}` : pattern;
+      const cleanQuery = query.replace(/[\r\n]+/g, ' ').trim();
+      const queryShort = cleanQuery.length > 30 ? cleanQuery.slice(0, 30) + '...' : cleanQuery;
+      return info ? `${displayName} ("${queryShort}" in ${info})` : `${displayName} ("${queryShort}")`;
     }
     case 'bash': {
       const command = typeof args.command === 'string' ? args.command : '';
-      const cleanCommand = command.replace(/\s+--timeout\s+\d+$/, '');
+      const cleanCommand = command.replace(/[\r\n]+/g, ' ').trim().replace(/\s+--timeout\s+\d+$/, '');
       return cleanCommand ? `${displayName} (${cleanCommand})` : displayName;
     }
     case 'explore': {
       const purpose = typeof args.purpose === 'string' ? args.purpose : '';
-      return purpose ? `${displayName} (${purpose})` : displayName;
+      const cleanPurpose = purpose.replace(/[\r\n]+/g, ' ').trim();
+      return cleanPurpose ? `${displayName} (${cleanPurpose})` : displayName;
     }
-    default:
+    case 'fetch': {
+      const url = typeof args.url === 'string' ? args.url : '';
+      try {
+        const urlObj = new URL(url);
+        const shortUrl = urlObj.hostname + (urlObj.pathname !== '/' ? urlObj.pathname : '');
+        return shortUrl ? `${displayName} (${shortUrl})` : displayName;
+      } catch {
+        return url ? `${displayName} (${url})` : displayName;
+      }
+    }
+    case 'plan':
+      return displayName;
+    default: {
+      if (toolName.startsWith('mcp__')) {
+        const info = getMcpHeaderInfo('', args);
+        return info ? `${displayName} ("${info}")` : displayName;
+      }
       return displayName;
+    }
+  }
+}
+
+function formatPlanHeader(result: unknown): string {
+  const displayName = getToolDisplayName('plan');
+  if (!result || typeof result !== 'object') return displayName;
+  const obj = result as Record<string, unknown>;
+  const planItems = Array.isArray(obj.plan) ? obj.plan : [];
+  const total = planItems.length;
+  if (total === 0) return displayName;
+
+  let completed = 0;
+  let inProgress = 0;
+
+  for (const item of planItems) {
+    if (!item || typeof item !== 'object') continue;
+    const status = typeof (item as Record<string, unknown>).status === 'string'
+      ? (item as Record<string, unknown>).status
+      : 'pending';
+    if (status === 'completed') completed += 1;
+    if (status === 'in_progress') inProgress += 1;
   }
+
+  return `${displayName} (${completed}/${total} done, ${inProgress} in progress)`;
 }
 
 export function parseToolHeader(toolName: string, args: Record<string, unknown>): { name: string; info: string | null } {
@@ -136,20 +257,43 @@ export function parseToolHeader(toolName: string, args: Record<string, unknown>)
       return { name: displayName, info: pattern || null };
     }
     case 'grep': {
-      const pattern = typeof args.file_pattern === 'string' ? args.file_pattern : '';
-      return { name: displayName, info: pattern ? `pattern: ${pattern}` : null };
+      const query = typeof args.query === 'string' ? args.query : '';
+      const fileType = typeof args.file_type === 'string' ? args.file_type : '';
+      const pattern = typeof args.pattern === 'string' ? args.pattern : '';
+      const fileInfo = fileType ? `*.${fileType}` : pattern;
+      const cleanQuery = query.replace(/[\r\n]+/g, ' ').trim();
+      const queryShort = cleanQuery.length > 30 ? cleanQuery.slice(0, 30) + '...' : cleanQuery;
+      const info = fileInfo ? `"${queryShort}" in ${fileInfo}` : `"${queryShort}"`;
+      return { name: displayName, info };
     }
     case 'bash': {
       const command = typeof args.command === 'string' ? args.command : '';
-      const cleanCommand = command.replace(/\s+--timeout\s+\d+$/, '');
+      const cleanCommand = command.replace(/[\r\n]+/g, ' ').trim().replace(/\s+--timeout\s+\d+$/, '');
       return { name: displayName, info: cleanCommand || null };
     }
     case 'explore': {
       const purpose = typeof args.purpose === 'string' ? args.purpose : '';
       return { name: displayName, info: purpose || null };
     }
-    default:
+    case 'fetch': {
+      const url = typeof args.url === 'string' ? args.url : '';
+      try {
+        const urlObj = new URL(url);
+        const shortUrl = urlObj.hostname + (urlObj.pathname !== '/' ? urlObj.pathname : '');
+        return { name: displayName, info: shortUrl || null };
+      } catch {
+        return { name: displayName, info: url || null };
+      }
+    }
+    case 'plan':
+      return { name: displayName, info: null };
+    default: {
+      if (toolName.startsWith('mcp__')) {
+        const info = getMcpHeaderInfo('', args);
+        return { name: displayName, info: info || null };
+      }
       return { name: displayName, info: null };
+    }
   }
 }
 
@@ -161,10 +305,25 @@ function getLineCount(text: string): number {
 function formatListTree(result: unknown): string[] {
   if (typeof result !== 'string') return [];
   try {
-    const parsed = JSON.parse(result) as Array<{ name?: string; path?: string; type?: string }>;
-    if (!Array.isArray(parsed)) return [];
+    const parsed = JSON.parse(result);
 
-    const entries = parsed
+    let items: Array<{ name?: string; path?: string; type?: string }>;
+    let errors: string[] = [];
+
+    if (Array.isArray(parsed)) {
+      items = parsed;
+    } else if (parsed && typeof parsed === 'object' && Array.isArray(parsed.files)) {
+      items = parsed.files;
+      if (Array.isArray(parsed.errors)) {
+        errors = parsed.errors
+          .map((e: unknown) => (typeof e === 'string' ? e : ''))
+          .filter((e: string) => e);
+      }
+    } else {
+      return [];
+    }
+
+    const entries = items
       .map((e) => ({
         name: typeof e.name === 'string' ? e.name : (typeof e.path === 'string' ? e.path : ''),
         type: typeof e.type === 'string' ? e.type : '',
@@ -181,45 +340,34 @@ function formatListTree(result: unknown): string[] {
       .map((e) => e.name)
       .sort((a, b) => a.localeCompare(b));
 
-    return [...dirs, ...files];
+    const lines = [...dirs, ...files];
+
+    if (errors.length > 0) {
+      lines.push('', `Errors (${errors.length}):`);
+      for (const err of errors) {
+        lines.push(`  ${err}`);
+      }
+    }
+
+    return lines;
   } catch {
     return [];
   }
 }
 
 function formatGrepResult(result: unknown): string[] {
-  if (typeof result !== 'string') return [];
+  if (typeof result !== 'string') return ['No results returned'];
+
   try {
     const parsed = JSON.parse(result);
 
-    if (Array.isArray(parsed)) {
-      if (parsed.length === 0) return ['No results'];
-
-      if (typeof parsed[0] === 'string') {
-        return parsed.map(file => `  ${file}`);
-      }
-
-      if (typeof parsed[0] === 'object' && parsed[0] !== null) {
-        const lines: string[] = [];
-        for (const item of parsed) {
-          if (item.file) {
-            lines.push(`${item.file}:`);
-            if (Array.isArray(item.matches)) {
-              for (const match of item.matches) {
-                if (match.line && match.content) {
-                  lines.push(`  ${match.line}: ${match.content.trim()}`);
-                }
-              }
-            }
-          }
-        }
-        return lines.length > 0 ? lines : ['No matches'];
-      }
+    if (typeof parsed.total_matches === 'number' && typeof parsed.files_with_matches === 'number') {
+      return [`${parsed.total_matches} matches in ${parsed.files_with_matches} files`];
     }
 
-    return [result];
+    return ['No results returned'];
   } catch {
-    return typeof result === 'string' ? [result] : [];
+    return ['No results returned'];
   }
 }
 
@@ -236,9 +384,176 @@ function getToolErrorText(result: unknown): string | null {
   return typeof error === 'string' && error.trim() ? error.trim() : null;
 }
 
+function formatMcpResultBody(result: unknown): string[] {
+  if (typeof result !== 'string') {
+    if (result && typeof result === 'object') {
+      const obj = result as Record<string, unknown>;
+      if (typeof obj.error === 'string') {
+        return [`Error: ${obj.error}`];
+      }
+    }
+    return ['Completed'];
+  }
+
+  const text = result.trim();
+  if (!text) return ['(empty result)'];
+
+  try {
+    const parsed = JSON.parse(text);
+
+    if (Array.isArray(parsed)) {
+      return formatMcpArray(parsed);
+    }
+
+    if (typeof parsed === 'object' && parsed !== null) {
+      return formatMcpObject(parsed);
+    }
+
+    return [String(parsed)];
+  } catch {
+    const lines = text.split(/\r?\n/).filter(l => l.trim());
+    return lines.length > 0 ? lines : ['Completed'];
+  }
+}
+
+function formatMcpArray(arr: unknown[]): string[] {
+  if (arr.length === 0) return ['(no results)'];
+
+  const lines: string[] = [];
+
+  for (const item of arr) {
+    if (typeof item === 'string') {
+      lines.push(`  ${item}`);
+      continue;
+    }
+
+    if (item && typeof item === 'object') {
+      const obj = item as Record<string, unknown>;
+
+      if (typeof obj.error === 'string') {
+        const url = typeof obj.url === 'string' ? obj.url : '';
+        const detail = obj.details && typeof obj.details === 'object'
+          ? (obj.details as Record<string, unknown>).detail
+          : '';
+        const errMsg = typeof detail === 'string' && detail ? detail : obj.error;
+        lines.push(url ? `  ${url} - ${errMsg}` : `  Error: ${errMsg}`);
+        continue;
+      }
+
+      const title = obj.title ?? obj.name ?? obj.label;
+      const desc = obj.description ?? obj.summary ?? obj.snippet ?? obj.text ?? obj.content;
+      const url = obj.url ?? obj.link ?? obj.href;
+
+      if (typeof title === 'string' && title) {
+        let line = `  ${title}`;
+        if (typeof url === 'string' && url) {
+          try {
+            line += ` (${new URL(url).hostname})`;
+          } catch {
+            line += ` (${url.length > 40 ? url.slice(0, 40) + '...' : url})`;
+          }
+        }
+        lines.push(line);
+        if (typeof desc === 'string' && desc.trim()) {
+          const short = desc.trim().replace(/[\r\n]+/g, ' ');
+          lines.push(`    ${short.length > 80 ? short.slice(0, 80) + '...' : short}`);
+        }
+        continue;
+      }
+
+      if (typeof url === 'string' && url) {
+        let line = `  ${url}`;
+        if (typeof desc === 'string' && desc.trim()) {
+          const short = desc.trim().replace(/[\r\n]+/g, ' ');
+          line += ` - ${short.length > 60 ? short.slice(0, 60) + '...' : short}`;
+        }
+        lines.push(line);
+        continue;
+      }
+
+      const keys = Object.keys(obj);
+      const summary = keys.slice(0, 3).map(k => {
+        const v = obj[k];
+        const s = typeof v === 'string' ? v : JSON.stringify(v);
+        const short = s && s.length > 30 ? s.slice(0, 30) + '...' : s;
+        return `${k}: ${short}`;
+      }).join(', ');
+      lines.push(`  ${summary}`);
+    }
+  }
+
+  if (arr.length > 1) {
+    lines.unshift(`${arr.length} results:`);
+  }
+
+  return lines.length > 0 ? lines : ['Completed'];
+}
+
+function formatMcpObject(obj: Record<string, unknown>): string[] {
+  const lines: string[] = [];
+
+  if (typeof obj.error === 'string') {
+    const detail = obj.details && typeof obj.details === 'object'
+      ? (obj.details as Record<string, unknown>).detail
+      : '';
+    const errMsg = typeof detail === 'string' && detail ? detail : obj.error;
+    return [`Error: ${errMsg}`];
+  }
+
+  const status = obj.status ?? obj.statusCode ?? obj.code;
+  const message = obj.message ?? obj.result ?? obj.output ?? obj.text ?? obj.content ?? obj.data;
+
+  if (typeof status === 'number' || typeof status === 'string') {
+    lines.push(`Status: ${status}`);
+  }
+
+  if (typeof message === 'string' && message.trim()) {
+    const msgLines = message.trim().split(/\r?\n/);
+    lines.push(...msgLines);
+  } else if (message && typeof message === 'object') {
+    if (Array.isArray(message)) {
+      lines.push(...formatMcpArray(message));
+    } else {
+      const entries = Object.entries(message as Record<string, unknown>).slice(0, 5);
+      for (const [k, v] of entries) {
+        const s = typeof v === 'string' ? v : JSON.stringify(v);
+        const short = s && s.length > 60 ? s.slice(0, 60) + '...' : s;
+        lines.push(`  ${k}: ${short}`);
+      }
+    }
+  }
+
+  if (lines.length === 0) {
+    const entries = Object.entries(obj).slice(0, 5);
+    for (const [k, v] of entries) {
+      const s = typeof v === 'string' ? v : JSON.stringify(v);
+      const short = s && s.length > 60 ? s.slice(0, 60) + '...' : s;
+      lines.push(`  ${k}: ${short}`);
+    }
+  }
+
+  return lines.length > 0 ? lines : ['Completed'];
+}
+
 function formatToolBodyLines(toolName: string, args: Record<string, unknown>, result: unknown): string[] {
   const errorText = getToolErrorText(result);
-  if (errorText) return [`Tool error: ${errorText}`];
+  if (errorText) {
+    if (toolName === 'fetch') {
+      const statusMatch = errorText.match(/HTTP (\d+(?: [a-zA-Z ]+)?)/);
+      if (statusMatch) {
+        return [`${statusMatch[1]} - Failed to fetch`];
+      }
+    }
+    if (toolName.startsWith('mcp__')) {
+      const statusMatch = errorText.match(/status code (\d+)/i);
+      if (statusMatch) {
+        return [`Error ${statusMatch[1]}`];
+      }
+      const short = errorText.length > 80 ? errorText.slice(0, 80) + '...' : errorText;
+      return [`Error: ${short}`];
+    }
+    return [`Tool error: ${errorText}`];
+  }
 
   switch (toolName) {
     case 'read': {
@@ -318,7 +633,71 @@ function formatToolBodyLines(toolName: string, args: Record<string, unknown>, re
       return ['Exploration completed'];
     }
 
+    case 'fetch': {
+      if (typeof result === 'string') {
+        const url = typeof args.url === 'string' ? args.url : 'URL';
+        const statusMatch = result.match(/\*\*Status:\*\* (\d+(?: [a-zA-Z ]+)?)/);
+        if (statusMatch) {
+          return [`${statusMatch[1]} - Fetched ${url}`];
+        }
+        return [`Fetched ${url}`];
+      }
+      return ['Fetch completed'];
+    }
+
+    case 'plan': {
+      if (result && typeof result === 'object') {
+        const obj = result as Record<string, unknown>;
+        const explanation = typeof obj.explanation === 'string' ? obj.explanation.trim() : '';
+        const planItems = Array.isArray(obj.plan) ? obj.plan : [];
+        const lines: string[] = [];
+
+        if (explanation) {
+          lines.push(explanation);
+        }
+
+        const normalized = planItems
+          .map((item) => {
+            if (!item || typeof item !== 'object') return null;
+            const entry = item as Record<string, unknown>;
+            const step = typeof entry.step === 'string' ? entry.step : '';
+            const status = typeof entry.status === 'string' ? entry.status : 'pending';
+            if (!step.trim()) return null;
+            return { step: step.trim(), status };
+          })
+          .filter((item): item is { step: string; status: string } => !!item);
+
+        const inProgressItems = normalized.filter(item => item.status === 'in_progress');
+        const pendingItems = normalized.filter(item => item.status === 'pending');
+        const completedItems = normalized.filter(item => item.status === 'completed');
+
+        const sectionPrefix = '  ';
+        const itemPrefix = '      ';
+        const arrowPrefix = '> ';
+
+        const addSection = (label: string, items: Array<{ step: string; status: string }>, activeStep: string | null, marker: string) => {
+          if (items.length === 0) return;
+          lines.push(`${sectionPrefix}${label} (${items.length})`);
+          for (const item of items) {
+            const isActive = activeStep !== null && item.step === activeStep;
+            const prefix = isActive ? arrowPrefix : arrowPrefix;
+            lines.push(`${itemPrefix}${prefix}${marker} ${item.step}`);
+          }
+        };
+
+        addSection('In progress', inProgressItems, inProgressItems[0]?.step ?? null, '[~]');
+        addSection('Todo', pendingItems, null, '[ ]');
+        addSection('Completed', completedItems, null, '[✓]');
+
+        return lines.length > 0 ? lines : ['(no steps)'];
+      }
+      return ['(no steps)'];
+    }
+
     default: {
+      if (toolName.startsWith('mcp__')) {
+        return formatMcpResultBody(result);
+      }
       const toolResultText = formatToolResult(result);
       if (!toolResultText) return [];
       return toolResultText.split(/\r?\n/);
@@ -334,7 +713,8 @@ export function formatToolContent(
     maxLines?: number;
   }
 ): string {
-  const lines: string[] = [formatToolHeader(toolName, args)];
+  const header = toolName === 'plan' ? formatPlanHeader(result) : formatToolHeader(toolName, args);
+  const lines: string[] = [header];
 
   const argsLine = formatKnownToolArgs(toolName, args);
   if (argsLine) lines.push(argsLine);
@@ -342,7 +722,7 @@ export function formatToolContent(
   const bodyLines = formatToolBodyLines(toolName, args, result);
   for (const line of bodyLines) lines.push(line);
 
-  const skipTruncate = toolName === 'write' || toolName === 'edit';
+  const skipTruncate = toolName === 'write' || toolName === 'edit' || toolName === 'plan';
   if (skipTruncate) {
     return lines.join('\n');
   }