@shareai-lab/kode 1.0.70 → 1.0.73

package/src/tools/TodoWriteTool/TodoWriteTool.tsx

@@ -0,0 +1,290 @@
+import { Box, Text } from 'ink'
+import * as React from 'react'
+import { z } from 'zod'
+import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
+import { TodoItem as TodoItemComponent } from '../../components/TodoItem'
+import { Tool, ValidationResult } from '../../Tool'
+import { setTodos, getTodos, TodoItem } from '../../utils/todoStorage'
+import { emitReminderEvent } from '../../services/systemReminder'
+import { startWatchingTodoFile } from '../../services/fileFreshness'
+import { DESCRIPTION, PROMPT } from './prompt'
+import { getTheme } from '../../utils/theme'
+
+const TodoItemSchema = z.object({
+  content: z.string().min(1).describe('The task description or content'),
+  status: z
+    .enum(['pending', 'in_progress', 'completed'])
+    .describe('Current status of the task'),
+  priority: z
+    .enum(['high', 'medium', 'low'])
+    .describe('Priority level of the task'),
+  id: z.string().min(1).describe('Unique identifier for the task'),
+})
+
+const inputSchema = z.strictObject({
+  todos: z.array(TodoItemSchema).describe('The updated todo list'),
+})
+
+function validateTodos(todos: TodoItem[]): ValidationResult {
+  // Check for duplicate IDs
+  const ids = todos.map(todo => todo.id)
+  const uniqueIds = new Set(ids)
+  if (ids.length !== uniqueIds.size) {
+    return {
+      result: false,
+      errorCode: 1,
+      message: 'Duplicate todo IDs found',
+      meta: {
+        duplicateIds: ids.filter((id, index) => ids.indexOf(id) !== index),
+      },
+    }
+  }
+
+  // Check for multiple in_progress tasks
+  const inProgressTasks = todos.filter(todo => todo.status === 'in_progress')
+  if (inProgressTasks.length > 1) {
+    return {
+      result: false,
+      errorCode: 2,
+      message: 'Only one task can be in_progress at a time',
+      meta: { inProgressTaskIds: inProgressTasks.map(t => t.id) },
+    }
+  }
+
+  // Validate each todo
+  for (const todo of todos) {
+    if (!todo.content?.trim()) {
+      return {
+        result: false,
+        errorCode: 3,
+        message: `Todo with ID "${todo.id}" has empty content`,
+        meta: { todoId: todo.id },
+      }
+    }
+    if (!['pending', 'in_progress', 'completed'].includes(todo.status)) {
+      return {
+        result: false,
+        errorCode: 4,
+        message: `Invalid status "${todo.status}" for todo "${todo.id}"`,
+        meta: { todoId: todo.id, invalidStatus: todo.status },
+      }
+    }
+    if (!['high', 'medium', 'low'].includes(todo.priority)) {
+      return {
+        result: false,
+        errorCode: 5,
+        message: `Invalid priority "${todo.priority}" for todo "${todo.id}"`,
+        meta: { todoId: todo.id, invalidPriority: todo.priority },
+      }
+    }
+  }
+
+  return { result: true }
+}
+
+function generateTodoSummary(todos: TodoItem[]): string {
+  const stats = {
+    total: todos.length,
+    pending: todos.filter(t => t.status === 'pending').length,
+    inProgress: todos.filter(t => t.status === 'in_progress').length,
+    completed: todos.filter(t => t.status === 'completed').length,
+  }
+
+  // Enhanced summary with statistics
+  let summary = `Updated ${stats.total} todo(s)`
+  if (stats.total > 0) {
+    summary += ` (${stats.pending} pending, ${stats.inProgress} in progress, ${stats.completed} completed)`
+  }
+  summary += '. Continue tracking your progress with the todo list.'
+
+  return summary
+}
+
+export const TodoWriteTool = {
+  name: 'TodoWrite',
+  async description() {
+    return DESCRIPTION
+  },
+  async prompt() {
+    return PROMPT
+  },
+  inputSchema,
+  userFacingName() {
+    return 'Write Todos'
+  },
+  async isEnabled() {
+    return true
+  },
+  isReadOnly() {
+    return false
+  },
+  isConcurrencySafe() {
+    return false // TodoWrite modifies state, not safe for concurrent execution
+  },
+  needsPermissions() {
+    return false
+  },
+  renderResultForAssistant(result) {
+    // Match official implementation - return static confirmation message
+    return 'Todos have been modified successfully. Ensure that you continue to use the todo list to track your progress. Please proceed with the current tasks if applicable'
+  },
+  renderToolUseMessage(input, { verbose }) {
+    // Return empty string to match reference implementation and avoid double rendering
+    // The tool result message will show the todo list
+    return ''
+  },
+  renderToolUseRejectedMessage() {
+    return <FallbackToolUseRejectedMessage />
+  },
+  renderToolResultMessage(output) {
+    const isError = typeof output === 'string' && output.startsWith('Error')
+
+    // If output contains todo data, render simple checkbox list
+    if (typeof output === 'object' && output && 'newTodos' in output) {
+      const { newTodos = [] } = output as any
+
+      // sort: [completed, in_progress, pending]
+      newTodos.sort((a, b) => {
+        const order = ['completed', 'in_progress', 'pending']
+        return (
+          order.indexOf(a.status) - order.indexOf(b.status) ||
+          a.content.localeCompare(b.content)
+        )
+      })
+
+      // Render each todo item with proper styling
+      return (
+        <Box justifyContent="space-between" overflowX="hidden" width="100%">
+          <Box flexDirection="row">
+            <Text>&nbsp;&nbsp;⎿ &nbsp;</Text>
+            <Box flexDirection="column">
+              {newTodos.map((todo: TodoItem, index: number) => {
+                const status_icon_map = {
+                  completed: '🟢',
+                  in_progress: '🟢',
+                  pending: '🟡',
+                }
+                const checkbox = status_icon_map[todo.status]
+
+                const status_color_map = {
+                  completed: '#008000',
+                  in_progress: '#008000',
+                  pending: '#FFD700',
+                }
+                const text_color = status_color_map[todo.status]
+
+                return (
+                  <React.Fragment key={todo.id || index}>
+                    <Text
+                      color={text_color}
+                      bold={todo.status !== 'pending'}
+                      strikethrough={todo.status === 'completed'}
+                    >
+                      {checkbox} {todo.content}
+                    </Text>
+                  </React.Fragment>
+                )
+              })}
+            </Box>
+          </Box>
+        </Box>
+      )
+    }
+
+    // Fallback to simple text rendering for errors or string output
+    return (
+      <Box justifyContent="space-between" overflowX="hidden" width="100%">
+        <Box flexDirection="row">
+          <Text color={isError ? getTheme().error : getTheme().success}>
+            &nbsp;&nbsp;⎿ &nbsp;
+            {typeof output === 'string' ? output : JSON.stringify(output)}
+          </Text>
+        </Box>
+      </Box>
+    )
+  },
+  async validateInput({ todos }: z.infer<typeof inputSchema>) {
+    // Type assertion to ensure todos match TodoItem[] interface
+    const todoItems = todos as TodoItem[]
+    const validation = validateTodos(todoItems)
+    if (!validation.result) {
+      return validation
+    }
+    return { result: true }
+  },
+  async *call({ todos }: z.infer<typeof inputSchema>, context) {
+    try {
+      // Get agent ID from context
+      const agentId = context?.agentId
+
+      // Start watching todo file for this agent if not already watching
+      if (agentId) {
+        startWatchingTodoFile(agentId)
+      }
+
+      // Store previous todos for comparison (agent-scoped)
+      const previousTodos = getTodos(agentId)
+
+      // Type assertion to ensure todos match TodoItem[] interface
+      const todoItems = todos as TodoItem[]
+
+      // Note: Validation already done in validateInput, no need for duplicate validation
+      // This eliminates the double validation issue
+
+      // Update the todos in storage (agent-scoped)
+      setTodos(todoItems, agentId)
+
+      // Emit todo change event for system reminders (optimized - only if todos actually changed)
+      const hasChanged =
+        JSON.stringify(previousTodos) !== JSON.stringify(todoItems)
+      if (hasChanged) {
+        emitReminderEvent('todo:changed', {
+          previousTodos,
+          newTodos: todoItems,
+          timestamp: Date.now(),
+          agentId: agentId || 'default',
+          changeType:
+            todoItems.length > previousTodos.length
+              ? 'added'
+              : todoItems.length < previousTodos.length
+                ? 'removed'
+                : 'modified',
+        })
+      }
+
+      // Generate enhanced summary
+      const summary = generateTodoSummary(todoItems)
+
+      // Enhanced result data for rendering
+      const resultData = {
+        oldTodos: previousTodos,
+        newTodos: todoItems,
+        summary,
+      }
+
+      yield {
+        type: 'result',
+        data: summary, // Return string instead of object to match interface
+        resultForAssistant: summary,
+      }
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : 'Unknown error occurred'
+      const errorResult = `Error updating todos: ${errorMessage}`
+
+      // Emit error event for system monitoring
+      emitReminderEvent('todo:error', {
+        error: errorMessage,
+        timestamp: Date.now(),
+        agentId: context?.agentId || 'default',
+        context: 'TodoWriteTool.call',
+      })
+
+      yield {
+        type: 'result',
+        data: errorResult,
+        resultForAssistant: errorResult,
+      }
+    }
+  },
+} satisfies Tool<typeof inputSchema, string>

