@shareai-lab/kode 1.1.13 → 1.1.16

package/src/entrypoints/mcp.ts

@@ -1,175 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js'
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
-import {
-  CallToolRequestSchema,
-  CallToolResultSchema,
-  ListToolsRequestSchema,
-  ListToolsResultSchema,
-  ToolSchema,
-} from '@modelcontextprotocol/sdk/types.js'
-import { z } from 'zod'
-import { zodToJsonSchema } from 'zod-to-json-schema'
-import { TaskTool } from '../tools/TaskTool/TaskTool'
-import { hasPermissionsToUseTool } from '../permissions'
-import { setCwd } from '../utils/state'
-import { getModelManager } from '../utils/model'
-import { logError } from '../utils/log'
-import { LSTool } from '../tools/lsTool/lsTool'
-import { BashTool } from '../tools/BashTool/BashTool'
-import { FileEditTool } from '../tools/FileEditTool/FileEditTool'
-import { FileReadTool } from '../tools/FileReadTool/FileReadTool'
-import { GlobTool } from '../tools/GlobTool/GlobTool'
-import { GrepTool } from '../tools/GrepTool/GrepTool'
-import { FileWriteTool } from '../tools/FileWriteTool/FileWriteTool'
-import { Tool } from '../Tool'
-import { Command } from '../commands'
-import review from '../commands/review'
-import { lastX } from '../utils/generators'
-import { MACRO } from '../constants/macros'
-type ToolInput = z.infer<typeof ToolSchema.shape.inputSchema>
-
-const state: {
-  readFileTimestamps: Record<string, number>
-} = {
-  readFileTimestamps: {},
-}
-
-const MCP_COMMANDS: Command[] = [review]
-
-const MCP_TOOLS: Tool[] = [
-  TaskTool as unknown as Tool,
-  BashTool as unknown as Tool,
-  FileEditTool as unknown as Tool,
-  FileReadTool as unknown as Tool,
-  GlobTool as unknown as Tool,
-  GrepTool as unknown as Tool,
-  FileWriteTool as unknown as Tool,
-  LSTool as unknown as Tool,
-]
-
-export async function startMCPServer(cwd: string): Promise<void> {
-  await setCwd(cwd)
-  const server = new Server(
-    {
-      name: 'claude/tengu',
-      version: MACRO.VERSION,
-    },
-    {
-      capabilities: {
-        tools: {},
-      },
-    },
-  )
-
-  server.setRequestHandler(
-    ListToolsRequestSchema,
-    async (): Promise<z.infer<typeof ListToolsResultSchema>> => {
-      const tools = await Promise.all(
-        MCP_TOOLS.map(async tool => ({
-          ...tool,
-          description: await tool.description(),
-          inputSchema: zodToJsonSchema(tool.inputSchema) as ToolInput,
-        })),
-      )
-
-      return {
-        tools,
-      }
-    },
-  )
-
-  server.setRequestHandler(
-    CallToolRequestSchema,
-    async (request): Promise<z.infer<typeof CallToolResultSchema>> => {
-      const { name, arguments: args } = request.params
-      const tool = MCP_TOOLS.find(_ => _.name === name)
-      if (!tool) {
-        throw new Error(`Tool ${name} not found`)
-      }
-
-      // TODO: validate input types with zod
-      try {
-        if (!(await tool.isEnabled())) {
-          throw new Error(`Tool ${name} is not enabled`)
-        }
-        const model = getModelManager().getModelName('main')
-        const validationResult = await tool.validateInput?.(
-          (args as never) ?? {},
-          {
-            abortController: new AbortController(),
-            options: {
-              commands: MCP_COMMANDS,
-              tools: MCP_TOOLS,
-              forkNumber: 0,
-              messageLogName: 'unused',
-              maxThinkingTokens: 0,
-            },
-            messageId: undefined,
-            readFileTimestamps: state.readFileTimestamps,
-          },
-        )
-        if (validationResult && !validationResult.result) {
-          throw new Error(
-            `Tool ${name} input is invalid: ${validationResult.message}`,
-          )
-        }
-        const result = tool.call(
-          (args ?? {}) as never,
-          {
-            abortController: new AbortController(),
-            messageId: undefined,
-            options: {
-              commands: MCP_COMMANDS,
-              tools: MCP_TOOLS,
-              forkNumber: 0,
-              messageLogName: 'unused',
-              maxThinkingTokens: 0,
-            },
-            readFileTimestamps: state.readFileTimestamps,
-          },
-        )
-
-        const finalResult = await lastX(result)
-
-        if (finalResult.type !== 'result') {
-          throw new Error(`Tool ${name} did not return a result`)
-        }
-
-        return {
-          content: Array.isArray(finalResult)
-            ? finalResult.map(item => ({
-                type: 'text' as const,
-                text: 'text' in item ? item.text : JSON.stringify(item),
-              }))
-            : [
-                {
-                  type: 'text' as const,
-                  text:
-                    typeof finalResult === 'string'
-                      ? finalResult
-                      : JSON.stringify(finalResult.data),
-                },
-              ],
-        }
-      } catch (error) {
-        logError(error)
-        return {
-          isError: true,
-          content: [
-            {
-              type: 'text',
-              text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-            },
-          ],
-        }
-      }
-    },
-  )
-
-  async function runServer() {
-    const transport = new StdioServerTransport()
-    await server.connect(transport)
-  }
-
-  return await runServer()
-}

