@shareai-lab/kode 1.1.13 → 1.1.16-dev.1

package/src/tools/FileWriteTool/prompt.ts

@@ -1,10 +0,0 @@
-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.'

package/src/tools/GlobTool/GlobTool.tsx

@@ -1,119 +0,0 @@
-import { Box, Text } from 'ink'
-import React from 'react'
-import { z } from 'zod'
-import { Cost } from '../../components/Cost'
-import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
-import { Tool } from '../../Tool'
-import { getCwd } from '../../utils/state'
-import { glob } from '../../utils/file'
-import { DESCRIPTION, TOOL_NAME_FOR_PROMPT } from './prompt'
-import { isAbsolute, relative, resolve } from 'path'
-import { hasReadPermission } from '../../utils/permissions/filesystem'
-
-const inputSchema = z.strictObject({
-  pattern: z.string().describe('The glob pattern to match files against'),
-  path: z
-    .string()
-    .optional()
-    .describe(
-      'The directory to search in. Defaults to the current working directory.',
-    ),
-})
-
-type Output = {
-  durationMs: number
-  numFiles: number
-  filenames: string[]
-  truncated: boolean
-}
-
-export const GlobTool = {
-  name: TOOL_NAME_FOR_PROMPT,
-  async description() {
-    return DESCRIPTION
-  },
-  userFacingName() {
-    return 'Search'
-  },
-  inputSchema,
-  async isEnabled() {
-    return true
-  },
-  isReadOnly() {
-    return true
-  },
-  isConcurrencySafe() {
-    return true // GlobTool is read-only, safe for concurrent execution
-  },
-  needsPermissions({ path }) {
-    return !hasReadPermission(path || getCwd())
-  },
-  async prompt() {
-    return DESCRIPTION
-  },
-  renderToolUseMessage({ pattern, path }, { verbose }) {
-    const absolutePath = path
-      ? isAbsolute(path)
-        ? path
-        : resolve(getCwd(), path)
-      : undefined
-    const relativePath = absolutePath
-      ? relative(getCwd(), absolutePath)
-      : undefined
-    return `pattern: "${pattern}"${relativePath || verbose ? `, path: "${verbose ? absolutePath : relativePath}"` : ''}`
-  },
-  renderToolUseRejectedMessage() {
-    return <FallbackToolUseRejectedMessage />
-  },
-  renderToolResultMessage(output) {
-    // Handle string content for backward compatibility
-    if (typeof output === 'string') {
-      output = JSON.parse(output) as Output
-    }
-
-    return (
-      <Box justifyContent="space-between" width="100%">
-        <Box flexDirection="row">
-          <Text>&nbsp;&nbsp;⎿ &nbsp;Found </Text>
-          <Text bold>{output.numFiles} </Text>
-          <Text>
-            {output.numFiles === 0 || output.numFiles > 1 ? 'files' : 'file'}
-          </Text>
-        </Box>
-        <Cost costUSD={0} durationMs={output.durationMs} debug={false} />
-      </Box>
-    )
-  },
-  async *call({ pattern, path }, { abortController }) {
-    const start = Date.now()
-    const { files, truncated } = await glob(
-      pattern,
-      path ?? getCwd(),
-      { limit: 100, offset: 0 },
-      abortController.signal,
-    )
-    const output: Output = {
-      filenames: files,
-      durationMs: Date.now() - start,
-      numFiles: files.length,
-      truncated,
-    }
-    yield {
-      type: 'result',
-      resultForAssistant: this.renderResultForAssistant(output),
-      data: output,
-    }
-  },
-  renderResultForAssistant(output) {
-    let result = output.filenames.join('\n')
-    if (output.filenames.length === 0) {
-      result = 'No files found'
-    }
-    // Only add truncation message if results were actually truncated
-    else if (output.truncated) {
-      result +=
-        '\n(Results are truncated. Consider using a more specific path or pattern.)'
-    }
-    return result
-  },
-} satisfies Tool<typeof inputSchema, Output>

package/src/tools/GlobTool/prompt.ts

