@shareai-lab/kode 1.1.13 → 1.1.16-dev.1

package/src/services/mentionProcessor.ts

@@ -1,273 +0,0 @@
-/**
- * Mention Processor Service
- * Handles @agent and @file mentions through the system reminder infrastructure
- * Designed to integrate naturally with the existing event-driven architecture
- */
-
-import { emitReminderEvent } from './systemReminder'
-import { getAvailableAgentTypes } from '../utils/agentLoader'
-import { existsSync } from 'fs'
-import { resolve } from 'path'
-import { getCwd } from '../utils/state'
-
-export interface MentionContext {
-  type: 'agent' | 'file'
-  mention: string
-  resolved: string
-  exists: boolean
-  metadata?: any
-}
-
-export interface ProcessedMentions {
-  agents: MentionContext[]
-  files: MentionContext[]
-  hasAgentMentions: boolean
-  hasFileMentions: boolean
-}
-
-class MentionProcessorService {
-  // Centralized mention patterns - single source of truth
-  private static readonly MENTION_PATTERNS = {
-    runAgent: /@(run-agent-[\w\-]+)/g,
-    agent: /@(agent-[\w\-]+)/g,  // Legacy support
-    askModel: /@(ask-[\w\-]+)/g,
-    file: /@([a-zA-Z0-9/._-]+(?:\.[a-zA-Z0-9]+)?)/g
-  } as const
-
-  private agentCache: Map<string, boolean> = new Map()
-  private lastAgentCheck: number = 0
-  private CACHE_TTL = 60000 // 1 minute cache
-
-  /**
-   * Process mentions in user input and emit appropriate events
-   * This follows the event-driven philosophy of system reminders
-   */
-  public async processMentions(input: string): Promise<ProcessedMentions> {
-    const result: ProcessedMentions = {
-      agents: [],
-      files: [],
-      hasAgentMentions: false,
-      hasFileMentions: false,
-    }
-
-    try {
-
-    // Process agent mentions with unified logic to eliminate code duplication
-    const agentMentions = this.extractAgentMentions(input)
-    if (agentMentions.length > 0) {
-      await this.refreshAgentCache()
-      
-      for (const { mention, agentType, isAskModel } of agentMentions) {
-        if (isAskModel || this.agentCache.has(agentType)) {
-          result.agents.push({
-            type: 'agent',
-            mention,
-            resolved: agentType,
-            exists: true,
-            metadata: isAskModel ? { type: 'ask-model' } : undefined
-          })
-          result.hasAgentMentions = true
-          
-          // Emit appropriate event based on mention type
-          this.emitAgentMentionEvent(mention, agentType, isAskModel)
-        }
-      }
-    }
-    
-    // No longer process @xxx format - treat as regular text (emails, etc.)
-
-    // Process file mentions (exclude agent and ask-model mentions)
-    const fileMatches = [...input.matchAll(MentionProcessorService.MENTION_PATTERNS.file)]
-    const processedAgentMentions = new Set(agentMentions.map(am => am.mention))
-    
-    for (const match of fileMatches) {
-      const mention = match[1]
-      
-      // Skip if this is an agent or ask-model mention (already processed)
-      if (mention.startsWith('run-agent-') || mention.startsWith('agent-') || mention.startsWith('ask-') || processedAgentMentions.has(mention)) {
-        continue
-      }
-      
-      // Check if it's a file
-      const filePath = this.resolveFilePath(mention)
-      if (existsSync(filePath)) {
-        result.files.push({
-          type: 'file',
-          mention,
-          resolved: filePath,
-          exists: true,
-        })
-        result.hasFileMentions = true
-        
-        // Emit file mention event for system reminder to handle
-        emitReminderEvent('file:mentioned', {
-          filePath: filePath,
-          originalMention: mention,
-          timestamp: Date.now(),
-        })
-      }
-    }
-
-      return result
-    } catch (error) {
-      console.warn('[MentionProcessor] Failed to process mentions:', {
-        input: input.substring(0, 100) + (input.length > 100 ? '...' : ''),
-        error: error instanceof Error ? error.message : error
-      })
-      
-      // Return empty result on error to maintain system stability
-      return {
-        agents: [],
-        files: [],
-        hasAgentMentions: false,
-        hasFileMentions: false,
-      }
-    }
-  }
-
-  // Removed identifyMention method as it's no longer needed with separate processing
-
-  /**
-   * Resolve file path relative to current working directory
-   */
-  private resolveFilePath(mention: string): string {
-    // Simple consistent logic: mention is always relative to current directory
-    return resolve(getCwd(), mention)
-  }
-
-  /**
-   * Refresh the agent cache periodically
-   * This avoids hitting the agent loader on every mention
-   */
-  private async refreshAgentCache(): Promise<void> {
-    const now = Date.now()
-    if (now - this.lastAgentCheck < this.CACHE_TTL) {
-      return // Cache is still fresh
-    }
-
-    try {
-      const agents = await getAvailableAgentTypes()
-      const previousCacheSize = this.agentCache.size
-      this.agentCache.clear()
-      
-      for (const agent of agents) {
-        // Store only the agent type without prefix for consistent lookup
-        this.agentCache.set(agent.agentType, true)
-      }
-      
-      this.lastAgentCheck = now
-      
-      // Log cache refresh for debugging mention resolution issues
-      if (agents.length !== previousCacheSize) {
-        console.log('[MentionProcessor] Agent cache refreshed:', {
-          agentCount: agents.length,
-          previousCacheSize,
-          cacheAge: now - this.lastAgentCheck
-        })
-      }
-    } catch (error) {
-      console.warn('[MentionProcessor] Failed to refresh agent cache, keeping existing cache:', {
-        error: error instanceof Error ? error.message : error,
-        cacheSize: this.agentCache.size,
-        lastRefresh: new Date(this.lastAgentCheck).toISOString()
-      })
-      // Keep existing cache on error to maintain functionality
-    }
-  }
-
-  /**
-   * Extract agent mentions with unified pattern matching
-   * Consolidates run-agent, agent, and ask-model detection logic
-   */
-  private extractAgentMentions(input: string): Array<{ mention: string; agentType: string; isAskModel: boolean }> {
-    const mentions: Array<{ mention: string; agentType: string; isAskModel: boolean }> = []
-    
-    // Process @run-agent-xxx format (preferred)
-    const runAgentMatches = [...input.matchAll(MentionProcessorService.MENTION_PATTERNS.runAgent)]
-    for (const match of runAgentMatches) {
-      const mention = match[1]
-      const agentType = mention.replace(/^run-agent-/, '')
-      mentions.push({ mention, agentType, isAskModel: false })
-    }
-    
-    // Process @agent-xxx format (legacy)
-    const agentMatches = [...input.matchAll(MentionProcessorService.MENTION_PATTERNS.agent)]
-    for (const match of agentMatches) {
-      const mention = match[1]
-      const agentType = mention.replace(/^agent-/, '')
-      mentions.push({ mention, agentType, isAskModel: false })
-    }
-    
-    // Process @ask-model mentions
-    const askModelMatches = [...input.matchAll(MentionProcessorService.MENTION_PATTERNS.askModel)]
-    for (const match of askModelMatches) {
-      const mention = match[1]
-      mentions.push({ mention, agentType: mention, isAskModel: true })
-    }
-    
-    return mentions
-  }
-  
-  /**
-   * Emit agent mention event with proper typing
-   * Centralized event emission to ensure consistency
-   */
-  private emitAgentMentionEvent(mention: string, agentType: string, isAskModel: boolean): void {
-    try {
-      const eventData = {
-        originalMention: mention,
-        timestamp: Date.now(),
-      }
-
-      if (isAskModel) {
-        emitReminderEvent('ask-model:mentioned', {
-          ...eventData,
-          modelName: mention,
-        })
-      } else {
-        emitReminderEvent('agent:mentioned', {
-          ...eventData,
-          agentType,
-        })
-      }
-      
-      // Debug log for mention event emission tracking
-      console.log('[MentionProcessor] Emitted mention event:', {
-        type: isAskModel ? 'ask-model' : 'agent',
-        mention,
-        agentType: isAskModel ? undefined : agentType
-      })
-    } catch (error) {
-      console.error('[MentionProcessor] Failed to emit mention event:', {
-        mention,
-        agentType,
-        isAskModel,
-        error: error instanceof Error ? error.message : error
-      })
-    }
-  }
-
-  /**
-   * Clear caches - useful for testing or reset
-   */
-  public clearCache(): void {
-    this.agentCache.clear()
-    this.lastAgentCheck = 0
-  }
-}
-
-// Export singleton instance
-export const mentionProcessor = new MentionProcessorService()
-
-/**
- * Process mentions in user input
- * This is the main API for the mention processor
- */
-export const processMentions = (input: string) => 
-  mentionProcessor.processMentions(input)
-
-/**
- * Clear mention processor caches
- */
-export const clearMentionCache = () =>
-  mentionProcessor.clearCache()

