@shareai-lab/kode 1.0.69 → 1.0.71

package/src/hooks/usePermissionRequestLogging.ts

@@ -0,0 +1,44 @@
+import { useEffect } from 'react'
+import { logEvent } from '../services/statsig'
+import { logUnaryEvent, CompletionType } from '../utils/unaryLogging'
+import { ToolUseConfirm } from '../components/permissions/PermissionRequest'
+import { env } from '../utils/env'
+
+export type UnaryEvent = {
+  completion_type: CompletionType
+  language_name: string | Promise<string>
+}
+
+/**
+ * Logs permission request events using Statsig and unary logging.
+ * Handles both the Statsig event and the unary event logging.
+ * Can handle either a string or Promise<string> for language_name.
+ */
+export function usePermissionRequestLogging(
+  toolUseConfirm: ToolUseConfirm,
+  unaryEvent: UnaryEvent,
+): void {
+  useEffect(() => {
+    // Log Statsig event
+    logEvent('tengu_tool_use_show_permission_request', {
+      messageID: toolUseConfirm.assistantMessage.message.id,
+      toolName: toolUseConfirm.tool.name,
+    })
+
+    // Handle string or Promise language name
+    const languagePromise = Promise.resolve(unaryEvent.language_name)
+
+    // Log unary event once language is resolved
+    languagePromise.then(language => {
+      logUnaryEvent({
+        completion_type: unaryEvent.completion_type,
+        event: 'response',
+        metadata: {
+          language_name: language,
+          message_id: toolUseConfirm.assistantMessage.message.id,
+          platform: env.platform,
+        },
+      })
+    })
+  }, [toolUseConfirm, unaryEvent])
+}

package/src/hooks/useSlashCommandTypeahead.ts

@@ -0,0 +1,137 @@
+import { useInput } from 'ink'
+import { useState, useCallback, useEffect } from 'react'
+import { Command, getCommand } from '../commands'
+
+type Props = {
+  commands: Command[]
+  onInputChange: (value: string) => void
+  onSubmit: (value: string, isSubmittingSlashCommand?: boolean) => void
+  setCursorOffset: (offset: number) => void
+  currentInput?: string // Add current input for monitoring
+}
+
+export function useSlashCommandTypeahead({
+  commands,
+  onInputChange,
+  onSubmit,
+  setCursorOffset,
+  currentInput,
+}: Props): {
+  suggestions: string[]
+  selectedSuggestion: number
+  updateSuggestions: (value: string) => void
+  clearSuggestions: () => void
+} {
+  const [suggestions, setSuggestions] = useState<string[]>([])
+  const [selectedSuggestion, setSelectedSuggestion] = useState(-1)
+
+  // Force clear suggestions when input doesn't start with /
+  useEffect(() => {
+    if (
+      currentInput !== undefined &&
+      !currentInput.startsWith('/') &&
+      suggestions.length > 0
+    ) {
+      setSuggestions([])
+      setSelectedSuggestion(-1)
+    }
+  }, [currentInput, suggestions.length])
+
+  function updateSuggestions(value: string) {
+    if (value.startsWith('/')) {
+      const query = value.slice(1).toLowerCase()
+
+      // Find commands whose name or alias matches the query
+      const matchingCommands = commands
+        .filter(cmd => !cmd.isHidden)
+        .filter(cmd => {
+          const names = [cmd.userFacingName()]
+          if (cmd.aliases) {
+            names.push(...cmd.aliases)
+          }
+          return names.some(name => name.toLowerCase().startsWith(query))
+        })
+
+      // For each matching command, include its primary name
+      const filtered = matchingCommands.map(cmd => cmd.userFacingName())
+      setSuggestions(filtered)
+
+      // Try to preserve the selected suggestion
+      const newIndex =
+        selectedSuggestion > -1
+          ? filtered.indexOf(suggestions[selectedSuggestion]!)
+          : 0
+      if (newIndex > -1) {
+        setSelectedSuggestion(newIndex)
+      } else {
+        setSelectedSuggestion(0)
+      }
+    } else {
+      setSuggestions([])
+      setSelectedSuggestion(-1)
+    }
+  }
+
+  useInput((_, key) => {
+    if (suggestions.length > 0) {
+      // Handle suggestion navigation (up/down arrows)
+      if (key.downArrow) {
+        setSelectedSuggestion(prev =>
+          prev >= suggestions.length - 1 ? 0 : prev + 1,
+        )
+        return true
+      } else if (key.upArrow) {
+        setSelectedSuggestion(prev =>
+          prev <= 0 ? suggestions.length - 1 : prev - 1,
+        )
+        return true
+      }
+
+      // Handle selection completion via tab or return
+      else if (key.tab || (key.return && selectedSuggestion >= 0)) {
+        // Ensure a suggestion is selected
+        if (selectedSuggestion === -1 && key.tab) {
+          setSelectedSuggestion(0)
+        }
+
+        const suggestionIndex = selectedSuggestion >= 0 ? selectedSuggestion : 0
+        const suggestion = suggestions[suggestionIndex]
+        if (!suggestion) return true
+
+        const input = '/' + suggestion + ' '
+        onInputChange(input)
+        // Manually move cursor to end
+        setCursorOffset(input.length)
+        setSuggestions([])
+        setSelectedSuggestion(-1)
+
+        // If return was pressed and command doesn't take arguments, just run it
+        if (key.return) {
+          const command = getCommand(suggestion, commands)
+          if (
+            command.type !== 'prompt' ||
+            (command.argNames ?? []).length === 0
+          ) {
+            onSubmit(input, /* isSubmittingSlashCommand */ true)
+          }
+        }
+
+        return true
+      }
+    }
+    // Explicitly return false when not handling the input
+    return false
+  })
+
+  const clearSuggestions = useCallback(() => {
+    setSuggestions([])
+    setSelectedSuggestion(-1)
+  }, [])
+
+  return {
+    suggestions,
+    selectedSuggestion,
+    updateSuggestions,
+    clearSuggestions,
+  }
+}

