@shareai-lab/kode 1.0.71 → 1.0.75

package/src/tools/TaskTool/prompt.ts

@@ -8,6 +8,7 @@ import { NotebookEditTool } from '../NotebookEditTool/NotebookEditTool'
 import { GlobTool } from '../GlobTool/GlobTool'
 import { FileReadTool } from '../FileReadTool/FileReadTool'
 import { getModelManager } from '../../utils/model'
+import { getActiveAgents } from '../../utils/agentLoader'
 
 export async function getTaskTools(safeMode: boolean): Promise<Tool[]> {
   // No recursive tasks, yet..
@@ -17,40 +18,75 @@ export async function getTaskTools(safeMode: boolean): Promise<Tool[]> {
 }
 
 export async function getPrompt(safeMode: boolean): Promise<string> {
-  const tools = await getTaskTools(safeMode)
-  const toolNames = tools.map(_ => _.name).join(', ')
+  // Extracted directly from original Claude Code obfuscated source
+  const agents = await getActiveAgents()
+  
+  // Format exactly as in original: (Tools: tool1, tool2)
+  const agentDescriptions = agents.map(agent => {
+    const toolsStr = Array.isArray(agent.tools) 
+      ? agent.tools.join(', ')
+      : '*'
+    return `- ${agent.agentType}: ${agent.whenToUse} (Tools: ${toolsStr})`
+  }).join('\n')
+  
+  // 100% exact copy from original Claude Code source
+  return `Launch a new agent to handle complex, multi-step tasks autonomously. 
 
-  // Add dynamic model information for Task tool prompts
-  const modelManager = getModelManager()
-  const availableModels = modelManager.getAllAvailableModelNames()
-  const currentTaskModel =
-    modelManager.getModelName('task') || '<Not configured>'
+Available agent types and the tools they have access to:
+${agentDescriptions}
 
-  const modelInfo =
-    availableModels.length > 0
-      ? `
+When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
 
-Available models for Task tool: ${availableModels.join(', ')}
-Default task model: ${currentTaskModel}
-Specify model_name parameter to use a specific model for the task.`
-      : ''
+When to use the Agent tool:
+- When you are instructed to execute custom slash commands. Use the Agent tool with the slash command invocation as the entire prompt. The slash command can take arguments. For example: Task(description="Check the file", prompt="/check-file path/to/file.py")
 
-  return `Launch a new agent that has access to the following tools: ${toolNames}. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries, use the Task tool to perform the search for you.${modelInfo}
-
-When to use the Task tool:
-- If you are searching for a keyword like "config" or "logger", or for questions like "which file does X?", the Task tool is strongly recommended
-
-When NOT to use the Task tool:
-- If you want to read a specific file path, use the ${FileReadTool.name} or ${GlobTool.name} tool instead of the Task tool, to find the match more quickly
+When NOT to use the Agent tool:
+- If you want to read a specific file path, use the ${FileReadTool.name} or ${GlobTool.name} tool instead of the Agent tool, to find the match more quickly
 - If you are searching for a specific class definition like "class Foo", use the ${GlobTool.name} tool instead, to find the match more quickly
-- If you are searching for code within a specific file or set of 2-3 files, use the Read tool instead of the Task tool, to find the match more quickly
-- Writing code and running bash commands (use other tools for that)
-- Other tasks that are not related to searching for a keyword or file
+- If you are searching for code within a specific file or set of 2-3 files, use the ${FileReadTool.name} tool instead of the Agent tool, to find the match more quickly
+- Other tasks that are not related to the agent descriptions above
 
 Usage notes:
 1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
 2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
 3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
 4. The agent's outputs should generally be trusted
-5. Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent`
+5. Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
+6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
+
+Example usage:
+
+<example_agent_descriptions>
+"code-reviewer": use this agent after you are done writing a signficant piece of code
+"greeting-responder": use this agent when to respond to user greetings with a friendly joke
+</example_agent_description>
+
+<example>
+user: "Please write a function that checks if a number is prime"
+assistant: Sure let me write a function that checks if a number is prime
+assistant: First let me use the ${FileWriteTool.name} tool to write a function that checks if a number is prime
+assistant: I'm going to use the ${FileWriteTool.name} tool to write the following code:
+<code>
+function isPrime(n) {
+  if (n <= 1) return false
+  for (let i = 2; i * i <= n; i++) {
+    if (n % i === 0) return false
+  }
+  return true
+}
+</code>
+<commentary>
+Since a signficant piece of code was written and the task was completed, now use the code-reviewer agent to review the code
+</commentary>
+assistant: Now let me use the code-reviewer agent to review the code
+assistant: Uses the Task tool to launch the with the code-reviewer agent 
+</example>
+
+<example>
+user: "Hello"
+<commentary>
+Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
+</commentary>
+assistant: "I'm going to use the Task tool to launch the with the greeting-responder agent"
+</example>`
 }

package/src/tools/ThinkTool/ThinkTool.tsx

@@ -46,9 +46,7 @@ export const ThinkTool = {
 
   renderToolUseRejectedMessage() {
     return (
-      <MessageResponse>
-        <Text color={getTheme().error}>Thought cancelled</Text>
-      </MessageResponse>
+      <MessageResponse children={<Text color={getTheme().error}>Thought cancelled</Text>} />
     )
   },
 

package/src/tools/TodoWriteTool/TodoWriteTool.tsx

@@ -110,7 +110,7 @@ export const TodoWriteTool = {
   },
   inputSchema,
   userFacingName() {
-    return 'Write Todos'
+    return 'Update Todos'
   },
   async isEnabled() {
     return true
@@ -129,22 +129,32 @@ export const TodoWriteTool = {
     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 ''
+    // Show a simple confirmation message when the tool is being used
+    return '{ params.todo }'
   },
   renderToolUseRejectedMessage() {
     return <FallbackToolUseRejectedMessage />
   },
-  renderToolResultMessage(output, { verbose }) {
+  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
+    // For non-error output, get current todos from storage and render them
+    if (!isError && typeof output === 'string') {
+      const currentTodos = getTodos()
+      
+      if (currentTodos.length === 0) {
+        return (
+          <Box flexDirection="column" width="100%">
+            <Box flexDirection="row">
+              <Text color="#6B7280">&nbsp;&nbsp;⎿ &nbsp;</Text>
+              <Text color="#9CA3AF">No todos currently</Text>
+            </Box>
+          </Box>
+        )
+      }
 
-      // sort: [completed, in_progress, pending]
-      newTodos.sort((a, b) => {
+      // Sort: [completed, in_progress, pending]
+      const sortedTodos = [...currentTodos].sort((a, b) => {
         const order = ['completed', 'in_progress', 'pending']
         return (
           order.indexOf(a.status) - order.indexOf(b.status) ||
@@ -152,40 +162,52 @@ export const TodoWriteTool = {
         )
       })
 
-      // Render each todo item with proper styling
+      // Find the next pending task (first pending task after sorting)
+      const nextPendingIndex = sortedTodos.findIndex(todo => todo.status === 'pending')
+
       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]
+        <Box flexDirection="column" width="100%">
+          {sortedTodos.map((todo: TodoItem, index: number) => {
+            // Determine checkbox symbol and colors
+            let checkbox: string
+            let textColor: string
+            let isBold = false
+            let isStrikethrough = false
 
-                const status_color_map = {
-                  completed: '#008000',
-                  in_progress: '#008000',
-                  pending: '#FFD700',
-                }
-                const text_color = status_color_map[todo.status]
+            if (todo.status === 'completed') {
+              checkbox = '☒'
+              textColor = '#6B7280' // Professional gray for completed
+              isStrikethrough = true
+            } else if (todo.status === 'in_progress') {
+              checkbox = '☐'
+              textColor = '#10B981' // Professional green for in progress
+              isBold = true
+            } else if (todo.status === 'pending') {
+              checkbox = '☐'
+              // Only the FIRST pending task gets purple highlight
+              if (index === nextPendingIndex) {
+                textColor = '#8B5CF6' // Professional purple for next pending
+                isBold = true
+              } else {
+                textColor = '#9CA3AF' // Muted gray for other pending
+              }
+            }
 
-                return (
-                  <Text
-                    key={todo.id || index}
-                    color={text_color}
-                    bold={todo.status !== 'pending'}
-                    strikethrough={todo.status === 'completed'}
-                  >
-                    {checkbox} {todo.content}
+            return (
+              <Box key={todo.id || index} flexDirection="row" marginBottom={0}>
+                <Text color="#6B7280">&nbsp;&nbsp;⎿ &nbsp;</Text>
+                <Box flexDirection="row" flexGrow={1}>
+                  <Text color={textColor} bold={isBold} strikethrough={isStrikethrough}>
+                    {checkbox}
                   </Text>
-                )
-              })}
-            </Box>
-          </Box>
+                  <Text> </Text>
+                  <Text color={textColor} bold={isBold} strikethrough={isStrikethrough}>
+                    {todo.content}
+                  </Text>
+                </Box>
+              </Box>
+            )
+          })}
         </Box>
       )
     }
@@ -263,8 +285,10 @@ export const TodoWriteTool = {
 
       yield {
         type: 'result',
-        data: resultData,
+        data: summary, // Return string to satisfy interface
         resultForAssistant: summary,
+        // Store todo data in a way accessible to the renderer
+        // We'll modify the renderToolResultMessage to get todos from storage
       }
     } catch (error) {
       const errorMessage =

package/src/tools/lsTool/lsTool.tsx

@@ -63,7 +63,8 @@ export const LSTool = {
   renderToolUseRejectedMessage() {
     return <FallbackToolUseRejectedMessage />
   },
-  renderToolResultMessage(content, { verbose }) {
+  renderToolResultMessage(content) {
+    const verbose = false // Set default value for verbose
     if (typeof content !== 'string') {
       return null
     }
@@ -81,7 +82,9 @@ export const LSTool = {
               .filter(_ => _.trim() !== '')
               .slice(0, verbose ? undefined : MAX_LINES)
               .map((_, i) => (
-                <Text key={i}>{_}</Text>
+                <React.Fragment key={i}>
+                  <Text>{_}</Text>
+                </React.Fragment>
               ))}
             {!verbose && result.split('\n').length > MAX_LINES && (
               <Text color={getTheme().secondaryText}>

package/src/tools.ts

@@ -19,25 +19,25 @@ import { TodoWriteTool } from './tools/TodoWriteTool/TodoWriteTool'
 import { getMCPTools } from './services/mcpClient'
 import { memoize } from 'lodash-es'
 
-const ANT_ONLY_TOOLS = [MemoryReadTool, MemoryWriteTool]
+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,
-    AskExpertModelTool,
-    BashTool,
-    GlobTool,
-    GrepTool,
-    LSTool,
-    FileReadTool,
-    FileEditTool,
-    MultiEditTool,
-    FileWriteTool,
-    NotebookReadTool,
-    NotebookEditTool,
-    ThinkTool,
-    TodoWriteTool,
+    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,
   ]
 }
@@ -48,7 +48,7 @@ export const getTools = memoize(
 
     // Only include Architect tool if enabled via config or CLI flag
     if (enableArchitect) {
-      tools.push(ArchitectTool)
+      tools.push(ArchitectTool as unknown as Tool)
     }
 
     const isEnabled = await Promise.all(tools.map(tool => tool.isEnabled()))

package/src/types/conversation.ts

@@ -0,0 +1,51 @@
+// Type definitions for conversation and message functionality
+// Used by debugLogger and other conversation-related utilities
+
+import { UUID } from 'crypto'
+import type { MessageParam } from '@anthropic-ai/sdk/resources/index.mjs'
+import type { Message as APIAssistantMessage } from '@anthropic-ai/sdk/resources/index.mjs'
+
+/**
+ * Base message interface used throughout the conversation system
+ * This is a union type that matches the Message type from query.ts
+ */
+export type Message = UserMessage | AssistantMessage | ProgressMessage
+
+/**
+ * User message structure
+ */
+export interface UserMessage {
+  message: MessageParam
+  type: 'user'
+  uuid: UUID
+  toolUseResult?: any // FullToolUseResult type
+  options?: {
+    isKodingRequest?: boolean
+    kodingContext?: string
+  }
+}
+
+/**
+ * Assistant message structure
+ */
+export interface AssistantMessage {
+  costUSD: number
+  durationMs: number
+  message: APIAssistantMessage
+  type: 'assistant'
+  uuid: UUID
+  isApiErrorMessage?: boolean
+}
+
+/**
+ * Progress message structure for tool execution
+ */
+export interface ProgressMessage {
+  content: AssistantMessage
+  normalizedMessages: any[] // NormalizedMessage type
+  siblingToolUseIDs: Set<string>
+  tools: any[] // Tool type
+  toolUseID: string
+  type: 'progress'
+  uuid: UUID
+}

package/src/types/logs.ts

@@ -0,0 +1,58 @@
+// Type definitions for log-related functionality
+// Used by log selector, log list, and log utilities
+
+import { UUID } from 'crypto'
+
+/**
+ * Serialized message structure stored in log files
+ * Based on how messages are serialized and deserialized in log.ts
+ */
+export interface SerializedMessage {
+  type: 'user' | 'assistant' | 'progress'
+  uuid: UUID
+  message?: {
+    content: string | Array<{ type: string; text?: string }>
+    role: 'user' | 'assistant' | 'system'
+  }
+  costUSD?: number
+  durationMs?: number
+  timestamp: string
+  cwd?: string
+  userType?: string
+  sessionId?: string
+  version?: string
+}
+
+/**
+ * Log option representing a single conversation log
+ * Used by LogSelector and LogList components
+ */
+export interface LogOption {
+  // File metadata
+  date: string
+  fullPath: string
+  value: number // Index in the logs array
+  
+  // Timestamps for sorting
+  created: Date
+  modified: Date
+  
+  // Content metadata
+  firstPrompt: string
+  messageCount: number
+  messages: SerializedMessage[]
+  
+  // Fork and branch info
+  forkNumber?: number
+  sidechainNumber?: number
+}
+
+/**
+ * Props for LogList component
+ * Used by LogList.tsx
+ */
+export interface LogListProps {
+  context: {
+    unmount?: () => void
+  }
+}

package/src/types/modelCapabilities.ts

@@ -0,0 +1,64 @@
+// Model capability type definitions for unified API support
+export interface ModelCapabilities {
+  // API architecture type
+  apiArchitecture: {
+    primary: 'chat_completions' | 'responses_api'
+    fallback?: 'chat_completions'  // Responses API models can fallback
+  }
+  
+  // Parameter mapping
+  parameters: {
+    maxTokensField: 'max_tokens' | 'max_completion_tokens'
+    supportsReasoningEffort: boolean
+    supportsVerbosity: boolean
+    temperatureMode: 'flexible' | 'fixed_one' | 'restricted'
+  }
+  
+  // Tool calling capabilities
+  toolCalling: {
+    mode: 'none' | 'function_calling' | 'custom_tools'
+    supportsFreeform: boolean
+    supportsAllowedTools: boolean
+    supportsParallelCalls: boolean
+  }
+  
+  // State management
+  stateManagement: {
+    supportsResponseId: boolean
+    supportsConversationChaining: boolean
+    supportsPreviousResponseId: boolean
+  }
+  
+  // Streaming support
+  streaming: {
+    supported: boolean
+    includesUsage: boolean
+  }
+}
+
+// Unified request parameters
+export interface UnifiedRequestParams {
+  messages: any[]
+  systemPrompt: string[]
+  tools?: any[]
+  maxTokens: number
+  stream?: boolean
+  previousResponseId?: string
+  reasoningEffort?: 'minimal' | 'low' | 'medium' | 'high'
+  verbosity?: 'low' | 'medium' | 'high'
+  temperature?: number
+  allowedTools?: string[]
+}
+
+// Unified response format
+export interface UnifiedResponse {
+  id: string
+  content: string
+  toolCalls?: any[]
+  usage: {
+    promptTokens: number
+    completionTokens: number
+    reasoningTokens?: number
+  }
+  responseId?: string  // For Responses API state management
+}

package/src/types/notebook.ts

@@ -0,0 +1,87 @@
+// Type definitions for Jupyter notebook functionality
+// Used by NotebookReadTool and NotebookEditTool
+
+/**
+ * Valid notebook cell types
+ */
+export type NotebookCellType = 'code' | 'markdown'
+
+/**
+ * Notebook output image structure
+ */
+export interface NotebookOutputImage {
+  image_data: string
+  media_type: 'image/png' | 'image/jpeg'
+}
+
+/**
+ * Processed notebook cell output for display
+ */
+export interface NotebookCellSourceOutput {
+  output_type: 'stream' | 'execute_result' | 'display_data' | 'error'
+  text?: string
+  image?: NotebookOutputImage
+}
+
+/**
+ * Processed notebook cell structure used by tools
+ */
+export interface NotebookCellSource {
+  cell: number // Cell index
+  cellType: NotebookCellType
+  source: string
+  language: string
+  execution_count?: number | null
+  outputs?: NotebookCellSourceOutput[]
+}
+
+/**
+ * Raw notebook cell output from .ipynb file
+ */
+export interface NotebookCellOutput {
+  output_type: 'stream' | 'execute_result' | 'display_data' | 'error'
+  name?: string
+  text?: string | string[]
+  data?: Record<string, unknown>
+  execution_count?: number | null
+  metadata?: Record<string, unknown>
+  // For error outputs
+  ename?: string
+  evalue?: string
+  traceback?: string[]
+}
+
+/**
+ * Raw notebook cell structure from .ipynb file
+ */
+export interface NotebookCell {
+  cell_type: NotebookCellType
+  source: string | string[]
+  metadata: Record<string, unknown>
+  execution_count?: number | null
+  outputs?: NotebookCellOutput[]
+  id?: string
+}
+
+/**
+ * Complete notebook structure from .ipynb file
+ */
+export interface NotebookContent {
+  cells: NotebookCell[]
+  metadata: {
+    kernelspec?: {
+      display_name?: string
+      language?: string
+      name?: string
+    }
+    language_info?: {
+      name?: string
+      version?: string
+      mimetype?: string
+      file_extension?: string
+    }
+    [key: string]: unknown
+  }
+  nbformat: number
+  nbformat_minor: number
+}