@@ -1,8 +0,0 @@
-export const TOOL_NAME_FOR_PROMPT = 'GlobTool'
-
-export const DESCRIPTION = `- Fast file pattern matching tool that works with any codebase size
-- Supports glob patterns like "**/*.js" or "src/**/*.ts"
-- Returns matching file paths sorted by modification time
-- Use this tool when you need to find files by name patterns
-- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead
-`

package/src/tools/GrepTool/GrepTool.tsx

@@ -1,147 +0,0 @@
-import { stat } from 'fs/promises'
-import { Box, Text } from 'ink'
-import React from 'react'
-import { z } from 'zod'
-import { Cost } from '../../components/Cost'
-import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
-import { Tool } from '../../Tool'
-import { getCwd } from '../../utils/state'
-import {
-  getAbsolutePath,
-  getAbsoluteAndRelativePaths,
-} from '../../utils/file.js'
-import { ripGrep } from '../../utils/ripgrep'
-import { DESCRIPTION, TOOL_NAME_FOR_PROMPT } from './prompt'
-import { hasReadPermission } from '../../utils/permissions/filesystem'
-
-const inputSchema = z.strictObject({
-  pattern: z
-    .string()
-    .describe('The regular expression pattern to search for in file contents'),
-  path: z
-    .string()
-    .optional()
-    .describe(
-      'The directory to search in. Defaults to the current working directory.',
-    ),
-  include: z
-    .string()
-    .optional()
-    .describe(
-      'File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")',
-    ),
-})
-
-const MAX_RESULTS = 100
-
-type Input = typeof inputSchema
-type Output = {
-  durationMs: number
-  numFiles: number
-  filenames: string[]
-}
-
-export const GrepTool = {
-  name: TOOL_NAME_FOR_PROMPT,
-  async description() {
-    return DESCRIPTION
-  },
-  userFacingName() {
-    return 'Search'
-  },
-  inputSchema,
-  isReadOnly() {
-    return true
-  },
-  isConcurrencySafe() {
-    return true // GrepTool is read-only, safe for concurrent execution
-  },
-  async isEnabled() {
-    return true
-  },
-  needsPermissions({ path }) {
-    return !hasReadPermission(path || getCwd())
-  },
-  async prompt() {
-    return DESCRIPTION
-  },
-  renderToolUseMessage({ pattern, path, include }, { verbose }) {
-    const { absolutePath, relativePath } = getAbsoluteAndRelativePaths(path)
-    return `pattern: "${pattern}"${relativePath || verbose ? `, path: "${verbose ? absolutePath : relativePath}"` : ''}${include ? `, include: "${include}"` : ''}`
-  },
-  renderToolUseRejectedMessage() {
-    return <FallbackToolUseRejectedMessage />
-  },
-  renderToolResultMessage(output) {
-    // Handle string content for backward compatibility
-    if (typeof output === 'string') {
-      // Convert string to Output type using tmpDeserializeOldLogResult if needed
-      output = output as unknown as Output
-    }
-
-    return (
-      <Box justifyContent="space-between" width="100%">
-        <Box flexDirection="row">
-          <Text>&nbsp;&nbsp;⎿ &nbsp;Found </Text>
-          <Text bold>{output.numFiles} </Text>
-          <Text>
-            {output.numFiles === 0 || output.numFiles > 1 ? 'files' : 'file'}
-          </Text>
-        </Box>
-        <Cost costUSD={0} durationMs={output.durationMs} debug={false} />
-      </Box>
-    )
-  },
-  renderResultForAssistant({ numFiles, filenames }) {
-    if (numFiles === 0) {
-      return 'No files found'
-    }
-    let result = `Found ${numFiles} file${numFiles === 1 ? '' : 's'}\n${filenames.slice(0, MAX_RESULTS).join('\n')}`
-    if (numFiles > MAX_RESULTS) {
-      result +=
-        '\n(Results are truncated. Consider using a more specific path or pattern.)'
-    }
-    return result
-  },
-  async *call({ pattern, path, include }, { abortController }) {
-    const start = Date.now()
-    const absolutePath = getAbsolutePath(path) || getCwd()
-
-    const args = ['-li', pattern]
-    if (include) {
-      args.push('--glob', include)
-    }
-
-    const results = await ripGrep(args, absolutePath, abortController.signal)
-
-    const stats = await Promise.all(results.map(_ => stat(_)))
-    const matches = results
-      // Sort by modification time
-      .map((_, i) => [_, stats[i]!] as const)
-      .sort((a, b) => {
-        if (process.env.NODE_ENV === 'test') {
-          // In tests, we always want to sort by filename, so that results are deterministic
-          return a[0].localeCompare(b[0])
-        }
-        const timeComparison = (b[1].mtimeMs ?? 0) - (a[1].mtimeMs ?? 0)
-        if (timeComparison === 0) {
-          // Sort by filename as a tiebreaker
-          return a[0].localeCompare(b[0])
-        }
-        return timeComparison
-      })
-      .map(_ => _[0])
-
-    const output = {
-      filenames: matches,
-      durationMs: Date.now() - start,
-      numFiles: matches.length,
-    }
-
-    yield {
-      type: 'result',
-      resultForAssistant: this.renderResultForAssistant(output),
-      data: output,
-    }
-  },
-} satisfies Tool<Input, Output>