package/src/hooks/useTerminalSize.ts

@@ -0,0 +1,49 @@
+import { useEffect, useState } from 'react'
+
+// Global state to share across all hook instances
+let globalSize = {
+  columns: process.stdout.columns || 80,
+  rows: process.stdout.rows || 24,
+}
+
+const listeners = new Set<() => void>()
+let isListenerAttached = false
+
+function updateAllListeners() {
+  globalSize = {
+    columns: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24,
+  }
+  listeners.forEach(listener => listener())
+}
+
+export function useTerminalSize() {
+  const [size, setSize] = useState(globalSize)
+
+  useEffect(() => {
+    // Add this component's listener to the set
+    const updateSize = () => setSize({ ...globalSize })
+    listeners.add(updateSize)
+
+    // Only attach the global resize listener once
+    if (!isListenerAttached) {
+      // Increase max listeners to prevent warnings
+      process.stdout.setMaxListeners(20)
+      process.stdout.on('resize', updateAllListeners)
+      isListenerAttached = true
+    }
+
+    return () => {
+      // Remove this component's listener
+      listeners.delete(updateSize)
+
+      // If no more listeners, remove the global listener
+      if (listeners.size === 0 && isListenerAttached) {
+        process.stdout.off('resize', updateAllListeners)
+        isListenerAttached = false
+      }
+    }
+  }, [])
+
+  return size
+}

package/src/hooks/useTextInput.ts