package/src/services/modelAdapterFactory.ts

@@ -1,69 +0,0 @@
-import { ModelAPIAdapter } from './adapters/base'
-import { ResponsesAPIAdapter } from './adapters/responsesAPI'
-import { ChatCompletionsAdapter } from './adapters/chatCompletions'
-import { getModelCapabilities } from '../constants/modelCapabilities'
-import { ModelProfile, getGlobalConfig } from '../utils/config'
-import { ModelCapabilities } from '../types/modelCapabilities'
-
-export class ModelAdapterFactory {
-  /**
-   * Create appropriate adapter based on model configuration
-   */
-  static createAdapter(modelProfile: ModelProfile): ModelAPIAdapter {
-    const capabilities = getModelCapabilities(modelProfile.modelName)
-    
-    // Determine which API to use
-    const apiType = this.determineAPIType(modelProfile, capabilities)
-    
-    // Create corresponding adapter
-    switch (apiType) {
-      case 'responses_api':
-        return new ResponsesAPIAdapter(capabilities, modelProfile)
-      case 'chat_completions':
-      default:
-        return new ChatCompletionsAdapter(capabilities, modelProfile)
-    }
-  }
-  
-  /**
-   * Determine which API should be used
-   */
-  private static determineAPIType(
-    modelProfile: ModelProfile,
-    capabilities: ModelCapabilities
-  ): 'responses_api' | 'chat_completions' {
-    // If model doesn't support Responses API, use Chat Completions directly
-    if (capabilities.apiArchitecture.primary !== 'responses_api') {
-      return 'chat_completions'
-    }
-    
-    // Check if this is official OpenAI endpoint
-    const isOfficialOpenAI = !modelProfile.baseURL || 
-      modelProfile.baseURL.includes('api.openai.com')
-    
-    // Non-official endpoints use Chat Completions (even if model supports Responses API)
-    if (!isOfficialOpenAI) {
-      // If there's a fallback option, use fallback
-      if (capabilities.apiArchitecture.fallback === 'chat_completions') {
-        return 'chat_completions'
-      }
-      // Otherwise use primary (might fail, but let it try)
-      return capabilities.apiArchitecture.primary
-    }
-    
-    // For now, always use Responses API for supported models when on official endpoint
-    // Streaming fallback will be handled at runtime if needed
-    
-    // Use primary API type
-    return capabilities.apiArchitecture.primary
-  }
-  
-  /**
-   * Check if model should use Responses API
-   */
-  static shouldUseResponsesAPI(modelProfile: ModelProfile): boolean {
-    const capabilities = getModelCapabilities(modelProfile.modelName)
-    const apiType = this.determineAPIType(modelProfile, capabilities)
-    return apiType === 'responses_api'
-  }
-}

package/src/services/notifier.ts

@@ -1,40 +0,0 @@
-import { getGlobalConfig } from '../utils/config'
-
-export type NotificationOptions = {
-  message: string
-  title?: string
-}
-
-function sendITerm2Notification({ message, title }: NotificationOptions): void {
-  const displayString = title ? `${title}:\n${message}` : message
-  try {
-    process.stdout.write(`\x1b]9;\n\n${displayString}\x07`)
-  } catch {
-    // Ignore errors
-  }
-}
-
-function sendTerminalBell(): void {
-  process.stdout.write('\x07')
-}
-
-export async function sendNotification(
-  notif: NotificationOptions,
-): Promise<void> {
-  const channel = getGlobalConfig().preferredNotifChannel
-  switch (channel) {
-    case 'iterm2':
-      sendITerm2Notification(notif)
-      break
-    case 'terminal_bell':
-      sendTerminalBell()
-      break
-    case 'iterm2_with_bell':
-      sendITerm2Notification(notif)
-      sendTerminalBell()
-      break
-    case 'notifications_disabled':
-      // Do nothing
-      break
-  }
-}