@xortex/xcode 3.0.1 → 3.0.2

package/components/permissions/FilePermissionDialog/useFilePermissionDialog.ts

@@ -0,0 +1,212 @@
+import { useCallback, useMemo, useState } from 'react'
+import { useAppState } from 'src/state/AppState.js'
+import { useKeybindings } from '../../../keybindings/useKeybinding.js'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../../../services/analytics/index.js'
+import { sanitizeToolNameForAnalytics } from '../../../services/analytics/metadata.js'
+import type { PermissionUpdate } from '../../../utils/permissions/PermissionUpdateSchema.js'
+import type { CompletionType } from '../../../utils/unaryLogging.js'
+import type { ToolUseConfirm } from '../PermissionRequest.js'
+import {
+  type FileOperationType,
+  getFilePermissionOptions,
+  type PermissionOption,
+  type PermissionOptionWithLabel,
+} from './permissionOptions.js'
+import {
+  PERMISSION_HANDLERS,
+  type PermissionHandlerParams,
+} from './usePermissionHandler.js'
+
+export interface ToolInput {
+  [key: string]: unknown
+}
+
+export type UseFilePermissionDialogProps<T extends ToolInput> = {
+  filePath: string
+  completionType: CompletionType
+  languageName: string | Promise<string>
+  toolUseConfirm: ToolUseConfirm
+  onDone: () => void
+  onReject: () => void
+  parseInput: (input: unknown) => T
+  operationType?: FileOperationType
+}
+
+export type UseFilePermissionDialogResult<T> = {
+  options: PermissionOptionWithLabel[]
+  onChange: (option: PermissionOption, input: T, feedback?: string) => void
+  acceptFeedback: string
+  rejectFeedback: string
+  focusedOption: string
+  setFocusedOption: (option: string) => void
+  handleInputModeToggle: (value: string) => void
+  yesInputMode: boolean
+  noInputMode: boolean
+}
+
+/**
+ * Hook for handling file permission dialogs with common logic
+ */
+export function useFilePermissionDialog<T extends ToolInput>({
+  filePath,
+  completionType,
+  languageName,
+  toolUseConfirm,
+  onDone,
+  onReject,
+  parseInput,
+  operationType = 'write',
+}: UseFilePermissionDialogProps<T>): UseFilePermissionDialogResult<T> {
+  const toolPermissionContext = useAppState(s => s.toolPermissionContext)
+  const [acceptFeedback, setAcceptFeedback] = useState('')
+  const [rejectFeedback, setRejectFeedback] = useState('')
+  const [focusedOption, setFocusedOption] = useState('yes')
+  const [yesInputMode, setYesInputMode] = useState(false)
+  const [noInputMode, setNoInputMode] = useState(false)
+  // Track whether user ever entered feedback mode (persists after collapse)
+  const [yesFeedbackModeEntered, setYesFeedbackModeEntered] = useState(false)
+  const [noFeedbackModeEntered, setNoFeedbackModeEntered] = useState(false)
+
+  // Generate options based on context
+  const options = useMemo(
+    () =>
+      getFilePermissionOptions({
+        filePath,
+        toolPermissionContext,
+        operationType,
+        onRejectFeedbackChange: setRejectFeedback,
+        onAcceptFeedbackChange: setAcceptFeedback,
+        yesInputMode,
+        noInputMode,
+      }),
+    [filePath, toolPermissionContext, operationType, yesInputMode, noInputMode],
+  )
+
+  // Handle option selection using shared handlers
+  const onChange = useCallback(
+    (option: PermissionOption, input: T, feedback?: string) => {
+      const params: PermissionHandlerParams = {
+        messageId: toolUseConfirm.assistantMessage.message.id,
+        path: filePath,
+        toolUseConfirm,
+        toolPermissionContext,
+        onDone,
+        onReject,
+        completionType,
+        languageName,
+        operationType,
+      }
+
+      // Override the input in toolUseConfirm to pass the parsed input
+      const originalOnAllow = toolUseConfirm.onAllow
+      toolUseConfirm.onAllow = (
+        _input: unknown,
+        permissionUpdates: PermissionUpdate[],
+        feedback?: string,
+      ) => {
+        originalOnAllow(input, permissionUpdates, feedback)
+      }
+
+      const handler = PERMISSION_HANDLERS[option.type]
+      handler(params, {
+        feedback,
+        hasFeedback: !!feedback,
+        enteredFeedbackMode:
+          option.type === 'accept-once'
+            ? yesFeedbackModeEntered
+            : noFeedbackModeEntered,
+        scope: option.type === 'accept-session' ? option.scope : undefined,
+      })
+    },
+    [
+      filePath,
+      completionType,
+      languageName,
+      toolUseConfirm,
+      toolPermissionContext,
+      onDone,
+      onReject,
+      operationType,
+      yesFeedbackModeEntered,
+      noFeedbackModeEntered,
+    ],
+  )
+
+  // Handler for confirm:cycleMode - select accept-session option
+  const handleCycleMode = useCallback(() => {
+    const sessionOption = options.find(o => o.option.type === 'accept-session')
+    if (sessionOption) {
+      const parsedInput = parseInput(toolUseConfirm.input)
+      onChange(sessionOption.option, parsedInput)
+    }
+  }, [options, parseInput, toolUseConfirm.input, onChange])
+
+  // Register keyboard shortcut handler via keybindings system
+  useKeybindings(
+    { 'confirm:cycleMode': handleCycleMode },
+    { context: 'Confirmation' },
+  )
+
+  // Wrap setFocusedOption and reset input mode when navigating away
+  const handleFocusedOptionChange = useCallback(
+    (value: string) => {
+      // Reset input mode when navigating away, but only if no text typed
+      if (value !== 'yes' && yesInputMode && !acceptFeedback.trim()) {
+        setYesInputMode(false)
+      }
+      if (value !== 'no' && noInputMode && !rejectFeedback.trim()) {
+        setNoInputMode(false)
+      }
+      setFocusedOption(value)
+    },
+    [yesInputMode, noInputMode, acceptFeedback, rejectFeedback],
+  )
+
+  // Handle Tab key toggling input mode for Yes/No options
+  const handleInputModeToggle = useCallback(
+    (value: string) => {
+      const analyticsProps = {
+        toolName: sanitizeToolNameForAnalytics(
+          toolUseConfirm.tool.name,
+        ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        isMcp: toolUseConfirm.tool.isMcp ?? false,
+      }
+
+      if (value === 'yes') {
+        if (yesInputMode) {
+          setYesInputMode(false)
+          logEvent('tengu_accept_feedback_mode_collapsed', analyticsProps)
+        } else {
+          setYesInputMode(true)
+          setYesFeedbackModeEntered(true)
+          logEvent('tengu_accept_feedback_mode_entered', analyticsProps)
+        }
+      } else if (value === 'no') {
+        if (noInputMode) {
+          setNoInputMode(false)
+          logEvent('tengu_reject_feedback_mode_collapsed', analyticsProps)
+        } else {
+          setNoInputMode(true)
+          setNoFeedbackModeEntered(true)
+          logEvent('tengu_reject_feedback_mode_entered', analyticsProps)
+        }
+      }
+    },
+    [yesInputMode, noInputMode, toolUseConfirm],
+  )
+
+  return {
+    options,
+    onChange,
+    acceptFeedback,
+    rejectFeedback,
+    focusedOption,
+    setFocusedOption: handleFocusedOptionChange,
+    handleInputModeToggle,
+    yesInputMode,
+    noInputMode,
+  }
+}

package/components/permissions/FilePermissionDialog/usePermissionHandler.ts

@@ -0,0 +1,185 @@
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../../../services/analytics/index.js'
+import { sanitizeToolNameForAnalytics } from '../../../services/analytics/metadata.js'
+import type { ToolPermissionContext } from '../../../Tool.js'
+import {
+  CLAUDE_FOLDER_PERMISSION_PATTERN,
+  FILE_EDIT_TOOL_NAME,
+  GLOBAL_CLAUDE_FOLDER_PERMISSION_PATTERN,
+} from '../../../tools/FileEditTool/constants.js'
+import { env } from '../../../utils/env.js'
+import { generateSuggestions } from '../../../utils/permissions/filesystem.js'
+import type { PermissionUpdate } from '../../../utils/permissions/PermissionUpdateSchema.js'
+import {
+  type CompletionType,
+  logUnaryEvent,
+} from '../../../utils/unaryLogging.js'
+import type { ToolUseConfirm } from '../PermissionRequest.js'
+import type {
+  FileOperationType,
+  PermissionOption,
+} from './permissionOptions.js'
+
+function logPermissionEvent(
+  event: 'accept' | 'reject',
+  completionType: CompletionType,
+  languageName: string | Promise<string>,
+  messageId: string,
+  hasFeedback?: boolean,
+): void {
+  void logUnaryEvent({
+    completion_type: completionType,
+    event,
+    metadata: {
+      language_name: languageName,
+      message_id: messageId,
+      platform: env.platform,
+      hasFeedback: hasFeedback ?? false,
+    },
+  })
+}
+
+export type PermissionHandlerParams = {
+  messageId: string
+  path: string | null
+  toolUseConfirm: ToolUseConfirm
+  toolPermissionContext: ToolPermissionContext
+  onDone: () => void
+  onReject: () => void
+  completionType: CompletionType
+  languageName: string | Promise<string>
+  operationType: FileOperationType
+}
+
+export type PermissionHandlerOptions = {
+  hasFeedback?: boolean
+  feedback?: string
+  enteredFeedbackMode?: boolean
+  scope?: 'claude-folder' | 'global-claude-folder'
+}
+
+function handleAcceptOnce(
+  params: PermissionHandlerParams,
+  options?: PermissionHandlerOptions,
+): void {
+  const { messageId, toolUseConfirm, onDone, completionType, languageName } =
+    params
+
+  logPermissionEvent('accept', completionType, languageName, messageId)
+
+  // Log accept submission with feedback context
+  logEvent('tengu_accept_submitted', {
+    toolName: sanitizeToolNameForAnalytics(
+      toolUseConfirm.tool.name,
+    ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    isMcp: toolUseConfirm.tool.isMcp ?? false,
+    has_instructions: !!options?.feedback,
+    instructions_length: options?.feedback?.length ?? 0,
+    entered_feedback_mode: options?.enteredFeedbackMode ?? false,
+  })
+
+  onDone()
+  toolUseConfirm.onAllow(toolUseConfirm.input, [], options?.feedback)
+}
+
+function handleAcceptSession(
+  params: PermissionHandlerParams,
+  options?: PermissionHandlerOptions,
+): void {
+  const {
+    messageId,
+    path,
+    toolUseConfirm,
+    toolPermissionContext,
+    onDone,
+    completionType,
+    languageName,
+    operationType,
+  } = params
+
+  logPermissionEvent('accept', completionType, languageName, messageId)
+
+  // For claude-folder scope, grant session-level access to all .claude/ files
+  if (
+    options?.scope === 'claude-folder' ||
+    options?.scope === 'global-claude-folder'
+  ) {
+    const pattern =
+      options.scope === 'global-claude-folder'
+        ? GLOBAL_CLAUDE_FOLDER_PERMISSION_PATTERN
+        : CLAUDE_FOLDER_PERMISSION_PATTERN
+    const suggestions: PermissionUpdate[] = [
+      {
+        type: 'addRules',
+        rules: [
+          {
+            toolName: FILE_EDIT_TOOL_NAME,
+            ruleContent: pattern,
+          },
+        ],
+        behavior: 'allow',
+        destination: 'session',
+      },
+    ]
+    onDone()
+    toolUseConfirm.onAllow(toolUseConfirm.input, suggestions)
+    return
+  }
+
+  // Generate permission updates if path is provided
+  const suggestions = path
+    ? generateSuggestions(path, operationType, toolPermissionContext)
+    : []
+
+  onDone()
+  // Pass permission updates directly to onAllow
+  toolUseConfirm.onAllow(toolUseConfirm.input, suggestions)
+}
+
+function handleReject(
+  params: PermissionHandlerParams,
+  options?: PermissionHandlerOptions,
+): void {
+  const {
+    messageId,
+    toolUseConfirm,
+    onDone,
+    onReject,
+    completionType,
+    languageName,
+  } = params
+
+  logPermissionEvent(
+    'reject',
+    completionType,
+    languageName,
+    messageId,
+    options?.hasFeedback,
+  )
+
+  // Log reject submission with feedback context
+  logEvent('tengu_reject_submitted', {
+    toolName: sanitizeToolNameForAnalytics(
+      toolUseConfirm.tool.name,
+    ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    isMcp: toolUseConfirm.tool.isMcp ?? false,
+    has_instructions: !!options?.feedback,
+    instructions_length: options?.feedback?.length ?? 0,
+    entered_feedback_mode: options?.enteredFeedbackMode ?? false,
+  })
+
+  onDone()
+  onReject()
+  toolUseConfirm.onReject(options?.feedback)
+}
+
+export const PERMISSION_HANDLERS: Record<
+  PermissionOption['type'],
+  (params: PermissionHandlerParams, options?: PermissionHandlerOptions) => void
+> = {
+  'accept-once': handleAcceptOnce,
+  'accept-session': handleAcceptSession,
+  reject: handleReject,
+}

package/components/permissions/FileWritePermissionRequest/FileWritePermissionRequest.tsx

@@ -0,0 +1,161 @@
+import { c as _c } from "react/compiler-runtime";
+import { basename, relative } from 'path';
+import React, { useMemo } from 'react';
+import type { z } from 'zod/v4';
+import { Text } from '../../../ink.js';
+import { FileWriteTool } from '../../../tools/FileWriteTool/FileWriteTool.js';
+import { getCwd } from '../../../utils/cwd.js';
+import { isENOENT } from '../../../utils/errors.js';
+import { readFileSync } from '../../../utils/fileRead.js';
+import { FilePermissionDialog } from '../FilePermissionDialog/FilePermissionDialog.js';
+import { createSingleEditDiffConfig, type FileEdit, type IDEDiffSupport } from '../FilePermissionDialog/ideDiffConfig.js';
+import type { PermissionRequestProps } from '../PermissionRequest.js';
+import { FileWriteToolDiff } from './FileWriteToolDiff.js';
+type FileWriteToolInput = z.infer<typeof FileWriteTool.inputSchema>;
+const ideDiffSupport: IDEDiffSupport<FileWriteToolInput> = {
+  getConfig: (input: FileWriteToolInput) => {
+    let oldContent: string;
+    try {
+      oldContent = readFileSync(input.file_path);
+    } catch (e) {
+      if (!isENOENT(e)) throw e;
+      oldContent = '';
+    }
+    return createSingleEditDiffConfig(input.file_path, oldContent, input.content, false // For file writes, we replace the entire content
+    );
+  },
+  applyChanges: (input: FileWriteToolInput, modifiedEdits: FileEdit[]) => {
+    const firstEdit = modifiedEdits[0];
+    if (firstEdit) {
+      return {
+        ...input,
+        content: firstEdit.new_string
+      };
+    }
+    return input;
+  }
+};
+export function FileWritePermissionRequest(props) {
+  const $ = _c(30);
+  const parseInput = _temp;
+  let t0;
+  if ($[0] !== props.toolUseConfirm.input) {
+    t0 = parseInput(props.toolUseConfirm.input);
+    $[0] = props.toolUseConfirm.input;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const parsed = t0;
+  const {
+    file_path,
+    content
+  } = parsed;
+  let t1;
+  if ($[2] !== file_path) {
+    ;
+    try {
+      t1 = {
+        fileExists: true,
+        oldContent: readFileSync(file_path)
+      };
+    } catch (t2) {
+      const e = t2;
+      if (!isENOENT(e)) {
+        throw e;
+      }
+      let t3;
+      if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+        t3 = {
+          fileExists: false,
+          oldContent: ""
+        };
+        $[4] = t3;
+      } else {
+        t3 = $[4];
+      }
+      t1 = t3;
+    }
+    $[2] = file_path;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const {
+    fileExists,
+    oldContent
+  } = t1;
+  const actionText = fileExists ? "overwrite" : "create";
+  const t2 = props.toolUseConfirm;
+  const t3 = props.toolUseContext;
+  const t4 = props.onDone;
+  const t5 = props.onReject;
+  const t6 = props.workerBadge;
+  const t7 = fileExists ? "Overwrite file" : "Create file";
+  let t8;
+  if ($[5] !== file_path) {
+    t8 = relative(getCwd(), file_path);
+    $[5] = file_path;
+    $[6] = t8;
+  } else {
+    t8 = $[6];
+  }
+  let t9;
+  if ($[7] !== file_path) {
+    t9 = basename(file_path);
+    $[7] = file_path;
+    $[8] = t9;
+  } else {
+    t9 = $[8];
+  }
+  let t10;
+  if ($[9] !== t9) {
+    t10 = <Text bold={true}>{t9}</Text>;
+    $[9] = t9;
+    $[10] = t10;
+  } else {
+    t10 = $[10];
+  }
+  let t11;
+  if ($[11] !== actionText || $[12] !== t10) {
+    t11 = <Text>Do you want to {actionText} {t10}?</Text>;
+    $[11] = actionText;
+    $[12] = t10;
+    $[13] = t11;
+  } else {
+    t11 = $[13];
+  }
+  let t12;
+  if ($[14] !== content || $[15] !== fileExists || $[16] !== file_path || $[17] !== oldContent) {
+    t12 = <FileWriteToolDiff file_path={file_path} content={content} fileExists={fileExists} oldContent={oldContent} />;
+    $[14] = content;
+    $[15] = fileExists;
+    $[16] = file_path;
+    $[17] = oldContent;
+    $[18] = t12;
+  } else {
+    t12 = $[18];
+  }
+  let t13;
+  if ($[19] !== file_path || $[20] !== props.onDone || $[21] !== props.onReject || $[22] !== props.toolUseConfirm || $[23] !== props.toolUseContext || $[24] !== props.workerBadge || $[25] !== t11 || $[26] !== t12 || $[27] !== t7 || $[28] !== t8) {
+    t13 = <FilePermissionDialog toolUseConfirm={t2} toolUseContext={t3} onDone={t4} onReject={t5} workerBadge={t6} title={t7} subtitle={t8} question={t11} content={t12} path={file_path} completionType="write_file_single" parseInput={parseInput} ideDiffSupport={ideDiffSupport} />;
+    $[19] = file_path;
+    $[20] = props.onDone;
+    $[21] = props.onReject;
+    $[22] = props.toolUseConfirm;
+    $[23] = props.toolUseContext;
+    $[24] = props.workerBadge;
+    $[25] = t11;
+    $[26] = t12;
+    $[27] = t7;
+    $[28] = t8;
+    $[29] = t13;
+  } else {
+    t13 = $[29];
+  }
+  return t13;
+}
+function _temp(input) {
+  return FileWriteTool.inputSchema.parse(input);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["basename","relative","React","useMemo","z","Text","FileWriteTool","getCwd","isENOENT","readFileSync","FilePermissionDialog","createSingleEditDiffConfig","FileEdit","IDEDiffSupport","PermissionRequestProps","FileWriteToolDiff","FileWriteToolInput","infer","inputSchema","ideDiffSupport","getConfig","input","oldContent","file_path","e","content","applyChanges","modifiedEdits","firstEdit","new_string","FileWritePermissionRequest","props","$","_c","parseInput","_temp","t0","toolUseConfirm","parsed","t1","fileExists","t2","t3","Symbol","for","actionText","toolUseContext","t4","onDone","t5","onReject","t6","workerBadge","t7","t8","t9","t10","t11","t12","t13","parse"],"sources":["FileWritePermissionRequest.tsx"],"sourcesContent":["import { basename, relative } from 'path'\nimport React, { useMemo } from 'react'\nimport type { z } from 'zod/v4'\nimport { Text } from '../../../ink.js'\nimport { FileWriteTool } from '../../../tools/FileWriteTool/FileWriteTool.js'\nimport { getCwd } from '../../../utils/cwd.js'\nimport { isENOENT } from '../../../utils/errors.js'\nimport { readFileSync } from '../../../utils/fileRead.js'\nimport { FilePermissionDialog } from '../FilePermissionDialog/FilePermissionDialog.js'\nimport {\n  createSingleEditDiffConfig,\n  type FileEdit,\n  type IDEDiffSupport,\n} from '../FilePermissionDialog/ideDiffConfig.js'\nimport type { PermissionRequestProps } from '../PermissionRequest.js'\nimport { FileWriteToolDiff } from './FileWriteToolDiff.js'\n\ntype FileWriteToolInput = z.infer<typeof FileWriteTool.inputSchema>\n\nconst ideDiffSupport: IDEDiffSupport<FileWriteToolInput> = {\n  getConfig: (input: FileWriteToolInput) => {\n    let oldContent: string\n    try {\n      oldContent = readFileSync(input.file_path)\n    } catch (e) {\n      if (!isENOENT(e)) throw e\n      oldContent = ''\n    }\n\n    return createSingleEditDiffConfig(\n      input.file_path,\n      oldContent,\n      input.content,\n      false, // For file writes, we replace the entire content\n    )\n  },\n  applyChanges: (input: FileWriteToolInput, modifiedEdits: FileEdit[]) => {\n    const firstEdit = modifiedEdits[0]\n    if (firstEdit) {\n      return {\n        ...input,\n        content: firstEdit.new_string,\n      }\n    }\n    return input\n  },\n}\n\nexport function FileWritePermissionRequest(\n  props: PermissionRequestProps,\n): React.ReactNode {\n  const parseInput = (input: unknown): FileWriteToolInput => {\n    return FileWriteTool.inputSchema.parse(input)\n  }\n\n  const parsed = parseInput(props.toolUseConfirm.input)\n  const { file_path, content } = parsed\n\n  // Single read drives both UI text (\"Create\" vs \"Overwrite\") and the diff\n  // shown by FileWriteToolDiff — avoids a redundant existsSync stat that would\n  // block first-mount commit on slow/networked filesystems.\n  const { fileExists, oldContent } = useMemo(() => {\n    try {\n      return { fileExists: true, oldContent: readFileSync(file_path) }\n    } catch (e) {\n      if (!isENOENT(e)) throw e\n      return { fileExists: false, oldContent: '' }\n    }\n  }, [file_path])\n\n  const actionText = fileExists ? 'overwrite' : 'create'\n\n  return (\n    <FilePermissionDialog\n      toolUseConfirm={props.toolUseConfirm}\n      toolUseContext={props.toolUseContext}\n      onDone={props.onDone}\n      onReject={props.onReject}\n      workerBadge={props.workerBadge}\n      title={fileExists ? 'Overwrite file' : 'Create file'}\n      subtitle={relative(getCwd(), file_path)}\n      question={\n        <Text>\n          Do you want to {actionText} <Text bold>{basename(file_path)}</Text>?\n        </Text>\n      }\n      content={\n        <FileWriteToolDiff\n          file_path={file_path}\n          content={content}\n          fileExists={fileExists}\n          oldContent={oldContent}\n        />\n      }\n      path={file_path}\n      completionType=\"write_file_single\"\n      parseInput={parseInput}\n      ideDiffSupport={ideDiffSupport}\n    />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/components/permissions/FileWritePermissionRequest/FileWriteToolDiff.tsx

@@ -0,0 +1,89 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useMemo } from 'react';
+import { useTerminalSize } from '../../../hooks/useTerminalSize.js';
+import { Box, NoSelect, Text } from '../../../ink.js';
+import { intersperse } from '../../../utils/array.js';
+import { getPatchForDisplay } from '../../../utils/diff.js';
+import { HighlightedCode } from '../../HighlightedCode.js';
+import { StructuredDiff } from '../../StructuredDiff.js';
+type Props = {
+  file_path: string;
+  content: string;
+  fileExists: boolean;
+  oldContent: string;
+};
+export function FileWriteToolDiff(t0) {
+  const $ = _c(15);
+  const {
+    file_path,
+    content,
+    fileExists,
+    oldContent
+  } = t0;
+  const {
+    columns
+  } = useTerminalSize();
+  let t1;
+  bb0: {
+    if (!fileExists) {
+      t1 = null;
+      break bb0;
+    }
+    let t2;
+    if ($[0] !== content || $[1] !== file_path || $[2] !== oldContent) {
+      t2 = getPatchForDisplay({
+        filePath: file_path,
+        fileContents: oldContent,
+        edits: [{
+          old_string: oldContent,
+          new_string: content,
+          replace_all: false
+        }]
+      });
+      $[0] = content;
+      $[1] = file_path;
+      $[2] = oldContent;
+      $[3] = t2;
+    } else {
+      t2 = $[3];
+    }
+    t1 = t2;
+  }
+  const hunks = t1;
+  let t2;
+  if ($[4] !== content) {
+    t2 = content.split("\n")[0] ?? null;
+    $[4] = content;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const firstLine = t2;
+  let t3;
+  if ($[6] !== columns || $[7] !== content || $[8] !== file_path || $[9] !== firstLine || $[10] !== hunks || $[11] !== oldContent) {
+    t3 = hunks ? intersperse(hunks.map(_ => <StructuredDiff key={_.newStart} patch={_} dim={false} filePath={file_path} firstLine={firstLine} fileContent={oldContent} width={columns - 2} />), _temp) : <HighlightedCode code={content || "(No content)"} filePath={file_path} />;
+    $[6] = columns;
+    $[7] = content;
+    $[8] = file_path;
+    $[9] = firstLine;
+    $[10] = hunks;
+    $[11] = oldContent;
+    $[12] = t3;
+  } else {
+    t3 = $[12];
+  }
+  let t4;
+  if ($[13] !== t3) {
+    t4 = <Box flexDirection="column"><Box borderColor="subtle" borderStyle="dashed" flexDirection="column" borderLeft={false} borderRight={false} paddingX={1}>{t3}</Box></Box>;
+    $[13] = t3;
+    $[14] = t4;
+  } else {
+    t4 = $[14];
+  }
+  return t4;
+}
+function _temp(i) {
+  return <NoSelect fromLeftEdge={true} key={`ellipsis-${i}`}><Text dimColor={true}>...</Text></NoSelect>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsInVzZU1lbW8iLCJ1c2VUZXJtaW5hbFNpemUiLCJCb3giLCJOb1NlbGVjdCIsIlRleHQiLCJpbnRlcnNwZXJzZSIsImdldFBhdGNoRm9yRGlzcGxheSIsIkhpZ2hsaWdodGVkQ29kZSIsIlN0cnVjdHVyZWREaWZmIiwiUHJvcHMiLCJmaWxlX3BhdGgiLCJjb250ZW50IiwiZmlsZUV4aXN0cyIsIm9sZENvbnRlbnQiLCJGaWxlV3JpdGVUb29sRGlmZiIsInQwIiwiJCIsIl9jIiwiY29sdW1ucyIsInQxIiwiYmIwIiwidDIiLCJmaWxlUGF0aCIsImZpbGVDb250ZW50cyIsImVkaXRzIiwib2xkX3N0cmluZyIsIm5ld19zdHJpbmciLCJyZXBsYWNlX2FsbCIsImh1bmtzIiwic3BsaXQiLCJmaXJzdExpbmUiLCJ0MyIsIm1hcCIsIl8iLCJuZXdTdGFydCIsIl90ZW1wIiwidDQiLCJwYWRkaW5nWCIsImkiXSwic291cmNlcyI6WyJGaWxlV3JpdGVUb29sRGlmZi50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgUmVhY3QgZnJvbSAncmVhY3QnXG5pbXBvcnQgeyB1c2VNZW1vIH0gZnJvbSAncmVhY3QnXG5pbXBvcnQgeyB1c2VUZXJtaW5hbFNpemUgfSBmcm9tICcuLi8uLi8uLi9ob29rcy91c2VUZXJtaW5hbFNpemUuanMnXG5pbXBvcnQgeyBCb3gsIE5vU2VsZWN0LCBUZXh0IH0gZnJvbSAnLi4vLi4vLi4vaW5rLmpzJ1xuaW1wb3J0IHsgaW50ZXJzcGVyc2UgfSBmcm9tICcuLi8uLi8uLi91dGlscy9hcnJheS5qcydcbmltcG9ydCB7IGdldFBhdGNoRm9yRGlzcGxheSB9IGZyb20gJy4uLy4uLy4uL3V0aWxzL2RpZmYuanMnXG5pbXBvcnQgeyBIaWdobGlnaHRlZENvZGUgfSBmcm9tICcuLi8uLi9IaWdobGlnaHRlZENvZGUuanMnXG5pbXBvcnQgeyBTdHJ1Y3R1cmVkRGlmZiB9IGZyb20gJy4uLy4uL1N0cnVjdHVyZWREaWZmLmpzJ1xuXG50eXBlIFByb3BzID0ge1xuICBmaWxlX3BhdGg6IHN0cmluZ1xuICBjb250ZW50OiBzdHJpbmdcbiAgZmlsZUV4aXN0czogYm9vbGVhblxuICBvbGRDb250ZW50OiBzdHJpbmdcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIEZpbGVXcml0ZVRvb2xEaWZmKHtcbiAgZmlsZV9wYXRoLFxuICBjb250ZW50LFxuICBmaWxlRXhpc3RzLFxuICBvbGRDb250ZW50LFxufTogUHJvcHMpOiBSZWFjdC5SZWFjdE5vZGUge1xuICBjb25zdCB7IGNvbHVtbnMgfSA9IHVzZVRlcm1pbmFsU2l6ZSgpXG4gIGNvbnN0IGh1bmtzID0gdXNlTWVtbygoKSA9PiB7XG4gICAgaWYgKCFmaWxlRXhpc3RzKSB7XG4gICAgICByZXR1cm4gbnVsbFxuICAgIH1cbiAgICByZXR1cm4gZ2V0UGF0Y2hGb3JEaXNwbGF5KHtcbiAgICAgIGZpbGVQYXRoOiBmaWxlX3BhdGgsXG4gICAgICBmaWxlQ29udGVudHM6IG9sZENvbnRlbnQsXG4gICAgICBlZGl0czogW1xuICAgICAgICB7XG4gICAgICAgICAgb2xkX3N0cmluZzogb2xkQ29udGVudCxcbiAgICAgICAgICBuZXdfc3RyaW5nOiBjb250ZW50LFxuICAgICAgICAgIHJlcGxhY2VfYWxsOiBmYWxzZSxcbiAgICAgICAgfSxcbiAgICAgIF0sXG4gICAgfSlcbiAgfSwgW2ZpbGVFeGlzdHMsIGZpbGVfcGF0aCwgb2xkQ29udGVudCwgY29udGVudF0pXG5cbiAgY29uc3QgZmlyc3RMaW5lID0gY29udGVudC5zcGxpdCgnXFxuJylbMF0gPz8gbnVsbFxuICBjb25zdCBwYWRkaW5nWCA9IDFcblxuICByZXR1cm4gKFxuICAgIDxCb3ggZmxleERpcmVjdGlvbj1cImNvbHVtblwiPlxuICAgICAgPEJveFxuICAgICAgICBib3JkZXJDb2xvcj1cInN1YnRsZVwiXG4gICAgICAgIGJvcmRlclN0eWxlPVwiZGFzaGVkXCJcbiAgICAgICAgZmxleERpcmVjdGlvbj1cImNvbHVtblwiXG4gICAgICAgIGJvcmRlckxlZnQ9e2ZhbHNlfVxuICAgICAgICBib3JkZXJSaWdodD17ZmFsc2V9XG4gICAgICAgIHBhZGRpbmdYPXtwYWRkaW5nWH1cbiAgICAgID5cbiAgICAgICAge2h1bmtzID8gKFxuICAgICAgICAgIGludGVyc3BlcnNlKFxuICAgICAgICAgICAgaHVua3MubWFwKF8gPT4gKFxuICAgICAgICAgICAgICA8U3RydWN0dXJlZERpZmZcbiAgICAgICAgICAgICAgICBrZXk9e18ubmV3U3RhcnR9XG4gICAgICAgICAgICAgICAgcGF0Y2g9e199XG4gICAgICAgICAgICAgICAgZGltPXtmYWxzZX1cbiAgICAgICAgICAgICAgICBmaWxlUGF0aD17ZmlsZV9wYXRofVxuICAgICAgICAgICAgICAgIGZpcnN0TGluZT17Zmlyc3RMaW5lfVxuICAgICAgICAgICAgICAgIGZpbGVDb250ZW50PXtvbGRDb250ZW50fVxuICAgICAgICAgICAgICAgIHdpZHRoPXtjb2x1bW5zIC0gMiAqIHBhZGRpbmdYfVxuICAgICAgICAgICAgICAvPlxuICAgICAgICAgICAgKSksXG4gICAgICAgICAgICBpID0+IChcbiAgICAgICAgICAgICAgPE5vU2VsZWN0IGZyb21MZWZ0RWRnZSBrZXk9e2BlbGxpcHNpcy0ke2l9YH0+XG4gICAgICAgICAgICAgICAgPFRleHQgZGltQ29sb3I+Li4uPC9UZXh0PlxuICAgICAgICAgICAgICA8L05vU2VsZWN0PlxuICAgICAgICAgICAgKSxcbiAgICAgICAgICApXG4gICAgICAgICkgOiAoXG4gICAgICAgICAgPEhpZ2hsaWdodGVkQ29kZVxuICAgICAgICAgICAgY29kZT17Y29udGVudCB8fCAnKE5vIGNvbnRlbnQpJ31cbiAgICAgICAgICAgIGZpbGVQYXRoPXtmaWxlX3BhdGh9XG4gICAgICAgICAgLz5cbiAgICAgICAgKX1cbiAgICAgIDwvQm94PlxuICAgIDwvQm94PlxuICApXG59XG4iXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEtBQUtBLEtBQUssTUFBTSxPQUFPO0FBQzlCLFNBQVNDLE9BQU8sUUFBUSxPQUFPO0FBQy9CLFNBQVNDLGVBQWUsUUFBUSxtQ0FBbUM7QUFDbkUsU0FBU0MsR0FBRyxFQUFFQyxRQUFRLEVBQUVDLElBQUksUUFBUSxpQkFBaUI7QUFDckQsU0FBU0MsV0FBVyxRQUFRLHlCQUF5QjtBQUNyRCxTQUFTQyxrQkFBa0IsUUFBUSx3QkFBd0I7QUFDM0QsU0FBU0MsZUFBZSxRQUFRLDBCQUEwQjtBQUMxRCxTQUFTQyxjQUFjLFFBQVEseUJBQXlCO0FBRXhELEtBQUtDLEtBQUssR0FBRztFQUNYQyxTQUFTLEVBQUUsTUFBTTtFQUNqQkMsT0FBTyxFQUFFLE1BQU07RUFDZkMsVUFBVSxFQUFFLE9BQU87RUFDbkJDLFVBQVUsRUFBRSxNQUFNO0FBQ3BCLENBQUM7QUFFRCxPQUFPLFNBQUFDLGtCQUFBQyxFQUFBO0VBQUEsTUFBQUMsQ0FBQSxHQUFBQyxFQUFBO0VBQTJCO0lBQUFQLFNBQUE7SUFBQUMsT0FBQTtJQUFBQyxVQUFBO0lBQUFDO0VBQUEsSUFBQUUsRUFLMUI7RUFDTjtJQUFBRztFQUFBLElBQW9CakIsZUFBZSxDQUFDLENBQUM7RUFBQSxJQUFBa0IsRUFBQTtFQUFBQyxHQUFBO0lBRW5DLElBQUksQ0FBQ1IsVUFBVTtNQUNiTyxFQUFBLEdBQU8sSUFBSTtNQUFYLE1BQUFDLEdBQUE7SUFBVztJQUNaLElBQUFDLEVBQUE7SUFBQSxJQUFBTCxDQUFBLFFBQUFMLE9BQUEsSUFBQUssQ0FBQSxRQUFBTixTQUFBLElBQUFNLENBQUEsUUFBQUgsVUFBQTtNQUNNUSxFQUFBLEdBQUFmLGtCQUFrQixDQUFDO1FBQUFnQixRQUFBLEVBQ2RaLFNBQVM7UUFBQWEsWUFBQSxFQUNMVixVQUFVO1FBQUFXLEtBQUEsRUFDakIsQ0FDTDtVQUFBQyxVQUFBLEVBQ2NaLFVBQVU7VUFBQWEsVUFBQSxFQUNWZixPQUFPO1VBQUFnQixXQUFBLEVBQ047UUFDZixDQUFDO01BRUwsQ0FBQyxDQUFDO01BQUFYLENBQUEsTUFBQUwsT0FBQTtNQUFBSyxDQUFBLE1BQUFOLFNBQUE7TUFBQU0sQ0FBQSxNQUFBSCxVQUFBO01BQUFHLENBQUEsTUFBQUssRUFBQTtJQUFBO01BQUFBLEVBQUEsR0FBQUwsQ0FBQTtJQUFBO0lBVkZHLEVBQUEsR0FBT0UsRUFVTDtFQUFBO0VBZEosTUFBQU8sS0FBQSxHQUFjVCxFQWVrQztFQUFBLElBQUFFLEVBQUE7RUFBQSxJQUFBTCxDQUFBLFFBQUFMLE9BQUE7SUFFOUJVLEVBQUEsR0FBQVYsT0FBTyxDQUFBa0IsS0FBTSxDQUFDLElBQUksQ0FBQyxHQUFXLElBQTlCLElBQThCO0lBQUFiLENBQUEsTUFBQUwsT0FBQTtJQUFBSyxDQUFBLE1BQUFLLEVBQUE7RUFBQTtJQUFBQSxFQUFBLEdBQUFMLENBQUE7RUFBQTtFQUFoRCxNQUFBYyxTQUFBLEdBQWtCVCxFQUE4QjtFQUFBLElBQUFVLEVBQUE7RUFBQSxJQUFBZixDQUFBLFFBQUFFLE9BQUEsSUFBQUYsQ0FBQSxRQUFBTCxPQUFBLElBQUFLLENBQUEsUUFBQU4sU0FBQSxJQUFBTSxDQUFBLFFBQUFjLFNBQUEsSUFBQWQsQ0FBQSxTQUFBWSxLQUFBLElBQUFaLENBQUEsU0FBQUgsVUFBQTtJQWF6Q2tCLEVBQUEsR0FBQUgsS0FBSyxHQUNKdkIsV0FBVyxDQUNUdUIsS0FBSyxDQUFBSSxHQUFJLENBQUNDLENBQUEsSUFDUixDQUFDLGNBQWMsQ0FDUixHQUFVLENBQVYsQ0FBQUEsQ0FBQyxDQUFBQyxRQUFRLENBQUMsQ0FDUkQsS0FBQyxDQUFEQSxFQUFBLENBQUMsQ0FDSCxHQUFLLENBQUwsTUFBSSxDQUFDLENBQ0F2QixRQUFTLENBQVRBLFVBQVEsQ0FBQyxDQUNSb0IsU0FBUyxDQUFUQSxVQUFRLENBQUMsQ0FDUGpCLFdBQVUsQ0FBVkEsV0FBUyxDQUFDLENBQ2hCLEtBQXNCLENBQXRCLENBQUFLLE9BQU8sR0FBRyxDQUFXLENBQUMsR0FFaEMsQ0FBQyxFQUNGaUIsS0FXSixDQUFDLEdBSkMsQ0FBQyxlQUFlLENBQ1IsSUFBeUIsQ0FBekIsQ0FBQXhCLE9BQXlCLElBQXpCLGNBQXdCLENBQUMsQ0FDckJELFFBQVMsQ0FBVEEsVUFBUSxDQUFDLEdBRXRCO0lBQUFNLENBQUEsTUFBQUUsT0FBQTtJQUFBRixDQUFBLE1BQUFMLE9BQUE7SUFBQUssQ0FBQSxNQUFBTixTQUFBO0lBQUFNLENBQUEsTUFBQWMsU0FBQTtJQUFBZCxDQUFBLE9BQUFZLEtBQUE7SUFBQVosQ0FBQSxPQUFBSCxVQUFBO0lBQUFHLENBQUEsT0FBQWUsRUFBQTtFQUFBO0lBQUFBLEVBQUEsR0FBQWYsQ0FBQTtFQUFBO0VBQUEsSUFBQW9CLEVBQUE7RUFBQSxJQUFBcEIsQ0FBQSxTQUFBZSxFQUFBO0lBakNMSyxFQUFBLElBQUMsR0FBRyxDQUFlLGFBQVEsQ0FBUixRQUFRLENBQ3pCLENBQUMsR0FBRyxDQUNVLFdBQVEsQ0FBUixRQUFRLENBQ1IsV0FBUSxDQUFSLFFBQVEsQ0FDTixhQUFRLENBQVIsUUFBUSxDQUNWLFVBQUssQ0FBTCxNQUFJLENBQUMsQ0FDSixXQUFLLENBQUwsTUFBSSxDQUFDLENBQ1JDLFFBQVEsQ0FBUkEsQ0FWQ0EsQ0FVTUEsQ0FBQyxDQUVqQixDQUFBTixFQXdCRCxDQUNGLEVBakNDLEdBQUcsQ0FrQ04sRUFuQ0MsR0FBRyxDQW1DRTtJQUFBZixDQUFBLE9BQUFlLEVBQUE7SUFBQWYsQ0FBQSxPQUFBb0IsRUFBQTtFQUFBO0lBQUFBLEVBQUEsR0FBQXBCLENBQUE7RUFBQTtFQUFBLE9BbkNOb0IsRUFtQ007QUFBQTtBQS9ESCxTQUFBRCxNQUFBRyxDQUFBO0VBQUEsT0FtRE8sQ0FBQyxRQUFRLENBQUMsWUFBWSxDQUFaLEtBQVcsQ0FBQyxDQUFNLEdBQWUsQ0FBZixhQUFZQSxDQUFDLEVBQUMsQ0FBQyxDQUN6QyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQVIsS0FBTyxDQUFDLENBQUMsR0FBRyxFQUFqQixJQUFJLENBQ1AsRUFGQyxRQUFRLENBRUU7QUFBQSIsImlnbm9yZUxpc3QiOltdfQ==