@shareai-lab/kode 1.0.70 → 1.0.71

package/src/tools/MultiEditTool/MultiEditTool.tsx

@@ -0,0 +1,366 @@
+import { existsSync, mkdirSync, readFileSync, statSync } from 'fs'
+import { Box, Text } from 'ink'
+import { dirname, isAbsolute, relative, resolve, sep } from 'path'
+import * as React from 'react'
+import { z } from 'zod'
+import { FileEditToolUpdatedMessage } from '../../components/FileEditToolUpdatedMessage'
+import { StructuredDiff } from '../../components/StructuredDiff'
+import { logEvent } from '../../services/statsig'
+import { Tool, ValidationResult } from '../../Tool'
+import { intersperse } from '../../utils/array'
+import {
+  addLineNumbers,
+  detectFileEncoding,
+  detectLineEndings,
+  findSimilarFile,
+  writeTextContent,
+} from '../../utils/file.js'
+import { logError } from '../../utils/log'
+import { getCwd } from '../../utils/state'
+import { getTheme } from '../../utils/theme'
+import { NotebookEditTool } from '../NotebookEditTool/NotebookEditTool'
+import { applyEdit } from '../FileEditTool/utils'
+import { hasWritePermission } from '../../utils/permissions/filesystem'
+import { PROJECT_FILE } from '../../constants/product'
+import { DESCRIPTION, PROMPT } from './prompt'
+import { emitReminderEvent } from '../../services/systemReminder'
+import { recordFileEdit } from '../../services/fileFreshness'
+
+const EditSchema = z.object({
+  old_string: z.string().describe('The text to replace'),
+  new_string: z.string().describe('The text to replace it with'),
+  replace_all: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('Replace all occurences of old_string (default false)'),
+})
+
+const inputSchema = z.strictObject({
+  file_path: z.string().describe('The absolute path to the file to modify'),
+  edits: z
+    .array(EditSchema)
+    .min(1)
+    .describe('Array of edit operations to perform sequentially on the file'),
+})
+
+export type In = typeof inputSchema
+
+// Number of lines of context to include before/after the change in our result message
+const N_LINES_SNIPPET = 4
+
+export const MultiEditTool = {
+  name: 'MultiEdit',
+  async description() {
+    return 'A tool for making multiple edits to a single file atomically'
+  },
+  async prompt() {
+    return PROMPT
+  },
+  inputSchema,
+  userFacingName({ edits }) {
+    return `Multi-Edit (${edits.length} changes)`
+  },
+  async isEnabled() {
+    return true
+  },
+  isReadOnly() {
+    return false
+  },
+  isConcurrencySafe() {
+    return false // MultiEdit modifies files, not safe for concurrent execution
+  },
+  needsPermissions(input?: z.infer<typeof inputSchema>) {
+    if (!input) return true
+    return !hasWritePermission(input.file_path)
+  },
+  renderResultForAssistant(content) {
+    return content
+  },
+  renderToolUseMessage(input, { verbose }) {
+    const { file_path, edits } = input
+    const workingDir = getCwd()
+    const relativePath = isAbsolute(file_path)
+      ? relative(workingDir, file_path)
+      : file_path
+
+    if (verbose) {
+      const editSummary = edits
+        .map(
+          (edit, index) =>
+            `${index + 1}. Replace "${edit.old_string.substring(0, 50)}${edit.old_string.length > 50 ? '...' : ''}" with "${edit.new_string.substring(0, 50)}${edit.new_string.length > 50 ? '...' : ''}"`,
+        )
+        .join('\n')
+      return `Multiple edits to ${relativePath}:\n${editSummary}`
+    }
+
+    return `Making ${edits.length} edits to ${relativePath}`
+  },
+  renderToolUseRejectedMessage() {
+    return (
+      <Box>
+        <Text color={getTheme().error}>⚠ Edit request rejected</Text>
+      </Box>
+    )
+  },
+  renderToolResultMessage(output) {
+    if (typeof output === 'string') {
+      const isError = output.includes('Error:')
+      return (
+        <Box flexDirection="column">
+          <Text color={isError ? getTheme().error : getTheme().success}>
+            {output}
+          </Text>
+        </Box>
+      )
+    }
+
+    return <FileEditToolUpdatedMessage {...output} />
+  },
+  async validateInput(
+    { file_path, edits }: z.infer<typeof inputSchema>,
+    context?: { readFileTimestamps?: Record<string, number> },
+  ): Promise<ValidationResult> {
+    const workingDir = getCwd()
+    const normalizedPath = isAbsolute(file_path)
+      ? resolve(file_path)
+      : resolve(workingDir, file_path)
+
+    // Check if it's a notebook file
+    if (normalizedPath.endsWith('.ipynb')) {
+      return {
+        result: false,
+        errorCode: 1,
+        message: `For Jupyter notebooks (.ipynb files), use the ${NotebookEditTool.name} tool instead.`,
+      }
+    }
+
+    // For new files, check parent directory exists
+    if (!existsSync(normalizedPath)) {
+      const parentDir = dirname(normalizedPath)
+      if (!existsSync(parentDir)) {
+        return {
+          result: false,
+          errorCode: 2,
+          message: `Parent directory does not exist: ${parentDir}`,
+        }
+      }
+
+      // For new files, ensure first edit creates the file (empty old_string)
+      if (edits.length === 0 || edits[0].old_string !== '') {
+        return {
+          result: false,
+          errorCode: 6,
+          message:
+            'For new files, the first edit must have an empty old_string to create the file content.',
+        }
+      }
+    } else {
+      // For existing files, apply file protection mechanisms
+      const readFileTimestamps = context?.readFileTimestamps || {}
+      const readTimestamp = readFileTimestamps[normalizedPath]
+
+      if (!readTimestamp) {
+        return {
+          result: false,
+          errorCode: 7,
+          message:
+            'File has not been read yet. Read it first before editing it.',
+          meta: {
+            filePath: normalizedPath,
+            isFilePathAbsolute: String(isAbsolute(file_path)),
+          },
+        }
+      }
+
+      // Check if file has been modified since last read
+      const stats = statSync(normalizedPath)
+      const lastWriteTime = stats.mtimeMs
+      if (lastWriteTime > readTimestamp) {
+        return {
+          result: false,
+          errorCode: 8,
+          message:
+            'File has been modified since read, either by the user or by a linter. Read it again before attempting to edit it.',
+          meta: {
+            filePath: normalizedPath,
+            lastWriteTime,
+            readTimestamp,
+          },
+        }
+      }
+
+      // Pre-validate that all old_strings exist in the file
+      const encoding = detectFileEncoding(normalizedPath)
+      if (encoding === 'binary') {
+        return {
+          result: false,
+          errorCode: 9,
+          message: 'Cannot edit binary files.',
+        }
+      }
+
+      const currentContent = readFileSync(normalizedPath, 'utf-8')
+      for (let i = 0; i < edits.length; i++) {
+        const edit = edits[i]
+        if (
+          edit.old_string !== '' &&
+          !currentContent.includes(edit.old_string)
+        ) {
+          return {
+            result: false,
+            errorCode: 10,
+            message: `Edit ${i + 1}: String to replace not found in file: "${edit.old_string.substring(0, 100)}${edit.old_string.length > 100 ? '...' : ''}"`,
+            meta: {
+              editIndex: i + 1,
+              oldString: edit.old_string.substring(0, 200),
+            },
+          }
+        }
+      }
+    }
+
+    // Validate each edit
+    for (let i = 0; i < edits.length; i++) {
+      const edit = edits[i]
+      if (edit.old_string === edit.new_string) {
+        return {
+          result: false,
+          errorCode: 3,
+          message: `Edit ${i + 1}: old_string and new_string cannot be the same`,
+        }
+      }
+    }
+
+    return { result: true }
+  },
+  async *call({ file_path, edits }, { readFileTimestamps }) {
+    const startTime = Date.now()
+    const workingDir = getCwd()
+    const filePath = isAbsolute(file_path)
+      ? resolve(file_path)
+      : resolve(workingDir, file_path)
+
+    try {
+      // Read current file content (or empty for new files)
+      let currentContent = ''
+      let fileExists = existsSync(filePath)
+
+      if (fileExists) {
+        const encoding = detectFileEncoding(filePath)
+        if (encoding === 'binary') {
+          yield {
+            type: 'result',
+            data: 'Error: Cannot edit binary files',
+            resultForAssistant: 'Error: Cannot edit binary files',
+          }
+          return
+        }
+        currentContent = readFileSync(filePath, 'utf-8')
+      } else {
+        // For new files, ensure parent directory exists
+        const parentDir = dirname(filePath)
+        if (!existsSync(parentDir)) {
+          mkdirSync(parentDir, { recursive: true })
+        }
+      }
+
+      // Apply all edits sequentially
+      let modifiedContent = currentContent
+      const appliedEdits = []
+
+      for (let i = 0; i < edits.length; i++) {
+        const edit = edits[i]
+        const { old_string, new_string, replace_all } = edit
+
+        try {
+          const result = applyEdit(
+            modifiedContent,
+            old_string,
+            new_string,
+            replace_all,
+          )
+          modifiedContent = result.newContent
+          appliedEdits.push({
+            editIndex: i + 1,
+            success: true,
+            old_string: old_string.substring(0, 100),
+            new_string: new_string.substring(0, 100),
+            occurrences: result.occurrences,
+          })
+        } catch (error) {
+          // If any edit fails, abort the entire operation
+          const errorMessage =
+            error instanceof Error ? error.message : 'Unknown error'
+          yield {
+            type: 'result',
+            data: `Error in edit ${i + 1}: ${errorMessage}`,
+            resultForAssistant: `Error in edit ${i + 1}: ${errorMessage}`,
+          }
+          return
+        }
+      }
+
+      // Write the modified content
+      const lineEndings = fileExists ? detectLineEndings(currentContent) : '\n'
+      writeTextContent(filePath, modifiedContent, lineEndings)
+
+      // Record Agent edit operation for file freshness tracking
+      recordFileEdit(filePath, modifiedContent)
+
+      // Update readFileTimestamps to prevent stale file warnings
+      readFileTimestamps[filePath] = Date.now()
+
+      // Emit file edited event for system reminders
+      emitReminderEvent('file:edited', {
+        filePath,
+        edits: edits.map(e => ({
+          oldString: e.old_string,
+          newString: e.new_string,
+        })),
+        originalContent: currentContent,
+        newContent: modifiedContent,
+        timestamp: Date.now(),
+        operation: fileExists ? 'update' : 'create',
+      })
+
+      // Generate result data
+      const relativePath = relative(workingDir, filePath)
+      const summary = `Successfully applied ${edits.length} edits to ${relativePath}`
+
+      const resultData = {
+        filePath: relativePath,
+        wasNewFile: !fileExists,
+        editsApplied: appliedEdits,
+        totalEdits: edits.length,
+        summary,
+      }
+
+      // Log the operation
+      logEvent('multi_edit_tool_used', {
+        file_path: relativePath,
+        edits_count: String(edits.length),
+        was_new_file: String(!fileExists),
+        duration_ms: String(Date.now() - startTime),
+      })
+
+      yield {
+        type: 'result',
+        data: resultData,
+        resultForAssistant: summary,
+      }
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : 'Unknown error occurred'
+      const errorResult = `Error applying multi-edit: ${errorMessage}`
+
+      logError(error)
+
+      yield {
+        type: 'result',
+        data: errorResult,
+        resultForAssistant: errorResult,
+      }
+    }
+  },
+} satisfies Tool<typeof inputSchema, any>

