@shareai-lab/kode 1.0.70 → 1.0.71

package/src/services/sentry.ts

@@ -0,0 +1,3 @@
+export function initSentry(): void {}
+
+export async function captureException(error: unknown): Promise<void> {}

package/src/services/statsig.ts

@@ -0,0 +1,171 @@
+import React from 'react'
+import { memoize } from 'lodash-es'
+import chalk from 'chalk'
+import {
+  StatsigClient,
+  StatsigOptions,
+  StatsigEvent,
+  LogLevel,
+} from '@statsig/js-client'
+import './browserMocks.js' // Initialize browser mocks
+import { FileSystemStorageProvider } from './statsigStorage'
+import { STATSIG_CLIENT_KEY } from '../constants/keys'
+import { env } from '../utils/env'
+import { getUser } from '../utils/user'
+import { logError } from '../utils/log'
+import { SESSION_ID } from '../utils/log'
+import { getBetas } from '../utils/betas'
+import { getIsGit } from '../utils/git'
+import { getModelManager } from '../utils/model'
+import { MACRO } from '../constants/macros'
+const gateValues: Record<string, boolean> = {}
+let client: StatsigClient | null = null
+
+export const initializeStatsig = memoize(
+  async (): Promise<StatsigClient | null> => {
+    if (env.isCI || process.env.NODE_ENV === 'test') {
+      return null
+    }
+
+    const user = await getUser()
+    const options: StatsigOptions = {
+      networkConfig: {
+        api: 'https://statsig.anthropic.com/v1/',
+      },
+      environment: {
+        tier:
+          env.isCI ||
+          ['test', 'development'].includes(process.env.NODE_ENV ?? '')
+            ? 'dev'
+            : 'production',
+      },
+      logLevel: LogLevel.None,
+      storageProvider: new FileSystemStorageProvider(),
+    }
+
+    client = new StatsigClient(STATSIG_CLIENT_KEY, user, options)
+    client.on('error', errorEvent => {
+      logError(`Statsig error: ${errorEvent}`)
+    })
+    await client.initializeAsync()
+    process.on('exit', () => {
+      client?.flush()
+    })
+    return client
+  },
+)
+
+export function logEvent(
+  eventName: string,
+  metadata: { [key: string]: string | undefined },
+): void {
+  // console.log('logEvent', eventName, metadata)
+  if (env.isCI || process.env.NODE_ENV === 'test') {
+    return
+  }
+  Promise.all([
+    initializeStatsig(),
+    getIsGit(),
+    getBetas(),
+    metadata.model ? Promise.resolve(metadata.model) : Promise.resolve(getModelManager().getModelName('main') || 'unknown'),
+  ]).then(([statsigClient, isGit, betas, model]) => {
+    if (!statsigClient) return
+
+    const eventMetadata: Record<string, string> = {
+      ...metadata,
+      model,
+      sessionId: SESSION_ID,
+      userType: process.env.USER_TYPE || '',
+      ...(process.env.SWE_BENCH_RUN_ID
+        ? { sweBenchId: process.env.SWE_BENCH_RUN_ID }
+        : {}),
+      ...(betas.length > 0 ? { betas: betas.join(',') } : {}),
+      env: JSON.stringify({
+        isGit,
+        platform: env.platform,
+        nodeVersion: env.nodeVersion,
+        terminal: env.terminal,
+        version: MACRO.VERSION,
+      }),
+    }
+
+    // Debug logging when debug mode is enabled
+    if (process.argv.includes('--debug') || process.argv.includes('-d')) {
+      console.log(
+        chalk.dim(
+          `[DEBUG-ONLY] Statsig event: ${eventName} ${JSON.stringify(metadata, null, 0)}`,
+        ),
+      )
+    }
+
+    const event: StatsigEvent = {
+      eventName,
+      metadata: eventMetadata,
+    }
+    // statsigClient.logEvent(event)
+  })
+}
+
+export const checkGate = memoize(async (gateName: string): Promise<boolean> => {
+  return true
+  // if (env.isCI || process.env.NODE_ENV === 'test') {
+  //   return false
+  // }
+  // const statsigClient = await initializeStatsig()
+  // if (!statsigClient) return false
+
+  // const value = statsigClient.checkGate(gateName)
+  // gateValues[gateName] = value
+  // return value
+})
+
+export const useStatsigGate = (gateName: string, defaultValue = false) => {
+  return true
+  // const [gateValue, setGateValue] = React.useState(defaultValue)
+  // React.useEffect(() => {
+  //   checkGate(gateName).then(setGateValue)
+  // }, [gateName])
+  // return gateValue
+}
+
+export function getGateValues(): Record<string, boolean> {
+  return { ...gateValues }
+}
+
+export const getExperimentValue = memoize(
+  async <T>(experimentName: string, defaultValue: T): Promise<T> => {
+    return defaultValue
+    // if (env.isCI || process.env.NODE_ENV === 'test') {
+    //   return defaultValue
+    // }
+    // const statsigClient = await initializeStatsig()
+    // if (!statsigClient) return defaultValue
+
+    // const experiment = statsigClient.getExperiment(experimentName)
+    // if (Object.keys(experiment.value).length === 0) {
+    //   logError(`getExperimentValue got empty value for ${experimentName}`)
+    //   return defaultValue
+    // }
+    // return experiment.value as T
+  },
+)
+
+// NB Not memoized like other methods, to allow for dynamic config changes
+export const getDynamicConfig = async <T>(
+  configName: string,
+  defaultValue: T,
+): Promise<T> => {
+  return defaultValue
+  // if (env.isCI || process.env.NODE_ENV === 'test') {
+  //   return defaultValue
+  // }
+  // const statsigClient = await initializeStatsig()
+  // if (!statsigClient) return defaultValue
+
+  // const config = statsigClient.getDynamicConfig(configName)
+  // if (Object.keys(config.value).length === 0) {
+  //   logError(`getDynamicConfig got empty value for ${configName}`)
+  //   return defaultValue
+  // }
+  // return config.value as T
+}

