mu-coding 0.15.0 → 0.16.1

package/src/tui/components/messageView.tsx

@@ -1,72 +0,0 @@
-import type { DOMElement } from 'ink';
-import { Box, Text } from 'ink';
-import type { ChatMessage } from 'mu-core';
-import { type RefObject, useMemo } from 'react';
-import type { StreamState } from '../chat/useChatSession';
-import { useTheme } from '../context/ThemeContext';
-import { MessageItem } from './messages/messageItem';
-import { StreamingOutput } from './messages/streamingOutput';
-import { Scrollbar } from './primitives/scrollbar';
-
-/**
- * Walk `messages` once and group every assistant-with-tool-calls index to
- * its trailing `tool` messages. Avoids the previous O(n²) scan where each
- * `MessageItem` re-walked the array forward to find its tool replies.
- */
-function indexToolMessages(messages: ChatMessage[]): Map<number, ChatMessage[]> {
-  const map = new Map<number, ChatMessage[]>();
-  let activeAssistant = -1;
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg.role === 'assistant' && msg.toolCalls?.length) {
-      activeAssistant = i;
-      map.set(i, []);
-    } else if (msg.role === 'tool' && activeAssistant !== -1) {
-      map.get(activeAssistant)?.push(msg);
-    } else {
-      activeAssistant = -1;
-    }
-  }
-  return map;
-}
-
-export function MessageView({
-  viewRef,
-  contentRef,
-  messages,
-  streaming,
-  stream,
-  error,
-  scrollOffset,
-  viewHeight,
-  contentHeight,
-}: {
-  viewRef: RefObject<DOMElement | null>;
-  contentRef: RefObject<DOMElement | null>;
-  messages: ChatMessage[];
-  streaming: boolean;
-  stream: StreamState;
-  error: string | null;
-  scrollOffset: number;
-  viewHeight: number;
-  contentHeight: number;
-}) {
-  const theme = useTheme();
-  const toolMessageIndex = useMemo(() => indexToolMessages(messages), [messages]);
-
-  return (
-    <Box flexGrow={1} overflow="hidden">
-      <Box ref={viewRef} flexDirection="column" flexGrow={1} paddingX={1} overflow="hidden">
-        <Box ref={contentRef} flexDirection="column" flexShrink={0} marginTop={-scrollOffset}>
-          {messages.map((msg, i) => (
-            // biome-ignore lint/suspicious/noArrayIndexKey: messages have no stable id
-            <MessageItem key={i} msg={msg} toolMessages={toolMessageIndex.get(i)} />
-          ))}
-          {streaming && <StreamingOutput currentText={stream.text} currentReasoning={stream.reasoning} />}
-          {error && <Text color={theme.common.error}>Error: {error}</Text>}
-        </Box>
-      </Box>
-      <Scrollbar viewHeight={viewHeight} contentHeight={contentHeight} scrollOffset={scrollOffset} />
-    </Box>
-  );
-}

package/src/tui/components/messages/EditOutput.tsx