package/src/history.ts

@@ -1,25 +0,0 @@
-import {
-  getCurrentProjectConfig,
-  saveCurrentProjectConfig,
-} from './utils/config.js'
-
-const MAX_HISTORY_ITEMS = 100
-
-export function getHistory(): string[] {
-  return getCurrentProjectConfig().history ?? []
-}
-
-export function addToHistory(command: string): void {
-  const projectConfig = getCurrentProjectConfig()
-  const history = projectConfig.history ?? []
-
-  if (history[0] === command) {
-    return
-  }
-
-  history.unshift(command)
-  saveCurrentProjectConfig({
-    ...projectConfig,
-    history: history.slice(0, MAX_HISTORY_ITEMS),
-  })
-}

package/src/hooks/useApiKeyVerification.ts

@@ -1,59 +0,0 @@
-import { useCallback, useState } from 'react'
-import { verifyApiKey } from '../services/claude'
-import { getAnthropicApiKey } from '../utils/config'
-
-export type VerificationStatus =
-  | 'loading'
-  | 'valid'
-  | 'invalid'
-  | 'missing'
-  | 'error'
-
-export type ApiKeyVerificationResult = {
-  status: VerificationStatus
-  reverify: () => Promise<void>
-  error: Error | null
-}
-
-export function useApiKeyVerification(): ApiKeyVerificationResult {
-  // const [status, setStatus] = useState<VerificationStatus>(() => {
-  //   const apiKey = getAnthropicApiKey()
-  //   return apiKey ? 'loading' : 'missing'
-  // })
-  // const [error, setError] = useState<Error | null>(null)
-
-  // const verify = useCallback(async (): Promise<void> => {
-  //   if (isDefaultApiKey()) {
-  //     setStatus('valid')
-  //     return
-  //   }
-
-  //   const apiKey = getAnthropicApiKey()
-  //   if (!apiKey) {
-  //     const newStatus = 'missing' as const
-  //     setStatus(newStatus)
-  //     return
-  //   }
-
-  //   try {
-  //     const isValid = await verifyApiKey(apiKey)
-  //     const newStatus = isValid ? 'valid' : 'invalid'
-  //     setStatus(newStatus)
-  //     return
-  //   } catch (error) {
-  //     // This happens when there an error response from the API but it's not an invalid API key error
-  //     // In this case, we still mark the API key as invalid - but we also log the error so we can
-  //     // display it to the user to be more helpful
-  //     setError(error as Error)
-  //     const newStatus = 'error' as const
-  //     setStatus(newStatus)
-  //     return
-  //   }
-  // }, [])
-
-  return {
-    status: 'valid',
-    reverify: async () => {},
-    error: null,
-  }
-}

package/src/hooks/useArrowKeyHistory.ts