package/src/services/statsigStorage.ts

@@ -0,0 +1,86 @@
+import { StorageProvider } from '@statsig/client-core'
+import * as fs from 'fs'
+import * as path from 'path'
+import { homedir } from 'os'
+import { logError } from '../utils/log'
+import { existsSync, unlinkSync } from 'fs'
+import { CONFIG_BASE_DIR } from '../constants/product'
+
+// Support both KODE_CONFIG_DIR and CLAUDE_CONFIG_DIR environment variables
+const CONFIG_DIR = process.env.KODE_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR ?? path.join(homedir(), CONFIG_BASE_DIR)
+const STATSIG_DIR = path.join(CONFIG_DIR, 'statsig')
+
+// Ensure the directory exists
+try {
+  fs.mkdirSync(STATSIG_DIR, { recursive: true })
+} catch (error) {
+  logError(`Failed to create statsig storage directory: ${error}`)
+}
+
+export class FileSystemStorageProvider implements StorageProvider {
+  private cache: Map<string, string> = new Map()
+  private ready = false
+
+  constructor() {
+    // Load all existing files into cache on startup
+    try {
+      if (!fs.existsSync(STATSIG_DIR)) {
+        fs.mkdirSync(STATSIG_DIR, { recursive: true })
+      }
+      const files = fs.readdirSync(STATSIG_DIR)
+      for (const file of files) {
+        const key = decodeURIComponent(file)
+        const value = fs.readFileSync(path.join(STATSIG_DIR, file), 'utf8')
+        this.cache.set(key, value)
+      }
+      this.ready = true
+    } catch (error) {
+      logError(`Failed to initialize statsig storage: ${error}`)
+      this.ready = true // Still mark as ready to avoid blocking
+    }
+  }
+
+  isReady(): boolean {
+    return this.ready
+  }
+
+  isReadyResolver(): Promise<void> | null {
+    return this.ready ? Promise.resolve() : null
+  }
+
+  getProviderName(): string {
+    return 'FileSystemStorageProvider'
+  }
+
+  getItem(key: string): string | null {
+    return this.cache.get(key) ?? null
+  }
+
+  setItem(key: string, value: string): void {
+    this.cache.set(key, value)
+    try {
+      const encodedKey = encodeURIComponent(key)
+      fs.writeFileSync(path.join(STATSIG_DIR, encodedKey), value, 'utf8')
+    } catch (error) {
+      logError(`Failed to write statsig storage item: ${error}`)
+    }
+  }
+
+  removeItem(key: string): void {
+    this.cache.delete(key)
+    const encodedKey = encodeURIComponent(key)
+    const file = path.join(STATSIG_DIR, encodedKey)
+    if (!existsSync(file)) {
+      return
+    }
+    try {
+      unlinkSync(file)
+    } catch (error) {
+      logError(`Failed to remove statsig storage item: ${error}`)
+    }
+  }
+
+  getAllKeys(): readonly string[] {
+    return Array.from(this.cache.keys())
+  }
+}

