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

package/src/tools/WebSearchTool/WebSearchTool.tsx

@@ -1,103 +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, ToolUseContext } from '../../Tool'
-import { DESCRIPTION, TOOL_NAME_FOR_PROMPT } from './prompt'
-import { SearchResult, searchProviders } from './searchProviders'
-
-const inputSchema = z.strictObject({
-  query: z.string().describe('The search query'),
-})
-
-type Input = z.infer<typeof inputSchema>
-type Output = {
-  durationMs: number
-  results: SearchResult[]
-}
-
-
-export const WebSearchTool = {
-  name: TOOL_NAME_FOR_PROMPT,
-  async description() {
-    return DESCRIPTION
-  },
-  userFacingName: () => 'Web Search',
-  inputSchema,
-  isReadOnly: () => true,
-  isConcurrencySafe: () => true,
-  async isEnabled() {
-    return true
-  },
-  needsPermissions() {
-    return false
-  },
-  async prompt() {
-    return DESCRIPTION
-  },
-  renderToolUseMessage({ query }: Input) {
-    return `Searching for: "${query}" using DuckDuckGo`
-  },
-  renderToolUseRejectedMessage() {
-    return <FallbackToolUseRejectedMessage />
-  },
-  renderToolResultMessage(output: Output) {
-    return (
-      <Box justifyContent="space-between" width="100%">
-        <Box flexDirection="row">
-          <Text>&nbsp;&nbsp;⎿ &nbsp;Found </Text>
-          <Text bold>{output.results.length} </Text>
-          <Text>
-            {output.results.length === 1 ? 'result' : 'results'} using DuckDuckGo
-          </Text>
-        </Box>
-        <Cost costUSD={0} durationMs={output.durationMs} debug={false} />
-      </Box>
-    )
-  },
-  renderResultForAssistant(output: Output) {
-    if (output.results.length === 0) {
-      return `No results found using DuckDuckGo.`
-    }
-    
-    let result = `Found ${output.results.length} search results using DuckDuckGo:\n\n`
-    
-    output.results.forEach((item, index) => {
-      result += `${index + 1}. **${item.title}**\n`
-      result += `   ${item.snippet}\n`
-      result += `   Link: ${item.link}\n\n`
-    })
-    
-    result += `You can reference these results to provide current, accurate information to the user.`
-    return result
-  },
-  async *call({ query }: Input, {}: ToolUseContext) {
-    const start = Date.now()
-
-    try {
-      const searchResults = await searchProviders.duckduckgo.search(query)
-      
-      const output: Output = {
-        results: searchResults,
-        durationMs: Date.now() - start,
-      }
-
-      yield {
-        type: 'result' as const,
-        resultForAssistant: this.renderResultForAssistant(output),
-        data: output,
-      }
-    } catch (error: any) {
-      const output: Output = {
-        results: [],
-        durationMs: Date.now() - start,
-      }
-      yield {
-        type: 'result' as const,
-        resultForAssistant: `An error occurred during web search with DuckDuckGo: ${error.message}`,
-        data: output,
-      }
-    }
-  },
-} satisfies Tool<typeof inputSchema, Output>

package/src/tools/WebSearchTool/prompt.ts

@@ -1,13 +0,0 @@
-
-export const TOOL_NAME_FOR_PROMPT = 'WebSearch'
-export const DESCRIPTION = `- Allows Kode to search the web and use the results to inform responses
-- Provides up-to-date information for current events and recent data
-- Returns search result information formatted as search result blocks
-- Use this tool for accessing information beyond the Kode's knowledge cutoff
-- Searches are performed automatically within a single API call using DuckDuckGo
-
-Usage notes:
-- Use when you need current information not in training data
-- Effective for recent news, current events, product updates, or real-time data
-- Search queries should be specific and well-targeted for best results
-- Results include both title and snippet content for context`

package/src/tools/WebSearchTool/searchProviders.ts