@@ -0,0 +1,315 @@
+import { useState } from 'react'
+import { type Key } from 'ink'
+import { useDoublePress } from './useDoublePress'
+import { Cursor } from '../utils/Cursor'
+import {
+  getImageFromClipboard,
+  CLIPBOARD_ERROR_MESSAGE,
+} from '../utils/imagePaste.js'
+
+const IMAGE_PLACEHOLDER = '[Image pasted]'
+
+type MaybeCursor = void | Cursor
+type InputHandler = (input: string) => MaybeCursor
+type InputMapper = (input: string) => MaybeCursor
+function mapInput(input_map: Array<[string, InputHandler]>): InputMapper {
+  return function (input: string): MaybeCursor {
+    const handler = new Map(input_map).get(input) ?? (() => {})
+    return handler(input)
+  }
+}
+
+type UseTextInputProps = {
+  value: string
+  onChange: (value: string) => void
+  onSubmit?: (value: string) => void
+  onExit?: () => void
+  onExitMessage?: (show: boolean, key?: string) => void
+  onMessage?: (show: boolean, message?: string) => void
+  onHistoryUp?: () => void
+  onHistoryDown?: () => void
+  onHistoryReset?: () => void
+  focus?: boolean
+  mask?: string
+  multiline?: boolean
+  cursorChar: string
+  highlightPastedText?: boolean
+  invert: (text: string) => string
+  themeText: (text: string) => string
+  columns: number
+  onImagePaste?: (base64Image: string) => void
+  disableCursorMovementForUpDownKeys?: boolean
+  externalOffset: number
+  onOffsetChange: (offset: number) => void
+}
+
+type UseTextInputResult = {
+  renderedValue: string
+  onInput: (input: string, key: Key) => void
+  offset: number
+  setOffset: (offset: number) => void
+}
+
+export function useTextInput({
+  value: originalValue,
+  onChange,
+  onSubmit,
+  onExit,
+  onExitMessage,
+  onMessage,
+  onHistoryUp,
+  onHistoryDown,
+  onHistoryReset,
+  mask = '',
+  multiline = false,
+  cursorChar,
+  invert,
+  columns,
+  onImagePaste,
+  disableCursorMovementForUpDownKeys = false,
+  externalOffset,
+  onOffsetChange,
+}: UseTextInputProps): UseTextInputResult {
+  const offset = externalOffset
+  const setOffset = onOffsetChange
+  const cursor = Cursor.fromText(originalValue, columns, offset)
+  const [imagePasteErrorTimeout, setImagePasteErrorTimeout] =
+    useState<NodeJS.Timeout | null>(null)
+
+  function maybeClearImagePasteErrorTimeout() {
+    if (!imagePasteErrorTimeout) {
+      return
+    }
+    clearTimeout(imagePasteErrorTimeout)
+    setImagePasteErrorTimeout(null)
+    onMessage?.(false)
+  }
+
+  const handleCtrlC = useDoublePress(
+    show => {
+      maybeClearImagePasteErrorTimeout()
+      onExitMessage?.(show, 'Ctrl-C')
+    },
+    () => onExit?.(),
+    () => {
+      if (originalValue) {
+        onChange('')
+        onHistoryReset?.()
+      }
+    },
+  )
+
+  // Keep Escape for clearing input
+  const handleEscape = useDoublePress(
+    show => {
+      maybeClearImagePasteErrorTimeout()
+      onMessage?.(!!originalValue && show, `Press Escape again to clear`)
+    },
+    () => {
+      if (originalValue) {
+        onChange('')
+      }
+    },
+  )
+  function clear() {
+    return Cursor.fromText('', columns, 0)
+  }
+
+  const handleEmptyCtrlD = useDoublePress(
+    show => onExitMessage?.(show, 'Ctrl-D'),
+    () => onExit?.(),
+  )
+
+  function handleCtrlD(): MaybeCursor {
+    maybeClearImagePasteErrorTimeout()
+    if (cursor.text === '') {
+      // When input is empty, handle double-press
+      handleEmptyCtrlD()
+      return cursor
+    }
+    // When input is not empty, delete forward like iPython
+    return cursor.del()
+  }
+
+  function tryImagePaste() {
+    const base64Image = getImageFromClipboard()
+    if (base64Image === null) {
+      if (process.platform !== 'darwin') {
+        return cursor
+      }
+      onMessage?.(true, CLIPBOARD_ERROR_MESSAGE)
+      maybeClearImagePasteErrorTimeout()
+      setImagePasteErrorTimeout(
+        // @ts-expect-error: Bun is overloading types here, but we're using the NodeJS runtime
+        setTimeout(() => {
+          onMessage?.(false)
+        }, 4000),
+      )
+      return cursor
+    }
+
+    onImagePaste?.(base64Image)
+    return cursor.insert(IMAGE_PLACEHOLDER)
+  }
+
+  const handleCtrl = mapInput([
+    ['a', () => cursor.startOfLine()],
+    ['b', () => cursor.left()],
+    ['c', handleCtrlC],
+    ['d', handleCtrlD],
+    ['e', () => cursor.endOfLine()],
+    ['f', () => cursor.right()],
+    [
+      'h',
+      () => {
+        maybeClearImagePasteErrorTimeout()
+        return cursor.backspace()
+      },
+    ],
+    ['k', () => cursor.deleteToLineEnd()],
+    ['l', () => clear()],
+    ['n', () => downOrHistoryDown()],
+    ['p', () => upOrHistoryUp()],
+    ['u', () => cursor.deleteToLineStart()],
+    ['v', tryImagePaste],
+    ['w', () => cursor.deleteWordBefore()],
+  ])
+
+  const handleMeta = mapInput([
+    ['b', () => cursor.prevWord()],
+    ['f', () => cursor.nextWord()],
+    ['d', () => cursor.deleteWordAfter()],
+  ])
+
+  function handleEnter(key: Key) {
+    if (
+      multiline &&
+      cursor.offset > 0 &&
+      cursor.text[cursor.offset - 1] === '\\'
+    ) {
+      return cursor.backspace().insert('\n')
+    }
+    if (key.meta) {
+      return cursor.insert('\n')
+    }
+    onSubmit?.(originalValue)
+  }
+
+  function upOrHistoryUp() {
+    if (disableCursorMovementForUpDownKeys) {
+      onHistoryUp?.()
+      return cursor
+    }
+    const cursorUp = cursor.up()
+    if (cursorUp.equals(cursor)) {
+      // already at beginning
+      onHistoryUp?.()
+    }
+    return cursorUp
+  }
+  function downOrHistoryDown() {
+    if (disableCursorMovementForUpDownKeys) {
+      onHistoryDown?.()
+      return cursor
+    }
+    const cursorDown = cursor.down()
+    if (cursorDown.equals(cursor)) {
+      onHistoryDown?.()
+    }
+    return cursorDown
+  }
+
+  function onInput(input: string, key: Key): void {
+    // Direct handling for backspace or delete (which is being detected as delete)
+    if (
+      key.backspace ||
+      key.delete ||
+      input === '\b' ||
+      input === '\x7f' ||
+      input === '\x08'
+    ) {
+      const nextCursor = cursor.backspace()
+      if (!cursor.equals(nextCursor)) {
+        setOffset(nextCursor.offset)
+        if (cursor.text !== nextCursor.text) {
+          onChange(nextCursor.text)
+        }
+      }
+      return
+    }
+
+    const nextCursor = mapKey(key)(input)
+    if (nextCursor) {
+      if (!cursor.equals(nextCursor)) {
+        setOffset(nextCursor.offset)
+        if (cursor.text !== nextCursor.text) {
+          onChange(nextCursor.text)
+        }
+      }
+    }
+  }
+
+  function mapKey(key: Key): InputMapper {
+    // Direct handling for backspace or delete
+    if (key.backspace || key.delete) {
+      maybeClearImagePasteErrorTimeout()
+      return () => cursor.backspace()
+    }
+
+    switch (true) {
+      case key.escape:
+        return handleEscape
+      case key.leftArrow && (key.ctrl || key.meta || key.fn):
+        return () => cursor.prevWord()
+      case key.rightArrow && (key.ctrl || key.meta || key.fn):
+        return () => cursor.nextWord()
+      case key.ctrl:
+        return handleCtrl
+      case key.home:
+        return () => cursor.startOfLine()
+      case key.end:
+        return () => cursor.endOfLine()
+      case key.pageDown:
+        return () => cursor.endOfLine()
+      case key.pageUp:
+        return () => cursor.startOfLine()
+      case key.meta:
+        return handleMeta
+      case key.return:
+        return () => handleEnter(key)
+      case key.tab:
+        return () => {}
+      case key.upArrow:
+        return upOrHistoryUp
+      case key.downArrow:
+        return downOrHistoryDown
+      case key.leftArrow:
+        return () => cursor.left()
+      case key.rightArrow:
+        return () => cursor.right()
+    }
+    return function (input: string) {
+      switch (true) {
+        // Home key
+        case input == '\x1b[H' || input == '\x1b[1~':
+          return cursor.startOfLine()
+        // End key
+        case input == '\x1b[F' || input == '\x1b[4~':
+          return cursor.endOfLine()
+        // Handle backspace character explicitly - this is the key fix
+        case input === '\b' || input === '\x7f' || input === '\x08':
+          maybeClearImagePasteErrorTimeout()
+          return cursor.backspace()
+        default:
+          return cursor.insert(input.replace(/\r/g, '\n'))
+      }
+    }
+  }
+
+  return {
+    onInput,
+    renderedValue: cursor.render(cursorChar, mask, invert),
+    offset,
+    setOffset,
+  }
+}

package/src/messages.ts

@@ -0,0 +1,37 @@
+import type { Message } from './query'
+
+let getMessages: () => Message[] = () => []
+let setMessages: React.Dispatch<React.SetStateAction<Message[]>> = () => {}
+
+export function setMessagesGetter(getter: () => Message[]) {
+  getMessages = getter
+}
+
+export function getMessagesGetter(): () => Message[] {
+  return getMessages
+}
+
+export function setMessagesSetter(
+  setter: React.Dispatch<React.SetStateAction<Message[]>>,
+) {
+  setMessages = setter
+}
+
+export function getMessagesSetter(): React.Dispatch<
+  React.SetStateAction<Message[]>
+> {
+  return setMessages
+}
+
+// Global UI refresh mechanism for model configuration changes
+let onModelConfigChange: (() => void) | null = null
+
+export function setModelConfigChangeHandler(handler: () => void) {
+  onModelConfigChange = handler
+}
+
+export function triggerModelConfigChange() {
+  if (onModelConfigChange) {
+    onModelConfigChange()
+  }
+}