@shareai-lab/kode 1.0.9

package/src/services/responseStateManager.ts

@@ -0,0 +1,90 @@
+/**
+ * GPT-5 Responses API state management
+ * Manages previous_response_id for conversation continuity and reasoning context reuse
+ */
+
+interface ConversationState {
+  previousResponseId?: string
+  lastUpdate: number
+}
+
+class ResponseStateManager {
+  private conversationStates = new Map<string, ConversationState>()
+  
+  // Cache cleanup after 1 hour of inactivity
+  private readonly CLEANUP_INTERVAL = 60 * 60 * 1000
+  
+  constructor() {
+    // Periodic cleanup of stale conversations
+    setInterval(() => {
+      this.cleanup()
+    }, this.CLEANUP_INTERVAL)
+  }
+  
+  /**
+   * Set the previous response ID for a conversation
+   */
+  setPreviousResponseId(conversationId: string, responseId: string): void {
+    this.conversationStates.set(conversationId, {
+      previousResponseId: responseId,
+      lastUpdate: Date.now()
+    })
+  }
+  
+  /**
+   * Get the previous response ID for a conversation
+   */
+  getPreviousResponseId(conversationId: string): string | undefined {
+    const state = this.conversationStates.get(conversationId)
+    if (state) {
+      // Update last access time
+      state.lastUpdate = Date.now()
+      return state.previousResponseId
+    }
+    return undefined
+  }
+  
+  /**
+   * Clear state for a conversation
+   */
+  clearConversation(conversationId: string): void {
+    this.conversationStates.delete(conversationId)
+  }
+  
+  /**
+   * Clear all conversation states
+   */
+  clearAll(): void {
+    this.conversationStates.clear()
+  }
+  
+  /**
+   * Clean up stale conversations
+   */
+  private cleanup(): void {
+    const now = Date.now()
+    for (const [conversationId, state] of this.conversationStates.entries()) {
+      if (now - state.lastUpdate > this.CLEANUP_INTERVAL) {
+        this.conversationStates.delete(conversationId)
+      }
+    }
+  }
+  
+  /**
+   * Get current state size (for debugging/monitoring)
+   */
+  getStateSize(): number {
+    return this.conversationStates.size
+  }
+}
+
+// Singleton instance
+export const responseStateManager = new ResponseStateManager()
+
+/**
+ * Helper to generate conversation ID from context
+ */
+export function getConversationId(agentId?: string, messageId?: string): string {
+  // Use agentId as primary identifier, fallback to messageId or timestamp
+  return agentId || messageId || `conv_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+}

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,172 @@
+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> => {
+  // Default to disabled gates when Statsig is not active
+  return false
+  // 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 false
+  // 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())
+  }
+}