package/src/tools/TodoWriteTool/prompt.ts

@@ -0,0 +1,63 @@
+export const DESCRIPTION =
+  'Creates and manages todo items for task tracking and progress management in the current session.'
+
+export const PROMPT = `Use this tool to create and manage todo items for tracking tasks and progress. This tool provides comprehensive todo management:
+
+## When to Use This Tool
+
+Use this tool proactively in these scenarios:
+
+1. **Complex multi-step tasks** - When a task requires 3 or more distinct steps or actions
+2. **Non-trivial and complex tasks** - Tasks that require careful planning or multiple operations
+3. **User explicitly requests todo list** - When the user directly asks you to use the todo list
+4. **User provides multiple tasks** - When users provide a list of things to be done (numbered or comma-separated)
+5. **After receiving new instructions** - Immediately capture user requirements as todos
+6. **When you start working on a task** - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
+7. **After completing a task** - Mark it as completed and add any new follow-up tasks discovered during implementation
+
+## When NOT to Use This Tool
+
+Skip using this tool when:
+1. There is only a single, straightforward task
+2. The task is trivial and tracking it provides no organizational benefit
+3. The task can be completed in less than 3 trivial steps
+4. The task is purely conversational or informational
+
+## Task States and Management
+
+1. **Task States**: Use these states to track progress:
+   - pending: Task not yet started
+   - in_progress: Currently working on (limit to ONE task at a time)
+   - completed: Task finished successfully
+
+2. **Task Management**:
+   - Update task status in real-time as you work
+   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+   - Only have ONE task in_progress at any time
+   - Complete current tasks before starting new ones
+   - Remove tasks that are no longer relevant from the list entirely
+
+3. **Task Completion Requirements**:
+   - ONLY mark a task as completed when you have FULLY accomplished it
+   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
+   - When blocked, create a new task describing what needs to be resolved
+   - Never mark a task as completed if:
+     - Tests are failing
+     - Implementation is partial
+     - You encountered unresolved errors
+     - You couldn't find necessary files or dependencies
+
+4. **Task Breakdown**:
+   - Create specific, actionable items
+   - Break complex tasks into smaller, manageable steps
+   - Use clear, descriptive task names
+
+## Tool Capabilities
+
+- **Create new todos**: Add tasks with content, priority, and status
+- **Update existing todos**: Modify any aspect of a todo (status, priority, content)
+- **Delete todos**: Remove completed or irrelevant tasks
+- **Batch operations**: Update multiple todos in a single operation
+- **Clear all todos**: Reset the entire todo list
+
+When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.`