package/src/services/systemReminder.ts

@@ -0,0 +1,406 @@
+import { getTodos, TodoItem } from '../utils/todoStorage'
+import { logEvent } from './statsig'
+
+export interface ReminderMessage {
+  role: 'system'
+  content: string
+  isMeta: boolean
+  timestamp: number
+  type: string
+  priority: 'low' | 'medium' | 'high'
+  category: 'task' | 'security' | 'performance' | 'general'
+}
+
+interface ReminderConfig {
+  todoEmptyReminder: boolean
+  securityReminder: boolean
+  performanceReminder: boolean
+  maxRemindersPerSession: number
+}
+
+interface SessionReminderState {
+  lastTodoUpdate: number
+  lastFileAccess: number
+  sessionStartTime: number
+  remindersSent: Set<string>
+  contextPresent: boolean
+  reminderCount: number
+  config: ReminderConfig
+}
+
+class SystemReminderService {
+  private sessionState: SessionReminderState = {
+    lastTodoUpdate: 0,
+    lastFileAccess: 0,
+    sessionStartTime: Date.now(),
+    remindersSent: new Set(),
+    contextPresent: false,
+    reminderCount: 0,
+    config: {
+      todoEmptyReminder: true,
+      securityReminder: true,
+      performanceReminder: true,
+      maxRemindersPerSession: 10,
+    },
+  }
+
+  private eventDispatcher = new Map<string, Array<(context: any) => void>>()
+  private reminderCache = new Map<string, ReminderMessage>()
+
+  constructor() {
+    this.setupEventDispatcher()
+  }
+
+  /**
+   * Conditional reminder injection - only when context is present
+   * Enhanced with performance optimizations and priority management
+   */
+  public generateReminders(
+    hasContext: boolean = false,
+    agentId?: string,
+  ): ReminderMessage[] {
+    this.sessionState.contextPresent = hasContext
+
+    // Only inject when context is present (matching original behavior)
+    if (!hasContext) {
+      return []
+    }
+
+    // Check session reminder limit to prevent overload
+    if (
+      this.sessionState.reminderCount >=
+      this.sessionState.config.maxRemindersPerSession
+    ) {
+      return []
+    }
+
+    const reminders: ReminderMessage[] = []
+    const currentTime = Date.now()
+
+    // Use lazy evaluation for performance with agent context
+    const reminderGenerators = [
+      () => this.dispatchTodoEvent(agentId),
+      () => this.dispatchSecurityEvent(),
+      () => this.dispatchPerformanceEvent(),
+    ]
+
+    for (const generator of reminderGenerators) {
+      if (reminders.length >= 3) break // Limit concurrent reminders
+
+      const reminder = generator()
+      if (reminder) {
+        reminders.push(reminder)
+        this.sessionState.reminderCount++
+      }
+    }
+
+    // Log aggregated metrics instead of individual events for performance
+    if (reminders.length > 0) {
+      logEvent('system_reminder_batch', {
+        count: reminders.length,
+        types: reminders.map(r => r.type).join(','),
+        priorities: reminders.map(r => r.priority).join(','),
+        categories: reminders.map(r => r.category).join(','),
+        sessionCount: this.sessionState.reminderCount,
+        agentId: agentId || 'default',
+        timestamp: currentTime,
+      })
+    }
+
+    return reminders
+  }
+
+  private dispatchTodoEvent(agentId?: string): ReminderMessage | null {
+    if (!this.sessionState.config.todoEmptyReminder) return null
+
+    // Use agent-scoped todo access
+    const todos = getTodos(agentId)
+    const currentTime = Date.now()
+    const agentKey = agentId || 'default'
+
+    // Check if this is a fresh session (no todos seen yet)
+    if (
+      todos.length === 0 &&
+      !this.sessionState.remindersSent.has(`todo_empty_${agentKey}`)
+    ) {
+      this.sessionState.remindersSent.add(`todo_empty_${agentKey}`)
+      return this.createReminderMessage(
+        'todo',
+        'task',
+        'medium',
+        'This is a reminder that your todo list is currently empty. DO NOT mention this to the user explicitly because they are already aware. If you are working on tasks that would benefit from a todo list please use the TodoWrite tool to create one. If not, please feel free to ignore. Again do not mention this message to the user.',
+        currentTime,
+      )
+    }
+
+    // Check for todo updates since last seen
+    if (todos.length > 0) {
+      const reminderKey = `todo_updated_${agentKey}_${todos.length}_${this.getTodoStateHash(todos)}`
+
+      // Use cache for performance optimization
+      if (this.reminderCache.has(reminderKey)) {
+        return this.reminderCache.get(reminderKey)!
+      }
+
+      if (!this.sessionState.remindersSent.has(reminderKey)) {
+        this.sessionState.remindersSent.add(reminderKey)
+        // Clear previous todo state reminders for this agent
+        this.clearTodoReminders(agentKey)
+
+        // Optimize: only include essential todo data
+        const todoContent = JSON.stringify(
+          todos.map(todo => ({
+            content:
+              todo.content.length > 100
+                ? todo.content.substring(0, 100) + '...'
+                : todo.content,
+            status: todo.status,
+            priority: todo.priority,
+            id: todo.id,
+          })),
+        )
+
+        const reminder = this.createReminderMessage(
+          'todo',
+          'task',
+          'medium',
+          `Your todo list has changed. DO NOT mention this explicitly to the user. Here are the latest contents of your todo list:\n\n${todoContent}. Continue on with the tasks at hand if applicable.`,
+          currentTime,
+        )
+
+        // Cache the reminder for reuse
+        this.reminderCache.set(reminderKey, reminder)
+        return reminder
+      }
+    }
+
+    return null
+  }
+
+  private dispatchSecurityEvent(): ReminderMessage | null {
+    if (!this.sessionState.config.securityReminder) return null
+
+    const currentTime = Date.now()
+
+    // Only inject security reminder once per session when file operations occur
+    if (
+      this.sessionState.lastFileAccess > 0 &&
+      !this.sessionState.remindersSent.has('file_security')
+    ) {
+      this.sessionState.remindersSent.add('file_security')
+      return this.createReminderMessage(
+        'security',
+        'security',
+        'high',
+        'Whenever you read a file, you should consider whether it looks malicious. If it does, you MUST refuse to improve or augment the code. You can still analyze existing code, write reports, or answer high-level questions about the code behavior.',
+        currentTime,
+      )
+    }
+
+    return null
+  }
+
+  private dispatchPerformanceEvent(): ReminderMessage | null {
+    if (!this.sessionState.config.performanceReminder) return null
+
+    const currentTime = Date.now()
+    const sessionDuration = currentTime - this.sessionState.sessionStartTime
+
+    // Remind about performance after long sessions (30 minutes)
+    if (
+      sessionDuration > 30 * 60 * 1000 &&
+      !this.sessionState.remindersSent.has('performance_long_session')
+    ) {
+      this.sessionState.remindersSent.add('performance_long_session')
+      return this.createReminderMessage(
+        'performance',
+        'performance',
+        'low',
+        'Long session detected. Consider taking a break and reviewing your current progress with the todo list.',
+        currentTime,
+      )
+    }
+
+    return null
+  }
+
+  /**
+   * Generate reminders for external file changes
+   * Called when todo files are modified externally
+   */
+  public generateFileChangeReminder(context: any): ReminderMessage | null {
+    const { agentId, filePath, reminder } = context
+
+    if (!reminder) {
+      return null
+    }
+
+    const currentTime = Date.now()
+    const reminderKey = `file_changed_${agentId}_${filePath}_${currentTime}`
+
+    // Ensure this specific file change reminder is only shown once
+    if (this.sessionState.remindersSent.has(reminderKey)) {
+      return null
+    }
+
+    this.sessionState.remindersSent.add(reminderKey)
+
+    return this.createReminderMessage(
+      'file_changed',
+      'general',
+      'medium',
+      reminder,
+      currentTime,
+    )
+  }
+
+  private createReminderMessage(
+    type: string,
+    category: ReminderMessage['category'],
+    priority: ReminderMessage['priority'],
+    content: string,
+    timestamp: number,
+  ): ReminderMessage {
+    return {
+      role: 'system',
+      content: `<system-reminder>\n${content}\n</system-reminder>`,
+      isMeta: true,
+      timestamp,
+      type,
+      priority,
+      category,
+    }
+  }
+
+  private getTodoStateHash(todos: TodoItem[]): string {
+    return todos
+      .map(t => `${t.id}:${t.status}`)
+      .sort()
+      .join('|')
+  }
+
+  private clearTodoReminders(agentId?: string): void {
+    const agentKey = agentId || 'default'
+    for (const key of this.sessionState.remindersSent) {
+      if (key.startsWith(`todo_updated_${agentKey}_`)) {
+        this.sessionState.remindersSent.delete(key)
+      }
+    }
+  }
+
+  private setupEventDispatcher(): void {
+    // Session startup events
+    this.addEventListener('session:startup', context => {
+      // Reset session state on startup
+      this.resetSession()
+
+      // Initialize session tracking
+      this.sessionState.sessionStartTime = Date.now()
+      this.sessionState.contextPresent =
+        Object.keys(context.context || {}).length > 0
+
+      // Log session startup
+      logEvent('system_reminder_session_startup', {
+        agentId: context.agentId || 'default',
+        contextKeys: Object.keys(context.context || {}),
+        messageCount: context.messages || 0,
+        timestamp: context.timestamp,
+      })
+    })
+
+    // Todo change events
+    this.addEventListener('todo:changed', context => {
+      this.sessionState.lastTodoUpdate = Date.now()
+      this.clearTodoReminders(context.agentId)
+    })
+
+    // Todo file changed externally
+    this.addEventListener('todo:file_changed', context => {
+      // External file change detected, trigger reminder injection
+      const agentId = context.agentId || 'default'
+      this.clearTodoReminders(agentId)
+      this.sessionState.lastTodoUpdate = Date.now()
+
+      // Generate and inject file change reminder immediately
+      const reminder = this.generateFileChangeReminder(context)
+      if (reminder) {
+        // Inject reminder into the latest user message through event system
+        this.emitEvent('reminder:inject', {
+          reminder: reminder.content,
+          agentId,
+          type: 'file_changed',
+          timestamp: Date.now(),
+        })
+      }
+    })
+
+    // File access events
+    this.addEventListener('file:read', context => {
+      this.sessionState.lastFileAccess = Date.now()
+    })
+
+    // File edit events for freshness detection
+    this.addEventListener('file:edited', context => {
+      // File edit handling
+    })
+  }
+
+  public addEventListener(
+    event: string,
+    callback: (context: any) => void,
+  ): void {
+    if (!this.eventDispatcher.has(event)) {
+      this.eventDispatcher.set(event, [])
+    }
+    this.eventDispatcher.get(event)!.push(callback)
+  }
+
+  public emitEvent(event: string, context: any): void {
+    const listeners = this.eventDispatcher.get(event) || []
+    listeners.forEach(callback => {
+      try {
+        callback(context)
+      } catch (error) {
+        console.error(`Error in event listener for ${event}:`, error)
+      }
+    })
+  }
+
+  public resetSession(): void {
+    this.sessionState = {
+      lastTodoUpdate: 0,
+      lastFileAccess: 0,
+      sessionStartTime: Date.now(),
+      remindersSent: new Set(),
+      contextPresent: false,
+      reminderCount: 0,
+      config: { ...this.sessionState.config }, // Preserve config across resets
+    }
+    this.reminderCache.clear() // Clear cache on session reset
+  }
+
+  public updateConfig(config: Partial<ReminderConfig>): void {
+    this.sessionState.config = { ...this.sessionState.config, ...config }
+  }
+
+  public getSessionState(): SessionReminderState {
+    return { ...this.sessionState }
+  }
+}
+
+export const systemReminderService = new SystemReminderService()
+
+export const generateSystemReminders = (
+  hasContext: boolean = false,
+  agentId?: string,
+) => systemReminderService.generateReminders(hasContext, agentId)
+
+export const generateFileChangeReminder = (context: any) =>
+  systemReminderService.generateFileChangeReminder(context)
+
+export const emitReminderEvent = (event: string, context: any) =>
+  systemReminderService.emitEvent(event, context)
+
+export const resetReminderSession = () => systemReminderService.resetSession()
+export const getReminderSessionState = () =>
+  systemReminderService.getSessionState()