@shareai-lab/kode 1.1.13 → 1.1.16

package/src/tools/TodoWriteTool/TodoWriteTool.tsx

@@ -1,313 +0,0 @@
-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 'Update 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 }) {
-    // Show a simple confirmation message when the tool is being used
-    return '{ params.todo }'
-  },
-  renderToolUseRejectedMessage() {
-    return <FallbackToolUseRejectedMessage />
-  },
-  renderToolResultMessage(output) {
-    const isError = typeof output === 'string' && output.startsWith('Error')
-
-    // 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]
-      const sortedTodos = [...currentTodos].sort((a, b) => {
-        const order = ['completed', 'in_progress', 'pending']
-        return (
-          order.indexOf(a.status) - order.indexOf(b.status) ||
-          a.content.localeCompare(b.content)
-        )
-      })
-
-      // Find the next pending task (first pending task after sorting)
-      const nextPendingIndex = sortedTodos.findIndex(todo => todo.status === 'pending')
-
-      return (
-        <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
-
-            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 (
-              <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>
-                  <Text> </Text>
-                  <Text color={textColor} bold={isBold} strikethrough={isStrikethrough}>
-                    {todo.content}
-                  </Text>
-                </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 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 =
-        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

@@ -1,63 +0,0 @@
-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/URLFetcherTool/URLFetcherTool.tsx

@@ -1,178 +0,0 @@
-import { Box, Text } from 'ink'
-import React from 'react'
-import { z } from 'zod'
-import fetch from 'node-fetch'
-import { Cost } from '../../components/Cost'
-import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
-import { Tool, ToolUseContext } from '../../Tool'
-import { DESCRIPTION, TOOL_NAME_FOR_PROMPT } from './prompt'
-import { convertHtmlToMarkdown } from './htmlToMarkdown'
-import { urlCache } from './cache'
-import { queryQuick } from '../../services/claude'
-
-const inputSchema = z.strictObject({
-  url: z.string().url().describe('The URL to fetch content from'),
-  prompt: z.string().describe('The prompt to run on the fetched content'),
-})
-
-type Input = z.infer<typeof inputSchema>
-type Output = {
-  url: string
-  fromCache: boolean
-  aiAnalysis: string
-}
-
-function normalizeUrl(url: string): string {
-  // Auto-upgrade HTTP to HTTPS
-  if (url.startsWith('http://')) {
-    return url.replace('http://', 'https://')
-  }
-  return url
-}
-
-export const URLFetcherTool = {
-  name: TOOL_NAME_FOR_PROMPT,
-  async description() {
-    return DESCRIPTION
-  },
-  userFacingName: () => 'URL Fetcher',
-  inputSchema,
-  isReadOnly: () => true,
-  isConcurrencySafe: () => true,
-  async isEnabled() {
-    return true
-  },
-  needsPermissions() {
-    return false
-  },
-  async prompt() {
-    return DESCRIPTION
-  },
-  renderToolUseMessage({ url, prompt }: Input) {
-    return `Fetching content from ${url} and analyzing with prompt: "${prompt}"`
-  },
-  renderToolUseRejectedMessage() {
-    return <FallbackToolUseRejectedMessage />
-  },
-  renderToolResultMessage(output: Output) {
-    const statusText = output.fromCache ? 'from cache' : 'fetched'
-    
-    return (
-      <Box justifyContent="space-between" width="100%">
-        <Box flexDirection="row">
-          <Text>&nbsp;&nbsp;⎿ &nbsp;Content </Text>
-          <Text bold>{statusText} </Text>
-          <Text>and analyzed</Text>
-        </Box>
-        <Cost costUSD={0} durationMs={0} debug={false} />
-      </Box>
-    )
-  },
-  renderResultForAssistant(output: Output) {
-    if (!output.aiAnalysis.trim()) {
-      return `No content could be analyzed from URL: ${output.url}`
-    }
-    
-    return output.aiAnalysis
-  },
-  async *call({ url, prompt }: Input, {}: ToolUseContext) {
-    const normalizedUrl = normalizeUrl(url)
-    
-    try {
-      let content: string
-      let fromCache = false
-
-      // Check cache first
-      const cachedContent = urlCache.get(normalizedUrl)
-      if (cachedContent) {
-        content = cachedContent
-        fromCache = true
-      } else {
-        // Fetch from URL with AbortController for timeout
-        const abortController = new AbortController()
-        const timeout = setTimeout(() => abortController.abort(), 30000)
-        
-        const response = await fetch(normalizedUrl, {
-          method: 'GET',
-          headers: {
-            'User-Agent': 'Mozilla/5.0 (compatible; URLFetcher/1.0)',
-            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-            'Accept-Language': 'en-US,en;q=0.5',
-            'Accept-Encoding': 'gzip, deflate',
-            'Connection': 'keep-alive',
-            'Upgrade-Insecure-Requests': '1',
-          },
-          signal: abortController.signal,
-          redirect: 'follow',
-        })
-        
-        clearTimeout(timeout)
-
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`)
-        }
-
-        const contentType = response.headers.get('content-type') || ''
-        if (!contentType.includes('text/') && !contentType.includes('application/')) {
-          throw new Error(`Unsupported content type: ${contentType}`)
-        }
-
-        const html = await response.text()
-        content = convertHtmlToMarkdown(html)
-        
-        // Cache the result
-        urlCache.set(normalizedUrl, content)
-        fromCache = false
-      }
-
-      // Truncate content if too large (keep within reasonable token limits)
-      const maxContentLength = 50000 // ~15k tokens approximately
-      const truncatedContent = content.length > maxContentLength 
-        ? content.substring(0, maxContentLength) + '\n\n[Content truncated due to length]'
-        : content
-
-      // AI Analysis - always performed fresh, even with cached content
-      const systemPrompt = [
-        'You are analyzing web content based on a user\'s specific request.',
-        'The content has been extracted from a webpage and converted to markdown.',
-        'Provide a focused response that directly addresses the user\'s prompt.',
-      ]
-
-      const userPrompt = `Here is the content from ${normalizedUrl}:
-
-${truncatedContent}
-
-User request: ${prompt}`
-
-      const aiResponse = await queryQuick({
-        systemPrompt,
-        userPrompt,
-        enablePromptCaching: false,
-      })
-
-      const output: Output = {
-        url: normalizedUrl,
-        fromCache,
-        aiAnalysis: aiResponse.message.content[0]?.text || 'Unable to analyze content',
-      }
-
-      yield {
-        type: 'result' as const,
-        resultForAssistant: this.renderResultForAssistant(output),
-        data: output,
-      }
-    } catch (error: any) {
-      const output: Output = {
-        url: normalizedUrl,
-        fromCache: false,
-        aiAnalysis: '',
-      }
-      
-      yield {
-        type: 'result' as const,
-        resultForAssistant: `Error processing URL ${normalizedUrl}: ${error.message}`,
-        data: output,
-      }
-    }
-  },
-} satisfies Tool<typeof inputSchema, Output>

package/src/tools/URLFetcherTool/cache.ts

@@ -1,55 +0,0 @@
-interface CacheEntry {
-  content: string
-  timestamp: number
-}
-
-class URLCache {
-  private cache = new Map<string, CacheEntry>()
-  private readonly CACHE_DURATION = 15 * 60 * 1000 // 15 minutes in milliseconds
-
-  set(url: string, content: string): void {
-    this.cache.set(url, {
-      content,
-      timestamp: Date.now()
-    })
-  }
-
-  get(url: string): string | null {
-    const entry = this.cache.get(url)
-    if (!entry) {
-      return null
-    }
-
-    // Check if entry has expired
-    if (Date.now() - entry.timestamp > this.CACHE_DURATION) {
-      this.cache.delete(url)
-      return null
-    }
-
-    return entry.content
-  }
-
-  clear(): void {
-    this.cache.clear()
-  }
-
-  // Clean expired entries
-  private cleanExpired(): void {
-    const now = Date.now()
-    for (const [url, entry] of this.cache.entries()) {
-      if (now - entry.timestamp > this.CACHE_DURATION) {
-        this.cache.delete(url)
-      }
-    }
-  }
-
-  // Auto-clean expired entries every 5 minutes
-  constructor() {
-    setInterval(() => {
-      this.cleanExpired()
-    }, 5 * 60 * 1000) // 5 minutes
-  }
-}
-
-// Export singleton instance
-export const urlCache = new URLCache()

package/src/tools/URLFetcherTool/htmlToMarkdown.ts

@@ -1,55 +0,0 @@
-import TurndownService from 'turndown'
-
-const turndownService = new TurndownService({
-  headingStyle: 'atx',
-  hr: '---',
-  bulletListMarker: '-',
-  codeBlockStyle: 'fenced',
-  fence: '```',
-  emDelimiter: '_',
-  strongDelimiter: '**'
-})
-
-// Configure rules to handle common HTML elements
-turndownService.addRule('removeScripts', {
-  filter: ['script', 'style', 'noscript'],
-  replacement: () => ''
-})
-
-turndownService.addRule('removeComments', {
-  filter: (node) => node.nodeType === 8, // Comment nodes
-  replacement: () => ''
-})
-
-turndownService.addRule('cleanLinks', {
-  filter: 'a',
-  replacement: (content, node) => {
-    const href = node.getAttribute('href')
-    if (!href || href.startsWith('javascript:') || href.startsWith('#')) {
-      return content
-    }
-    return `[${content}](${href})`
-  }
-})
-
-export function convertHtmlToMarkdown(html: string): string {
-  try {
-    // Clean up the HTML before conversion
-    const cleanHtml = html
-      .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '') // Remove script tags
-      .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '') // Remove style tags
-      .replace(/<!--[\s\S]*?-->/g, '') // Remove HTML comments
-      .replace(/\s+/g, ' ') // Normalize whitespace
-      .trim()
-
-    const markdown = turndownService.turndown(cleanHtml)
-    
-    // Clean up the resulting markdown
-    return markdown
-      .replace(/\n{3,}/g, '\n\n') // Remove excessive line breaks
-      .replace(/^\s+|\s+$/gm, '') // Remove leading/trailing spaces on each line
-      .trim()
-  } catch (error) {
-    throw new Error(`Failed to convert HTML to markdown: ${error instanceof Error ? error.message : String(error)}`)
-  }
-}

package/src/tools/URLFetcherTool/prompt.ts

@@ -1,17 +0,0 @@
-export const TOOL_NAME_FOR_PROMPT = 'URLFetcher'
-export const DESCRIPTION = `- Fetches content from a specified URL and processes it using an AI model
-- Takes a URL and a prompt as input
-- Fetches the URL content, converts HTML to markdown
-- Processes the content with the prompt using a small, fast model
-- Returns the model's response about the content
-- Use this tool when you need to retrieve and analyze web content
-
-Usage notes:
-- IMPORTANT: If an MCP-provided web fetch tool is available, prefer using that tool instead of this one, as it may have fewer restrictions. All MCP-provided tools start with "mcp__".
-- The URL must be a fully-formed valid URL (e.g., https://example.com)
-- HTTP URLs will be automatically upgraded to HTTPS
-- The prompt should describe what information you want to extract from the page
-- This tool is read-only and does not modify any files
-- Results may be summarized if the content is very large
-- Includes a self-cleaning 15-minute cache for faster responses when repeatedly accessing the same URL
-- When a URL redirects, the tool will inform you and provide the redirect URL in a special format. You should then make a new URLFetcher request with the redirect URL to fetch the content.`