package/src/tools/GrepTool/prompt.ts

@@ -1,11 +0,0 @@
-export const TOOL_NAME_FOR_PROMPT = 'GrepTool'
-
-export const DESCRIPTION = `
-- Fast content search tool that works with any codebase size
-- Searches file contents using regular expressions
-- Supports full regex syntax (eg. "log.*Error", "function\\s+\\w+", etc.)
-- Filter files by pattern with the include parameter (eg. "*.js", "*.{ts,tsx}")
-- Returns matching file paths sorted by modification time
-- Use this tool when you need to find files containing specific patterns
-- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead
-`

package/src/tools/MCPTool/MCPTool.tsx

@@ -1,107 +0,0 @@
-import { Box, Text } from 'ink'
-import * as React from 'react'
-import { z } from 'zod'
-import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
-import { type Tool } from '../../Tool'
-import { getTheme } from '../../utils/theme'
-import { DESCRIPTION, PROMPT } from './prompt'
-import { OutputLine } from '../BashTool/OutputLine'
-
-// Allow any input object since MCP tools define their own schemas
-const inputSchema = z.object({}).passthrough()
-
-export const MCPTool = {
-  async isEnabled() {
-    return true
-  },
-  isReadOnly() {
-    return false
-  },
-  isConcurrencySafe() {
-    return false // MCPTool can modify state through MCP calls, not safe for concurrent execution
-  },
-  // Overridden in mcpClient.ts
-  name: 'mcp',
-  // Overridden in mcpClient.ts
-  async description() {
-    return DESCRIPTION
-  },
-  // Overridden in mcpClient.ts
-  async prompt() {
-    return PROMPT
-  },
-  inputSchema,
-  // Overridden in mcpClient.ts
-  async *call() {
-    yield {
-      type: 'result',
-      data: '',
-      resultForAssistant: '',
-    }
-  },
-  needsPermissions() {
-    return true
-  },
-  renderToolUseMessage(input) {
-    return Object.entries(input)
-      .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
-      .join(', ')
-  },
-  // Overridden in mcpClient.ts
-  userFacingName: () => 'mcp',
-  renderToolUseRejectedMessage() {
-    return <FallbackToolUseRejectedMessage />
-  },
-  renderToolResultMessage(output) {
-    const verbose = false // Set default value for verbose
-    if (Array.isArray(output)) {
-      return (
-        <Box flexDirection="column">
-          {output.map((item, i) => {
-            if (item.type === 'image') {
-              return (
-                <Box
-                  key={i}
-                  justifyContent="space-between"
-                  overflowX="hidden"
-                  width="100%"
-                >
-                  <Box flexDirection="row">
-                    <Text>&nbsp;&nbsp;⎿ &nbsp;</Text>
-                    <Text>[Image]</Text>
-                  </Box>
-                </Box>
-              )
-            }
-            const lines = item.text.split('\n').length
-            return (
-              <OutputLine
-                key={i}
-                content={item.text}
-                lines={lines}
-                verbose={verbose}
-              />
-            )
-          })}
-        </Box>
-      )
-    }
-
-    if (!output) {
-      return (
-        <Box justifyContent="space-between" overflowX="hidden" width="100%">
-          <Box flexDirection="row">
-            <Text>&nbsp;&nbsp;⎿ &nbsp;</Text>
-            <Text color={getTheme().secondaryText}>(No content)</Text>
-          </Box>
-        </Box>
-      )
-    }
-
-    const lines = output.split('\n').length
-    return <OutputLine content={output} lines={lines} verbose={verbose} />
-  },
-  renderResultForAssistant(content) {
-    return content
-  },
-} satisfies Tool<typeof inputSchema, string>