@@ -1,112 +0,0 @@
-import { Box, Text } from 'ink';
-import type { ToolDisplayHint } from 'mu-core';
-import { computeDiff, renderDiff } from '../../../utils/diff';
-import { useTheme } from '../../context/ThemeContext';
-import { ToolHeader } from './ToolHeader';
-
-interface EditOutputProps {
-  args: string;
-  content: string;
-  error: boolean;
-  /**
-   * Display hint from the tool's plugin. Used to resolve which JSON arg field
-   * holds the path / from-string / to-string, so a plugin can register a
-   * diff-kind tool with arbitrary field names.
-   */
-  hint?: ToolDisplayHint;
-}
-
-interface ParsedEditArgs {
-  path: string;
-  before: string;
-  after: string;
-}
-
-const MAX_DIFF_LINES = 30;
-
-function parseEditArgs(args: string, hint: ToolDisplayHint | undefined): ParsedEditArgs {
-  const fields = hint?.fields ?? {};
-  const pathField = fields.path ?? 'path';
-  const fromField = fields.from ?? 'old_string';
-  const toField = fields.to ?? 'new_string';
-  try {
-    const parsed = JSON.parse(args);
-    return {
-      path: parsed[pathField] ?? '(unknown)',
-      before: parsed[fromField] ?? '',
-      after: parsed[toField] ?? '',
-    };
-  } catch {
-    return { path: '(unknown)', before: '', after: '' };
-  }
-}
-
-export function EditOutput({ args, content, error, hint }: EditOutputProps) {
-  const theme = useTheme();
-  const { path, before, after } = parseEditArgs(args, hint);
-  const verb = hint?.verb ?? 'edit_file';
-
-  if (error) {
-    return (
-      <Box flexDirection="column" flexShrink={0} marginBottom={0}>
-        <ToolHeader name={verb} subtitle={path} error={true} />
-        <Text dimColor={true} wrap="wrap">
-          {content}
-        </Text>
-      </Box>
-    );
-  }
-
-  const diff = computeDiff(before, after);
-
-  if (diff.lines.length === 0 && diff.totalOldLines > 0 && diff.totalNewLines > 0) {
-    return (
-      <Box flexDirection="column" flexShrink={0} marginBottom={0}>
-        <Text color={theme.diff.warning} bold={true}>
-          ! {verb}
-        </Text>
-        <Text dimColor={true}> {path}</Text>
-        <Text dimColor={true}>
-          Diff too large to display ({diff.totalOldLines} → {diff.totalNewLines} lines)
-        </Text>
-      </Box>
-    );
-  }
-
-  if (diff.lines.length === 0) {
-    return (
-      <Box flexDirection="column" flexShrink={0} marginBottom={0}>
-        <ToolHeader name={verb} subtitle={path} />
-        <Text dimColor={true}>No changes (content identical)</Text>
-      </Box>
-    );
-  }
-
-  const { lines, truncated } = renderDiff(diff, MAX_DIFF_LINES);
-
-  return (
-    <Box flexDirection="column" flexShrink={0} marginBottom={0}>
-      <ToolHeader name={verb} subtitle={path} />
-      <Box
-        flexDirection="column"
-        flexShrink={0}
-        backgroundColor={theme.tool.previewBackground}
-        paddingX={1}
-        paddingY={0}
-      >
-        {lines.map((line, i) => {
-          let color: string | undefined;
-          if (line.startsWith('-')) color = theme.diff.removed;
-          else if (line.startsWith('+')) color = theme.diff.added;
-          return (
-            // biome-ignore lint/suspicious/noArrayIndexKey: diff lines may repeat (blank lines, braces); index disambiguates
-            <Text key={`${i}-${line}`} color={color} dimColor={color === undefined} wrap="wrap">
-              {line}
-            </Text>
-          );
-        })}
-        {truncated && <Text dimColor={true}>… (truncated, {MAX_DIFF_LINES} line limit)</Text>}
-      </Box>
-    </Box>
-  );
-}

package/src/tui/components/messages/ReadOutput.tsx

@@ -1,48 +0,0 @@
-import { Box, Text } from 'ink';
-import { ToolHeader } from './ToolHeader';
-
-interface ReadOutputProps {
-  args: string;
-  error: boolean;
-}
-
-interface ReadArgs {
-  paths: string[];
-  startLine?: number;
-  endLine?: number;
-}
-
-function parseReadArgs(args: string): ReadArgs {
-  try {
-    const parsed = JSON.parse(args);
-    const p = parsed.path;
-    return {
-      paths: Array.isArray(p) ? p : [p ?? '(unknown)'],
-      startLine: typeof parsed.start === 'number' ? parsed.start : undefined,
-      endLine: typeof parsed.end === 'number' ? parsed.end : undefined,
-    };
-  } catch {
-    return { paths: ['(unknown)'] };
-  }
-}
-
-export function ReadOutput({ args, error }: ReadOutputProps) {
-  const { paths, startLine, endLine } = parseReadArgs(args);
-  const rangeLabel = startLine != null && endLine != null ? ` (lines ${startLine}-${endLine})` : '';
-  const subtitle = paths.length === 1 ? `${paths[0]}${rangeLabel}` : `${paths.length} files${rangeLabel}`;
-
-  return (
-    <Box flexDirection="column" flexShrink={0} marginBottom={0}>
-      <ToolHeader name="read_file" subtitle={subtitle} error={error} />
-      {paths.length > 1 && (
-        <Box flexDirection="column" flexShrink={0}>
-          {paths.map((p) => (
-            <Text key={p} dimColor={true} wrap="wrap">
-              {`  • ${p}`}
-            </Text>
-          ))}
-        </Box>
-      )}
-    </Box>
-  );
-}

