@xelauvas/xela-cli 0.1.0

package/src/tools/FileWriteTool/UI.tsx

@@ -0,0 +1,405 @@
+import { c as _c } from "react/compiler-runtime";
+import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs';
+import type { StructuredPatchHunk } from 'diff';
+import { isAbsolute, relative, resolve } from 'path';
+import * as React from 'react';
+import { Suspense, use, useState } from 'react';
+import { MessageResponse } from 'src/components/MessageResponse.js';
+import { extractTag } from 'src/utils/messages.js';
+import { CtrlOToExpand } from '../../components/CtrlOToExpand.js';
+import { FallbackToolUseErrorMessage } from '../../components/FallbackToolUseErrorMessage.js';
+import { FileEditToolUpdatedMessage } from '../../components/FileEditToolUpdatedMessage.js';
+import { FileEditToolUseRejectedMessage } from '../../components/FileEditToolUseRejectedMessage.js';
+import { FilePathLink } from '../../components/FilePathLink.js';
+import { HighlightedCode } from '../../components/HighlightedCode.js';
+import { useTerminalSize } from '../../hooks/useTerminalSize.js';
+import { Box, Text } from '../../ink.js';
+import type { ToolProgressData } from '../../Tool.js';
+import type { ProgressMessage } from '../../types/message.js';
+import { getCwd } from '../../utils/cwd.js';
+import { getPatchForDisplay } from '../../utils/diff.js';
+import { getDisplayPath } from '../../utils/file.js';
+import { logError } from '../../utils/log.js';
+import { getPlansDirectory } from '../../utils/plans.js';
+import { openForScan, readCapped } from '../../utils/readEditContext.js';
+import type { Output } from './FileWriteTool.js';
+const MAX_LINES_TO_RENDER = 10;
+// Model output uses \n regardless of platform, so always split on \n.
+// os.EOL is \r\n on Windows, which would give numLines=1 for all files.
+const EOL = '\n';
+
+/**
+ * Count visible lines in file content. A trailing newline is treated as a
+ * line terminator (not a new empty line), matching editor line numbering.
+ */
+export function countLines(content: string): number {
+  const parts = content.split(EOL);
+  return content.endsWith(EOL) ? parts.length - 1 : parts.length;
+}
+function FileWriteToolCreatedMessage(t0) {
+  const $ = _c(25);
+  const {
+    filePath,
+    content,
+    verbose
+  } = t0;
+  const {
+    columns
+  } = useTerminalSize();
+  const contentWithFallback = content || "(No content)";
+  const numLines = countLines(content);
+  const plusLines = numLines - MAX_LINES_TO_RENDER;
+  let t1;
+  if ($[0] !== numLines) {
+    t1 = <Text bold={true}>{numLines}</Text>;
+    $[0] = numLines;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] !== filePath || $[3] !== verbose) {
+    t2 = verbose ? filePath : relative(getCwd(), filePath);
+    $[2] = filePath;
+    $[3] = verbose;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] !== t2) {
+    t3 = <Text bold={true}>{t2}</Text>;
+    $[5] = t2;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  let t4;
+  if ($[7] !== t1 || $[8] !== t3) {
+    t4 = <Text>Wrote {t1} lines to{" "}{t3}</Text>;
+    $[7] = t1;
+    $[8] = t3;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  let t5;
+  if ($[10] !== contentWithFallback || $[11] !== verbose) {
+    t5 = verbose ? contentWithFallback : contentWithFallback.split("\n").slice(0, MAX_LINES_TO_RENDER).join("\n");
+    $[10] = contentWithFallback;
+    $[11] = verbose;
+    $[12] = t5;
+  } else {
+    t5 = $[12];
+  }
+  const t6 = columns - 12;
+  let t7;
+  if ($[13] !== filePath || $[14] !== t5 || $[15] !== t6) {
+    t7 = <Box flexDirection="column"><HighlightedCode code={t5} filePath={filePath} width={t6} /></Box>;
+    $[13] = filePath;
+    $[14] = t5;
+    $[15] = t6;
+    $[16] = t7;
+  } else {
+    t7 = $[16];
+  }
+  let t8;
+  if ($[17] !== numLines || $[18] !== plusLines || $[19] !== verbose) {
+    t8 = !verbose && plusLines > 0 && <Text dimColor={true}>… +{plusLines} {plusLines === 1 ? "line" : "lines"}{" "}{numLines > 0 && <CtrlOToExpand />}</Text>;
+    $[17] = numLines;
+    $[18] = plusLines;
+    $[19] = verbose;
+    $[20] = t8;
+  } else {
+    t8 = $[20];
+  }
+  let t9;
+  if ($[21] !== t4 || $[22] !== t7 || $[23] !== t8) {
+    t9 = <MessageResponse><Box flexDirection="column">{t4}{t7}{t8}</Box></MessageResponse>;
+    $[21] = t4;
+    $[22] = t7;
+    $[23] = t8;
+    $[24] = t9;
+  } else {
+    t9 = $[24];
+  }
+  return t9;
+}
+export function userFacingName(input: Partial<{
+  file_path: string;
+  content: string;
+}> | undefined): string {
+  if (input?.file_path?.startsWith(getPlansDirectory())) {
+    return 'Updated plan';
+  }
+  return 'Write';
+}
+
+/** Gates fullscreen click-to-expand. Only `create` truncates (to
+ *  MAX_LINES_TO_RENDER); `update` renders the full diff regardless of verbose.
+ *  Called per visible message on hover/scroll, so early-exit after finding the
+ *  (MAX+1)th line instead of splitting the whole (possibly huge) content. */
+export function isResultTruncated({
+  type,
+  content
+}: Output): boolean {
+  if (type !== 'create') return false;
+  let pos = 0;
+  for (let i = 0; i < MAX_LINES_TO_RENDER; i++) {
+    pos = content.indexOf(EOL, pos);
+    if (pos === -1) return false;
+    pos++;
+  }
+  // countLines treats a trailing EOL as a terminator, not a new line
+  return pos < content.length;
+}
+export function getToolUseSummary(input: Partial<{
+  file_path: string;
+  content: string;
+}> | undefined): string | null {
+  if (!input?.file_path) {
+    return null;
+  }
+  return getDisplayPath(input.file_path);
+}
+export function renderToolUseMessage(input: Partial<{
+  file_path: string;
+  content: string;
+}>, {
+  verbose
+}: {
+  verbose: boolean;
+}): React.ReactNode {
+  if (!input.file_path) {
+    return null;
+  }
+  // For plan files, path is already in userFacingName
+  if (input.file_path.startsWith(getPlansDirectory())) {
+    return '';
+  }
+  return <FilePathLink filePath={input.file_path}>
+      {verbose ? input.file_path : getDisplayPath(input.file_path)}
+    </FilePathLink>;
+}
+export function renderToolUseRejectedMessage({
+  file_path,
+  content
+}: {
+  file_path: string;
+  content: string;
+}, {
+  style,
+  verbose
+}: {
+  style?: 'condensed';
+  verbose: boolean;
+}): React.ReactNode {
+  return <WriteRejectionDiff filePath={file_path} content={content} style={style} verbose={verbose} />;
+}
+type RejectionDiffData = {
+  type: 'create';
+} | {
+  type: 'update';
+  patch: StructuredPatchHunk[];
+  oldContent: string;
+} | {
+  type: 'error';
+};
+function WriteRejectionDiff(t0) {
+  const $ = _c(20);
+  const {
+    filePath,
+    content,
+    style,
+    verbose
+  } = t0;
+  let t1;
+  if ($[0] !== content || $[1] !== filePath) {
+    t1 = () => loadRejectionDiff(filePath, content);
+    $[0] = content;
+    $[1] = filePath;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const [dataPromise] = useState(t1);
+  let t2;
+  if ($[3] !== content) {
+    t2 = content.split("\n")[0] ?? null;
+    $[3] = content;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  const firstLine = t2;
+  let t3;
+  if ($[5] !== content || $[6] !== filePath || $[7] !== firstLine || $[8] !== verbose) {
+    t3 = <FileEditToolUseRejectedMessage file_path={filePath} operation="write" content={content} firstLine={firstLine} verbose={verbose} />;
+    $[5] = content;
+    $[6] = filePath;
+    $[7] = firstLine;
+    $[8] = verbose;
+    $[9] = t3;
+  } else {
+    t3 = $[9];
+  }
+  const createFallback = t3;
+  let t4;
+  if ($[10] !== createFallback || $[11] !== dataPromise || $[12] !== filePath || $[13] !== firstLine || $[14] !== style || $[15] !== verbose) {
+    t4 = <WriteRejectionBody promise={dataPromise} filePath={filePath} firstLine={firstLine} createFallback={createFallback} style={style} verbose={verbose} />;
+    $[10] = createFallback;
+    $[11] = dataPromise;
+    $[12] = filePath;
+    $[13] = firstLine;
+    $[14] = style;
+    $[15] = verbose;
+    $[16] = t4;
+  } else {
+    t4 = $[16];
+  }
+  let t5;
+  if ($[17] !== createFallback || $[18] !== t4) {
+    t5 = <Suspense fallback={createFallback}>{t4}</Suspense>;
+    $[17] = createFallback;
+    $[18] = t4;
+    $[19] = t5;
+  } else {
+    t5 = $[19];
+  }
+  return t5;
+}
+function WriteRejectionBody(t0) {
+  const $ = _c(8);
+  const {
+    promise,
+    filePath,
+    firstLine,
+    createFallback,
+    style,
+    verbose
+  } = t0;
+  const data = use(promise);
+  if (data.type === "create") {
+    return createFallback;
+  }
+  if (data.type === "error") {
+    let t1;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+      t1 = <MessageResponse><Text>(No changes)</Text></MessageResponse>;
+      $[0] = t1;
+    } else {
+      t1 = $[0];
+    }
+    return t1;
+  }
+  let t1;
+  if ($[1] !== data.oldContent || $[2] !== data.patch || $[3] !== filePath || $[4] !== firstLine || $[5] !== style || $[6] !== verbose) {
+    t1 = <FileEditToolUseRejectedMessage file_path={filePath} operation="update" patch={data.patch} firstLine={firstLine} fileContent={data.oldContent} style={style} verbose={verbose} />;
+    $[1] = data.oldContent;
+    $[2] = data.patch;
+    $[3] = filePath;
+    $[4] = firstLine;
+    $[5] = style;
+    $[6] = verbose;
+    $[7] = t1;
+  } else {
+    t1 = $[7];
+  }
+  return t1;
+}
+async function loadRejectionDiff(filePath: string, content: string): Promise<RejectionDiffData> {
+  try {
+    const fullFilePath = isAbsolute(filePath) ? filePath : resolve(getCwd(), filePath);
+    const handle = await openForScan(fullFilePath);
+    if (handle === null) return {
+      type: 'create'
+    };
+    let oldContent: string | null;
+    try {
+      oldContent = await readCapped(handle);
+    } finally {
+      await handle.close();
+    }
+    // File exceeds MAX_SCAN_BYTES — fall back to the create view rather than
+    // OOMing on a diff of a multi-GB file.
+    if (oldContent === null) return {
+      type: 'create'
+    };
+    const patch = getPatchForDisplay({
+      filePath,
+      fileContents: oldContent,
+      edits: [{
+        old_string: oldContent,
+        new_string: content,
+        replace_all: false
+      }]
+    });
+    return {
+      type: 'update',
+      patch,
+      oldContent
+    };
+  } catch (e) {
+    // User may have manually applied the change while the diff was shown.
+    logError(e as Error);
+    return {
+      type: 'error'
+    };
+  }
+}
+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 writing file</Text>
+      </MessageResponse>;
+  }
+  return <FallbackToolUseErrorMessage result={result} verbose={verbose} />;
+}
+export function renderToolResultMessage({
+  filePath,
+  content,
+  structuredPatch,
+  type,
+  originalFile
+}: Output, _progressMessagesForMessage: ProgressMessage<ToolProgressData>[], {
+  style,
+  verbose
+}: {
+  style?: 'condensed';
+  verbose: boolean;
+}): React.ReactNode {
+  switch (type) {
+    case 'create':
+      {
+        const isPlanFile = filePath.startsWith(getPlansDirectory());
+
+        // Plan files: invert condensed behavior
+        // - Regular mode: just show hint (user can type /plan to see full content)
+        // - Condensed mode (subagent view): show full content
+        if (isPlanFile && !verbose) {
+          if (style !== 'condensed') {
+            return <MessageResponse>
+              <Text dimColor>/plan to preview</Text>
+            </MessageResponse>;
+          }
+        } else if (style === 'condensed' && !verbose) {
+          const numLines = countLines(content);
+          return <Text>
+            Wrote <Text bold>{numLines}</Text> lines to{' '}
+            <Text bold>{relative(getCwd(), filePath)}</Text>
+          </Text>;
+        }
+        return <FileWriteToolCreatedMessage filePath={filePath} content={content} verbose={verbose} />;
+      }
+    case 'update':
+      {
+        const isPlanFile = filePath.startsWith(getPlansDirectory());
+        return <FileEditToolUpdatedMessage filePath={filePath} structuredPatch={structuredPatch} firstLine={content.split('\n')[0] ?? null} fileContent={originalFile ?? undefined} style={style} verbose={verbose} previewHint={isPlanFile ? '/plan to preview' : undefined} />;
+      }
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ToolResultBlockParam","StructuredPatchHunk","isAbsolute","relative","resolve","React","Suspense","use","useState","MessageResponse","extractTag","CtrlOToExpand","FallbackToolUseErrorMessage","FileEditToolUpdatedMessage","FileEditToolUseRejectedMessage","FilePathLink","HighlightedCode","useTerminalSize","Box","Text","ToolProgressData","ProgressMessage","getCwd","getPatchForDisplay","getDisplayPath","logError","getPlansDirectory","openForScan","readCapped","Output","MAX_LINES_TO_RENDER","EOL","countLines","content","parts","split","endsWith","length","FileWriteToolCreatedMessage","t0","$","_c","filePath","verbose","columns","contentWithFallback","numLines","plusLines","t1","t2","t3","t4","t5","slice","join","t6","t7","t8","t9","userFacingName","input","Partial","file_path","startsWith","isResultTruncated","type","pos","i","indexOf","getToolUseSummary","renderToolUseMessage","ReactNode","renderToolUseRejectedMessage","style","RejectionDiffData","patch","oldContent","WriteRejectionDiff","loadRejectionDiff","dataPromise","firstLine","createFallback","WriteRejectionBody","promise","data","Symbol","for","Promise","fullFilePath","handle","close","fileContents","edits","old_string","new_string","replace_all","e","Error","renderToolUseErrorMessage","result","renderToolResultMessage","structuredPatch","originalFile","_progressMessagesForMessage","isPlanFile","undefined"],"sources":["UI.tsx"],"sourcesContent":["import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'\nimport type { StructuredPatchHunk } from 'diff'\nimport { isAbsolute, relative, resolve } from 'path'\nimport * as React from 'react'\nimport { Suspense, use, useState } from 'react'\nimport { MessageResponse } from 'src/components/MessageResponse.js'\nimport { extractTag } from 'src/utils/messages.js'\nimport { CtrlOToExpand } from '../../components/CtrlOToExpand.js'\nimport { FallbackToolUseErrorMessage } from '../../components/FallbackToolUseErrorMessage.js'\nimport { FileEditToolUpdatedMessage } from '../../components/FileEditToolUpdatedMessage.js'\nimport { FileEditToolUseRejectedMessage } from '../../components/FileEditToolUseRejectedMessage.js'\nimport { FilePathLink } from '../../components/FilePathLink.js'\nimport { HighlightedCode } from '../../components/HighlightedCode.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport { Box, Text } from '../../ink.js'\nimport type { ToolProgressData } from '../../Tool.js'\nimport type { ProgressMessage } from '../../types/message.js'\nimport { getCwd } from '../../utils/cwd.js'\nimport { getPatchForDisplay } from '../../utils/diff.js'\nimport { getDisplayPath } from '../../utils/file.js'\nimport { logError } from '../../utils/log.js'\nimport { getPlansDirectory } from '../../utils/plans.js'\nimport { openForScan, readCapped } from '../../utils/readEditContext.js'\nimport type { Output } from './FileWriteTool.js'\n\nconst MAX_LINES_TO_RENDER = 10\n// Model output uses \\n regardless of platform, so always split on \\n.\n// os.EOL is \\r\\n on Windows, which would give numLines=1 for all files.\nconst EOL = '\\n'\n\n/**\n * Count visible lines in file content. A trailing newline is treated as a\n * line terminator (not a new empty line), matching editor line numbering.\n */\nexport function countLines(content: string): number {\n  const parts = content.split(EOL)\n  return content.endsWith(EOL) ? parts.length - 1 : parts.length\n}\n\nfunction FileWriteToolCreatedMessage({\n  filePath,\n  content,\n  verbose,\n}: {\n  filePath: string\n  content: string\n  verbose: boolean\n}): React.ReactNode {\n  const { columns } = useTerminalSize()\n  const contentWithFallback = content || '(No content)'\n  const numLines = countLines(content)\n  const plusLines = numLines - MAX_LINES_TO_RENDER\n\n  return (\n    <MessageResponse>\n      <Box flexDirection=\"column\">\n        <Text>\n          Wrote <Text bold>{numLines}</Text> lines to{' '}\n          <Text bold>{verbose ? filePath : relative(getCwd(), filePath)}</Text>\n        </Text>\n        <Box flexDirection=\"column\">\n          <HighlightedCode\n            code={\n              verbose\n                ? contentWithFallback\n                : contentWithFallback\n                    .split('\\n')\n                    .slice(0, MAX_LINES_TO_RENDER)\n                    .join('\\n')\n            }\n            filePath={filePath}\n            width={columns - 12}\n          />\n        </Box>\n        {!verbose && plusLines > 0 && (\n          <Text dimColor>\n            … +{plusLines} {plusLines === 1 ? 'line' : 'lines'}{' '}\n            {numLines > 0 && <CtrlOToExpand />}\n          </Text>\n        )}\n      </Box>\n    </MessageResponse>\n  )\n}\n\nexport function userFacingName(\n  input: Partial<{ file_path: string; content: string }> | undefined,\n): string {\n  if (input?.file_path?.startsWith(getPlansDirectory())) {\n    return 'Updated plan'\n  }\n  return 'Write'\n}\n\n/** Gates fullscreen click-to-expand. Only `create` truncates (to\n *  MAX_LINES_TO_RENDER); `update` renders the full diff regardless of verbose.\n *  Called per visible message on hover/scroll, so early-exit after finding the\n *  (MAX+1)th line instead of splitting the whole (possibly huge) content. */\nexport function isResultTruncated({ type, content }: Output): boolean {\n  if (type !== 'create') return false\n  let pos = 0\n  for (let i = 0; i < MAX_LINES_TO_RENDER; i++) {\n    pos = content.indexOf(EOL, pos)\n    if (pos === -1) return false\n    pos++\n  }\n  // countLines treats a trailing EOL as a terminator, not a new line\n  return pos < content.length\n}\n\nexport function getToolUseSummary(\n  input: Partial<{ file_path: string; content: string }> | undefined,\n): string | null {\n  if (!input?.file_path) {\n    return null\n  }\n  return getDisplayPath(input.file_path)\n}\n\nexport function renderToolUseMessage(\n  input: Partial<{ file_path: string; content: string }>,\n  { verbose }: { verbose: boolean },\n): React.ReactNode {\n  if (!input.file_path) {\n    return null\n  }\n  // For plan files, path is already in userFacingName\n  if (input.file_path.startsWith(getPlansDirectory())) {\n    return ''\n  }\n  return (\n    <FilePathLink filePath={input.file_path}>\n      {verbose ? input.file_path : getDisplayPath(input.file_path)}\n    </FilePathLink>\n  )\n}\n\nexport function renderToolUseRejectedMessage(\n  { file_path, content }: { file_path: string; content: string },\n  { style, verbose }: { style?: 'condensed'; verbose: boolean },\n): React.ReactNode {\n  return (\n    <WriteRejectionDiff\n      filePath={file_path}\n      content={content}\n      style={style}\n      verbose={verbose}\n    />\n  )\n}\n\ntype RejectionDiffData =\n  | { type: 'create' }\n  | { type: 'update'; patch: StructuredPatchHunk[]; oldContent: string }\n  | { type: 'error' }\n\nfunction WriteRejectionDiff({\n  filePath,\n  content,\n  style,\n  verbose,\n}: {\n  filePath: string\n  content: string\n  style?: 'condensed'\n  verbose: boolean\n}): React.ReactNode {\n  const [dataPromise] = useState(() => loadRejectionDiff(filePath, content))\n  const firstLine = content.split('\\n')[0] ?? null\n  const createFallback = (\n    <FileEditToolUseRejectedMessage\n      file_path={filePath}\n      operation=\"write\"\n      content={content}\n      firstLine={firstLine}\n      verbose={verbose}\n    />\n  )\n  return (\n    <Suspense fallback={createFallback}>\n      <WriteRejectionBody\n        promise={dataPromise}\n        filePath={filePath}\n        firstLine={firstLine}\n        createFallback={createFallback}\n        style={style}\n        verbose={verbose}\n      />\n    </Suspense>\n  )\n}\n\nfunction WriteRejectionBody({\n  promise,\n  filePath,\n  firstLine,\n  createFallback,\n  style,\n  verbose,\n}: {\n  promise: Promise<RejectionDiffData>\n  filePath: string\n  firstLine: string | null\n  createFallback: React.ReactNode\n  style?: 'condensed'\n  verbose: boolean\n}): React.ReactNode {\n  const data = use(promise)\n  if (data.type === 'create') return createFallback\n  if (data.type === 'error') {\n    return (\n      <MessageResponse>\n        <Text>(No changes)</Text>\n      </MessageResponse>\n    )\n  }\n  return (\n    <FileEditToolUseRejectedMessage\n      file_path={filePath}\n      operation=\"update\"\n      patch={data.patch}\n      firstLine={firstLine}\n      fileContent={data.oldContent}\n      style={style}\n      verbose={verbose}\n    />\n  )\n}\n\nasync function loadRejectionDiff(\n  filePath: string,\n  content: string,\n): Promise<RejectionDiffData> {\n  try {\n    const fullFilePath = isAbsolute(filePath)\n      ? filePath\n      : resolve(getCwd(), filePath)\n    const handle = await openForScan(fullFilePath)\n    if (handle === null) return { type: 'create' }\n    let oldContent: string | null\n    try {\n      oldContent = await readCapped(handle)\n    } finally {\n      await handle.close()\n    }\n    // File exceeds MAX_SCAN_BYTES — fall back to the create view rather than\n    // OOMing on a diff of a multi-GB file.\n    if (oldContent === null) return { type: 'create' }\n    const patch = getPatchForDisplay({\n      filePath,\n      fileContents: oldContent,\n      edits: [\n        { old_string: oldContent, new_string: content, replace_all: false },\n      ],\n    })\n    return { type: 'update', patch, oldContent }\n  } catch (e) {\n    // User may have manually applied the change while the diff was shown.\n    logError(e as Error)\n    return { type: 'error' }\n  }\n}\n\nexport function renderToolUseErrorMessage(\n  result: ToolResultBlockParam['content'],\n  { verbose }: { verbose: boolean },\n): React.ReactNode {\n  if (\n    !verbose &&\n    typeof result === 'string' &&\n    extractTag(result, 'tool_use_error')\n  ) {\n    return (\n      <MessageResponse>\n        <Text color=\"error\">Error writing file</Text>\n      </MessageResponse>\n    )\n  }\n  return <FallbackToolUseErrorMessage result={result} verbose={verbose} />\n}\n\nexport function renderToolResultMessage(\n  { filePath, content, structuredPatch, type, originalFile }: Output,\n  _progressMessagesForMessage: ProgressMessage<ToolProgressData>[],\n  { style, verbose }: { style?: 'condensed'; verbose: boolean },\n): React.ReactNode {\n  switch (type) {\n    case 'create': {\n      const isPlanFile = filePath.startsWith(getPlansDirectory())\n\n      // Plan files: invert condensed behavior\n      // - Regular mode: just show hint (user can type /plan to see full content)\n      // - Condensed mode (subagent view): show full content\n      if (isPlanFile && !verbose) {\n        if (style !== 'condensed') {\n          return (\n            <MessageResponse>\n              <Text dimColor>/plan to preview</Text>\n            </MessageResponse>\n          )\n        }\n      } else if (style === 'condensed' && !verbose) {\n        const numLines = countLines(content)\n        return (\n          <Text>\n            Wrote <Text bold>{numLines}</Text> lines to{' '}\n            <Text bold>{relative(getCwd(), filePath)}</Text>\n          </Text>\n        )\n      }\n\n      return (\n        <FileWriteToolCreatedMessage\n          filePath={filePath}\n          content={content}\n          verbose={verbose}\n        />\n      )\n    }\n    case 'update': {\n      const isPlanFile = filePath.startsWith(getPlansDirectory())\n      return (\n        <FileEditToolUpdatedMessage\n          filePath={filePath}\n          structuredPatch={structuredPatch}\n          firstLine={content.split('\\n')[0] ?? null}\n          fileContent={originalFile ?? undefined}\n          style={style}\n          verbose={verbose}\n          previewHint={isPlanFile ? '/plan to preview' : undefined}\n        />\n      )\n    }\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/src/tools/FileWriteTool/prompt.ts

@@ -0,0 +1,18 @@
+import { FILE_READ_TOOL_NAME } from '../FileReadTool/prompt.js'
+
+export const FILE_WRITE_TOOL_NAME = 'Write'
+export const DESCRIPTION = 'Write a file to the local filesystem.'
+
+function getPreReadInstruction(): string {
+  return `\n- If this is an existing file, you MUST use the ${FILE_READ_TOOL_NAME} tool first to read the file's contents. This tool will fail if you did not read the file first.`
+}
+
+export function getWriteToolDescription(): string {
+  return `Writes a file to the local filesystem.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.${getPreReadInstruction()}
+- Prefer the Edit tool for modifying existing files \u2014 it only sends the diff. Only use this tool to create new files or for complete rewrites.
+- NEVER create documentation files (*.md) or README files unless explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.`
+}

package/src/tools/GlobTool/GlobTool.ts

@@ -0,0 +1,198 @@
+import { z } from 'zod/v4'
+import type { ValidationResult } from '../../Tool.js'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { getCwd } from '../../utils/cwd.js'
+import { isENOENT } from '../../utils/errors.js'
+import {
+  FILE_NOT_FOUND_CWD_NOTE,
+  suggestPathUnderCwd,
+} from '../../utils/file.js'
+import { getFsImplementation } from '../../utils/fsOperations.js'
+import { glob } from '../../utils/glob.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { expandPath, toRelativePath } from '../../utils/path.js'
+import { checkReadPermissionForTool } from '../../utils/permissions/filesystem.js'
+import type { PermissionDecision } from '../../utils/permissions/PermissionResult.js'
+import { matchWildcardPattern } from '../../utils/permissions/shellRuleMatching.js'
+import { DESCRIPTION, GLOB_TOOL_NAME } from './prompt.js'
+import {
+  getToolUseSummary,
+  renderToolResultMessage,
+  renderToolUseErrorMessage,
+  renderToolUseMessage,
+  userFacingName,
+} from './UI.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    pattern: z.string().describe('The glob pattern to match files against'),
+    path: z
+      .string()
+      .optional()
+      .describe(
+        'The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.',
+      ),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    durationMs: z
+      .number()
+      .describe('Time taken to execute the search in milliseconds'),
+    numFiles: z.number().describe('Total number of files found'),
+    filenames: z
+      .array(z.string())
+      .describe('Array of file paths that match the pattern'),
+    truncated: z
+      .boolean()
+      .describe('Whether results were truncated (limited to 100 files)'),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+
+export type Output = z.infer<OutputSchema>
+
+export const GlobTool = buildTool({
+  name: GLOB_TOOL_NAME,
+  searchHint: 'find files by name pattern or wildcard',
+  maxResultSizeChars: 100_000,
+  async description() {
+    return DESCRIPTION
+  },
+  userFacingName,
+  getToolUseSummary,
+  getActivityDescription(input) {
+    const summary = getToolUseSummary(input)
+    return summary ? `Finding ${summary}` : 'Finding files'
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+  toAutoClassifierInput(input) {
+    return input.pattern
+  },
+  isSearchOrReadCommand() {
+    return { isSearch: true, isRead: false }
+  },
+  getPath({ path }): string {
+    return path ? expandPath(path) : getCwd()
+  },
+  async preparePermissionMatcher({ pattern }) {
+    return rulePattern => matchWildcardPattern(rulePattern, pattern)
+  },
+  async validateInput({ path }): Promise<ValidationResult> {
+    // If path is provided, validate that it exists and is a directory
+    if (path) {
+      const fs = getFsImplementation()
+      const absolutePath = expandPath(path)
+
+      // SECURITY: Skip filesystem operations for UNC paths to prevent NTLM credential leaks.
+      if (absolutePath.startsWith('\\\\') || absolutePath.startsWith('//')) {
+        return { result: true }
+      }
+
+      let stats
+      try {
+        stats = await fs.stat(absolutePath)
+      } catch (e: unknown) {
+        if (isENOENT(e)) {
+          const cwdSuggestion = await suggestPathUnderCwd(absolutePath)
+          let message = `Directory does not exist: ${path}. ${FILE_NOT_FOUND_CWD_NOTE} ${getCwd()}.`
+          if (cwdSuggestion) {
+            message += ` Did you mean ${cwdSuggestion}?`
+          }
+          return {
+            result: false,
+            message,
+            errorCode: 1,
+          }
+        }
+        throw e
+      }
+
+      if (!stats.isDirectory()) {
+        return {
+          result: false,
+          message: `Path is not a directory: ${path}`,
+          errorCode: 2,
+        }
+      }
+    }
+
+    return { result: true }
+  },
+  async checkPermissions(input, context): Promise<PermissionDecision> {
+    const appState = context.getAppState()
+    return checkReadPermissionForTool(
+      GlobTool,
+      input,
+      appState.toolPermissionContext,
+    )
+  },
+  async prompt() {
+    return DESCRIPTION
+  },
+  renderToolUseMessage,
+  renderToolUseErrorMessage,
+  renderToolResultMessage,
+  // Reuses Grep's render (UI.tsx:65) — shows filenames.join. durationMs/
+  // numFiles are "Found 3 files in 12ms" chrome (under-count, fine).
+  extractSearchText({ filenames }) {
+    return filenames.join('\n')
+  },
+  async call(input, { abortController, getAppState, globLimits }) {
+    const start = Date.now()
+    const appState = getAppState()
+    const limit = globLimits?.maxResults ?? 100
+    const { files, truncated } = await glob(
+      input.pattern,
+      GlobTool.getPath(input),
+      { limit, offset: 0 },
+      abortController.signal,
+      appState.toolPermissionContext,
+    )
+    // Relativize paths under cwd to save tokens (same as GrepTool)
+    const filenames = files.map(toRelativePath)
+    const output: Output = {
+      filenames,
+      durationMs: Date.now() - start,
+      numFiles: filenames.length,
+      truncated,
+    }
+    return {
+      data: output,
+    }
+  },
+  mapToolResultToToolResultBlockParam(output, toolUseID) {
+    if (output.filenames.length === 0) {
+      return {
+        tool_use_id: toolUseID,
+        type: 'tool_result',
+        content: 'No files found',
+      }
+    }
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: [
+        ...output.filenames,
+        ...(output.truncated
+          ? [
+              '(Results are truncated. Consider using a more specific path or pattern.)',
+            ]
+          : []),
+      ].join('\n'),
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)