package/src/tools/MultiEditTool/prompt.ts

@@ -0,0 +1,45 @@
+import { NotebookEditTool } from '../NotebookEditTool/NotebookEditTool'
+
+export const DESCRIPTION = `This is a tool for making multiple edits to a single file in one operation. It is built on top of the Edit tool and allows you to perform multiple find-and-replace operations efficiently. Prefer this tool over the Edit tool when you need to make multiple edits to the same file.
+
+Before using this tool:
+
+1. Use the Read tool to understand the file's contents and context
+2. Verify the directory path is correct
+
+To make multiple file edits, provide the following:
+1. file_path: The absolute path to the file to modify (must be absolute, not relative)
+2. edits: An array of edit operations to perform, where each edit contains:
+   - old_string: The text to replace (must match the file contents exactly, including all whitespace and indentation)
+   - new_string: The edited text to replace the old_string
+   - replace_all: Replace all occurences of old_string. This parameter is optional and defaults to false.
+
+IMPORTANT:
+- All edits are applied in sequence, in the order they are provided
+- Each edit operates on the result of the previous edit
+- All edits must be valid for the operation to succeed - if any edit fails, none will be applied
+- This tool is ideal when you need to make several changes to different parts of the same file
+- For Jupyter notebooks (.ipynb files), use the ${NotebookEditTool.name} instead
+
+CRITICAL REQUIREMENTS:
+1. All edits follow the same requirements as the single Edit tool
+2. The edits are atomic - either all succeed or none are applied
+3. Plan your edits carefully to avoid conflicts between sequential operations
+
+WARNING:
+- The tool will fail if edits.old_string doesn't match the file contents exactly (including whitespace)
+- The tool will fail if edits.old_string and edits.new_string are the same
+- Since edits are applied in sequence, ensure that earlier edits don't affect the text that later edits are trying to find
+
+When making edits:
+- Ensure all edits result in idiomatic, correct code
+- Do not leave the code in a broken state
+- Always use absolute file paths (starting with /)
+- Use replace_all for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.
+
+If you want to create a new file, use:
+- A new file path, including dir name if needed
+- First edit: empty old_string and the new file's contents as new_string
+- Subsequent edits: normal edit operations on the created content`
+
+export const PROMPT = DESCRIPTION