package/src/tui/components/messages/ToolHeader.tsx

@@ -1,30 +0,0 @@
-import { Box, Text } from 'ink';
-import { useTheme } from '../../context/ThemeContext';
-
-interface ToolHeaderProps {
-  /** The tool name shown after the status icon. */
-  name: string;
-  /** Optional subtitle (typically the file path or command). */
-  subtitle?: string;
-  /** When true, render with the failure styling. */
-  error?: boolean;
-}
-
-/**
- * Shared header used by every tool-output renderer (read/write/edit/bash).
- * Centralizes the ✓/✗ glyphs, color choice, and subtitle formatting so each
- * specific component doesn't have to re-implement the same layout.
- */
-export function ToolHeader({ name, subtitle, error = false }: ToolHeaderProps) {
-  const theme = useTheme();
-  return (
-    <Box flexShrink={0}>
-      <Text wrap="truncate-end">
-        <Text color={error ? theme.tool.error : theme.tool.success} bold={true}>
-          {error ? '✗' : '✓'} {name}
-        </Text>
-        {subtitle && <Text dimColor={true}> {subtitle}</Text>}
-      </Text>
-    </Box>
-  );
-}

package/src/tui/components/messages/WebFetchOutput.tsx

@@ -1,30 +0,0 @@
-import { Box } from 'ink';
-import { ToolHeader } from './ToolHeader';
-
-interface WebFetchOutputProps {
-  args: string;
-  error: boolean;
-}
-
-function parseUrl(args: string): string {
-  try {
-    const parsed = JSON.parse(args);
-    return typeof parsed.url === 'string' ? parsed.url : '(unknown)';
-  } catch {
-    return '(unknown)';
-  }
-}
-
-/**
- * Compact renderer for the `webfetch` tool — shows a one-line header with the
- * fetched URL and elides the (often huge) response body so it doesn't fill
- * the transcript. Mirrors `ReadOutput`'s minimal layout.
- */
-export function WebFetchOutput({ args, error }: WebFetchOutputProps) {
-  const url = parseUrl(args);
-  return (
-    <Box flexDirection="column" flexShrink={0} marginBottom={0}>
-      <ToolHeader name="webfetch" subtitle={url} error={error} />
-    </Box>
-  );
-}

package/src/tui/components/messages/WriteOutput.tsx

@@ -1,64 +0,0 @@
-import { Box, Text } from 'ink';
-import { useTheme } from '../../context/ThemeContext';
-import { ToolHeader } from './ToolHeader';
-
-const PREVIEW_LINES = 30;
-
-interface WriteOutputProps {
-  args: string;
-  content: string;
-  error: boolean;
-}
-
-function parsePath(args: string): string {
-  try {
-    const parsed = JSON.parse(args);
-    return parsed.path ?? '(unknown)';
-  } catch {
-    return '(unknown)';
-  }
-}
-
-export function WriteOutput({ args, content, error }: WriteOutputProps) {
-  const theme = useTheme();
-  const path = parsePath(args);
-
-  if (error) {
-    return (
-      <Box flexDirection="column" flexShrink={0} marginBottom={0}>
-        <ToolHeader name="write_file" error={true} />
-        <Text dimColor={true} wrap="wrap">
-          {content}
-        </Text>
-      </Box>
-    );
-  }
-
-  const lines = content.split('\n');
-  const totalLines = lines.length;
-  const preview = lines.slice(0, PREVIEW_LINES).join('\n');
-  const hasMore = totalLines > PREVIEW_LINES;
-
-  return (
-    <Box flexDirection="column" flexShrink={0} marginBottom={0}>
-      <ToolHeader name="write_file" subtitle={path} />
-      <Box flexDirection="column" flexShrink={0}>
-        <Text dimColor={true}>
-          {totalLines} line{totalLines !== 1 ? 's' : ''}
-        </Text>
-        <Box
-          flexDirection="column"
-          flexShrink={0}
-          backgroundColor={theme.tool.previewBackground}
-          paddingX={1}
-          paddingY={0}
-        >
-          <Text color={theme.tool.previewText} wrap="wrap">
-            {hasMore ? preview : content}
-          </Text>
-          {hasMore && <Text dimColor={true}>… ({totalLines - PREVIEW_LINES} more lines)</Text>}
-        </Box>
-      </Box>
-    </Box>
-  );
-}

