@shareai-lab/kode 1.0.70 → 1.0.73

package/src/utils/theme.ts

@@ -0,0 +1,133 @@
+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
+  // UI colors
+  primary: string
+  secondary: 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',
+  primary: '#000',
+  secondary: '#666',
+  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
+  primary: '#000',
+  secondary: '#666',
+  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',
+  primary: '#fff',
+  secondary: '#999',
+  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
+  primary: '#fff',
+  secondary: '#999',
+  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'
+}

package/src/utils/todoStorage.ts

@@ -0,0 +1,431 @@
+import { setSessionState, getSessionState } from './sessionState'
+import { readAgentData, writeAgentData, resolveAgentId } from './agentStorage'
+
+export interface TodoItem {
+  id: string
+  content: string
+  status: 'pending' | 'in_progress' | 'completed'
+  priority: 'high' | 'medium' | 'low'
+  createdAt?: number
+  updatedAt?: number
+  tags?: string[]
+  estimatedHours?: number
+  previousStatus?: 'pending' | 'in_progress' | 'completed'
+}
+
+export interface TodoQuery {
+  status?: TodoItem['status'][]
+  priority?: TodoItem['priority'][]
+  contentMatch?: string
+  tags?: string[]
+  dateRange?: { from?: Date; to?: Date }
+}
+
+export interface TodoStorageConfig {
+  maxTodos: number
+  autoArchiveCompleted: boolean
+  sortBy: 'createdAt' | 'updatedAt' | 'priority' | 'status'
+  sortOrder: 'asc' | 'desc'
+}
+
+const TODO_STORAGE_KEY = 'todos'
+const TODO_CONFIG_KEY = 'todoConfig'
+const TODO_CACHE_KEY = 'todoCache'
+
+// Default configuration
+const DEFAULT_CONFIG: TodoStorageConfig = {
+  maxTodos: 100,
+  autoArchiveCompleted: false,
+  sortBy: 'status', // Using smart sorting now
+  sortOrder: 'desc',
+}
+
+// In-memory cache for performance
+let todoCache: TodoItem[] | null = null
+let cacheTimestamp = 0
+const CACHE_TTL = 5000 // 5 seconds cache
+
+// Performance metrics
+export interface TodoMetrics {
+  totalOperations: number
+  cacheHits: number
+  cacheMisses: number
+  lastOperation: number
+}
+
+function invalidateCache(): void {
+  todoCache = null
+  cacheTimestamp = 0
+}
+
+function updateMetrics(operation: string, cacheHit: boolean = false): void {
+  const sessionState = getSessionState() as any
+  const metrics = sessionState.todoMetrics || {
+    totalOperations: 0,
+    cacheHits: 0,
+    cacheMisses: 0,
+    lastOperation: 0,
+  }
+
+  metrics.totalOperations++
+  metrics.lastOperation = Date.now()
+
+  if (cacheHit) {
+    metrics.cacheHits++
+  } else {
+    metrics.cacheMisses++
+  }
+
+  setSessionState({
+    ...sessionState,
+    todoMetrics: metrics,
+  })
+}
+
+export function getTodoMetrics(): TodoMetrics {
+  const sessionState = getSessionState() as any
+  return (
+    sessionState.todoMetrics || {
+      totalOperations: 0,
+      cacheHits: 0,
+      cacheMisses: 0,
+      lastOperation: 0,
+    }
+  )
+}
+
+export function getTodos(agentId?: string): TodoItem[] {
+  const resolvedAgentId = resolveAgentId(agentId)
+  const now = Date.now()
+
+  // For agent-scoped storage, use file-based storage instead of session state
+  if (agentId) {
+    updateMetrics('getTodos', false)
+    const agentTodos = readAgentData<TodoItem[]>(resolvedAgentId) || []
+
+    // Update cache with agent-specific cache key
+    const agentCacheKey = `todoCache_${resolvedAgentId}`
+    // Note: In production, we'd want agent-specific caching
+
+    return agentTodos
+  }
+
+  // Original session-based storage for backward compatibility
+  // Check cache first
+  if (todoCache && now - cacheTimestamp < CACHE_TTL) {
+    updateMetrics('getTodos', true)
+    return todoCache
+  }
+
+  updateMetrics('getTodos', false)
+  const sessionState = getSessionState()
+  const todos = (sessionState as any)[TODO_STORAGE_KEY] || []
+
+  // Update cache
+  todoCache = [...todos]
+  cacheTimestamp = now
+
+  return todos
+}
+
+export function setTodos(todos: TodoItem[], agentId?: string): void {
+  const resolvedAgentId = resolveAgentId(agentId)
+  const config = getTodoConfig()
+  const existingTodos = getTodos(agentId)
+
+  // For agent-scoped storage, use file-based storage
+  if (agentId) {
+    // Validate todo limit
+    if (todos.length > config.maxTodos) {
+      throw new Error(
+        `Todo limit exceeded. Maximum ${config.maxTodos} todos allowed.`,
+      )
+    }
+
+    // Auto-archive completed todos if enabled
+    let processedTodos = todos
+    if (config.autoArchiveCompleted) {
+      processedTodos = todos.filter(todo => todo.status !== 'completed')
+    }
+
+    const updatedTodos = processedTodos.map(todo => {
+      // Find existing todo to track status changes
+      const existingTodo = existingTodos.find(
+        existing => existing.id === todo.id,
+      )
+
+      return {
+        ...todo,
+        updatedAt: Date.now(),
+        createdAt: todo.createdAt || Date.now(),
+        previousStatus:
+          existingTodo?.status !== todo.status
+            ? existingTodo?.status
+            : todo.previousStatus,
+      }
+    })
+
+    // Smart sorting for agent todos
+    updatedTodos.sort((a, b) => {
+      // 1. Status priority: in_progress > pending > completed
+      const statusOrder = { in_progress: 3, pending: 2, completed: 1 }
+      const statusDiff = statusOrder[b.status] - statusOrder[a.status]
+      if (statusDiff !== 0) return statusDiff
+
+      // 2. For same status, sort by priority: high > medium > low
+      const priorityOrder = { high: 3, medium: 2, low: 1 }
+      const priorityDiff = priorityOrder[b.priority] - priorityOrder[a.priority]
+      if (priorityDiff !== 0) return priorityDiff
+
+      // 3. For same status and priority, sort by updatedAt (newest first)
+      const aTime = a.updatedAt || 0
+      const bTime = b.updatedAt || 0
+      return bTime - aTime
+    })
+
+    // Write to agent-specific storage
+    writeAgentData(resolvedAgentId, updatedTodos)
+    updateMetrics('setTodos')
+    return
+  }
+
+  // Original session-based logic for backward compatibility
+  // Validate todo limit
+  if (todos.length > config.maxTodos) {
+    throw new Error(
+      `Todo limit exceeded. Maximum ${config.maxTodos} todos allowed.`,
+    )
+  }
+
+  // Auto-archive completed todos if enabled
+  let processedTodos = todos
+  if (config.autoArchiveCompleted) {
+    processedTodos = todos.filter(todo => todo.status !== 'completed')
+  }
+
+  const updatedTodos = processedTodos.map(todo => {
+    // Find existing todo to track status changes
+    const existingTodo = existingTodos.find(existing => existing.id === todo.id)
+
+    return {
+      ...todo,
+      updatedAt: Date.now(),
+      createdAt: todo.createdAt || Date.now(),
+      previousStatus:
+        existingTodo?.status !== todo.status
+          ? existingTodo?.status
+          : todo.previousStatus,
+    }
+  })
+
+  // Smart sorting: status -> priority -> updatedAt
+  updatedTodos.sort((a, b) => {
+    // 1. Status priority: in_progress > pending > completed
+    const statusOrder = { in_progress: 3, pending: 2, completed: 1 }
+    const statusDiff = statusOrder[b.status] - statusOrder[a.status]
+    if (statusDiff !== 0) return statusDiff
+
+    // 2. For same status, sort by priority: high > medium > low
+    const priorityOrder = { high: 3, medium: 2, low: 1 }
+    const priorityDiff = priorityOrder[b.priority] - priorityOrder[a.priority]
+    if (priorityDiff !== 0) return priorityDiff
+
+    // 3. For same status and priority, sort by updatedAt (newest first)
+    const aTime = a.updatedAt || 0
+    const bTime = b.updatedAt || 0
+    return bTime - aTime
+  })
+
+  setSessionState({
+    ...getSessionState(),
+    [TODO_STORAGE_KEY]: updatedTodos,
+  } as any)
+
+  // Invalidate cache
+  invalidateCache()
+  updateMetrics('setTodos')
+}
+
+export function getTodoConfig(): TodoStorageConfig {
+  const sessionState = getSessionState() as any
+  return { ...DEFAULT_CONFIG, ...(sessionState[TODO_CONFIG_KEY] || {}) }
+}
+
+export function setTodoConfig(config: Partial<TodoStorageConfig>): void {
+  const currentConfig = getTodoConfig()
+  const newConfig = { ...currentConfig, ...config }
+
+  setSessionState({
+    ...getSessionState(),
+    [TODO_CONFIG_KEY]: newConfig,
+  } as any)
+
+  // Re-sort existing todos if sort order changed
+  if (config.sortBy || config.sortOrder) {
+    const todos = getTodos()
+    setTodos(todos) // This will re-sort according to new config
+  }
+}
+
+export function addTodo(
+  todo: Omit<TodoItem, 'createdAt' | 'updatedAt'>,
+): TodoItem[] {
+  const todos = getTodos()
+
+  // Check for duplicate IDs
+  if (todos.some(existing => existing.id === todo.id)) {
+    throw new Error(`Todo with ID '${todo.id}' already exists`)
+  }
+
+  const newTodo: TodoItem = {
+    ...todo,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  }
+
+  const updatedTodos = [...todos, newTodo]
+  setTodos(updatedTodos)
+  updateMetrics('addTodo')
+  return updatedTodos
+}
+
+export function updateTodo(id: string, updates: Partial<TodoItem>): TodoItem[] {
+  const todos = getTodos()
+  const existingTodo = todos.find(todo => todo.id === id)
+
+  if (!existingTodo) {
+    throw new Error(`Todo with ID '${id}' not found`)
+  }
+
+  const updatedTodos = todos.map(todo =>
+    todo.id === id ? { ...todo, ...updates, updatedAt: Date.now() } : todo,
+  )
+
+  setTodos(updatedTodos)
+  updateMetrics('updateTodo')
+  return updatedTodos
+}
+
+export function deleteTodo(id: string): TodoItem[] {
+  const todos = getTodos()
+  const todoExists = todos.some(todo => todo.id === id)
+
+  if (!todoExists) {
+    throw new Error(`Todo with ID '${id}' not found`)
+  }
+
+  const updatedTodos = todos.filter(todo => todo.id !== id)
+  setTodos(updatedTodos)
+  updateMetrics('deleteTodo')
+  return updatedTodos
+}
+
+export function clearTodos(): void {
+  setTodos([])
+  updateMetrics('clearTodos')
+}
+
+export function getTodoById(id: string): TodoItem | undefined {
+  const todos = getTodos()
+  updateMetrics('getTodoById')
+  return todos.find(todo => todo.id === id)
+}
+
+export function getTodosByStatus(status: TodoItem['status']): TodoItem[] {
+  const todos = getTodos()
+  updateMetrics('getTodosByStatus')
+  return todos.filter(todo => todo.status === status)
+}
+
+export function getTodosByPriority(priority: TodoItem['priority']): TodoItem[] {
+  const todos = getTodos()
+  updateMetrics('getTodosByPriority')
+  return todos.filter(todo => todo.priority === priority)
+}
+
+// Advanced query function
+export function queryTodos(query: TodoQuery): TodoItem[] {
+  const todos = getTodos()
+  updateMetrics('queryTodos')
+
+  return todos.filter(todo => {
+    // Status filter
+    if (query.status && !query.status.includes(todo.status)) {
+      return false
+    }
+
+    // Priority filter
+    if (query.priority && !query.priority.includes(todo.priority)) {
+      return false
+    }
+
+    // Content search
+    if (
+      query.contentMatch &&
+      !todo.content.toLowerCase().includes(query.contentMatch.toLowerCase())
+    ) {
+      return false
+    }
+
+    // Tags filter
+    if (query.tags && todo.tags) {
+      const hasMatchingTag = query.tags.some(tag => todo.tags!.includes(tag))
+      if (!hasMatchingTag) return false
+    }
+
+    // Date range filter
+    if (query.dateRange) {
+      const todoDate = new Date(todo.createdAt || 0)
+      if (query.dateRange.from && todoDate < query.dateRange.from) return false
+      if (query.dateRange.to && todoDate > query.dateRange.to) return false
+    }
+
+    return true
+  })
+}
+
+// Utility functions
+export function getTodoStatistics() {
+  const todos = getTodos()
+  const metrics = getTodoMetrics()
+
+  return {
+    total: todos.length,
+    byStatus: {
+      pending: todos.filter(t => t.status === 'pending').length,
+      in_progress: todos.filter(t => t.status === 'in_progress').length,
+      completed: todos.filter(t => t.status === 'completed').length,
+    },
+    byPriority: {
+      high: todos.filter(t => t.priority === 'high').length,
+      medium: todos.filter(t => t.priority === 'medium').length,
+      low: todos.filter(t => t.priority === 'low').length,
+    },
+    metrics,
+    cacheEfficiency:
+      metrics.totalOperations > 0
+        ? Math.round((metrics.cacheHits / metrics.totalOperations) * 100)
+        : 0,
+  }
+}
+
+export function optimizeTodoStorage(): void {
+  // Force cache refresh
+  invalidateCache()
+
+  // Compact storage by removing any invalid entries
+  const todos = getTodos()
+  const validTodos = todos.filter(
+    todo =>
+      todo.id &&
+      todo.content &&
+      ['pending', 'in_progress', 'completed'].includes(todo.status) &&
+      ['high', 'medium', 'low'].includes(todo.priority),
+  )
+
+  if (validTodos.length !== todos.length) {
+    setTodos(validTodos)
+  }
+
+  updateMetrics('optimizeTodoStorage')
+}