@@ -1,55 +0,0 @@
-import { useState } from 'react'
-import { getHistory } from '../history'
-
-export function useArrowKeyHistory(
-  onSetInput: (value: string, mode: 'bash' | 'prompt') => void,
-  currentInput: string,
-) {
-  const [historyIndex, setHistoryIndex] = useState(0)
-  const [lastTypedInput, setLastTypedInput] = useState('')
-
-  const updateInput = (input: string | undefined) => {
-    if (input !== undefined) {
-      const mode = input.startsWith('!') ? 'bash' : 'prompt'
-      const value = mode === 'bash' ? input.slice(1) : input
-      onSetInput(value, mode)
-    }
-  }
-
-  function onHistoryUp() {
-    const latestHistory = getHistory()
-    if (historyIndex < latestHistory.length) {
-      if (historyIndex === 0 && currentInput.trim() !== '') {
-        setLastTypedInput(currentInput)
-      }
-      const newIndex = historyIndex + 1
-      setHistoryIndex(newIndex)
-      updateInput(latestHistory[historyIndex])
-    }
-  }
-
-  function onHistoryDown() {
-    const latestHistory = getHistory()
-    if (historyIndex > 1) {
-      const newIndex = historyIndex - 1
-      setHistoryIndex(newIndex)
-      updateInput(latestHistory[newIndex - 1])
-    } else if (historyIndex === 1) {
-      setHistoryIndex(0)
-      updateInput(lastTypedInput)
-    }
-  }
-
-  function resetHistory() {
-    setLastTypedInput('')
-    setHistoryIndex(0)
-  }
-
-  return {
-    historyIndex,
-    setHistoryIndex,
-    onHistoryUp,
-    onHistoryDown,
-    resetHistory,
-  }
-}

package/src/hooks/useCanUseTool.ts

@@ -1,138 +0,0 @@
-import React, { useCallback } from 'react'
-import { hasPermissionsToUseTool } from '../permissions'
-import { logEvent } from '../services/statsig'
-import { BashTool, inputSchema } from '../tools/BashTool/BashTool'
-import { getCommandSubcommandPrefix } from '../utils/commands'
-import { REJECT_MESSAGE } from '../utils/messages'
-import type { Tool as ToolType, ToolUseContext } from '../Tool'
-import { AssistantMessage } from '../query'
-import { ToolUseConfirm } from '../components/permissions/PermissionRequest'
-import { AbortError } from '../utils/errors'
-import { logError } from '../utils/log'
-
-type SetState<T> = React.Dispatch<React.SetStateAction<T>>
-
-export type CanUseToolFn = (
-  tool: ToolType,
-  input: { [key: string]: unknown },
-  toolUseContext: ToolUseContext,
-  assistantMessage: AssistantMessage,
-) => Promise<{ result: true } | { result: false; message: string }>
-
-function useCanUseTool(
-  setToolUseConfirm: SetState<ToolUseConfirm | null>,
-): CanUseToolFn {
-  return useCallback<CanUseToolFn>(
-    async (tool, input, toolUseContext, assistantMessage) => {
-      return new Promise(resolve => {
-        function logCancelledEvent() {
-          logEvent('tengu_tool_use_cancelled', {
-            messageID: assistantMessage.message.id,
-            toolName: tool.name,
-          })
-        }
-
-        function resolveWithCancelledAndAbortAllToolCalls() {
-          resolve({
-            result: false,
-            message: REJECT_MESSAGE,
-          })
-          // Trigger a synthetic assistant message in query(), to cancel
-          // any other pending tool uses and stop further requests to the
-          // API and wait for user input.
-          toolUseContext.abortController.abort()
-        }
-
-        if (toolUseContext.abortController.signal.aborted) {
-          logCancelledEvent()
-          resolveWithCancelledAndAbortAllToolCalls()
-          return
-        }
-
-        return hasPermissionsToUseTool(
-          tool,
-          input,
-          toolUseContext,
-          assistantMessage,
-        )
-          .then(async result => {
-            // Has permissions to use tool, granted in config
-            if (result.result) {
-              logEvent('tengu_tool_use_granted_in_config', {
-                messageID: assistantMessage.message.id,
-                toolName: tool.name,
-              })
-              resolve({ result: true })
-              return
-            }
-
-            const [description, commandPrefix] = await Promise.all([
-              tool.description(input as never),
-              tool === BashTool
-                ? getCommandSubcommandPrefix(
-                    inputSchema.parse(input).command, // already validated upstream, so ok to parse (as opposed to safeParse)
-                    toolUseContext.abortController.signal,
-                  )
-                : Promise.resolve(null),
-            ])
-
-            if (toolUseContext.abortController.signal.aborted) {
-              logCancelledEvent()
-              resolveWithCancelledAndAbortAllToolCalls()
-              return
-            }
-
-            // Does not have permissions to use tool, ask the user
-            setToolUseConfirm({
-              assistantMessage,
-              tool,
-              description,
-              input,
-              commandPrefix,
-              riskScore: null,
-              onAbort() {
-                logCancelledEvent()
-                logEvent('tengu_tool_use_rejected_in_prompt', {
-                  messageID: assistantMessage.message.id,
-                  toolName: tool.name,
-                })
-                resolveWithCancelledAndAbortAllToolCalls()
-              },
-              onAllow(type) {
-                if (type === 'permanent') {
-                  logEvent('tengu_tool_use_granted_in_prompt_permanent', {
-                    messageID: assistantMessage.message.id,
-                    toolName: tool.name,
-                  })
-                } else {
-                  logEvent('tengu_tool_use_granted_in_prompt_temporary', {
-                    messageID: assistantMessage.message.id,
-                    toolName: tool.name,
-                  })
-                }
-                resolve({ result: true })
-              },
-              onReject() {
-                logEvent('tengu_tool_use_rejected_in_prompt', {
-                  messageID: assistantMessage.message.id,
-                  toolName: tool.name,
-                })
-                resolveWithCancelledAndAbortAllToolCalls()
-              },
-            })
-          })
-          .catch(error => {
-            if (error instanceof AbortError) {
-              logCancelledEvent()
-              resolveWithCancelledAndAbortAllToolCalls()
-            } else {
-              logError(error)
-            }
-          })
-      })
-    },
-    [setToolUseConfirm],
-  )
-}
-
-export default useCanUseTool

