@shareai-lab/kode 1.0.69 → 1.0.71

package/src/tools/FileReadTool/FileReadTool.tsx

@@ -0,0 +1,371 @@
+import { ImageBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'
+import { existsSync, readFileSync, statSync } from 'fs'
+import { Box, Text } from 'ink'
+import * as path from 'path'
+import { extname, relative } 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 { getCwd } from '../../utils/state'
+import {
+  addLineNumbers,
+  findSimilarFile,
+  normalizeFilePath,
+  readTextContent,
+} from '../../utils/file.js'
+import { logError } from '../../utils/log'
+import { getTheme } from '../../utils/theme'
+import { emitReminderEvent } from '../../services/systemReminder'
+import {
+  recordFileRead,
+  generateFileModificationReminder,
+} from '../../services/fileFreshness'
+import { DESCRIPTION, PROMPT } from './prompt'
+import { hasReadPermission } from '../../utils/permissions/filesystem'
+
+const MAX_LINES_TO_RENDER = 5
+const MAX_OUTPUT_SIZE = 0.25 * 1024 * 1024 // 0.25MB in bytes
+
+// Common image extensions
+const IMAGE_EXTENSIONS = new Set([
+  '.png',
+  '.jpg',
+  '.jpeg',
+  '.gif',
+  '.bmp',
+  '.webp',
+])
+
+// Maximum dimensions for images
+const MAX_WIDTH = 2000
+const MAX_HEIGHT = 2000
+const MAX_IMAGE_SIZE = 3.75 * 1024 * 1024 // 5MB in bytes, with base64 encoding
+
+const inputSchema = z.strictObject({
+  file_path: z.string().describe('The absolute path to the file to read'),
+  offset: z
+    .number()
+    .optional()
+    .describe(
+      'The line number to start reading from. Only provide if the file is too large to read at once',
+    ),
+  limit: z
+    .number()
+    .optional()
+    .describe(
+      'The number of lines to read. Only provide if the file is too large to read at once.',
+    ),
+})
+
+export const FileReadTool = {
+  name: 'View',
+  async description() {
+    return DESCRIPTION
+  },
+  async prompt() {
+    return PROMPT
+  },
+  inputSchema,
+  isReadOnly() {
+    return true
+  },
+  isConcurrencySafe() {
+    return true // FileRead is read-only, safe for concurrent execution
+  },
+  userFacingName() {
+    return 'Read'
+  },
+  async isEnabled() {
+    return true
+  },
+  needsPermissions({ file_path }) {
+    return !hasReadPermission(file_path || getCwd())
+  },
+  renderToolUseMessage(input, { verbose }) {
+    const { file_path, ...rest } = input
+    const entries = [
+      ['file_path', verbose ? file_path : relative(getCwd(), file_path)],
+      ...Object.entries(rest),
+    ]
+    return entries
+      .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+      .join(', ')
+  },
+  renderToolResultMessage(output, { verbose }) {
+    // TODO: Render recursively
+    switch (output.type) {
+      case 'image':
+        return (
+          <Box justifyContent="space-between" overflowX="hidden" width="100%">
+            <Box flexDirection="row">
+              <Text>&nbsp;&nbsp;⎿ &nbsp;</Text>
+              <Text>Read image</Text>
+            </Box>
+          </Box>
+        )
+      case 'text': {
+        const { filePath, content, numLines } = output.file
+        const contentWithFallback = content || '(No content)'
+        return (
+          <Box justifyContent="space-between" overflowX="hidden" width="100%">
+            <Box flexDirection="row">
+              <Text>&nbsp;&nbsp;⎿ &nbsp;</Text>
+              <Box flexDirection="column">
+                <HighlightedCode
+                  code={
+                    verbose
+                      ? contentWithFallback
+                      : contentWithFallback
+                          .split('\n')
+                          .slice(0, MAX_LINES_TO_RENDER)
+                          .filter(_ => _.trim() !== '')
+                          .join('\n')
+                  }
+                  language={extname(filePath).slice(1)}
+                />
+                {!verbose && numLines > MAX_LINES_TO_RENDER && (
+                  <Text color={getTheme().secondaryText}>
+                    ... (+{numLines - MAX_LINES_TO_RENDER} lines)
+                  </Text>
+                )}
+              </Box>
+            </Box>
+          </Box>
+        )
+      }
+    }
+  },
+  renderToolUseRejectedMessage() {
+    return <FallbackToolUseRejectedMessage />
+  },
+  async validateInput({ file_path, offset, limit }) {
+    const fullFilePath = normalizeFilePath(file_path)
+
+    if (!existsSync(fullFilePath)) {
+      // Try to find a similar file with a different extension
+      const similarFilename = findSimilarFile(fullFilePath)
+      let message = 'File does not exist.'
+
+      // If we found a similar file, suggest it to the assistant
+      if (similarFilename) {
+        message += ` Did you mean ${similarFilename}?`
+      }
+
+      return {
+        result: false,
+        message,
+      }
+    }
+
+    // Get file stats to check size
+    const stats = statSync(fullFilePath)
+    const fileSize = stats.size
+    const ext = path.extname(fullFilePath).toLowerCase()
+
+    // Skip size check for image files - they have their own size limits
+    if (!IMAGE_EXTENSIONS.has(ext)) {
+      // If file is too large and no offset/limit provided
+      if (fileSize > MAX_OUTPUT_SIZE && !offset && !limit) {
+        return {
+          result: false,
+          message: formatFileSizeError(fileSize),
+          meta: { fileSize },
+        }
+      }
+    }
+
+    return { result: true }
+  },
+  async *call(
+    { file_path, offset = 1, limit = undefined },
+    { readFileTimestamps },
+  ) {
+    const ext = path.extname(file_path).toLowerCase()
+    const fullFilePath = normalizeFilePath(file_path)
+
+    // Record file read for freshness tracking
+    recordFileRead(fullFilePath)
+
+    // Emit file read event for system reminders
+    emitReminderEvent('file:read', {
+      filePath: fullFilePath,
+      extension: ext,
+      timestamp: Date.now(),
+    })
+
+    // Update read timestamp, to invalidate stale writes
+    readFileTimestamps[fullFilePath] = Date.now()
+
+    // Check for file modifications and generate reminder if needed
+    const modificationReminder = generateFileModificationReminder(fullFilePath)
+    if (modificationReminder) {
+      emitReminderEvent('file:modified', {
+        filePath: fullFilePath,
+        reminder: modificationReminder,
+        timestamp: Date.now(),
+      })
+    }
+
+    // If it's an image file, process and return base64 encoded contents
+    if (IMAGE_EXTENSIONS.has(ext)) {
+      const data = await readImage(fullFilePath, ext)
+      yield {
+        type: 'result',
+        data,
+        resultForAssistant: this.renderResultForAssistant(data),
+      }
+      return
+    }
+
+    // Handle offset properly - if offset is 0, don't subtract 1
+    const lineOffset = offset === 0 ? 0 : offset - 1
+    const { content, lineCount, totalLines } = readTextContent(
+      fullFilePath,
+      lineOffset,
+      limit,
+    )
+
+    // Add size validation after reading for non-image files
+    if (!IMAGE_EXTENSIONS.has(ext) && content.length > MAX_OUTPUT_SIZE) {
+      throw new Error(formatFileSizeError(content.length))
+    }
+
+    const data = {
+      type: 'text' as const,
+      file: {
+        filePath: file_path,
+        content: content,
+        numLines: lineCount,
+        startLine: offset,
+        totalLines,
+      },
+    }
+
+    yield {
+      type: 'result',
+      data,
+      resultForAssistant: this.renderResultForAssistant(data),
+    }
+  },
+  renderResultForAssistant(data) {
+    switch (data.type) {
+      case 'image':
+        return [
+          {
+            type: 'image',
+            source: {
+              type: 'base64',
+              data: data.file.base64,
+              media_type: data.file.type,
+            },
+          },
+        ]
+      case 'text':
+        return addLineNumbers(data.file)
+    }
+  },
+} satisfies Tool<
+  typeof inputSchema,
+  | {
+      type: 'text'
+      file: {
+        filePath: string
+        content: string
+        numLines: number
+        startLine: number
+        totalLines: number
+      }
+    }
+  | {
+      type: 'image'
+      file: { base64: string; type: ImageBlockParam.Source['media_type'] }
+    }
+>
+
+const formatFileSizeError = (sizeInBytes: number) =>
+  `File content (${Math.round(sizeInBytes / 1024)}KB) exceeds maximum allowed size (${Math.round(MAX_OUTPUT_SIZE / 1024)}KB). Please use offset and limit parameters to read specific portions of the file, or use the GrepTool to search for specific content.`
+
+function createImageResponse(
+  buffer: Buffer,
+  ext: string,
+): {
+  type: 'image'
+  file: { base64: string; type: ImageBlockParam.Source['media_type'] }
+} {
+  return {
+    type: 'image',
+    file: {
+      base64: buffer.toString('base64'),
+      type: `image/${ext.slice(1)}` as ImageBlockParam.Source['media_type'],
+    },
+  }
+}
+
+async function readImage(
+  filePath: string,
+  ext: string,
+): Promise<{
+  type: 'image'
+  file: { base64: string; type: ImageBlockParam.Source['media_type'] }
+}> {
+  try {
+    const stats = statSync(filePath)
+    const sharp = (
+      (await import('sharp')) as unknown as { default: typeof import('sharp') }
+    ).default
+    const image = sharp(readFileSync(filePath))
+    const metadata = await image.metadata()
+
+    if (!metadata.width || !metadata.height) {
+      if (stats.size > MAX_IMAGE_SIZE) {
+        const compressedBuffer = await image.jpeg({ quality: 80 }).toBuffer()
+        return createImageResponse(compressedBuffer, 'jpeg')
+      }
+    }
+
+    // Calculate dimensions while maintaining aspect ratio
+    let width = metadata.width || 0
+    let height = metadata.height || 0
+
+    // Check if the original file just works
+    if (
+      stats.size <= MAX_IMAGE_SIZE &&
+      width <= MAX_WIDTH &&
+      height <= MAX_HEIGHT
+    ) {
+      return createImageResponse(readFileSync(filePath), ext)
+    }
+
+    if (width > MAX_WIDTH) {
+      height = Math.round((height * MAX_WIDTH) / width)
+      width = MAX_WIDTH
+    }
+
+    if (height > MAX_HEIGHT) {
+      width = Math.round((width * MAX_HEIGHT) / height)
+      height = MAX_HEIGHT
+    }
+
+    // Resize image and convert to buffer
+    const resizedImageBuffer = await image
+      .resize(width, height, {
+        fit: 'inside',
+        withoutEnlargement: true,
+      })
+      .toBuffer()
+
+    // If still too large after resize, compress quality
+    if (resizedImageBuffer.length > MAX_IMAGE_SIZE) {
+      const compressedBuffer = await image.jpeg({ quality: 80 }).toBuffer()
+      return createImageResponse(compressedBuffer, 'jpeg')
+    }
+
+    return createImageResponse(resizedImageBuffer, ext)
+  } catch (e) {
+    logError(e)
+    // If any error occurs during processing, return original image
+    return createImageResponse(readFileSync(filePath), ext)
+  }
+}

package/src/tools/FileReadTool/prompt.ts

@@ -0,0 +1,7 @@
+import { NotebookReadTool } from '../NotebookReadTool/NotebookReadTool'
+
+const MAX_LINES_TO_READ = 2000
+const MAX_LINE_LENGTH = 2000
+
+export const DESCRIPTION = 'Read a file from the local filesystem.'
+export const PROMPT = `Reads a file from the local filesystem. The file_path parameter must be an absolute path, not a relative path. By default, it reads up to ${MAX_LINES_TO_READ} lines starting from the beginning of the file. You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters. Any lines longer than ${MAX_LINE_LENGTH} characters will be truncated. For image files, the tool will display the image for you. For Jupyter notebooks (.ipynb files), use the ${NotebookReadTool.name} instead.`

package/src/tools/FileWriteTool/FileWriteTool.tsx

@@ -0,0 +1,297 @@
+import { Hunk } from 'diff'
+import { existsSync, mkdirSync, readFileSync, statSync } from 'fs'
+import { Box, Text } from 'ink'
+import { EOL } from 'os'
+import { dirname, extname, isAbsolute, relative, resolve, sep } from 'path'
+import * as React from 'react'
+import { z } from 'zod'
+import { FileEditToolUpdatedMessage } from '../../components/FileEditToolUpdatedMessage'
+import { HighlightedCode } from '../../components/HighlightedCode'
+import { StructuredDiff } from '../../components/StructuredDiff'
+import { logEvent } from '../../services/statsig'
+import type { Tool } from '../../Tool'
+import { intersperse } from '../../utils/array'
+import {
+  addLineNumbers,
+  detectFileEncoding,
+  detectLineEndings,
+  detectRepoLineEndings,
+  writeTextContent,
+} from '../../utils/file.js'
+import { logError } from '../../utils/log'
+import { getCwd } from '../../utils/state'
+import { getTheme } from '../../utils/theme'
+import { PROMPT } from './prompt'
+import { hasWritePermission } from '../../utils/permissions/filesystem'
+import { getPatch } from '../../utils/diff'
+import { PROJECT_FILE } from '../../constants/product'
+import { emitReminderEvent } from '../../services/systemReminder'
+import { recordFileEdit } from '../../services/fileFreshness'
+
+const MAX_LINES_TO_RENDER = 5
+const MAX_LINES_TO_RENDER_FOR_ASSISTANT = 16000
+const TRUNCATED_MESSAGE =
+  '<response clipped><NOTE>To save on context only part of this file has been shown to you. You should retry this tool after you have searched inside the file with Grep in order to find the line numbers of what you are looking for.</NOTE>'
+
+const inputSchema = z.strictObject({
+  file_path: z
+    .string()
+    .describe(
+      'The absolute path to the file to write (must be absolute, not relative)',
+    ),
+  content: z.string().describe('The content to write to the file'),
+})
+
+export const FileWriteTool = {
+  name: 'Replace',
+  async description() {
+    return 'Write a file to the local filesystem.'
+  },
+  userFacingName: () => 'Write',
+  async prompt() {
+    return PROMPT
+  },
+  inputSchema,
+  async isEnabled() {
+    return true
+  },
+  isReadOnly() {
+    return false
+  },
+  isConcurrencySafe() {
+    return false // FileWriteTool modifies state/files, not safe for concurrent execution
+  },
+  needsPermissions({ file_path }) {
+    return !hasWritePermission(file_path)
+  },
+  renderToolUseMessage(input, { verbose }) {
+    return `file_path: ${verbose ? input.file_path : relative(getCwd(), input.file_path)}`
+  },
+  renderToolUseRejectedMessage({ file_path, content }, { columns, verbose }) {
+    try {
+      const fullFilePath = isAbsolute(file_path)
+        ? file_path
+        : resolve(getCwd(), file_path)
+      const oldFileExists = existsSync(fullFilePath)
+      const enc = oldFileExists ? detectFileEncoding(fullFilePath) : 'utf-8'
+      const oldContent = oldFileExists ? readFileSync(fullFilePath, enc) : null
+      const type = oldContent ? 'update' : 'create'
+      const patch = getPatch({
+        filePath: file_path,
+        fileContents: oldContent ?? '',
+        oldStr: oldContent ?? '',
+        newStr: content,
+      })
+
+      return (
+        <Box flexDirection="column">
+          <Text>
+            {'  '}⎿{' '}
+            <Text color={getTheme().error}>
+              User rejected {type === 'update' ? 'update' : 'write'} to{' '}
+            </Text>
+            <Text bold>
+              {verbose ? file_path : relative(getCwd(), file_path)}
+            </Text>
+          </Text>
+          {intersperse(
+            patch.map(_ => (
+              <Box flexDirection="column" paddingLeft={5} key={_.newStart}>
+                <StructuredDiff patch={_} dim={true} width={columns - 12} />
+              </Box>
+            )),
+            i => (
+              <Box paddingLeft={5} key={`ellipsis-${i}`}>
+                <Text color={getTheme().secondaryText}>...</Text>
+              </Box>
+            ),
+          )}
+        </Box>
+      )
+    } catch (e) {
+      // Handle the case where while we were showing the diff, the user manually made the change.
+      // TODO: Find a way to show the diff in this case
+      logError(e)
+      return (
+        <Box flexDirection="column">
+          <Text>{'  '}⎿ (No changes)</Text>
+        </Box>
+      )
+    }
+  },
+  renderToolResultMessage(
+    { filePath, content, structuredPatch, type },
+    { verbose },
+  ) {
+    switch (type) {
+      case 'create': {
+        const contentWithFallback = content || '(No content)'
+        const numLines = content.split(EOL).length
+
+        return (
+          <Box flexDirection="column">
+            <Text>
+              {'  '}⎿ Wrote {numLines} lines to{' '}
+              <Text bold>
+                {verbose ? filePath : relative(getCwd(), filePath)}
+              </Text>
+            </Text>
+            <Box flexDirection="column" paddingLeft={5}>
+              <HighlightedCode
+                code={
+                  verbose
+                    ? contentWithFallback
+                    : contentWithFallback
+                        .split('\n')
+                        .slice(0, MAX_LINES_TO_RENDER)
+                        .filter(_ => _.trim() !== '')
+                        .join('\n')
+                }
+                language={extname(filePath).slice(1)}
+              />
+              {!verbose && numLines > MAX_LINES_TO_RENDER && (
+                <Text color={getTheme().secondaryText}>
+                  ... (+{numLines - MAX_LINES_TO_RENDER} lines)
+                </Text>
+              )}
+            </Box>
+          </Box>
+        )
+      }
+      case 'update':
+        return (
+          <FileEditToolUpdatedMessage
+            filePath={filePath}
+            structuredPatch={structuredPatch}
+            verbose={verbose}
+          />
+        )
+    }
+  },
+  async validateInput({ file_path }, { readFileTimestamps }) {
+    const fullFilePath = isAbsolute(file_path)
+      ? file_path
+      : resolve(getCwd(), file_path)
+    if (!existsSync(fullFilePath)) {
+      return { result: true }
+    }
+
+    const readTimestamp = readFileTimestamps[fullFilePath]
+    if (!readTimestamp) {
+      return {
+        result: false,
+        message:
+          'File has not been read yet. Read it first before writing to it.',
+      }
+    }
+
+    // Check if file exists and get its last modified time
+    const stats = statSync(fullFilePath)
+    const lastWriteTime = stats.mtimeMs
+    if (lastWriteTime > readTimestamp) {
+      return {
+        result: false,
+        message:
+          'File has been modified since read, either by the user or by a linter. Read it again before attempting to write it.',
+      }
+    }
+
+    return { result: true }
+  },
+  async *call({ file_path, content }, { readFileTimestamps }) {
+    const fullFilePath = isAbsolute(file_path)
+      ? file_path
+      : resolve(getCwd(), file_path)
+    const dir = dirname(fullFilePath)
+    const oldFileExists = existsSync(fullFilePath)
+    const enc = oldFileExists ? detectFileEncoding(fullFilePath) : 'utf-8'
+    const oldContent = oldFileExists ? readFileSync(fullFilePath, enc) : null
+
+    const endings = oldFileExists
+      ? detectLineEndings(fullFilePath)
+      : await detectRepoLineEndings(getCwd())
+
+    mkdirSync(dir, { recursive: true })
+    writeTextContent(fullFilePath, content, enc, endings!)
+
+    // Record Agent edit operation for file freshness tracking
+    recordFileEdit(fullFilePath, content)
+
+    // Update read timestamp, to invalidate stale writes
+    readFileTimestamps[fullFilePath] = statSync(fullFilePath).mtimeMs
+
+    // Log when writing to CLAUDE.md
+    if (fullFilePath.endsWith(`${sep}${PROJECT_FILE}`)) {
+      logEvent('tengu_write_claudemd', {})
+    }
+
+    // Emit file edited event for system reminders
+    emitReminderEvent('file:edited', {
+      filePath: fullFilePath,
+      content,
+      oldContent: oldContent || '',
+      timestamp: Date.now(),
+      operation: oldFileExists ? 'update' : 'create',
+    })
+
+    if (oldContent) {
+      const patch = getPatch({
+        filePath: file_path,
+        fileContents: oldContent,
+        oldStr: oldContent,
+        newStr: content,
+      })
+
+      const data = {
+        type: 'update' as const,
+        filePath: file_path,
+        content,
+        structuredPatch: patch,
+      }
+      yield {
+        type: 'result',
+        data,
+        resultForAssistant: this.renderResultForAssistant(data),
+      }
+      return
+    }
+
+    const data = {
+      type: 'create' as const,
+      filePath: file_path,
+      content,
+      structuredPatch: [],
+    }
+    yield {
+      type: 'result',
+      data,
+      resultForAssistant: this.renderResultForAssistant(data),
+    }
+  },
+  renderResultForAssistant({ filePath, content, type }) {
+    switch (type) {
+      case 'create':
+        return `File created successfully at: ${filePath}`
+      case 'update':
+        return `The file ${filePath} has been updated. Here's the result of running \`cat -n\` on a snippet of the edited file:
+${addLineNumbers({
+  content:
+    content.split(/\r?\n/).length > MAX_LINES_TO_RENDER_FOR_ASSISTANT
+      ? content
+          .split(/\r?\n/)
+          .slice(0, MAX_LINES_TO_RENDER_FOR_ASSISTANT)
+          .join('\n') + TRUNCATED_MESSAGE
+      : content,
+  startLine: 1,
+})}`
+    }
+  },
+} satisfies Tool<
+  typeof inputSchema,
+  {
+    type: 'create' | 'update'
+    filePath: string
+    content: string
+    structuredPatch: Hunk[]
+  }
+>

package/src/tools/FileWriteTool/prompt.ts

@@ -0,0 +1,10 @@
+export const PROMPT = `Write a file to the local filesystem. Overwrites the existing file if there is one.
+
+Before using this tool:
+
+1. Use the ReadFile tool to understand the file's contents and context
+
+2. Directory Verification (only applicable when creating new files):
+   - Use the LS tool to verify the parent directory exists and is the correct location`
+
+export const DESCRIPTION = 'Write a file to the local filesystem.'