package/src/tools/lsTool/lsTool.tsx

@@ -0,0 +1,272 @@
+import { readdirSync } from 'fs'
+import { Box, Text } from 'ink'
+import { basename, isAbsolute, join, relative, resolve, sep } from 'path'
+import * as React from 'react'
+import { z } from 'zod'
+import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
+import { Tool } from '../../Tool'
+import { logError } from '../../utils/log'
+import { getCwd } from '../../utils/state'
+import { getTheme } from '../../utils/theme'
+import { DESCRIPTION } from './prompt'
+import { hasReadPermission } from '../../utils/permissions/filesystem'
+
+const MAX_LINES = 5
+const MAX_FILES = 1000
+const TRUNCATED_MESSAGE = `There are more than ${MAX_FILES} files in the repository. Use the LS tool (passing a specific path), Bash tool, and other tools to explore nested directories. The first ${MAX_FILES} files and directories are included below:\n\n`
+
+const inputSchema = z.strictObject({
+  path: z
+    .string()
+    .describe(
+      'The absolute path to the directory to list (must be absolute, not relative)',
+    ),
+})
+
+// TODO: Kill this tool and use bash instead
+export const LSTool = {
+  name: 'LS',
+  async description() {
+    return DESCRIPTION
+  },
+  inputSchema,
+  userFacingName() {
+    return 'List'
+  },
+  async isEnabled() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+  isConcurrencySafe() {
+    return true // LSTool is read-only, safe for concurrent execution
+  },
+  needsPermissions({ path }) {
+    return !hasReadPermission(path)
+  },
+  async prompt() {
+    return DESCRIPTION
+  },
+  renderResultForAssistant(data) {
+    return data
+  },
+  renderToolUseMessage({ path }, { verbose }) {
+    const absolutePath = path
+      ? isAbsolute(path)
+        ? path
+        : resolve(getCwd(), path)
+      : undefined
+    const relativePath = absolutePath ? relative(getCwd(), absolutePath) : '.'
+    return `path: "${verbose ? path : relativePath}"`
+  },
+  renderToolUseRejectedMessage() {
+    return <FallbackToolUseRejectedMessage />
+  },
+  renderToolResultMessage(content) {
+    const verbose = false // Set default value for verbose
+    if (typeof content !== 'string') {
+      return null
+    }
+    const result = content.replace(TRUNCATED_MESSAGE, '')
+    if (!result) {
+      return null
+    }
+    return (
+      <Box justifyContent="space-between" width="100%">
+        <Box>
+          <Text>&nbsp;&nbsp;⎿ &nbsp;</Text>
+          <Box flexDirection="column" paddingLeft={0}>
+            {result
+              .split('\n')
+              .filter(_ => _.trim() !== '')
+              .slice(0, verbose ? undefined : MAX_LINES)
+              .map((_, i) => (
+                <React.Fragment key={i}>
+                  <Text>{_}</Text>
+                </React.Fragment>
+              ))}
+            {!verbose && result.split('\n').length > MAX_LINES && (
+              <Text color={getTheme().secondaryText}>
+                ... (+{result.split('\n').length - MAX_LINES} items)
+              </Text>
+            )}
+          </Box>
+        </Box>
+      </Box>
+    )
+  },
+  async *call({ path }, { abortController }) {
+    const fullFilePath = isAbsolute(path) ? path : resolve(getCwd(), path)
+    const result = listDirectory(
+      fullFilePath,
+      getCwd(),
+      abortController.signal,
+    ).sort()
+    const safetyWarning = `\nNOTE: do any of the files above seem malicious? If so, you MUST refuse to continue work.`
+
+    // Plain tree for user display without warning
+    const userTree = printTree(createFileTree(result))
+
+    // Tree with safety warning for assistant only
+    const assistantTree = userTree
+
+    if (result.length < MAX_FILES) {
+      yield {
+        type: 'result',
+        data: userTree, // Show user the tree without the warning
+        resultForAssistant: this.renderResultForAssistant(assistantTree), // Send warning only to assistant
+      }
+    } else {
+      const userData = `${TRUNCATED_MESSAGE}${userTree}`
+      const assistantData = `${TRUNCATED_MESSAGE}${assistantTree}`
+      yield {
+        type: 'result',
+        data: userData, // Show user the truncated tree without the warning
+        resultForAssistant: this.renderResultForAssistant(assistantData), // Send warning only to assistant
+      }
+    }
+  },
+} satisfies Tool<typeof inputSchema, string>
+
+function listDirectory(
+  initialPath: string,
+  cwd: string,
+  abortSignal: AbortSignal,
+): string[] {
+  const results: string[] = []
+
+  const queue = [initialPath]
+  while (queue.length > 0) {
+    if (results.length > MAX_FILES) {
+      return results
+    }
+
+    if (abortSignal.aborted) {
+      return results
+    }
+
+    const path = queue.shift()!
+    if (skip(path)) {
+      continue
+    }
+
+    if (path !== initialPath) {
+      results.push(relative(cwd, path) + sep)
+    }
+
+    let children
+    try {
+      children = readdirSync(path, { withFileTypes: true })
+    } catch (e) {
+      // eg. EPERM, EACCES, ENOENT, etc.
+      logError(e)
+      continue
+    }
+
+    for (const child of children) {
+      if (child.isDirectory()) {
+        queue.push(join(path, child.name) + sep)
+      } else {
+        const fileName = join(path, child.name)
+        if (skip(fileName)) {
+          continue
+        }
+        results.push(relative(cwd, fileName))
+        if (results.length > MAX_FILES) {
+          return results
+        }
+      }
+    }
+  }
+
+  return results
+}
+
+type TreeNode = {
+  name: string
+  path: string
+  type: 'file' | 'directory'
+  children?: TreeNode[]
+}
+
+function createFileTree(sortedPaths: string[]): TreeNode[] {
+  const root: TreeNode[] = []
+
+  for (const path of sortedPaths) {
+    const parts = path.split(sep)
+    let currentLevel = root
+    let currentPath = ''
+
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i]!
+      if (!part) {
+        // directories have trailing slashes
+        continue
+      }
+      currentPath = currentPath ? `${currentPath}${sep}${part}` : part
+      const isLastPart = i === parts.length - 1
+
+      const existingNode = currentLevel.find(node => node.name === part)
+
+      if (existingNode) {
+        currentLevel = existingNode.children || []
+      } else {
+        const newNode: TreeNode = {
+          name: part,
+          path: currentPath,
+          type: isLastPart ? 'file' : 'directory',
+        }
+
+        if (!isLastPart) {
+          newNode.children = []
+        }
+
+        currentLevel.push(newNode)
+        currentLevel = newNode.children || []
+      }
+    }
+  }
+
+  return root
+}
+
+/**
+ * eg.
+ * - src/
+ *   - index.ts
+ *   - utils/
+ *     - file.ts
+ */
+function printTree(tree: TreeNode[], level = 0, prefix = ''): string {
+  let result = ''
+
+  // Add absolute path at root level
+  if (level === 0) {
+    result += `- ${getCwd()}${sep}\n`
+    prefix = '  '
+  }
+
+  for (const node of tree) {
+    // Add the current node to the result
+    result += `${prefix}${'-'} ${node.name}${node.type === 'directory' ? sep : ''}\n`
+
+    // Recursively print children if they exist
+    if (node.children && node.children.length > 0) {
+      result += printTree(node.children, level + 1, `${prefix}  `)
+    }
+  }
+
+  return result
+}
+
+// TODO: Add windows support
+function skip(path: string): boolean {
+  if (path !== '.' && basename(path).startsWith('.')) {
+    return true
+  }
+  if (path.includes(`__pycache__${sep}`)) {
+    return true
+  }
+  return false
+}