package/src/hooks/useCancelRequest.ts

@@ -1,39 +0,0 @@
-import { useInput } from 'ink'
-import { ToolUseConfirm } from '../components/permissions/PermissionRequest'
-import { logEvent } from '../services/statsig'
-import { BinaryFeedbackContext } from '../screens/REPL'
-import type { SetToolJSXFn } from '../Tool'
-
-export function useCancelRequest(
-  setToolJSX: SetToolJSXFn,
-  setToolUseConfirm: (toolUseConfirm: ToolUseConfirm | null) => void,
-  setBinaryFeedbackContext: (bfContext: BinaryFeedbackContext | null) => void,
-  onCancel: () => void,
-  isLoading: boolean,
-  isMessageSelectorVisible: boolean,
-  abortSignal?: AbortSignal,
-) {
-  useInput((_, key) => {
-    if (!key.escape) {
-      return
-    }
-    if (abortSignal?.aborted) {
-      return
-    }
-    if (!abortSignal) {
-      return
-    }
-    if (!isLoading) {
-      return
-    }
-    if (isMessageSelectorVisible) {
-      // Esc closes the message selector
-      return
-    }
-    logEvent('tengu_cancel', {})
-    setToolJSX(null)
-    setToolUseConfirm(null)
-    setBinaryFeedbackContext(null)
-    onCancel()
-  })
-}

package/src/hooks/useDoublePress.ts

@@ -1,41 +0,0 @@
-// Creates a function that calls one function on the first call and another
-// function on the second call within a certain timeout
-
-import { useRef } from 'react'
-
-export const DOUBLE_PRESS_TIMEOUT_MS = 2000
-
-export function useDoublePress(
-  setPending: (pending: boolean) => void,
-  onDoublePress: () => void,
-  onFirstPress?: () => void,
-): () => void {
-  const lastPressRef = useRef<number>(0)
-  const timeoutRef = useRef<NodeJS.Timeout>()
-
-  return () => {
-    const now = Date.now()
-    const timeSinceLastPress = now - lastPressRef.current
-
-    // For this to count as a double-call, be sure to check that
-    // timeoutRef.current exists so we don't trigger on triple call
-    // (e.g. of Esc to clear the text input)
-    if (timeSinceLastPress <= DOUBLE_PRESS_TIMEOUT_MS && timeoutRef.current) {
-      if (timeoutRef.current) {
-        clearTimeout(timeoutRef.current)
-        timeoutRef.current = undefined
-      }
-      onDoublePress()
-      setPending(false)
-    } else {
-      onFirstPress?.()
-      setPending(true)
-      timeoutRef.current = setTimeout(
-        () => setPending(false),
-        DOUBLE_PRESS_TIMEOUT_MS,
-      )
-    }
-
-    lastPressRef.current = now
-  }
-}

package/src/hooks/useExitOnCtrlCD.ts

@@ -1,31 +0,0 @@
-import { useInput } from 'ink'
-import { useDoublePress } from './useDoublePress'
-import { useState } from 'react'
-
-type ExitState = {
-  pending: boolean
-  keyName: 'Ctrl-C' | 'Ctrl-D' | null
-}
-
-export function useExitOnCtrlCD(onExit: () => void): ExitState {
-  const [exitState, setExitState] = useState<ExitState>({
-    pending: false,
-    keyName: null,
-  })
-
-  const handleCtrlC = useDoublePress(
-    pending => setExitState({ pending, keyName: 'Ctrl-C' }),
-    onExit,
-  )
-  const handleCtrlD = useDoublePress(
-    pending => setExitState({ pending, keyName: 'Ctrl-D' }),
-    onExit,
-  )
-
-  useInput((input, key) => {
-    if (key.ctrl && input === 'c') handleCtrlC()
-    if (key.ctrl && input === 'd') handleCtrlD()
-  })
-
-  return exitState
-}

