@shareai-lab/kode 1.0.70 → 1.0.71

package/src/utils/permissions/filesystem.ts

@@ -0,0 +1,118 @@
+import { isAbsolute, resolve } from 'path'
+import { getCwd, getOriginalCwd } from '../state'
+
+// In-memory storage for file permissions that resets each session
+// Sets of allowed directories for read and write operations
+const readFileAllowedDirectories: Set<string> = new Set()
+const writeFileAllowedDirectories: Set<string> = new Set()
+
+/**
+ * Ensures a path is absolute by resolving it relative to cwd if necessary
+ * @param path The path to normalize
+ * @returns Absolute path
+ */
+export function toAbsolutePath(path: string): string {
+  return isAbsolute(path) ? resolve(path) : resolve(getCwd(), path)
+}
+
+/**
+ * Ensures a path is in the original cwd path
+ * @param directory The directory path to normalize
+ * @returns Absolute path
+ */
+export function pathInOriginalCwd(path: string): boolean {
+  const absolutePath = toAbsolutePath(path)
+  return absolutePath.startsWith(toAbsolutePath(getOriginalCwd()))
+}
+
+/**
+ * Check if read permission exists for the specified directory
+ * @param directory The directory to check permission for
+ * @returns true if read permission exists, false otherwise
+ */
+export function hasReadPermission(directory: string): boolean {
+  const absolutePath = toAbsolutePath(directory)
+
+  for (const allowedPath of readFileAllowedDirectories) {
+    // Permission exists for this directory or a path prefix
+    if (absolutePath.startsWith(allowedPath)) {
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ * Check if write permission exists for the specified directory
+ * @param directory The directory to check permission for
+ * @returns true if write permission exists, false otherwise
+ */
+export function hasWritePermission(directory: string): boolean {
+  const absolutePath = toAbsolutePath(directory)
+
+  for (const allowedPath of writeFileAllowedDirectories) {
+    // Permission exists for this directory or a path prefix
+    if (absolutePath.startsWith(allowedPath)) {
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ * Save read permission for a directory
+ * @param directory The directory to grant read permission for
+ */
+function saveReadPermission(directory: string): void {
+  const absolutePath = toAbsolutePath(directory)
+
+  // Clean up any existing subdirectories of this path
+  for (const allowedPath of readFileAllowedDirectories) {
+    if (allowedPath.startsWith(absolutePath)) {
+      readFileAllowedDirectories.delete(allowedPath)
+    }
+  }
+  readFileAllowedDirectories.add(absolutePath)
+}
+
+export const saveReadPermissionForTest = saveReadPermission
+
+/**
+ * Grants read permission for the original project directory.
+ * This is useful for initializing read access to the project root.
+ */
+export function grantReadPermissionForOriginalDir(): void {
+  const originalProjectDir = getOriginalCwd()
+  saveReadPermission(originalProjectDir)
+}
+
+/**
+ * Save write permission for a directory
+ * @param directory The directory to grant write permission for
+ */
+function saveWritePermission(directory: string): void {
+  const absolutePath = toAbsolutePath(directory)
+
+  // Clean up any existing subdirectories of this path
+  for (const allowedPath of writeFileAllowedDirectories) {
+    if (allowedPath.startsWith(absolutePath)) {
+      writeFileAllowedDirectories.delete(allowedPath)
+    }
+  }
+  writeFileAllowedDirectories.add(absolutePath)
+}
+
+/**
+ * Grants write permission for the original project directory.
+ * This is useful for initializing write access to the project root.
+ */
+export function grantWritePermissionForOriginalDir(): void {
+  const originalProjectDir = getOriginalCwd()
+  saveWritePermission(originalProjectDir)
+}
+
+// For testing purposes
+export function clearFilePermissions(): void {
+  readFileAllowedDirectories.clear()
+  writeFileAllowedDirectories.clear()
+}

package/src/utils/ripgrep.ts

@@ -0,0 +1,167 @@
+import { findActualExecutable } from 'spawn-rx'
+import { memoize } from 'lodash-es'
+import { fileURLToPath, resolve } from 'node:url'
+import * as path from 'path'
+import { logError } from './log'
+import { execFileNoThrow } from './execFileNoThrow'
+import { execFile } from 'child_process'
+import debug from 'debug'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = resolve(
+  __filename,
+  process.env.NODE_ENV === 'test' ? '../..' : '.',
+)
+
+const d = debug('claude:ripgrep')
+
+const useBuiltinRipgrep = !!process.env.USE_BUILTIN_RIPGREP
+if (useBuiltinRipgrep) {
+  d('Using builtin ripgrep because USE_BUILTIN_RIPGREP is set')
+}
+
+const ripgrepPath = memoize(() => {
+  const { cmd } = findActualExecutable('rg', [])
+  d(`ripgrep initially resolved as: ${cmd}`)
+
+  if (cmd !== 'rg' && !useBuiltinRipgrep) {
+    // NB: If we're able to find ripgrep in $PATH, cmd will be an absolute
+    // path rather than just returning 'rg'
+    return cmd
+  } else {
+    // Use the one we ship in-box
+    const rgRoot = path.resolve(__dirname, 'vendor', 'ripgrep')
+    if (process.platform === 'win32') {
+      // NB: Ripgrep doesn't ship an aarch64 binary for Windows, boooooo
+      return path.resolve(rgRoot, 'x64-win32', 'rg.exe')
+    }
+
+    const ret = path.resolve(
+      rgRoot,
+      `${process.arch}-${process.platform}`,
+      'rg',
+    )
+
+    d('internal ripgrep resolved as: %s', ret)
+    return ret
+  }
+})
+
+export async function ripGrep(
+  args: string[],
+  target: string,
+  abortSignal: AbortSignal,
+): Promise<string[]> {
+  await codesignRipgrepIfNecessary()
+  const rg = ripgrepPath()
+  d('ripgrep called: %s %o', rg, target, args)
+
+  // NB: When running interactively, ripgrep does not require a path as its last
+  // argument, but when run non-interactively, it will hang unless a path or file
+  // pattern is provided
+  return new Promise(resolve => {
+    execFile(
+      ripgrepPath(),
+      [...args, target],
+      {
+        maxBuffer: 1_000_000,
+        signal: abortSignal,
+        timeout: 10_000,
+      },
+      (error, stdout) => {
+        if (error) {
+          // Exit code 1 from ripgrep means "no matches found" - this is normal
+          if (error.code !== 1) {
+            d('ripgrep error: %o', error)
+            logError(error)
+          }
+          resolve([])
+        } else {
+          d('ripgrep succeeded with %s', stdout)
+          resolve(stdout.trim().split('\n').filter(Boolean))
+        }
+      },
+    )
+  })
+}
+
+// NB: We do something tricky here. We know that ripgrep processes common
+// ignore files for us, so we just ripgrep for any character, which matches
+// all non-empty files
+export async function listAllContentFiles(
+  path: string,
+  abortSignal: AbortSignal,
+  limit: number,
+): Promise<string[]> {
+  try {
+    d('listAllContentFiles called: %s', path)
+    return (await ripGrep(['-l', '.', path], path, abortSignal)).slice(0, limit)
+  } catch (e) {
+    d('listAllContentFiles failed: %o', e)
+
+    logError(e)
+    return []
+  }
+}
+
+let alreadyDoneSignCheck = false
+async function codesignRipgrepIfNecessary() {
+  if (process.platform !== 'darwin' || alreadyDoneSignCheck) {
+    return
+  }
+
+  alreadyDoneSignCheck = true
+
+  // First, check to see if ripgrep is already signed
+  d('checking if ripgrep is already signed')
+  const lines = (
+    await execFileNoThrow(
+      'codesign',
+      ['-vv', '-d', ripgrepPath()],
+      undefined,
+      undefined,
+      false,
+    )
+  ).stdout.split('\n')
+
+  const needsSigned = lines.find(line => line.includes('linker-signed'))
+  if (!needsSigned) {
+    d('seems to be already signed')
+    return
+  }
+
+  try {
+    d('signing ripgrep')
+    const signResult = await execFileNoThrow('codesign', [
+      '--sign',
+      '-',
+      '--force',
+      '--preserve-metadata=entitlements,requirements,flags,runtime',
+      ripgrepPath(),
+    ])
+
+    if (signResult.code !== 0) {
+      d('failed to sign ripgrep: %o', signResult)
+      logError(
+        `Failed to sign ripgrep: ${signResult.stdout} ${signResult.stderr}`,
+      )
+    }
+
+    d('removing quarantine')
+    const quarantineResult = await execFileNoThrow('xattr', [
+      '-d',
+      'com.apple.quarantine',
+      ripgrepPath(),
+    ])
+
+    if (quarantineResult.code !== 0) {
+      d('failed to remove quarantine: %o', quarantineResult)
+      logError(
+        `Failed to remove quarantine: ${quarantineResult.stdout} ${quarantineResult.stderr}`,
+      )
+    }
+  } catch (e) {
+    d('failed during sign: %o', e)
+    logError(e)
+  }
+}

package/src/utils/sessionState.ts

@@ -0,0 +1,49 @@
+import { logEvent } from '../services/statsig'
+type SessionState = {
+  modelErrors: Record<string, unknown>
+  currentError: string | null
+}
+
+const isDebug =
+  process.argv.includes('--debug') ||
+  process.argv.includes('-d') ||
+  process.env.DEBUG === 'true'
+
+const sessionState: SessionState = {
+  modelErrors: {},
+  currentError: null,
+} as const
+
+function setSessionState<K extends keyof SessionState>(
+  key: K,
+  value: SessionState[K],
+): void
+function setSessionState(partialState: Partial<SessionState>): void
+function setSessionState(
+  keyOrState: keyof SessionState | Partial<SessionState>,
+  value?: any,
+): void {
+  if (typeof keyOrState === 'string') {
+    logEvent('session_state_set', {
+      key: keyOrState,
+      value: JSON.stringify(value),
+    })
+    sessionState[keyOrState] = value
+  } else {
+    logEvent('session_state_set', {
+      key: 'partial',
+      value: JSON.stringify(keyOrState),
+    })
+    Object.assign(sessionState, keyOrState)
+  }
+}
+
+function getSessionState(): SessionState
+function getSessionState<K extends keyof SessionState>(key: K): SessionState[K]
+function getSessionState<K extends keyof SessionState>(key?: K) {
+  return key === undefined ? sessionState : sessionState[key]
+}
+
+export type { SessionState }
+export { setSessionState, getSessionState }
+export default sessionState

package/src/utils/state.ts

@@ -0,0 +1,25 @@
+import { cwd } from 'process'
+import { PersistentShell } from './PersistentShell'
+
+// DO NOT ADD MORE STATE HERE OR BORIS WILL CURSE YOU
+const STATE: {
+  originalCwd: string
+} = {
+  originalCwd: cwd(),
+}
+
+export async function setCwd(cwd: string): Promise<void> {
+  await PersistentShell.getInstance().setCwd(cwd)
+}
+
+export function setOriginalCwd(cwd: string): void {
+  STATE.originalCwd = cwd
+}
+
+export function getOriginalCwd(): string {
+  return STATE.originalCwd
+}
+
+export function getCwd(): string {
+  return PersistentShell.getInstance().pwd()
+}

package/src/utils/style.ts

@@ -0,0 +1,29 @@
+import { existsSync, readFileSync } from 'fs'
+import { join, parse, dirname } from 'path'
+import { memoize } from 'lodash-es'
+import { getCwd } from './state'
+import { PROJECT_FILE } from '../constants/product'
+
+const STYLE_PROMPT =
+  'The codebase follows strict style guidelines shown below. All code changes must strictly adhere to these guidelines to maintain consistency and quality.'
+
+export const getCodeStyle = memoize((): string => {
+  const styles: string[] = []
+  let currentDir = getCwd()
+
+  while (currentDir !== parse(currentDir).root) {
+    const stylePath = join(currentDir, PROJECT_FILE)
+    if (existsSync(stylePath)) {
+      styles.push(
+        `Contents of ${stylePath}:\n\n${readFileSync(stylePath, 'utf-8')}`,
+      )
+    }
+    currentDir = dirname(currentDir)
+  }
+
+  if (styles.length === 0) {
+    return ''
+  }
+
+  return `${STYLE_PROMPT}\n\n${styles.reverse().join('\n\n')}`
+})

package/src/utils/terminal.ts

@@ -0,0 +1,49 @@
+import { safeParseJSON } from './json'
+import { logError } from './log'
+
+export function setTerminalTitle(title: string): void {
+  if (process.platform === 'win32') {
+    process.title = title ? `✳ ${title}` : title
+  } else {
+    process.stdout.write(`\x1b]0;${title ? `✳ ${title}` : ''}\x07`)
+  }
+}
+
+export async function updateTerminalTitle(message: string): Promise<void> {
+  try {
+    const result = await queryQuick({
+      systemPrompt: [
+        "Analyze if this message indicates a new conversation topic. If it does, extract a 2-3 word title that captures the new topic. Format your response as a JSON object with two fields: 'isNewTopic' (boolean) and 'title' (string, or null if isNewTopic is false). Only include these fields, no other text.",
+      ],
+      userPrompt: message,
+      enablePromptCaching: true,
+    })
+
+    const content = result.message.content
+      .filter(_ => _.type === 'text')
+      .map(_ => _.text)
+      .join('')
+
+    const response = safeParseJSON(content)
+    if (
+      response &&
+      typeof response === 'object' &&
+      'isNewTopic' in response &&
+      'title' in response
+    ) {
+      if (response.isNewTopic && response.title) {
+        setTerminalTitle(response.title as string)
+      }
+    }
+  } catch (error) {
+    logError(error)
+  }
+}
+
+export function clearTerminal(): Promise<void> {
+  return new Promise(resolve => {
+    process.stdout.write('\x1b[2J\x1b[3J\x1b[H', () => {
+      resolve()
+    })
+  })
+}

package/src/utils/theme.ts

@@ -0,0 +1,122 @@
+import { getGlobalConfig } from './config'
+
+export interface Theme {
+  bashBorder: string
+  claude: string
+  koding: string
+  permission: string
+  secondaryBorder: string
+  text: string
+  secondaryText: string
+  suggestion: string
+  // Semantic colors
+  success: string
+  error: string
+  warning: string
+  diff: {
+    added: string
+    removed: string
+    addedDimmed: string
+    removedDimmed: string
+  }
+}
+
+const lightTheme: Theme = {
+  bashBorder: '#ff0087',
+  claude: '#7aff59ff',
+  koding: '#9dff00ff',
+  permission: '#e9c61aff',
+  secondaryBorder: '#999',
+  text: '#000',
+  secondaryText: '#666',
+  suggestion: '#32e98aff',
+  success: '#2c7a39',
+  error: '#ab2b3f',
+  warning: '#966c1e',
+  diff: {
+    added: '#69db7c',
+    removed: '#ffa8b4',
+    addedDimmed: '#c7e1cb',
+    removedDimmed: '#fdd2d8',
+  },
+}
+
+const lightDaltonizedTheme: Theme = {
+  bashBorder: '#0066cc', // Blue instead of pink for better contrast
+  claude: '#5f97cd', // Orange adjusted for deuteranopia
+  koding: '#0000ff',
+  permission: '#3366ff', // Brighter blue for better visibility
+  secondaryBorder: '#999',
+  text: '#000',
+  secondaryText: '#666',
+  suggestion: '#3366ff',
+  success: '#006699', // Blue instead of green
+  error: '#cc0000', // Pure red for better distinction
+  warning: '#ff9900', // Orange adjusted for deuteranopia
+  diff: {
+    added: '#99ccff', // Light blue instead of green
+    removed: '#ffcccc', // Light red for better contrast
+    addedDimmed: '#d1e7fd',
+    removedDimmed: '#ffe9e9',
+  },
+}
+
+const darkTheme: Theme = {
+  bashBorder: '#fd5db1',
+  claude: '#5f97cd',
+  koding: '#0000ff',
+  permission: '#b1b9f9',
+  secondaryBorder: '#888',
+  text: '#fff',
+  secondaryText: '#999',
+  suggestion: '#b1b9f9',
+  success: '#4eba65',
+  error: '#ff6b80',
+  warning: '#ffc107',
+  diff: {
+    added: '#225c2b',
+    removed: '#7a2936',
+    addedDimmed: '#47584a',
+    removedDimmed: '#69484d',
+  },
+}
+
+const darkDaltonizedTheme: Theme = {
+  bashBorder: '#3399ff', // Bright blue instead of pink
+  claude: '#5f97cd', // Orange adjusted for deuteranopia
+  koding: '#0000ff',
+  permission: '#99ccff', // Light blue for better contrast
+  secondaryBorder: '#888',
+  text: '#fff',
+  secondaryText: '#999',
+  suggestion: '#99ccff',
+  success: '#3399ff', // Bright blue instead of green
+  error: '#ff6666', // Bright red for better visibility
+  warning: '#ffcc00', // Yellow-orange for deuteranopia
+  diff: {
+    added: '#004466', // Dark blue instead of green
+    removed: '#660000', // Dark red for better contrast
+    addedDimmed: '#3e515b',
+    removedDimmed: '#3e2c2c',
+  },
+}
+
+export type ThemeNames =
+  | 'dark'
+  | 'light'
+  | 'light-daltonized'
+  | 'dark-daltonized'
+
+export function getTheme(overrideTheme?: ThemeNames): Theme {
+  const config = getGlobalConfig()
+  switch (overrideTheme ?? config.theme) {
+    case 'light':
+      return lightTheme
+    case 'light-daltonized':
+      return lightDaltonizedTheme
+    case 'dark-daltonized':
+      return darkDaltonizedTheme
+    default:
+      return darkTheme
+  }
+}

package/src/utils/thinking.ts

@@ -0,0 +1,144 @@
+import { last } from 'lodash-es'
+import type { Message } from '../query'
+import { logEvent } from '../services/statsig'
+import { getLastAssistantMessageId } from './messages'
+import { ThinkTool } from '../tools/ThinkTool/ThinkTool'
+import { USE_BEDROCK, USE_VERTEX, getModelManager } from './model'
+import { getGlobalConfig } from './config'
+
+export async function getMaxThinkingTokens(
+  messages: Message[],
+): Promise<number> {
+  if (process.env.MAX_THINKING_TOKENS) {
+    const tokens = parseInt(process.env.MAX_THINKING_TOKENS, 10)
+    logEvent('tengu_thinking', {
+      method: 'scratchpad',
+      tokenCount: tokens.toString(),
+      messageId: getLastAssistantMessageId(messages),
+      provider: USE_BEDROCK ? 'bedrock' : USE_VERTEX ? 'vertex' : '1p',
+    })
+    return tokens
+  }
+
+  if (await ThinkTool.isEnabled()) {
+    logEvent('tengu_thinking', {
+      method: 'scratchpad',
+      tokenCount: '0',
+      messageId: getLastAssistantMessageId(messages),
+      provider: USE_BEDROCK ? 'bedrock' : USE_VERTEX ? 'vertex' : '1p',
+    })
+    return 0
+  }
+
+  const lastMessage = last(messages)
+  if (
+    lastMessage?.type !== 'user' ||
+    typeof lastMessage.message.content !== 'string'
+  ) {
+    logEvent('tengu_thinking', {
+      method: 'scratchpad',
+      tokenCount: '0',
+      messageId: getLastAssistantMessageId(messages),
+      provider: USE_BEDROCK ? 'bedrock' : USE_VERTEX ? 'vertex' : '1p',
+    })
+    return 0
+  }
+
+  const content = lastMessage.message.content.toLowerCase()
+  if (
+    content.includes('think harder') ||
+    content.includes('think intensely') ||
+    content.includes('think longer') ||
+    content.includes('think really hard') ||
+    content.includes('think super hard') ||
+    content.includes('think very hard') ||
+    content.includes('ultrathink')
+  ) {
+    logEvent('tengu_thinking', {
+      method: 'scratchpad',
+      tokenCount: '31999',
+      messageId: getLastAssistantMessageId(messages),
+      provider: USE_BEDROCK ? 'bedrock' : USE_VERTEX ? 'vertex' : '1p',
+    })
+    return 32_000 - 1
+  }
+
+  if (
+    content.includes('think about it') ||
+    content.includes('think a lot') ||
+    content.includes('think hard') ||
+    content.includes('think more') ||
+    content.includes('megathink')
+  ) {
+    logEvent('tengu_thinking', {
+      method: 'scratchpad',
+      tokenCount: '10000',
+      messageId: getLastAssistantMessageId(messages),
+      provider: USE_BEDROCK ? 'bedrock' : USE_VERTEX ? 'vertex' : '1p',
+    })
+    return 10_000
+  }
+
+  if (content.includes('think')) {
+    logEvent('tengu_thinking', {
+      method: 'scratchpad',
+      tokenCount: '4000',
+      messageId: getLastAssistantMessageId(messages),
+      provider: USE_BEDROCK ? 'bedrock' : USE_VERTEX ? 'vertex' : '1p',
+    })
+    return 4_000
+  }
+
+  logEvent('tengu_thinking', {
+    method: 'scratchpad',
+    tokenCount: '0',
+    messageId: getLastAssistantMessageId(messages),
+    provider: USE_BEDROCK ? 'bedrock' : USE_VERTEX ? 'vertex' : '1p',
+  })
+  return 0
+}
+
+export async function getReasoningEffort(
+  modelProfile: any,
+  messages: Message[],
+): Promise<'low' | 'medium' | 'high' | null> {
+  const thinkingTokens = await getMaxThinkingTokens(messages)
+
+  // Get reasoning effort from ModelProfile first, then fallback to config
+  let reasoningEffort: 'low' | 'medium' | 'high' | undefined
+  if (modelProfile?.reasoningEffort) {
+    reasoningEffort = modelProfile.reasoningEffort
+  } else {
+    // 🔧 Fix: Use ModelManager fallback instead of legacy config
+    const modelManager = getModelManager()
+    const fallbackProfile = modelManager.getModel('main')
+    reasoningEffort = fallbackProfile?.reasoningEffort || 'medium'
+  }
+
+  const maxEffort =
+    reasoningEffort === 'high'
+      ? 2
+      : reasoningEffort === 'medium'
+        ? 1
+        : reasoningEffort === 'low'
+          ? 0
+          : null
+  if (!maxEffort) {
+    return null
+  }
+
+  let effort = 0
+  if (thinkingTokens < 10_000) {
+    effort = 0
+  } else if (thinkingTokens >= 10_000 && thinkingTokens < 30_000) {
+    effort = 1
+  } else {
+    effort = 2
+  }
+
+  if (effort > maxEffort) {
+    return maxEffort === 2 ? 'high' : maxEffort === 1 ? 'medium' : 'low'
+  }
+
+  return effort === 2 ? 'high' : effort === 1 ? 'medium' : 'low'
+}