package/src/tools/lsTool/prompt.ts

@@ -0,0 +1,2 @@
+export const DESCRIPTION =
+  'Lists files and directories in a given path. The path parameter must be an absolute path, not a relative path. You should generally prefer the Glob and Grep tools, if you know which directories to search.'

package/src/tools.ts

@@ -0,0 +1,63 @@
+import { Tool } from './Tool'
+import { TaskTool } from './tools/TaskTool/TaskTool'
+import { ArchitectTool } from './tools/ArchitectTool/ArchitectTool'
+import { BashTool } from './tools/BashTool/BashTool'
+import { AskExpertModelTool } from './tools/AskExpertModelTool/AskExpertModelTool'
+import { FileEditTool } from './tools/FileEditTool/FileEditTool'
+import { FileReadTool } from './tools/FileReadTool/FileReadTool'
+import { FileWriteTool } from './tools/FileWriteTool/FileWriteTool'
+import { GlobTool } from './tools/GlobTool/GlobTool'
+import { GrepTool } from './tools/GrepTool/GrepTool'
+import { LSTool } from './tools/lsTool/lsTool'
+import { MemoryReadTool } from './tools/MemoryReadTool/MemoryReadTool'
+import { MemoryWriteTool } from './tools/MemoryWriteTool/MemoryWriteTool'
+import { MultiEditTool } from './tools/MultiEditTool/MultiEditTool'
+import { NotebookEditTool } from './tools/NotebookEditTool/NotebookEditTool'
+import { NotebookReadTool } from './tools/NotebookReadTool/NotebookReadTool'
+import { ThinkTool } from './tools/ThinkTool/ThinkTool'
+import { TodoWriteTool } from './tools/TodoWriteTool/TodoWriteTool'
+import { getMCPTools } from './services/mcpClient'
+import { memoize } from 'lodash-es'
+
+const ANT_ONLY_TOOLS = [MemoryReadTool as unknown as Tool, MemoryWriteTool as unknown as Tool]
+
+// Function to avoid circular dependencies that break bun
+export const getAllTools = (): Tool[] => {
+  return [
+    TaskTool as unknown as Tool,
+    AskExpertModelTool as unknown as Tool,
+    BashTool as unknown as Tool,
+    GlobTool as unknown as Tool,
+    GrepTool as unknown as Tool,
+    LSTool as unknown as Tool,
+    FileReadTool as unknown as Tool,
+    FileEditTool as unknown as Tool,
+    MultiEditTool as unknown as Tool,
+    FileWriteTool as unknown as Tool,
+    NotebookReadTool as unknown as Tool,
+    NotebookEditTool as unknown as Tool,
+    ThinkTool as unknown as Tool,
+    TodoWriteTool as unknown as Tool,
+    ...ANT_ONLY_TOOLS,
+  ]
+}
+
+export const getTools = memoize(
+  async (enableArchitect?: boolean): Promise<Tool[]> => {
+    const tools = [...getAllTools(), ...(await getMCPTools())]
+
+    // Only include Architect tool if enabled via config or CLI flag
+    if (enableArchitect) {
+      tools.push(ArchitectTool as unknown as Tool)
+    }
+
+    const isEnabled = await Promise.all(tools.map(tool => tool.isEnabled()))
+    return tools.filter((_, i) => isEnabled[i])
+  },
+)
+
+export const getReadOnlyTools = memoize(async (): Promise<Tool[]> => {
+  const tools = getAllTools().filter(tool => tool.isReadOnly())
+  const isEnabled = await Promise.all(tools.map(tool => tool.isEnabled()))
+  return tools.filter((_, index) => isEnabled[index])
+})