@shareai-lab/kode 1.1.14 → 1.1.16-dev.2

package/src/services/responseStateManager.ts

@@ -1,90 +0,0 @@
-/**
- * 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

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

package/src/services/statsig.ts

@@ -1,172 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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())
-  }
-}