@shareai-lab/kode 1.0.69 → 1.0.71

package/src/entrypoints/mcp.ts

@@ -0,0 +1,176 @@
+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,
+  BashTool,
+  FileEditTool,
+  FileReadTool,
+  GlobTool,
+  GrepTool,
+  FileWriteTool,
+  LSTool,
+]
+
+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<Zod.infer<typeof ListToolsResultSchema>> => {
+      const tools = await Promise.all(
+        MCP_TOOLS.map(async tool => ({
+          ...tool,
+          description: await tool.description(z.object({})),
+          inputSchema: zodToJsonSchema(tool.inputSchema) as ToolInput,
+        })),
+      )
+
+      return {
+        tools,
+      }
+    },
+  )
+
+  server.setRequestHandler(
+    CallToolRequestSchema,
+    async (request): Promise<Zod.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,
+          },
+          hasPermissionsToUseTool,
+        )
+
+        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

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

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

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

@@ -0,0 +1,138 @@
+import { 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

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

@@ -0,0 +1,42 @@
+// 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)
+      // @ts-expect-error: Bun is overloading types here, but we're using the NodeJS runtime
+      timeoutRef.current = setTimeout(
+        () => setPending(false),
+        DOUBLE_PRESS_TIMEOUT_MS,
+      )
+    }
+
+    lastPressRef.current = now
+  }
+}

package/src/hooks/useExitOnCtrlCD.ts

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

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

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

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

@@ -0,0 +1,65 @@
+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])
+}