@shareai-lab/kode 1.1.13 → 1.1.16

package/src/services/fileFreshness.ts

@@ -1,377 +0,0 @@
-import { statSync, existsSync, watchFile, unwatchFile } from 'fs'
-import {
-  emitReminderEvent,
-  systemReminderService,
-} from '../services/systemReminder'
-import { getAgentFilePath } from '../utils/agentStorage'
-import { logEvent } from '../services/statsig'
-
-interface FileTimestamp {
-  path: string
-  lastRead: number
-  lastModified: number
-  size: number
-  lastAgentEdit?: number // Track when Agent last edited this file
-}
-
-interface FileFreshnessState {
-  readTimestamps: Map<string, FileTimestamp>
-  editConflicts: Set<string>
-  sessionFiles: Set<string>
-  watchedTodoFiles: Map<string, string> // agentId -> filePath
-}
-
-class FileFreshnessService {
-  private state: FileFreshnessState = {
-    readTimestamps: new Map(),
-    editConflicts: new Set(),
-    sessionFiles: new Set(),
-    watchedTodoFiles: new Map(),
-  }
-
-  constructor() {
-    this.setupEventListeners()
-  }
-
-  /**
-   * Setup event listeners for session management
-   */
-  private setupEventListeners(): void {
-    // Listen for session startup events through the SystemReminderService
-    systemReminderService.addEventListener(
-      'session:startup',
-      (context: any) => {
-        // Reset session state on startup
-        this.resetSession()
-
-        // Log session startup
-        logEvent('file_freshness_session_startup', {
-          agentId: context.agentId || 'default',
-          timestamp: context.timestamp,
-        })
-      },
-    )
-  }
-
-  /**
-   * Record file read operation with timestamp tracking
-   */
-  public recordFileRead(filePath: string): void {
-    try {
-      if (!existsSync(filePath)) {
-        return
-      }
-
-      const stats = statSync(filePath)
-      const timestamp: FileTimestamp = {
-        path: filePath,
-        lastRead: Date.now(),
-        lastModified: stats.mtimeMs,
-        size: stats.size,
-      }
-
-      this.state.readTimestamps.set(filePath, timestamp)
-      this.state.sessionFiles.add(filePath)
-
-      // Emit file read event for system reminders
-      emitReminderEvent('file:read', {
-        filePath,
-        timestamp: timestamp.lastRead,
-        size: timestamp.size,
-        modified: timestamp.lastModified,
-      })
-    } catch (error) {
-      console.error(`Error recording file read for ${filePath}:`, error)
-    }
-  }
-
-  /**
-   * Check if file has been modified since last read
-   */
-  public checkFileFreshness(filePath: string): {
-    isFresh: boolean
-    lastRead?: number
-    currentModified?: number
-    conflict: boolean
-  } {
-    const recorded = this.state.readTimestamps.get(filePath)
-
-    if (!recorded) {
-      return { isFresh: true, conflict: false }
-    }
-
-    try {
-      if (!existsSync(filePath)) {
-        return { isFresh: false, conflict: true }
-      }
-
-      const currentStats = statSync(filePath)
-      const isFresh = currentStats.mtimeMs <= recorded.lastModified
-      const conflict = !isFresh
-
-      if (conflict) {
-        this.state.editConflicts.add(filePath)
-
-        // Emit file conflict event
-        emitReminderEvent('file:conflict', {
-          filePath,
-          lastRead: recorded.lastRead,
-          lastModified: recorded.lastModified,
-          currentModified: currentStats.mtimeMs,
-          sizeDiff: currentStats.size - recorded.size,
-        })
-      }
-
-      return {
-        isFresh,
-        lastRead: recorded.lastRead,
-        currentModified: currentStats.mtimeMs,
-        conflict,
-      }
-    } catch (error) {
-      console.error(`Error checking freshness for ${filePath}:`, error)
-      return { isFresh: false, conflict: true }
-    }
-  }
-
-  /**
-   * Record file edit operation by Agent
-   */
-  public recordFileEdit(filePath: string, content?: string): void {
-    try {
-      const now = Date.now()
-
-      // Update recorded timestamp after edit
-      if (existsSync(filePath)) {
-        const stats = statSync(filePath)
-        const existing = this.state.readTimestamps.get(filePath)
-
-        if (existing) {
-          existing.lastModified = stats.mtimeMs
-          existing.size = stats.size
-          existing.lastAgentEdit = now // Mark this as Agent-initiated edit
-          this.state.readTimestamps.set(filePath, existing)
-        } else {
-          // Create new record for Agent-edited file
-          const timestamp: FileTimestamp = {
-            path: filePath,
-            lastRead: now,
-            lastModified: stats.mtimeMs,
-            size: stats.size,
-            lastAgentEdit: now,
-          }
-          this.state.readTimestamps.set(filePath, timestamp)
-        }
-      }
-
-      // Remove from conflicts since we just edited it
-      this.state.editConflicts.delete(filePath)
-
-      // Emit file edit event
-      emitReminderEvent('file:edited', {
-        filePath,
-        timestamp: now,
-        contentLength: content?.length || 0,
-        source: 'agent',
-      })
-    } catch (error) {
-      console.error(`Error recording file edit for ${filePath}:`, error)
-    }
-  }
-
-  public generateFileModificationReminder(filePath: string): string | null {
-    const recorded = this.state.readTimestamps.get(filePath)
-
-    if (!recorded) {
-      return null
-    }
-
-    try {
-      if (!existsSync(filePath)) {
-        return `Note: ${filePath} was deleted since last read.`
-      }
-
-      const currentStats = statSync(filePath)
-      const isModified = currentStats.mtimeMs > recorded.lastModified
-
-      if (!isModified) {
-        return null
-      }
-
-      // Check if this was an Agent-initiated change
-      // Use small time tolerance to handle filesystem timestamp precision issues
-      const TIME_TOLERANCE_MS = 100
-      if (
-        recorded.lastAgentEdit &&
-        recorded.lastAgentEdit >= recorded.lastModified - TIME_TOLERANCE_MS
-      ) {
-        // Agent modified this file recently, no reminder needed
-        // (context already contains before/after content)
-        return null
-      }
-
-      // External modification detected - generate reminder
-      return `Note: ${filePath} was modified externally since last read. The file may have changed outside of this session.`
-    } catch (error) {
-      console.error(`Error checking modification for ${filePath}:`, error)
-      return null
-    }
-  }
-
-  public getConflictedFiles(): string[] {
-    return Array.from(this.state.editConflicts)
-  }
-
-  public getSessionFiles(): string[] {
-    return Array.from(this.state.sessionFiles)
-  }
-
-  public resetSession(): void {
-    // Clean up existing todo file watchers
-    this.state.watchedTodoFiles.forEach(filePath => {
-      try {
-        unwatchFile(filePath)
-      } catch (error) {
-        console.error(`Error unwatching file ${filePath}:`, error)
-      }
-    })
-
-    this.state = {
-      readTimestamps: new Map(),
-      editConflicts: new Set(),
-      sessionFiles: new Set(),
-      watchedTodoFiles: new Map(),
-    }
-  }
-
-  /**
-   * Start watching todo file for an agent
-   */
-  public startWatchingTodoFile(agentId: string): void {
-    try {
-      const filePath = getAgentFilePath(agentId)
-
-      // Don't watch if already watching
-      if (this.state.watchedTodoFiles.has(agentId)) {
-        return
-      }
-
-      this.state.watchedTodoFiles.set(agentId, filePath)
-
-      // Record initial state if file exists
-      if (existsSync(filePath)) {
-        this.recordFileRead(filePath)
-      }
-
-      // Start watching for changes
-      watchFile(filePath, { interval: 1000 }, (curr, prev) => {
-        // Check if this was an external modification
-        const reminder = this.generateFileModificationReminder(filePath)
-        if (reminder) {
-          // File was modified externally, emit todo change reminder
-          emitReminderEvent('todo:file_changed', {
-            agentId,
-            filePath,
-            reminder,
-            timestamp: Date.now(),
-            currentStats: { mtime: curr.mtime, size: curr.size },
-            previousStats: { mtime: prev.mtime, size: prev.size },
-          })
-        }
-      })
-    } catch (error) {
-      console.error(
-        `Error starting todo file watch for agent ${agentId}:`,
-        error,
-      )
-    }
-  }
-
-  /**
-   * Stop watching todo file for an agent
-   */
-  public stopWatchingTodoFile(agentId: string): void {
-    try {
-      const filePath = this.state.watchedTodoFiles.get(agentId)
-      if (filePath) {
-        unwatchFile(filePath)
-        this.state.watchedTodoFiles.delete(agentId)
-      }
-    } catch (error) {
-      console.error(
-        `Error stopping todo file watch for agent ${agentId}:`,
-        error,
-      )
-    }
-  }
-
-  public getFileInfo(filePath: string): FileTimestamp | null {
-    return this.state.readTimestamps.get(filePath) || null
-  }
-
-  public isFileTracked(filePath: string): boolean {
-    return this.state.readTimestamps.has(filePath)
-  }
-
-  /**
-   * Retrieves files prioritized for recovery during conversation compression
-   *
-   * Selects recently accessed files based on:
-   * - File access recency (most recent first)
-   * - File type relevance (excludes dependencies, build artifacts)
-   * - Development workflow importance
-   *
-   * Used to maintain coding context when conversation history is compressed
-   */
-  public getImportantFiles(maxFiles: number = 5): Array<{
-    path: string
-    timestamp: number
-    size: number
-  }> {
-    return Array.from(this.state.readTimestamps.entries())
-      .map(([path, info]) => ({
-        path,
-        timestamp: info.lastRead,
-        size: info.size,
-      }))
-      .filter(file => this.isValidForRecovery(file.path))
-      .sort((a, b) => b.timestamp - a.timestamp) // Newest first
-      .slice(0, maxFiles)
-  }
-
-  /**
-   * Determines which files are suitable for automatic recovery
-   *
-   * Excludes files that are typically not relevant for development context:
-   * - Build artifacts and generated files
-   * - Dependencies and cached files
-   * - Temporary files and system directories
-   */
-  private isValidForRecovery(filePath: string): boolean {
-    return (
-      !filePath.includes('node_modules') &&
-      !filePath.includes('.git') &&
-      !filePath.startsWith('/tmp') &&
-      !filePath.includes('.cache') &&
-      !filePath.includes('dist/') &&
-      !filePath.includes('build/')
-    )
-  }
-}
-
-export const fileFreshnessService = new FileFreshnessService()
-
-export const recordFileRead = (filePath: string) =>
-  fileFreshnessService.recordFileRead(filePath)
-export const recordFileEdit = (filePath: string, content?: string) =>
-  fileFreshnessService.recordFileEdit(filePath, content)
-export const checkFileFreshness = (filePath: string) =>
-  fileFreshnessService.checkFileFreshness(filePath)
-export const generateFileModificationReminder = (filePath: string) =>
-  fileFreshnessService.generateFileModificationReminder(filePath)
-export const resetFileFreshnessSession = () =>
-  fileFreshnessService.resetSession()
-export const startWatchingTodoFile = (agentId: string) =>
-  fileFreshnessService.startWatchingTodoFile(agentId)
-export const stopWatchingTodoFile = (agentId: string) =>
-  fileFreshnessService.stopWatchingTodoFile(agentId)