package/src/tools/MCPTool/prompt.ts

@@ -1,3 +0,0 @@
-// Actual prompt and description are overridden in mcpClient.ts
-export const PROMPT = ''
-export const DESCRIPTION = ''

package/src/tools/MemoryReadTool/MemoryReadTool.tsx

@@ -1,127 +0,0 @@
-import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync } from 'fs'
-import { Box, Text } from 'ink'
-import { join } from 'path'
-import * as React from 'react'
-import { z } from 'zod'
-import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
-import { Tool } from '../../Tool'
-import { MEMORY_DIR } from '../../utils/env'
-import { resolveAgentId } from '../../utils/agentStorage'
-import { DESCRIPTION, PROMPT } from './prompt'
-
-const inputSchema = z.strictObject({
-  file_path: z
-    .string()
-    .optional()
-    .describe('Optional path to a specific memory file to read'),
-})
-
-export const MemoryReadTool = {
-  name: 'MemoryRead',
-  async description() {
-    return DESCRIPTION
-  },
-  async prompt() {
-    return PROMPT
-  },
-  inputSchema,
-  userFacingName() {
-    return 'Read Memory'
-  },
-  async isEnabled() {
-    // TODO: Use a statsig gate
-    // TODO: Figure out how to do that without regressing app startup perf
-    return false
-  },
-  isReadOnly() {
-    return true
-  },
-  isConcurrencySafe() {
-    return true // MemoryRead is read-only, safe for concurrent execution
-  },
-  needsPermissions() {
-    return false
-  },
-  renderResultForAssistant({ content }) {
-    return content
-  },
-  renderToolUseMessage(input) {
-    return Object.entries(input)
-      .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
-      .join(', ')
-  },
-  renderToolUseRejectedMessage() {
-    return <FallbackToolUseRejectedMessage />
-  },
-  renderToolResultMessage(output) {
-    return (
-      <Box justifyContent="space-between" overflowX="hidden" width="100%">
-        <Box flexDirection="row">
-          <Text>&nbsp;&nbsp;⎿ &nbsp;</Text>
-          <Text>{output.content}</Text>
-        </Box>
-      </Box>
-    )
-  },
-  async validateInput({ file_path }, context) {
-    const agentId = resolveAgentId(context?.agentId)
-    const agentMemoryDir = join(MEMORY_DIR, 'agents', agentId)
-
-    if (file_path) {
-      const fullPath = join(agentMemoryDir, file_path)
-      if (!fullPath.startsWith(agentMemoryDir)) {
-        return { result: false, message: 'Invalid memory file path' }
-      }
-      if (!existsSync(fullPath)) {
-        return { result: false, message: 'Memory file does not exist' }
-      }
-    }
-    return { result: true }
-  },
-  async *call({ file_path }, context) {
-    const agentId = resolveAgentId(context?.agentId)
-    const agentMemoryDir = join(MEMORY_DIR, 'agents', agentId)
-    mkdirSync(agentMemoryDir, { recursive: true })
-
-    // If a specific file is requested, return its contents
-    if (file_path) {
-      const fullPath = join(agentMemoryDir, file_path)
-      if (!existsSync(fullPath)) {
-        throw new Error('Memory file does not exist')
-      }
-      const content = readFileSync(fullPath, 'utf-8')
-      yield {
-        type: 'result',
-        data: {
-          content,
-        },
-        resultForAssistant: this.renderResultForAssistant({ content }),
-      }
-      return
-    }
-
-    // Otherwise return the index and file list for this agent
-    const files = readdirSync(agentMemoryDir, { recursive: true })
-      .map(f => join(agentMemoryDir, f.toString()))
-      .filter(f => !lstatSync(f).isDirectory())
-      .map(f => `- ${f}`)
-      .join('\n')
-
-    const indexPath = join(agentMemoryDir, 'index.md')
-    const index = existsSync(indexPath) ? readFileSync(indexPath, 'utf-8') : ''
-
-    const quotes = "'''"
-    const content = `Here are the contents of the agent memory file, \`${indexPath}\`:
-${quotes}
-${index}
-${quotes}
-
-Files in the agent memory directory:
-${files}`
-    yield {
-      type: 'result',
-      data: { content },
-      resultForAssistant: this.renderResultForAssistant({ content }),
-    }
-  },
-} satisfies Tool<typeof inputSchema, { content: string }>