package/src/tui/components/messages/assistantMessage.tsx

@@ -1,72 +0,0 @@
-import { Box, Text } from 'ink';
-import type { ChatMessage } from 'mu-core';
-import React from 'react';
-import { MarkdownContent } from './markdown';
-import { ReasoningBlock } from './reasoningBlock';
-import { ToolCallBlock } from './toolCallBlock';
-
-/**
- * Tool names whose calls are already represented in the transcript by the
- * `mu-agents.subagent` custom message renderer (`SubagentMessage`).
- * Filtering them out here prevents a redundant `✓ subagent` block from
- * rendering the same body the SubagentMessage already shows.
- *
- * Reload caveat: the `SubagentRunRegistry` is in-memory only, so after a
- * session reload the SubagentMessage block has no live run and shows
- * just the `↳ <name>` glyph without a body. The wrapped tool result
- * still lives in the persisted transcript (and the LLM payload), so the
- * parent agent's relay paragraph is intact; the user just can't see the
- * raw subagent output inline after reopening the session. Accepted
- * trade-off; revisit if/when run hydration is wired into reload.
- */
-const SUBAGENT_TOOL_NAMES = new Set(['subagent', 'subagent_parallel']);
-
-export const AssistantMessage: React.FC<{
-  msg: ChatMessage;
-  toolMessages?: ChatMessage[];
-}> = React.memo(function AssistantMessage({ msg, toolMessages }) {
-  const badge = msg.display?.badge;
-  const prefix = msg.display?.prefix;
-  const color = msg.display?.color;
-
-  // Filter subagent tool calls out of the visible list, dropping their
-  // matching `toolMessages` entries in lock-step so positional indexing
-  // stays correct for the surviving calls.
-  const visibleEntries = (msg.toolCalls ?? []).flatMap((tc, i) =>
-    SUBAGENT_TOOL_NAMES.has(tc.function.name) ? [] : [{ tc, toolMsg: toolMessages?.[i] }],
-  );
-
-  // If every renderable surface on this assistant message is empty after
-  // filtering, suppress the entire block — otherwise we'd render a
-  // dangling badge bubble for assistant turns that were nothing but a
-  // subagent dispatch.
-  const hasAnything = visibleEntries.length > 0 || !!msg.content || !!msg.reasoning;
-  if (!hasAnything) return null;
-
-  const hasVisibleToolCalls = visibleEntries.length > 0;
-  return (
-    <Box flexDirection="column" flexShrink={0} marginBottom={hasVisibleToolCalls ? 0 : 1}>
-      {badge && (
-        <Box>
-          <Text color={color} bold={true}>
-            {badge.charAt(0).toUpperCase() + badge.slice(1)}
-          </Text>
-        </Box>
-      )}
-      {msg.reasoning && <ReasoningBlock reasoning={msg.reasoning} />}
-      {hasVisibleToolCalls ? (
-        <Box flexDirection="column">
-          {visibleEntries.map(({ tc, toolMsg }) => (
-            <ToolCallBlock key={tc.id} toolCall={tc} toolMsg={toolMsg} />
-          ))}
-        </Box>
-      ) : null}
-      {msg.content && (
-        <Box flexDirection="column">
-          {prefix && <Text color={color}>{prefix}</Text>}
-          <MarkdownContent content={msg.content} color={color} />
-        </Box>
-      )}
-    </Box>
-  );
-});