claude-code/tools/NotebookEditTool/UI.tsx

import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs';
import * as React from 'react';
import type { Message, ProgressMessage } from 'src/types/message.js';
import { extractTag } from 'src/utils/messages.js';
import type { ThemeName } from 'src/utils/theme.js';
import type { z } from 'zod/v4';
import { FallbackToolUseErrorMessage } from '../../components/FallbackToolUseErrorMessage.js';
import { FilePathLink } from '../../components/FilePathLink.js';
import { HighlightedCode } from '../../components/HighlightedCode.js';
import { MessageResponse } from '../../components/MessageResponse.js';
import { NotebookEditToolUseRejectedMessage } from '../../components/NotebookEditToolUseRejectedMessage.js';
import { Box, Text } from '../../ink.js';
import type { Tools } from '../../Tool.js';
import { getDisplayPath } from '../../utils/file.js';
import type { inputSchema, Output } from './NotebookEditTool.js';
export function getToolUseSummary(input: Partial<z.infer<ReturnType<typeof inputSchema>>> | undefined): string | null {
  if (!input?.notebook_path) {
    return null;
  }
  return getDisplayPath(input.notebook_path);
}
export function renderToolUseMessage({
  notebook_path,
  cell_id,
  new_source,
  cell_type,
  edit_mode
}: Partial<z.infer<ReturnType<typeof inputSchema>>>, {
  verbose
}: {
  verbose: boolean;
}): React.ReactNode {
  if (!notebook_path || !new_source || !cell_type) {
    return null;
  }
  const displayPath = verbose ? notebook_path : getDisplayPath(notebook_path);
  if (verbose) {
    return <>
        <FilePathLink filePath={notebook_path}>{displayPath}</FilePathLink>
        {`@${cell_id}, content: ${new_source.slice(0, 30)}…, cell_type: ${cell_type}, edit_mode: ${edit_mode ?? 'replace'}`}
      </>;
  }
  return <>
      <FilePathLink filePath={notebook_path}>{displayPath}</FilePathLink>
      {`@${cell_id}`}
    </>;
}
export function renderToolUseRejectedMessage(input: z.infer<ReturnType<typeof inputSchema>>, {
  verbose
}: {
  columns?: number;
  messages?: Message[];
  progressMessagesForMessage?: ProgressMessage[];
  theme?: ThemeName;
  tools?: Tools;
  verbose: boolean;
}): React.ReactNode {
  return <NotebookEditToolUseRejectedMessage notebook_path={input.notebook_path} cell_id={input.cell_id} new_source={input.new_source} cell_type={input.cell_type} edit_mode={input.edit_mode} verbose={verbose} />;
}
export function renderToolUseErrorMessage(result: ToolResultBlockParam['content'], {
  verbose
}: {
  verbose: boolean;
}): React.ReactNode {
  if (!verbose && typeof result === 'string' && extractTag(result, 'tool_use_error')) {
    return <MessageResponse>
        <Text color="error">Error editing notebook</Text>
      </MessageResponse>;
  }
  return <FallbackToolUseErrorMessage result={result} verbose={verbose} />;
}
export function renderToolResultMessage({
  cell_id,
  new_source,
  error
}: Output): React.ReactNode {
  if (error) {
    return <MessageResponse>
        <Text color="error">{error}</Text>
      </MessageResponse>;
  }
  return <MessageResponse>
      <Box flexDirection="column">
        <Text>
          Updated cell <Text bold>{cell_id}</Text>:
        </Text>
        <Box marginLeft={2}>
          <HighlightedCode code={new_source} filePath="notebook.py" />
        </Box>
      </Box>
    </MessageResponse>;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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