package/src/tools/MemoryReadTool/prompt.ts

@@ -1,3 +0,0 @@
-// Actual prompt and description are overridden in mcpClient.ts
-export const PROMPT = ''
-export const DESCRIPTION = ''

package/src/tools/MemoryWriteTool/MemoryWriteTool.tsx

@@ -1,89 +0,0 @@
-import { mkdirSync, writeFileSync } from 'fs'
-import { Box, Text } from 'ink'
-import { dirname, join } from 'path'
-import * as React from 'react'
-import { z } from 'zod'
-import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
-import { Tool } from '../../Tool'
-import { MEMORY_DIR } from '../../utils/env'
-import { resolveAgentId } from '../../utils/agentStorage'
-import { recordFileEdit } from '../../services/fileFreshness'
-import { DESCRIPTION, PROMPT } from './prompt'
-
-const inputSchema = z.strictObject({
-  file_path: z.string().describe('Path to the memory file to write'),
-  content: z.string().describe('Content to write to the file'),
-})
-
-export const MemoryWriteTool = {
-  name: 'MemoryWrite',
-  async description() {
-    return DESCRIPTION
-  },
-  async prompt() {
-    return PROMPT
-  },
-  inputSchema,
-  userFacingName() {
-    return 'Write Memory'
-  },
-  async isEnabled() {
-    // TODO: Use a statsig gate
-    // TODO: Figure out how to do that without regressing app startup perf
-    return false
-  },
-  isReadOnly() {
-    return false
-  },
-  isConcurrencySafe() {
-    return false // MemoryWrite modifies state, not safe for concurrent execution
-  },
-  needsPermissions() {
-    return false
-  },
-  renderResultForAssistant(content) {
-    return content
-  },
-  renderToolUseMessage(input) {
-    return Object.entries(input)
-      .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
-      .join(', ')
-  },
-  renderToolUseRejectedMessage() {
-    return <FallbackToolUseRejectedMessage />
-  },
-  renderToolResultMessage() {
-    return (
-      <Box justifyContent="space-between" overflowX="hidden" width="100%">
-        <Box flexDirection="row">
-          <Text>{'  '}⎿ Updated memory</Text>
-        </Box>
-      </Box>
-    )
-  },
-  async validateInput({ file_path }, context) {
-    const agentId = resolveAgentId(context?.agentId)
-    const agentMemoryDir = join(MEMORY_DIR, 'agents', agentId)
-    const fullPath = join(agentMemoryDir, file_path)
-    if (!fullPath.startsWith(agentMemoryDir)) {
-      return { result: false, message: 'Invalid memory file path' }
-    }
-    return { result: true }
-  },
-  async *call({ file_path, content }, context) {
-    const agentId = resolveAgentId(context?.agentId)
-    const agentMemoryDir = join(MEMORY_DIR, 'agents', agentId)
-    const fullPath = join(agentMemoryDir, file_path)
-    mkdirSync(dirname(fullPath), { recursive: true })
-    writeFileSync(fullPath, content, 'utf-8')
-
-    // Record Agent edit operation for file freshness tracking
-    recordFileEdit(fullPath, content)
-
-    yield {
-      type: 'result',
-      data: 'Saved',
-      resultForAssistant: 'Saved',
-    }
-  },
-} satisfies Tool<typeof inputSchema, string>

package/src/tools/MemoryWriteTool/prompt.ts

@@ -1,3 +0,0 @@
-// Actual prompt and description are overridden in mcpClient.ts
-export const PROMPT = ''
-export const DESCRIPTION = ''