package/src/hooks/useInterval.ts

@@ -1,25 +0,0 @@
-import { useEffect, useRef } from 'react'
-
-/**
- * A custom hook that runs a callback at a specified interval.
- * The interval is cleared when the component unmounts.
- * The interval is also cleared and restarted if the delay changes.
- */
-export function useInterval(callback: () => void, delay: number): void {
-  const savedCallback = useRef(callback)
-
-  // Remember the latest callback
-  useEffect(() => {
-    savedCallback.current = callback
-  }, [callback])
-
-  // Set up the interval
-  useEffect(() => {
-    function tick() {
-      savedCallback.current()
-    }
-
-    const id = setInterval(tick, delay)
-    return () => clearInterval(id)
-  }, [delay])
-}

package/src/hooks/useLogMessages.ts

@@ -1,16 +0,0 @@
-import { useEffect } from 'react'
-import { type Message } from '../query'
-import { overwriteLog, getMessagesPath } from '../utils/log'
-
-export function useLogMessages(
-  messages: Message[],
-  messageLogName: string,
-  forkNumber: number,
-): void {
-  useEffect(() => {
-    overwriteLog(
-      getMessagesPath(messageLogName, forkNumber, 0),
-      messages.filter(_ => _.type !== 'progress'),
-    )
-  }, [messages, messageLogName, forkNumber])
-}

package/src/hooks/useLogStartupTime.ts

@@ -1,12 +0,0 @@
-import { useEffect } from 'react'
-import { logEvent } from '../services/statsig'
-
-export function useLogStartupTime(): void {
-  useEffect(() => {
-    const startupTimeMs = Math.round(process.uptime() * 1000)
-    logEvent('tengu_timer', {
-      event: 'startup',
-      durationMs: String(startupTimeMs),
-    })
-  }, [])
-}

package/src/hooks/useNotifyAfterTimeout.ts

@@ -1,65 +0,0 @@
-import { useEffect } from 'react'
-import { sendNotification } from '../services/notifier'
-import { memoize } from 'lodash-es'
-
-// The time threshold in milliseconds for considering an interaction "recent" (6 seconds)
-const DEFAULT_INTERACTION_THRESHOLD_MS = 6000
-
-const STATE = {
-  lastInteractionTime: Date.now(),
-}
-
-function updateLastInteractionTime(): void {
-  STATE.lastInteractionTime = Date.now()
-}
-
-function getTimeSinceLastInteraction(): number {
-  return Date.now() - STATE.lastInteractionTime
-}
-
-function hasRecentInteraction(threshold: number): boolean {
-  return getTimeSinceLastInteraction() < threshold
-}
-
-function shouldNotify(threshold: number): boolean {
-  return process.env.NODE_ENV !== 'test' && !hasRecentInteraction(threshold)
-}
-
-// Start tracking the time of the user's last interaction with the app
-const init = memoize(() => process.stdin.on('data', updateLastInteractionTime))
-
-/**
- * Hook that manages desktop notifications after a timeout period.
- *
- * Shows a notification in two cases:
- * 1. Immediately if the app has been idle for longer than the threshold
- * 2. After the specified timeout if the user doesn't interact within that time
- *
- * @param message - The notification message to display
- * @param timeout - The timeout in milliseconds (defaults to 6000ms)
- */
-export function useNotifyAfterTimeout(
-  message: string,
-  timeout: number = DEFAULT_INTERACTION_THRESHOLD_MS,
-): void {
-  // Reset interaction time when hook is called to make sure that requests
-  // that took a long time to complete don't pop up a notification right away
-  useEffect(() => {
-    init()
-    updateLastInteractionTime()
-  }, [])
-
-  useEffect(() => {
-    let hasNotified = false
-    const timer = setInterval(() => {
-      if (shouldNotify(timeout) && !hasNotified) {
-        hasNotified = true
-        sendNotification({
-          message,
-        })
-      }
-    }, timeout)
-
-    return () => clearTimeout(timer)
-  }, [message, timeout])
-}