package/src/tools/NotebookEditTool/NotebookEditTool.tsx

@@ -0,0 +1,298 @@
+import { existsSync, readFileSync } from 'fs'
+import { Box, Text } from 'ink'
+import { extname, isAbsolute, relative, resolve } from 'path'
+import * as React from 'react'
+import { z } from 'zod'
+import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
+import { HighlightedCode } from '../../components/HighlightedCode'
+import type { Tool } from '../../Tool'
+import { NotebookCellType, NotebookContent } from '../../types/notebook'
+import {
+  detectFileEncoding,
+  detectLineEndings,
+  writeTextContent,
+} from '../../utils/file.js'
+import { safeParseJSON } from '../../utils/json'
+import { getCwd } from '../../utils/state'
+import { DESCRIPTION, PROMPT } from './prompt'
+import { hasWritePermission } from '../../utils/permissions/filesystem'
+import { emitReminderEvent } from '../../services/systemReminder'
+import { recordFileEdit } from '../../services/fileFreshness'
+
+const inputSchema = z.strictObject({
+  notebook_path: z
+    .string()
+    .describe(
+      'The absolute path to the Jupyter notebook file to edit (must be absolute, not relative)',
+    ),
+  cell_number: z.number().describe('The index of the cell to edit (0-based)'),
+  new_source: z.string().describe('The new source for the cell'),
+  cell_type: z
+    .enum(['code', 'markdown'])
+    .optional()
+    .describe(
+      'The type of the cell (code or markdown). If not specified, it defaults to the current cell type. If using edit_mode=insert, this is required.',
+    ),
+  edit_mode: z
+    .string()
+    .optional()
+    .describe(
+      'The type of edit to make (replace, insert, delete). Defaults to replace.',
+    ),
+})
+
+export const NotebookEditTool = {
+  name: 'NotebookEditCell',
+  async description() {
+    return DESCRIPTION
+  },
+  async prompt() {
+    return PROMPT
+  },
+  inputSchema,
+  userFacingName() {
+    return 'Edit Notebook'
+  },
+  async isEnabled() {
+    return true
+  },
+  isReadOnly() {
+    return false
+  },
+  isConcurrencySafe() {
+    return false // NotebookEditTool modifies state/files, not safe for concurrent execution
+  },
+  needsPermissions({ notebook_path }) {
+    return !hasWritePermission(notebook_path)
+  },
+  renderResultForAssistant({ cell_number, edit_mode, new_source, error }) {
+    if (error) {
+      return error
+    }
+    switch (edit_mode) {
+      case 'replace':
+        return `Updated cell ${cell_number} with ${new_source}`
+      case 'insert':
+        return `Inserted cell ${cell_number} with ${new_source}`
+      case 'delete':
+        return `Deleted cell ${cell_number}`
+    }
+  },
+  renderToolUseMessage(input, { verbose }) {
+    return `notebook_path: ${verbose ? input.notebook_path : relative(getCwd(), input.notebook_path)}, cell: ${input.cell_number}, content: ${input.new_source.slice(0, 30)}…, cell_type: ${input.cell_type}, edit_mode: ${input.edit_mode ?? 'replace'}`
+  },
+  renderToolUseRejectedMessage() {
+    return <FallbackToolUseRejectedMessage />
+  },
+  renderToolResultMessage({ cell_number, new_source, language, error }) {
+    if (error) {
+      return (
+        <Box flexDirection="column">
+          <Text color="red">{error}</Text>
+        </Box>
+      )
+    }
+
+    return (
+      <Box flexDirection="column">
+        <Text>Updated cell {cell_number}:</Text>
+        <Box marginLeft={2}>
+          <HighlightedCode code={new_source} language={language} />
+        </Box>
+      </Box>
+    )
+  },
+  async validateInput({
+    notebook_path,
+    cell_number,
+    cell_type,
+    edit_mode = 'replace',
+  }) {
+    const fullPath = isAbsolute(notebook_path)
+      ? notebook_path
+      : resolve(getCwd(), notebook_path)
+
+    if (!existsSync(fullPath)) {
+      return {
+        result: false,
+        message: 'Notebook file does not exist.',
+      }
+    }
+
+    if (extname(fullPath) !== '.ipynb') {
+      return {
+        result: false,
+        message:
+          'File must be a Jupyter notebook (.ipynb file). For editing other file types, use the FileEdit tool.',
+      }
+    }
+
+    if (cell_number < 0) {
+      return {
+        result: false,
+        message: 'Cell number must be non-negative.',
+      }
+    }
+
+    if (
+      edit_mode !== 'replace' &&
+      edit_mode !== 'insert' &&
+      edit_mode !== 'delete'
+    ) {
+      return {
+        result: false,
+        message: 'Edit mode must be replace, insert, or delete.',
+      }
+    }
+
+    if (edit_mode === 'insert' && !cell_type) {
+      return {
+        result: false,
+        message: 'Cell type is required when using edit_mode=insert.',
+      }
+    }
+
+    const enc = detectFileEncoding(fullPath)
+    const content = readFileSync(fullPath, enc)
+    const notebook = safeParseJSON(content) as NotebookContent | null
+    if (!notebook) {
+      return {
+        result: false,
+        message: 'Notebook is not valid JSON.',
+      }
+    }
+
+    if (edit_mode === 'insert' && cell_number > notebook.cells.length) {
+      return {
+        result: false,
+        message: `Cell number is out of bounds. For insert mode, the maximum value is ${notebook.cells.length} (to append at the end).`,
+      }
+    } else if (
+      (edit_mode === 'replace' || edit_mode === 'delete') &&
+      (cell_number >= notebook.cells.length || !notebook.cells[cell_number])
+    ) {
+      return {
+        result: false,
+        message: `Cell number is out of bounds. Notebook has ${notebook.cells.length} cells.`,
+      }
+    }
+
+    return { result: true }
+  },
+  async *call({
+    notebook_path,
+    cell_number,
+    new_source,
+    cell_type,
+    edit_mode,
+  }) {
+    const fullPath = isAbsolute(notebook_path)
+      ? notebook_path
+      : resolve(getCwd(), notebook_path)
+
+    try {
+      const enc = detectFileEncoding(fullPath)
+      const content = readFileSync(fullPath, enc)
+      const notebook = JSON.parse(content) as NotebookContent
+      const language = notebook.metadata.language_info?.name ?? 'python'
+
+      if (edit_mode === 'delete') {
+        // Delete the specified cell
+        notebook.cells.splice(cell_number, 1)
+      } else if (edit_mode === 'insert') {
+        // Insert the new cell
+        const new_cell = {
+          cell_type: cell_type!, // validateInput ensures cell_type is not undefined
+          source: new_source,
+          metadata: {},
+        }
+        notebook.cells.splice(
+          cell_number,
+          0,
+          cell_type == 'markdown' ? new_cell : { ...new_cell, outputs: [] },
+        )
+      } else {
+        // Find the specified cell
+        const targetCell = notebook.cells[cell_number]! // validateInput ensures cell_number is in bounds
+        targetCell.source = new_source
+        // Reset execution count and clear outputs since cell was modified
+        targetCell.execution_count = undefined
+        targetCell.outputs = []
+        if (cell_type && cell_type !== targetCell.cell_type) {
+          targetCell.cell_type = cell_type
+        }
+      }
+      // Write back to file
+      const endings = detectLineEndings(fullPath)
+      const updatedNotebook = JSON.stringify(notebook, null, 1)
+      writeTextContent(fullPath, updatedNotebook, enc, endings!)
+
+      // Record Agent edit operation for file freshness tracking
+      recordFileEdit(fullPath, updatedNotebook)
+
+      // Emit file edited event for system reminders
+      emitReminderEvent('file:edited', {
+        filePath: fullPath,
+        cellNumber: cell_number,
+        newSource: new_source,
+        cellType: cell_type,
+        editMode: edit_mode || 'replace',
+        timestamp: Date.now(),
+        operation: 'notebook_edit',
+      })
+      const data = {
+        cell_number,
+        new_source,
+        cell_type: cell_type ?? 'code',
+        language,
+        edit_mode: edit_mode ?? 'replace',
+        error: '',
+      }
+      yield {
+        type: 'result',
+        data,
+        resultForAssistant: this.renderResultForAssistant(data),
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        const data = {
+          cell_number,
+          new_source,
+          cell_type: cell_type ?? 'code',
+          language: 'python',
+          edit_mode: 'replace',
+          error: error.message,
+        }
+        yield {
+          type: 'result',
+          data,
+          resultForAssistant: this.renderResultForAssistant(data),
+        }
+        return
+      }
+      const data = {
+        cell_number,
+        new_source,
+        cell_type: cell_type ?? 'code',
+        language: 'python',
+        edit_mode: 'replace',
+        error: 'Unknown error occurred while editing notebook',
+      }
+      yield {
+        type: 'result',
+        data,
+        resultForAssistant: this.renderResultForAssistant(data),
+      }
+    }
+  },
+} satisfies Tool<
+  typeof inputSchema,
+  {
+    cell_number: number
+    new_source: string
+    cell_type: NotebookCellType
+    language: string
+    edit_mode: string
+    error?: string
+  }
+>