@shareai-lab/kode 1.0.71 → 1.0.73

package/src/tools/FileReadTool/FileReadTool.tsx

@@ -1,8 +1,8 @@
 import { ImageBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'
-import { existsSync, readFileSync, statSync } from 'fs'
+import { statSync } from 'node:fs'
 import { Box, Text } from 'ink'
-import * as path from 'path'
-import { extname, relative } from 'path'
+import * as path from 'node:path'
+import { extname, relative } from 'node:path'
 import * as React from 'react'
 import { z } from 'zod'
 import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
@@ -24,6 +24,7 @@ import {
 } from '../../services/fileFreshness'
 import { DESCRIPTION, PROMPT } from './prompt'
 import { hasReadPermission } from '../../utils/permissions/filesystem'
+import { secureFileService } from '../../utils/secureFile'
 
 const MAX_LINES_TO_RENDER = 5
 const MAX_OUTPUT_SIZE = 0.25 * 1024 * 1024 // 0.25MB in bytes
@@ -93,7 +94,8 @@ export const FileReadTool = {
       .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
       .join(', ')
   },
-  renderToolResultMessage(output, { verbose }) {
+  renderToolResultMessage(output) {
+    const verbose = false // Set default value for verbose
     // TODO: Render recursively
     switch (output.type) {
       case 'image':
@@ -143,7 +145,9 @@ export const FileReadTool = {
   async validateInput({ file_path, offset, limit }) {
     const fullFilePath = normalizeFilePath(file_path)
 
-    if (!existsSync(fullFilePath)) {
+    // Use secure file service to check if file exists and get file info
+    const fileCheck = secureFileService.safeGetFileInfo(fullFilePath)
+    if (!fileCheck.success) {
       // Try to find a similar file with a different extension
       const similarFilename = findSimilarFile(fullFilePath)
       let message = 'File does not exist.'
@@ -159,8 +163,7 @@ export const FileReadTool = {
       }
     }
 
-    // Get file stats to check size
-    const stats = statSync(fullFilePath)
+    const stats = fileCheck.stats!
     const fileSize = stats.size
     const ext = path.extname(fullFilePath).toLowerCase()
 
@@ -315,7 +318,18 @@ async function readImage(
     const sharp = (
       (await import('sharp')) as unknown as { default: typeof import('sharp') }
     ).default
-    const image = sharp(readFileSync(filePath))
+    
+    // Use secure file service to read the file
+    const fileReadResult = secureFileService.safeReadFile(filePath, {
+      encoding: 'buffer' as BufferEncoding,
+      maxFileSize: MAX_IMAGE_SIZE
+    })
+    
+    if (!fileReadResult.success) {
+      throw new Error(`Failed to read image file: ${fileReadResult.error}`)
+    }
+    
+    const image = sharp(fileReadResult.content as Buffer)
     const metadata = await image.metadata()
 
     if (!metadata.width || !metadata.height) {
@@ -335,7 +349,17 @@ async function readImage(
       width <= MAX_WIDTH &&
       height <= MAX_HEIGHT
     ) {
-      return createImageResponse(readFileSync(filePath), ext)
+      // Use secure file service to read the file
+      const fileReadResult = secureFileService.safeReadFile(filePath, {
+        encoding: 'buffer' as BufferEncoding,
+        maxFileSize: MAX_IMAGE_SIZE
+      })
+      
+      if (!fileReadResult.success) {
+        throw new Error(`Failed to read image file: ${fileReadResult.error}`)
+      }
+      
+      return createImageResponse(fileReadResult.content as Buffer, ext)
     }
 
     if (width > MAX_WIDTH) {
@@ -366,6 +390,15 @@ async function readImage(
   } catch (e) {
     logError(e)
     // If any error occurs during processing, return original image
-    return createImageResponse(readFileSync(filePath), ext)
+    const fileReadResult = secureFileService.safeReadFile(filePath, {
+      encoding: 'buffer' as BufferEncoding,
+      maxFileSize: MAX_IMAGE_SIZE
+    })
+    
+    if (!fileReadResult.success) {
+      throw new Error(`Failed to read image file: ${fileReadResult.error}`)
+    }
+    
+    return createImageResponse(fileReadResult.content as Buffer, ext)
   }
 }

package/src/tools/MCPTool/MCPTool.tsx

@@ -52,7 +52,8 @@ export const MCPTool = {
   renderToolUseRejectedMessage() {
     return <FallbackToolUseRejectedMessage />
   },
-  renderToolResultMessage(output, { verbose }) {
+  renderToolResultMessage(output) {
+    const verbose = false // Set default value for verbose
     if (Array.isArray(output)) {
       return (
         <Box flexDirection="column">

package/src/tools/MultiEditTool/MultiEditTool.tsx

@@ -58,8 +58,8 @@ export const MultiEditTool = {
     return PROMPT
   },
   inputSchema,
-  userFacingName({ edits }) {
-    return `Multi-Edit (${edits.length} changes)`
+  userFacingName() {
+    return 'Multi-Edit'
   },
   async isEnabled() {
     return true

package/src/tools/NotebookReadTool/NotebookReadTool.tsx

@@ -18,7 +18,7 @@ import {
   NotebookCellSourceOutput,
   NotebookCellOutput,
   NotebookCellType,
-} from '../../types/notebook.js'
+} from '../../types/notebook'
 import { formatOutput } from '../BashTool/utils'
 import { getCwd } from '../../utils/state'
 import { findSimilarFile } from '../../utils/file'
@@ -36,26 +36,6 @@ const inputSchema = z.strictObject({
 type In = typeof inputSchema
 type Out = NotebookCellSource[]
 
-function renderResultForAssistant(data: NotebookCellSource[]) {
-  const allResults = data.flatMap(getToolResultFromCell)
-
-  // Merge adjacent text blocks
-  return allResults.reduce<(TextBlockParam | ImageBlockParam)[]>(
-    (acc, curr) => {
-      if (acc.length === 0) return [curr]
-
-      const prev = acc[acc.length - 1]
-      if (prev && prev.type === 'text' && curr.type === 'text') {
-        // Merge the text blocks
-        prev.text += '\n' + curr.text
-        return acc
-      }
-
-      return [...acc, curr]
-    },
-    [],
-  )
-}
 
 export const NotebookReadTool = {
   name: 'ReadNotebook',
@@ -141,11 +121,23 @@ export const NotebookReadTool = {
 
     yield {
       type: 'result',
-      resultForAssistant: renderResultForAssistant(cells),
+      resultForAssistant: this.renderResultForAssistant(cells),
       data: cells,
     }
   },
-  renderResultForAssistant,
+  renderResultForAssistant(data: NotebookCellSource[]) {
+    // Convert the complex structure to a string representation for the assistant
+    return data.map((cell, index) => {
+      let content = `Cell ${index + 1} (${cell.cellType}):\n${cell.source}`
+      if (cell.outputs && cell.outputs.length > 0) {
+        const outputText = cell.outputs.map(output => output.text).filter(Boolean).join('\n')
+        if (outputText) {
+          content += `\nOutput:\n${outputText}`
+        }
+      }
+      return content
+    }).join('\n\n')
+  },
 } satisfies Tool<In, Out>
 
 function processOutputText(text: string | string[] | undefined): string {

package/src/tools/StickerRequestTool/StickerRequestTool.tsx

@@ -6,7 +6,7 @@ import { DESCRIPTION, PROMPT } from './prompt'
 import {
   StickerRequestForm,
   FormData,
-} from '../../components/StickerRequestForm.js'
+} from '../../components/StickerRequestForm'
 import { checkGate, logEvent } from '../../services/statsig'
 import { getTheme } from '../../utils/theme'
 

package/src/tools/TaskTool/TaskTool.tsx

@@ -2,7 +2,7 @@ import { TextBlock } from '@anthropic-ai/sdk/resources/index.mjs'
 import chalk from 'chalk'
 import { last, memoize } from 'lodash-es'
 import { EOL } from 'os'
-import * as React from 'react'
+import React, { useState, useEffect } from 'react'
 import { Box, Text } from 'ink'
 import { z } from 'zod'
 import { Tool, ValidationResult } from '../../Tool'
@@ -32,6 +32,7 @@ import { generateAgentId } from '../../utils/agentStorage'
 import { debug as debugLogger } from '../../utils/debugLogger'
 import { getTaskTools, getPrompt } from './prompt'
 import { TOOL_NAME } from './constants'
+import { getActiveAgents, getAgentByType, getAvailableAgentTypes } from '../../utils/agentLoader'
 
 const inputSchema = z.object({
   description: z
@@ -44,46 +45,28 @@ const inputSchema = z.object({
     .describe(
       'Optional: Specific model name to use for this task. If not provided, uses the default task model pointer.',
     ),
+  subagent_type: z
+    .string()
+    .optional()
+    .describe(
+      'The type of specialized agent to use for this task',
+    ),
 })
 
 export const TaskTool = {
   async prompt({ safeMode }) {
+    // Match original Claude Code - prompt returns full agent descriptions
     return await getPrompt(safeMode)
   },
   name: TOOL_NAME,
   async description() {
-    const modelManager = getModelManager()
-    const availableModels = modelManager.getAllAvailableModelNames()
-    const currentTaskModel =
-      modelManager.getModelName('task') || '<Not configured>'
-
-    if (availableModels.length === 0) {
-      return `Launch a new agent to handle complex, multi-step tasks autonomously.
-
-⚠️ No models configured. Use /model to configure models first.
-
-Usage: Provide detailed task description for autonomous execution. The agent will return results in a single response.`
-    }
-
-    return `Launch a new agent to handle complex, multi-step tasks autonomously.
-
-Available models: ${availableModels.join(', ')}
-
-When to specify a model_name:
-- Specify model_name for tasks requiring specific model capabilities  
-- If not provided, uses current task default: '${currentTaskModel}'
-- Use reasoning models for complex analysis
-- Use quick models for simple operations
-
-The model_name parameter accepts actual model names (like 'claude-3-5-sonnet-20241022', 'gpt-4', etc.)
-
-Usage: Provide detailed task description for autonomous execution. The agent will return results in a single response.`
+    // Match original Claude Code exactly - simple description
+    return "Launch a new task"
   },
   inputSchema,
   
-  // 🔧 ULTRA FIX: Complete revert to original AgentTool pattern
   async *call(
-    { description, prompt, model_name },
+    { description, prompt, model_name, subagent_type },
     {
       abortController,
       options: { safeMode = false, forkNumber, messageLogName, verbose },
@@ -91,14 +74,72 @@ Usage: Provide detailed task description for autonomous execution. The agent wil
     },
   ) {
     const startTime = Date.now()
-    const messages: MessageType[] = [createUserMessage(prompt)]
-    const tools = await getTaskTools(safeMode)
+    
+    // Default to general-purpose if no subagent_type specified
+    const agentType = subagent_type || 'general-purpose'
+    
+    // Apply subagent configuration
+    let effectivePrompt = prompt
+    let effectiveModel = model_name || 'task'
+    let toolFilter = null
+    let temperature = undefined
+    
+    // Load agent configuration dynamically
+    if (agentType) {
+      const agentConfig = await getAgentByType(agentType)
+      
+      if (!agentConfig) {
+        // If agent type not found, return helpful message instead of throwing
+        const availableTypes = await getAvailableAgentTypes()
+        const helpMessage = `Agent type '${agentType}' not found.\n\nAvailable agents:\n${availableTypes.map(t => `  • ${t}`).join('\n')}\n\nUse /agents command to manage agent configurations.`
+        
+        yield {
+          type: 'result',
+          data: { error: helpMessage },
+          resultForAssistant: helpMessage,
+        }
+        return
+      }
+      
+      // Apply system prompt if configured
+      if (agentConfig.systemPrompt) {
+        effectivePrompt = `${agentConfig.systemPrompt}\n\n${prompt}`
+      }
+      
+      // Apply model if not overridden by model_name parameter
+      if (!model_name && agentConfig.model_name) {
+        // Support inherit: keep pointer-based default
+        if (agentConfig.model_name !== 'inherit') {
+          effectiveModel = agentConfig.model_name as string
+        }
+      }
+      
+      // Store tool filter for later application
+      toolFilter = agentConfig.tools
+      
+      // Note: temperature is not currently in our agent configs
+      // but could be added in the future
+    }
+    
+    const messages: MessageType[] = [createUserMessage(effectivePrompt)]
+    let tools = await getTaskTools(safeMode)
+    
+    // Apply tool filtering if specified by subagent config
+    if (toolFilter) {
+      // Back-compat: ['*'] means all tools
+      const isAllArray = Array.isArray(toolFilter) && toolFilter.length === 1 && toolFilter[0] === '*'
+      if (toolFilter === '*' || isAllArray) {
+        // no-op, keep all tools
+      } else if (Array.isArray(toolFilter)) {
+        tools = tools.filter(tool => toolFilter.includes(tool.name))
+      }
+    }
 
     // We yield an initial message immediately so the UI
     // doesn't move around when messages start streaming back.
     yield {
       type: 'progress',
-      content: createAssistantMessage(chalk.dim('Initializing…')),
+      content: createAssistantMessage(chalk.dim(`[${agentType}] ${description}`)),
       normalizedMessages: normalizeMessages(messages),
       tools,
     }
@@ -109,8 +150,8 @@ Usage: Provide detailed task description for autonomous execution. The agent wil
       getMaxThinkingTokens(messages),
     ])
 
-    // Simple model resolution - match original AgentTool pattern  
-    const modelToUse = model_name || 'task'
+    // Model already resolved in effectiveModel variable above
+    const modelToUse = effectiveModel
     
     // Inject model context to prevent self-referential expert consultations
     taskPrompt.push(`\nIMPORTANT: You are currently running as ${modelToUse}. You do not need to consult ${modelToUse} via AskExpertModel since you ARE ${modelToUse}. Complete tasks directly using your capabilities.`)
@@ -125,6 +166,23 @@ Usage: Provide detailed task description for autonomous execution. The agent wil
     const taskId = generateAgentId()
 
     // 🔧 ULTRA SIMPLIFIED: Exact original AgentTool pattern
+    // Build query options, adding temperature if specified
+    const queryOptions = {
+      safeMode,
+      forkNumber,
+      messageLogName,
+      tools,
+      commands: [],
+      verbose,
+      maxThinkingTokens,
+      model: modelToUse,
+    }
+    
+    // Add temperature if specified by subagent config
+    if (temperature !== undefined) {
+      queryOptions['temperature'] = temperature
+    }
+    
     for await (const message of query(
       messages,
       taskPrompt,
@@ -132,16 +190,7 @@ Usage: Provide detailed task description for autonomous execution. The agent wil
       hasPermissionsToUseTool,
       {
         abortController,
-        options: {
-          safeMode,
-          forkNumber,
-          messageLogName,
-          tools,
-          commands: [],
-          verbose,
-          maxThinkingTokens,
-          model: modelToUse,
-        },
+        options: queryOptions,
         messageId: getLastAssistantMessageId(messages),
         agentId: taskId,
         readFileTimestamps,
@@ -159,22 +208,55 @@ Usage: Provide detailed task description for autonomous execution. The agent wil
       }
 
       const normalizedMessages = normalizeMessages(messages)
+      
+      // Process tool uses and text content for better visibility
       for (const content of message.message.content) {
-        if (content.type !== 'tool_use') {
-          continue
-        }
-
-        toolUseCount++
-        yield {
-          type: 'progress',
-          content: normalizedMessages.find(
+        if (content.type === 'text' && content.text && content.text !== INTERRUPT_MESSAGE) {
+          // Show agent's reasoning/responses
+          const preview = content.text.length > 200 ? content.text.substring(0, 200) + '...' : content.text
+          yield {
+            type: 'progress',
+            content: createAssistantMessage(`[${agentType}] ${preview}`),
+            normalizedMessages,
+            tools,
+          }
+        } else if (content.type === 'tool_use') {
+          toolUseCount++
+          
+          // Show which tool is being used with agent context
+          const toolMessage = normalizedMessages.find(
             _ =>
               _.type === 'assistant' &&
               _.message.content[0]?.type === 'tool_use' &&
               _.message.content[0].id === content.id,
-          ) as AssistantMessage,
-          normalizedMessages,
-          tools,
+          ) as AssistantMessage
+          
+          if (toolMessage) {
+            // Clone and modify the message to show agent context
+            const modifiedMessage = {
+              ...toolMessage,
+              message: {
+                ...toolMessage.message,
+                content: toolMessage.message.content.map(c => {
+                  if (c.type === 'tool_use' && c.id === content.id) {
+                    // Add agent context to tool name display
+                    return {
+                      ...c,
+                      name: c.name // Keep original name, UI will handle display
+                    }
+                  }
+                  return c
+                })
+              }
+            }
+            
+            yield {
+              type: 'progress',
+              content: modifiedMessage,
+              normalizedMessages,
+              tools,
+            }
+          }
         }
       }
     }
@@ -210,7 +292,7 @@ Usage: Provide detailed task description for autonomous execution. The agent wil
       ]
       yield {
         type: 'progress',
-        content: createAssistantMessage(`Done (${result.join(' · ')})`),
+        content: createAssistantMessage(`[${agentType}] Completed (${result.join(' · ')})`),
         normalizedMessages,
         tools,
       }
@@ -265,41 +347,59 @@ Usage: Provide detailed task description for autonomous execution. The agent wil
       }
     }
 
+    // Validate subagent_type if provided
+    if (input.subagent_type) {
+      const availableTypes = await getAvailableAgentTypes()
+      if (!availableTypes.includes(input.subagent_type)) {
+        return {
+          result: false,
+          message: `Agent type '${input.subagent_type}' does not exist. Available types: ${availableTypes.join(', ')}`,
+          meta: {
+            subagent_type: input.subagent_type,
+            availableTypes,
+          },
+        }
+      }
+    }
+
     return { result: true }
   },
   async isEnabled() {
     return true
   },
-  userFacingName() {
-    return 'Task'
+  userFacingName(input?: any) {
+    // Return agent name with proper prefix
+    const agentType = input?.subagent_type || 'general-purpose'
+    return `agent-${agentType}`
   },
   needsPermissions() {
     return false
   },
-  renderResultForAssistant(data) {
-    return data
+  renderResultForAssistant(data: TextBlock[]) {
+    return data.map(block => block.type === 'text' ? block.text : '').join('\n')
   },
-  renderToolUseMessage({ description, prompt, model_name }, { verbose }) {
+  renderToolUseMessage({ description, prompt, model_name, subagent_type }, { verbose }) {
     if (!description || !prompt) return null
 
     const modelManager = getModelManager()
     const defaultTaskModel = modelManager.getModelName('task')
     const actualModel = model_name || defaultTaskModel
+    const agentType = subagent_type || 'general-purpose'
     const promptPreview =
       prompt.length > 80 ? prompt.substring(0, 80) + '...' : prompt
 
+    const theme = getTheme()
+    
     if (verbose) {
-      const theme = getTheme()
       return (
         <Box flexDirection="column">
-          <Text bold color={theme.text}>
-            🚀 Task ({actualModel}): {description}
+          <Text>
+            [{agentType}] {actualModel}: {description}
           </Text>
           <Box
-            marginTop={1}
             paddingLeft={2}
             borderLeftStyle="single"
-            borderLeftColor={theme.border}
+            borderLeftColor={theme.secondaryBorder}
           >
             <Text color={theme.secondaryText}>{promptPreview}</Text>
           </Box>
@@ -307,12 +407,13 @@ Usage: Provide detailed task description for autonomous execution. The agent wil
       )
     }
 
-    return `Task (${actualModel}): ${description}`
+    // Simple display: agent type, model and description
+    return `[${agentType}] ${actualModel}: ${description}`
   },
   renderToolUseRejectedMessage() {
     return <FallbackToolUseRejectedMessage />
   },
-  renderToolResultMessage(content, { verbose }) {
+  renderToolResultMessage(content) {
     const theme = getTheme()
 
     if (Array.isArray(content)) {
@@ -351,23 +452,6 @@ Usage: Provide detailed task description for autonomous execution. The agent wil
               )}
             </Box>
           </Box>
-          {verbose && textBlocks.length > 0 && (
-            <Box
-              marginTop={1}
-              paddingLeft={4}
-              borderLeftStyle="single"
-              borderLeftColor={theme.border}
-            >
-              <Text color={theme.secondaryText}>
-                {textBlocks
-                  .slice(0, 2)
-                  .map(block => block.text)
-                  .join('\n')
-                  .substring(0, 200)}
-                {totalLength > 200 ? '...' : ''}
-              </Text>
-            </Box>
-          )}
         </Box>
       )
     }
@@ -379,4 +463,4 @@ Usage: Provide detailed task description for autonomous execution. The agent wil
       </Box>
     )
   },
-} satisfies Tool<typeof inputSchema, TextBlock[]>
+} satisfies Tool<typeof inputSchema, TextBlock[]>