package/src/services/gpt5ConnectionTest.ts

@@ -1,340 +0,0 @@
-/**
- * 🔥 GPT-5 Connection Test Service
- * 
- * Specialized connection testing for GPT-5 models that supports both
- * Responses API and Chat Completions API with proper fallback handling.
- */
-
-import { getModelFeatures } from './openai'
-
-export interface ConnectionTestResult {
-  success: boolean
-  message: string
-  endpoint?: string
-  details?: string
-  apiUsed?: 'responses' | 'chat_completions'
-  responseTime?: number
-}
-
-export interface GPT5TestConfig {
-  model: string
-  apiKey: string
-  baseURL?: string
-  maxTokens?: number
-  provider?: string
-}
-
-/**
- * Test GPT-5 model connection with intelligent API selection
- */
-export async function testGPT5Connection(config: GPT5TestConfig): Promise<ConnectionTestResult> {
-  const startTime = Date.now()
-  
-  // Validate configuration
-  if (!config.model || !config.apiKey) {
-    return {
-      success: false,
-      message: 'Invalid configuration',
-      details: 'Model name and API key are required',
-    }
-  }
-
-  const isGPT5 = config.model.toLowerCase().includes('gpt-5')
-  const modelFeatures = getModelFeatures(config.model)
-  const baseURL = config.baseURL || 'https://api.openai.com/v1'
-  const isOfficialOpenAI = !config.baseURL || config.baseURL.includes('api.openai.com')
-
-  console.log(`🔧 Testing GPT-5 connection for model: ${config.model}`)
-  console.log(`🔧 Base URL: ${baseURL}`)
-  console.log(`🔧 Official OpenAI: ${isOfficialOpenAI}`)
-  console.log(`🔧 Supports Responses API: ${modelFeatures.supportsResponsesAPI}`)
-
-  // Try Responses API first for official GPT-5 models
-  if (isGPT5 && modelFeatures.supportsResponsesAPI && isOfficialOpenAI) {
-    console.log(`🚀 Attempting Responses API for ${config.model}`)
-    const responsesResult = await testResponsesAPI(config, baseURL, startTime)
-    
-    if (responsesResult.success) {
-      console.log(`✅ Responses API test successful for ${config.model}`)
-      return responsesResult
-    } else {
-      console.log(`⚠️ Responses API failed, falling back to Chat Completions: ${responsesResult.details}`)
-    }
-  }
-
-  // Fallback to Chat Completions API
-  console.log(`🔄 Using Chat Completions API for ${config.model}`)
-  return await testChatCompletionsAPI(config, baseURL, startTime)
-}
-
-/**
- * Test using GPT-5 Responses API
- */
-async function testResponsesAPI(
-  config: GPT5TestConfig, 
-  baseURL: string, 
-  startTime: number
-): Promise<ConnectionTestResult> {
-  const testURL = `${baseURL.replace(/\/+$/, '')}/responses`
-  
-  const testPayload = {
-    model: config.model,
-    input: [
-      {
-        role: 'user',
-        content: 'Please respond with exactly "YES" (in capital letters) to confirm this connection is working.',
-      },
-    ],
-    max_completion_tokens: Math.max(config.maxTokens || 8192, 8192),
-    temperature: 1, // GPT-5 requirement
-    reasoning: {
-      effort: 'low', // Fast response for connection test
-    },
-  }
-
-  const headers = {
-    'Content-Type': 'application/json',
-    'Authorization': `Bearer ${config.apiKey}`,
-  }
-
-  console.log(`🔧 Responses API URL: ${testURL}`)
-  console.log(`🔧 Responses API payload:`, JSON.stringify(testPayload, null, 2))
-
-  try {
-    const response = await fetch(testURL, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(testPayload),
-    })
-
-    const responseTime = Date.now() - startTime
-
-    if (response.ok) {
-      const data = await response.json()
-      console.log(`✅ Responses API successful response:`, data)
-
-      // Extract content from Responses API format
-      let responseContent = ''
-      if (data.output_text) {
-        responseContent = data.output_text
-      } else if (data.output && Array.isArray(data.output)) {
-        // Extract from structured output format
-        const messageOutput = data.output.find(item => item.type === 'message')
-        if (messageOutput && messageOutput.content) {
-          const textContent = messageOutput.content.find(c => c.type === 'output_text')
-          responseContent = textContent?.text || ''
-        }
-      }
-
-      const containsYes = responseContent.toLowerCase().includes('yes')
-
-      if (containsYes) {
-        return {
-          success: true,
-          message: '✅ GPT-5 Responses API connection successful',
-          endpoint: '/responses',
-          details: `Model responded correctly: "${responseContent.trim()}"`,
-          apiUsed: 'responses',
-          responseTime,
-        }
-      } else {
-        return {
-          success: false,
-          message: '⚠️ Responses API connected but unexpected response',
-          endpoint: '/responses',
-          details: `Expected "YES" but got: "${responseContent.trim() || '(empty response)'}"`,
-          apiUsed: 'responses',
-          responseTime,
-        }
-      }
-    } else {
-      const errorData = await response.json().catch(() => null)
-      const errorMessage = errorData?.error?.message || errorData?.message || response.statusText
-
-      console.log(`❌ Responses API error (${response.status}):`, errorData)
-
-      return {
-        success: false,
-        message: `❌ Responses API failed (${response.status})`,
-        endpoint: '/responses',
-        details: `Error: ${errorMessage}`,
-        apiUsed: 'responses',
-        responseTime: Date.now() - startTime,
-      }
-    }
-  } catch (error) {
-    console.log(`❌ Responses API connection error:`, error)
-    
-    return {
-      success: false,
-      message: '❌ Responses API connection failed',
-      endpoint: '/responses',
-      details: error instanceof Error ? error.message : String(error),
-      apiUsed: 'responses',
-      responseTime: Date.now() - startTime,
-    }
-  }
-}
-
-/**
- * Test using Chat Completions API with GPT-5 compatibility
- */
-async function testChatCompletionsAPI(
-  config: GPT5TestConfig, 
-  baseURL: string, 
-  startTime: number
-): Promise<ConnectionTestResult> {
-  const testURL = `${baseURL.replace(/\/+$/, '')}/chat/completions`
-  
-  const isGPT5 = config.model.toLowerCase().includes('gpt-5')
-  
-  // Create test payload with GPT-5 compatibility
-  const testPayload: any = {
-    model: config.model,
-    messages: [
-      {
-        role: 'user',
-        content: 'Please respond with exactly "YES" (in capital letters) to confirm this connection is working.',
-      },
-    ],
-    temperature: isGPT5 ? 1 : 0, // GPT-5 requires temperature=1
-    stream: false,
-  }
-
-  // 🔧 Apply GPT-5 parameter transformations
-  if (isGPT5) {
-    testPayload.max_completion_tokens = Math.max(config.maxTokens || 8192, 8192)
-    delete testPayload.max_tokens  // 🔥 CRITICAL: Remove max_tokens for GPT-5
-    console.log(`🔧 GPT-5 mode: Using max_completion_tokens = ${testPayload.max_completion_tokens}`)
-  } else {
-    testPayload.max_tokens = Math.max(config.maxTokens || 8192, 8192)
-  }
-
-  const headers = {
-    'Content-Type': 'application/json',
-  }
-
-  // Add provider-specific headers
-  if (config.provider === 'azure') {
-    headers['api-key'] = config.apiKey
-  } else {
-    headers['Authorization'] = `Bearer ${config.apiKey}`
-  }
-
-  console.log(`🔧 Chat Completions URL: ${testURL}`)
-  console.log(`🔧 Chat Completions payload:`, JSON.stringify(testPayload, null, 2))
-
-  try {
-    const response = await fetch(testURL, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(testPayload),
-    })
-
-    const responseTime = Date.now() - startTime
-
-    if (response.ok) {
-      const data = await response.json()
-      console.log(`✅ Chat Completions successful response:`, data)
-
-      const responseContent = data.choices?.[0]?.message?.content || ''
-      const containsYes = responseContent.toLowerCase().includes('yes')
-
-      if (containsYes) {
-        return {
-          success: true,
-          message: `✅ ${isGPT5 ? 'GPT-5' : 'Model'} Chat Completions connection successful`,
-          endpoint: '/chat/completions',
-          details: `Model responded correctly: "${responseContent.trim()}"`,
-          apiUsed: 'chat_completions',
-          responseTime,
-        }
-      } else {
-        return {
-          success: false,
-          message: '⚠️ Chat Completions connected but unexpected response',
-          endpoint: '/chat/completions',
-          details: `Expected "YES" but got: "${responseContent.trim() || '(empty response)'}"`,
-          apiUsed: 'chat_completions',
-          responseTime,
-        }
-      }
-    } else {
-      const errorData = await response.json().catch(() => null)
-      const errorMessage = errorData?.error?.message || errorData?.message || response.statusText
-
-      console.log(`❌ Chat Completions error (${response.status}):`, errorData)
-
-      // 🔧 Provide specific guidance for GPT-5 errors
-      let details = `Error: ${errorMessage}`
-      if (response.status === 400 && errorMessage.includes('max_tokens') && isGPT5) {
-        details += '\n\n🔧 GPT-5 Fix Applied: This error suggests a parameter compatibility issue. Please check if the provider supports GPT-5 with max_completion_tokens.'
-      }
-
-      return {
-        success: false,
-        message: `❌ Chat Completions failed (${response.status})`,
-        endpoint: '/chat/completions',
-        details: details,
-        apiUsed: 'chat_completions',
-        responseTime: Date.now() - startTime,
-      }
-    }
-  } catch (error) {
-    console.log(`❌ Chat Completions connection error:`, error)
-    
-    return {
-      success: false,
-      message: '❌ Chat Completions connection failed',
-      endpoint: '/chat/completions',
-      details: error instanceof Error ? error.message : String(error),
-      apiUsed: 'chat_completions',
-      responseTime: Date.now() - startTime,
-    }
-  }
-}
-
-/**
- * Quick validation for GPT-5 configuration
- */
-export function validateGPT5Config(config: GPT5TestConfig): { valid: boolean; errors: string[] } {
-  console.log(`🔧 validateGPT5Config called with:`, {
-    model: config.model,
-    hasApiKey: !!config.apiKey,
-    baseURL: config.baseURL,
-    provider: config.provider,
-  })
-  
-  const errors: string[] = []
-
-  if (!config.model) {
-    errors.push('Model name is required')
-  }
-
-  if (!config.apiKey) {
-    errors.push('API key is required')
-  }
-
-  if (config.apiKey && config.apiKey.length < 10) {
-    errors.push('API key appears to be invalid (too short)')
-  }
-
-  const isGPT5 = config.model?.toLowerCase().includes('gpt-5')
-  if (isGPT5) {
-    console.log(`🔧 GPT-5 validation: model=${config.model}, maxTokens=${config.maxTokens}`)
-    
-    if (config.maxTokens && config.maxTokens < 1000) {
-      errors.push('GPT-5 models typically require at least 1000 max tokens')
-    }
-    
-    // 完全移除第三方provider限制，允许所有代理中转站使用GPT-5
-    console.log(`🔧 No third-party restrictions applied for GPT-5`)
-  }
-
-  console.log(`🔧 Validation result:`, { valid: errors.length === 0, errors })
-
-  return {
-    valid: errors.length === 0,
-    errors,
-  }
-}