@@ -1,66 +0,0 @@
-import fetch from 'node-fetch'
-import { parse } from 'node-html-parser'
-
-export interface SearchResult {
-  title: string
-  snippet: string
-  link: string
-}
-
-export interface SearchProvider {
-  search: (query: string, apiKey?: string) => Promise<SearchResult[]>
-  isEnabled: (apiKey?: string) => boolean
-}
-
-
-const duckDuckGoSearchProvider: SearchProvider = {
-  isEnabled: () => true,
-  search: async (query: string): Promise<SearchResult[]> => {
-    const response = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`, {
-        headers: {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-        }
-    });
-
-    if (!response.ok) {
-        throw new Error(`DuckDuckGo search failed with status: ${response.status}`);
-    }
-
-    const html = await response.text();
-    const root = parse(html);
-    const results: SearchResult[] = [];
-
-    const resultNodes = root.querySelectorAll('.result.web-result');
-
-    for (const node of resultNodes) {
-        const titleNode = node.querySelector('.result__a');
-        const snippetNode = node.querySelector('.result__snippet');
-
-        if (titleNode && snippetNode) {
-            const title = titleNode.text;
-            const link = titleNode.getAttribute('href');
-            const snippet = snippetNode.text;
-
-            if (title && link && snippet) {
-                // Clean the link - DuckDuckGo doesn't use uddg parameter anymore
-                let cleanLink = link;
-                if (link.startsWith('https://duckduckgo.com/l/?uddg=')) {
-                    try {
-                        const url = new URL(link);
-                        cleanLink = url.searchParams.get('uddg') || link;
-                    } catch {
-                        cleanLink = link;
-                    }
-                }
-                results.push({ title: title.trim(), snippet: snippet.trim(), link: cleanLink });
-            }
-        }
-    }
-
-    return results;
-  },
-}
-
-export const searchProviders = {
-  duckduckgo: duckDuckGoSearchProvider,
-}

package/src/tools/lsTool/lsTool.tsx

@@ -1,272 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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 { WebSearchTool } from './tools/WebSearchTool/WebSearchTool'
-import { URLFetcherTool } from './tools/URLFetcherTool/URLFetcherTool'
-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,
-    WebSearchTool as unknown as Tool,
-    URLFetcherTool 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])
-})

package/src/types/PermissionMode.ts

@@ -1,120 +0,0 @@
-// Permission mode types based on original Claude Code implementation
-export type PermissionMode =
-  | 'default'
-  | 'acceptEdits'
-  | 'plan'
-  | 'bypassPermissions'
-
-export interface PermissionContext {
-  mode: PermissionMode
-  allowedTools: string[]
-  allowedPaths: string[]
-  restrictions: {
-    readOnly: boolean
-    requireConfirmation: boolean
-    bypassValidation: boolean
-  }
-  metadata: {
-    activatedAt?: string
-    previousMode?: PermissionMode
-    transitionCount: number
-  }
-}
-
-export interface ModeConfig {
-  name: PermissionMode
-  label: string
-  icon: string
-  color: string
-  description: string
-  allowedTools: string[]
-  restrictions: {
-    readOnly: boolean
-    requireConfirmation: boolean
-    bypassValidation: boolean
-  }
-}
-
-// Mode configuration based on original Claude Code
-export const MODE_CONFIGS: Record<PermissionMode, ModeConfig> = {
-  default: {
-    name: 'default',
-    label: 'DEFAULT',
-    icon: '🔒',
-    color: 'blue',
-    description: 'Standard permission checking',
-    allowedTools: ['*'],
-    restrictions: {
-      readOnly: false,
-      requireConfirmation: true,
-      bypassValidation: false,
-    },
-  },
-  acceptEdits: {
-    name: 'acceptEdits',
-    label: 'ACCEPT EDITS',
-    icon: '✅',
-    color: 'green',
-    description: 'Auto-approve edit operations',
-    allowedTools: ['*'],
-    restrictions: {
-      readOnly: false,
-      requireConfirmation: false,
-      bypassValidation: false,
-    },
-  },
-  plan: {
-    name: 'plan',
-    label: 'PLAN MODE',
-    icon: '📝',
-    color: 'yellow',
-    description: 'Research and planning - read-only tools only',
-    allowedTools: [
-      'Read',
-      'Grep',
-      'Glob',
-      'LS',
-      'WebSearch',
-      'WebFetch',
-      'NotebookRead',
-      'exit_plan_mode',
-    ],
-    restrictions: {
-      readOnly: true,
-      requireConfirmation: true,
-      bypassValidation: false,
-    },
-  },
-  bypassPermissions: {
-    name: 'bypassPermissions',
-    label: 'BYPASS PERMISSIONS',
-    icon: '🔓',
-    color: 'red',
-    description: 'All permissions bypassed',
-    allowedTools: ['*'],
-    restrictions: {
-      readOnly: false,
-      requireConfirmation: false,
-      bypassValidation: true,
-    },
-  },
-}
-
-// Mode cycling function (based on original yg2 function)
-export function getNextPermissionMode(
-  currentMode: PermissionMode,
-  isBypassAvailable: boolean = true,
-): PermissionMode {
-  switch (currentMode) {
-    case 'default':
-      return 'acceptEdits'
-    case 'acceptEdits':
-      return 'plan'
-    case 'plan':
-      return isBypassAvailable ? 'bypassPermissions' : 'default'
-    case 'bypassPermissions':
-      return 'default'
-    default:
-      return 'default'
-  }
-}