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

package/src/hooks/useUnifiedCompletion.ts

@@ -1,1405 +0,0 @@
-import { useState, useCallback, useEffect, useRef } from 'react'
-import { useInput } from 'ink'
-import { existsSync, statSync, readdirSync } from 'fs'
-import { join, dirname, basename, resolve } from 'path'
-import { getCwd } from '../utils/state'
-import { getCommand } from '../commands'
-import { getActiveAgents } from '../utils/agentLoader'
-import { getModelManager } from '../utils/model'
-import { glob } from 'glob'
-import { matchCommands } from '../utils/fuzzyMatcher'
-import { 
-  getCommonSystemCommands, 
-  getCommandPriority,
-  getEssentialCommands,
-  getMinimalFallbackCommands 
-} from '../utils/commonUnixCommands'
-import type { Command } from '../commands'
-
-// Unified suggestion type for all completion types
-export interface UnifiedSuggestion {
-  value: string
-  displayValue: string
-  type: 'command' | 'agent' | 'file' | 'ask'
-  icon?: string
-  score: number
-  metadata?: any
-  // Clean type system for smart matching
-  isSmartMatch?: boolean  // Instead of magic string checking
-  originalContext?: 'mention' | 'file' | 'command'  // Track source context
-}
-
-interface CompletionContext {
-  type: 'command' | 'agent' | 'file' | null
-  prefix: string
-  startPos: number
-  endPos: number
-}
-
-// Terminal behavior state for preview and cycling
-interface TerminalState {
-  originalWord: string
-  wordContext: { start: number; end: number } | null
-  isPreviewMode: boolean
-}
-
-interface Props {
-  input: string
-  cursorOffset: number
-  onInputChange: (value: string) => void
-  setCursorOffset: (offset: number) => void
-  commands: Command[]
-  onSubmit?: (value: string, isSubmittingSlashCommand?: boolean) => void
-}
-
-/**
- * Unified completion system - Linus approved
- * One hook to rule them all, no bullshit, no complexity
- */
-// Unified completion state - single source of truth
-interface CompletionState {
-  suggestions: UnifiedSuggestion[]
-  selectedIndex: number
-  isActive: boolean
-  context: CompletionContext | null
-  preview: {
-    isActive: boolean
-    originalInput: string
-    wordRange: [number, number]
-  } | null
-  emptyDirMessage: string
-  suppressUntil: number // timestamp for suppression
-}
-
-const INITIAL_STATE: CompletionState = {
-  suggestions: [],
-  selectedIndex: 0,
-  isActive: false,
-  context: null,
-  preview: null,
-  emptyDirMessage: '',
-  suppressUntil: 0
-}
-
-export function useUnifiedCompletion({
-  input,
-  cursorOffset,
-  onInputChange,
-  setCursorOffset,
-  commands,
-  onSubmit,
-}: Props) {
-  // Single state for entire completion system - Linus approved
-  const [state, setState] = useState<CompletionState>(INITIAL_STATE)
-
-  // State update helpers - clean and simple
-  const updateState = useCallback((updates: Partial<CompletionState>) => {
-    setState(prev => ({ ...prev, ...updates }))
-  }, [])
-
-  const resetCompletion = useCallback(() => {
-    setState(prev => ({
-      ...prev,
-      suggestions: [],
-      selectedIndex: 0,
-      isActive: false,
-      context: null,
-      preview: null,
-      emptyDirMessage: ''
-    }))
-  }, [])
-
-  const activateCompletion = useCallback((suggestions: UnifiedSuggestion[], context: CompletionContext) => {
-    setState(prev => ({
-      ...prev,
-      suggestions: suggestions, // Keep the order from generateSuggestions (already sorted with weights)
-      selectedIndex: 0,
-      isActive: true,
-      context,
-      preview: null
-    }))
-  }, [])
-
-  // Direct state access - no legacy wrappers needed
-  const { suggestions, selectedIndex, isActive, emptyDirMessage } = state
-
-  // Find common prefix among suggestions (terminal behavior)
-  const findCommonPrefix = useCallback((suggestions: UnifiedSuggestion[]): string => {
-    if (suggestions.length === 0) return ''
-    if (suggestions.length === 1) return suggestions[0].value
-    
-    let prefix = suggestions[0].value
-    
-    for (let i = 1; i < suggestions.length; i++) {
-      const str = suggestions[i].value
-      let j = 0
-      while (j < prefix.length && j < str.length && prefix[j] === str[j]) {
-        j++
-      }
-      prefix = prefix.slice(0, j)
-      
-      if (prefix.length === 0) return ''
-    }
-    
-    return prefix
-  }, [])
-
-  // Clean word detection - Linus approved simplicity
-  const getWordAtCursor = useCallback((): CompletionContext | null => {
-    if (!input) return null
-    
-    // IMPORTANT: Only match the word/prefix BEFORE the cursor
-    // Don't include text after cursor to avoid confusion
-    let start = cursorOffset
-    
-    // Move start backwards to find word beginning
-    // Stop at whitespace or special boundaries
-    while (start > 0) {
-      const char = input[start - 1]
-      // Stop at whitespace
-      if (/\s/.test(char)) break
-      
-      // For @mentions, include @ and stop
-      if (char === '@' && start < cursorOffset) {
-        start--
-        break
-      }
-      
-      // For paths, be smarter about / handling
-      if (char === '/') {
-        // Look ahead to see what we've collected so far
-        const collectedSoFar = input.slice(start, cursorOffset)
-        
-        // If we already have a path component, this / is part of the path
-        if (collectedSoFar.includes('/') || collectedSoFar.includes('.')) {
-          start--
-          continue
-        }
-        
-        // Check if this is part of a path pattern like ./ or ../ or ~/
-        if (start > 1) {
-          const prevChar = input[start - 2]
-          if (prevChar === '.' || prevChar === '~') {
-            // It's part of ./ or ../ or ~/ - keep going
-            start--
-            continue
-          }
-        }
-        
-        // Check if this is a standalone / at the beginning (command)
-        if (start === 1 || (start > 1 && /\s/.test(input[start - 2]))) {
-          start--
-          break // It's a command slash
-        }
-        
-        // Otherwise treat as path separator
-        start--
-        continue
-      }
-      
-      // Special handling for dots in paths
-      if (char === '.' && start > 0) {
-        // Check if this might be start of ./ or ../
-        const nextChar = start < input.length ? input[start] : ''
-        if (nextChar === '/' || nextChar === '.') {
-          start--
-          continue // Part of a path pattern
-        }
-      }
-      
-      start--
-    }
-    
-    // The word is from start to cursor position (not beyond)
-    const word = input.slice(start, cursorOffset)
-    if (!word) return null
-    
-    // Priority-based type detection - no special cases needed
-    if (word.startsWith('/')) {
-      const beforeWord = input.slice(0, start).trim()
-      const isCommand = beforeWord === '' && !word.includes('/', 1)
-      return {
-        type: isCommand ? 'command' : 'file',
-        prefix: isCommand ? word.slice(1) : word,
-        startPos: start,
-        endPos: cursorOffset // Use cursor position as end
-      }
-    }
-    
-    if (word.startsWith('@')) {
-      const content = word.slice(1) // Remove @
-      
-      // Check if this looks like an email (contains @ in the middle)
-      if (word.includes('@', 1)) {
-        // This looks like an email, treat as regular text
-        return null
-      }
-      
-      // Trigger completion for @mentions (agents, ask-models, files)
-      return {
-        type: 'agent', // This will trigger mixed agent+file completion
-        prefix: content,
-        startPos: start,
-        endPos: cursorOffset // Use cursor position as end
-      }
-    }
-    
-    // Everything else defaults to file completion
-    return {
-      type: 'file', 
-      prefix: word,
-      startPos: start,
-      endPos: cursorOffset // Use cursor position as end
-    }
-  }, [input, cursorOffset])
-
-  // System commands cache - populated dynamically from $PATH
-  const [systemCommands, setSystemCommands] = useState<string[]>([])
-  const [isLoadingCommands, setIsLoadingCommands] = useState(false)
-  
-  // Dynamic command classification based on intrinsic features
-  const classifyCommand = useCallback((cmd: string): 'core' | 'common' | 'dev' | 'system' => {
-    const lowerCmd = cmd.toLowerCase()
-    let score = 0
-    
-    // === FEATURE 1: Name Length & Complexity ===
-    // Short, simple names are usually core commands
-    if (cmd.length <= 4) score += 40
-    else if (cmd.length <= 6) score += 20
-    else if (cmd.length <= 8) score += 10
-    else if (cmd.length > 15) score -= 30 // Very long names are specialized
-    
-    // === FEATURE 2: Character Patterns ===
-    // Simple alphabetic names are more likely core
-    if (/^[a-z]+$/.test(lowerCmd)) score += 30
-    
-    // Mixed case, numbers, dots suggest specialized tools
-    if (/[A-Z]/.test(cmd)) score -= 15
-    if (/\d/.test(cmd)) score -= 20
-    if (cmd.includes('.')) score -= 25
-    if (cmd.includes('-')) score -= 10
-    if (cmd.includes('_')) score -= 15
-    
-    // === FEATURE 3: Linguistic Patterns ===
-    // Single, common English words
-    const commonWords = ['list', 'copy', 'move', 'find', 'print', 'show', 'edit', 'view']
-    if (commonWords.some(word => lowerCmd.includes(word.slice(0, 3)))) score += 25
-    
-    // Domain-specific prefixes/suffixes
-    const devPrefixes = ['git', 'npm', 'node', 'py', 'docker', 'kubectl']
-    if (devPrefixes.some(prefix => lowerCmd.startsWith(prefix))) score += 15
-    
-    // System/daemon indicators  
-    const systemIndicators = ['daemon', 'helper', 'responder', 'service', 'd$', 'ctl$']
-    if (systemIndicators.some(indicator => 
-      indicator.endsWith('$') ? lowerCmd.endsWith(indicator.slice(0, -1)) : lowerCmd.includes(indicator)
-    )) score -= 40
-    
-    // === FEATURE 4: File Extension Indicators ===
-    // Commands with extensions are usually scripts/specialized tools
-    if (/\.(pl|py|sh|rb|js)$/.test(lowerCmd)) score -= 35
-    
-    // === FEATURE 5: Path Location Heuristics ===
-    // Note: We don't have path info here, but can infer from name patterns
-    // Commands that look like they belong in /usr/local/bin or specialized dirs
-    const buildToolPatterns = ['bindep', 'render', 'mako', 'webpack', 'babel', 'eslint']
-    if (buildToolPatterns.some(pattern => lowerCmd.includes(pattern))) score -= 25
-    
-    // === FEATURE 6: Vowel/Consonant Patterns ===
-    // Unix commands often have abbreviated names with few vowels
-    const vowelRatio = (lowerCmd.match(/[aeiou]/g) || []).length / lowerCmd.length
-    if (vowelRatio < 0.2) score += 15 // Very few vowels (like 'ls', 'cp', 'mv')
-    if (vowelRatio > 0.5) score -= 10  // Too many vowels (usually full words)
-    
-    // === CLASSIFICATION BASED ON SCORE ===
-    if (score >= 50) return 'core'      // 50+: Core unix commands
-    if (score >= 20) return 'common'    // 20-49: Common dev tools  
-    if (score >= -10) return 'dev'      // -10-19: Specialized dev tools
-    return 'system'                     // <-10: System/edge commands
-  }, [])
-
-  // Load system commands from PATH (like real terminal)
-  const loadSystemCommands = useCallback(async () => {
-    if (systemCommands.length > 0 || isLoadingCommands) return // Already loaded or loading
-    
-    setIsLoadingCommands(true)
-    try {
-      const { readdirSync, statSync } = await import('fs')
-      const pathDirs = (process.env.PATH || '').split(':').filter(Boolean)
-      const commandSet = new Set<string>()
-      
-      // Get essential commands from utils
-      const essentialCommands = getEssentialCommands()
-      
-      // Add essential commands first
-      essentialCommands.forEach(cmd => commandSet.add(cmd))
-      
-      // Scan PATH directories for executables
-      for (const dir of pathDirs) {
-        try {
-          if (readdirSync && statSync) {
-            const entries = readdirSync(dir)
-            for (const entry of entries) {
-              try {
-                const fullPath = `${dir}/${entry}`
-                const stats = statSync(fullPath)
-                // Check if it's executable (rough check)
-                if (stats.isFile() && (stats.mode & 0o111) !== 0) {
-                  commandSet.add(entry)
-                }
-              } catch {
-                // Skip files we can't stat
-              }
-            }
-          }
-        } catch {
-          // Skip directories we can't read
-        }
-      }
-      
-      const commands = Array.from(commandSet).sort()
-      setSystemCommands(commands)
-    } catch (error) {
-      console.warn('Failed to load system commands, using fallback:', error)
-      // Use minimal fallback commands from utils if system scan fails
-      setSystemCommands(getMinimalFallbackCommands())
-    } finally {
-      setIsLoadingCommands(false)
-    }
-  }, [systemCommands.length, isLoadingCommands])
-  
-  // Load commands on first use
-  useEffect(() => {
-    loadSystemCommands()
-  }, [loadSystemCommands])
-
-  // Generate command suggestions (slash commands)
-  const generateCommandSuggestions = useCallback((prefix: string): UnifiedSuggestion[] => {
-    const filteredCommands = commands.filter(cmd => !cmd.isHidden)
-    
-    if (!prefix) {
-      // Show all commands when prefix is empty (for single /)
-      return filteredCommands.map(cmd => ({
-        value: cmd.userFacingName(),
-        displayValue: `/${cmd.userFacingName()}`,
-        type: 'command' as const,
-        score: 100,
-      }))
-    }
-    
-    return filteredCommands
-      .filter(cmd => {
-        const names = [cmd.userFacingName(), ...(cmd.aliases || [])]
-        return names.some(name => name.toLowerCase().startsWith(prefix.toLowerCase()))
-      })
-      .map(cmd => ({
-        value: cmd.userFacingName(),
-        displayValue: `/${cmd.userFacingName()}`,
-        type: 'command' as const,
-        score: 100 - prefix.length + (cmd.userFacingName().startsWith(prefix) ? 10 : 0),
-      }))
-  }, [commands])
-
-  // Clean Unix command scoring using fuzzy matcher
-  const calculateUnixCommandScore = useCallback((cmd: string, prefix: string): number => {
-    const result = matchCommands([cmd], prefix)
-    return result.length > 0 ? result[0].score : 0
-  }, [])
-
-  // Clean Unix command suggestions using fuzzy matcher with common commands boost
-  const generateUnixCommandSuggestions = useCallback((prefix: string): UnifiedSuggestion[] => {
-    if (!prefix) return []
-    
-    // Loading state
-    if (isLoadingCommands) {
-      return [{
-        value: 'loading...',
-        displayValue: `⏳ Loading system commands...`,
-        type: 'file' as const,
-        score: 0,
-        metadata: { isLoading: true }
-      }]
-    }
-    
-    // IMPORTANT: Only use commands that exist on the system (intersection)
-    const commonCommands = getCommonSystemCommands(systemCommands)
-    
-    // Deduplicate commands (in case of any duplicates)
-    const uniqueCommands = Array.from(new Set(commonCommands))
-    
-    // Use fuzzy matcher ONLY on the unique intersection
-    const matches = matchCommands(uniqueCommands, prefix)
-    
-    // Boost common commands
-    const boostedMatches = matches.map(match => {
-      const priority = getCommandPriority(match.command)
-      return {
-        ...match,
-        score: match.score + priority * 0.5 // Add priority boost
-      }
-    }).sort((a, b) => b.score - a.score)
-    
-    // Limit results intelligently
-    let results = boostedMatches.slice(0, 8)
-    
-    // If we have very high scores (900+), show fewer
-    const perfectMatches = boostedMatches.filter(m => m.score >= 900)
-    if (perfectMatches.length > 0 && perfectMatches.length <= 3) {
-      results = perfectMatches
-    }
-    // If we have good scores (100+), prefer them
-    else if (boostedMatches.length > 8) {
-      const goodMatches = boostedMatches.filter(m => m.score >= 100)
-      if (goodMatches.length <= 5) {
-        results = goodMatches
-      }
-    }
-    
-    return results.map(item => ({
-      value: item.command,
-      displayValue: `$ ${item.command}`,
-      type: 'command' as const,
-      score: item.score,
-      metadata: { isUnixCommand: true }
-    }))
-  }, [systemCommands, isLoadingCommands])
-
-  // Agent suggestions cache
-  const [agentSuggestions, setAgentSuggestions] = useState<UnifiedSuggestion[]>([])
-  
-  // Model suggestions cache
-  const [modelSuggestions, setModelSuggestions] = useState<UnifiedSuggestion[]>([])
-  
-  // Load model suggestions
-  useEffect(() => {
-    try {
-      const modelManager = getModelManager()
-      const allModels = modelManager.getAllAvailableModelNames()
-      
-      const suggestions = allModels.map(modelId => {
-        // Professional and clear description for expert model consultation
-        return {
-          value: `ask-${modelId}`,
-          displayValue: `🦜 ask-${modelId} :: Consult ${modelId} for expert opinion and specialized analysis`,
-          type: 'ask' as const,
-          score: 90, // Higher than agents - put ask-models on top
-          metadata: { modelId },
-        }
-      })
-      
-      setModelSuggestions(suggestions)
-    } catch (error) {
-      console.warn('[useUnifiedCompletion] Failed to load models:', error)
-      // No fallback - rely on dynamic loading only
-      setModelSuggestions([])
-    }
-  }, [])
-  
-  // Load agent suggestions on mount
-  useEffect(() => {
-    getActiveAgents().then(agents => {
-      // agents is an array of AgentConfig, not an object
-      const suggestions = agents.map(config => {
-        // 🧠 智能描述算法 - 适应性长度控制
-        let shortDesc = config.whenToUse
-        
-        // 移除常见的冗余前缀，但保留核心内容
-        const prefixPatterns = [
-          /^Use this agent when you need (assistance with: )?/i,
-          /^Use PROACTIVELY (when|to) /i,
-          /^Specialized in /i,
-          /^Implementation specialist for /i,
-          /^Design validation specialist\.? Use PROACTIVELY to /i,
-          /^Task validation specialist\.? Use PROACTIVELY to /i,
-          /^Requirements validation specialist\.? Use PROACTIVELY to /i
-        ]
-        
-        for (const pattern of prefixPatterns) {
-          shortDesc = shortDesc.replace(pattern, '')
-        }
-        
-        // 🎯 精准断句算法：中英文句号感叹号优先 → 逗号 → 省略
-        const findSmartBreak = (text: string, maxLength: number) => {
-          if (text.length <= maxLength) return text
-          
-          // 第一优先级：中英文句号、感叹号
-          const sentenceEndings = /[.!。！]/
-          const firstSentenceMatch = text.search(sentenceEndings)
-          if (firstSentenceMatch !== -1) {
-            const firstSentence = text.slice(0, firstSentenceMatch).trim()
-            if (firstSentence.length >= 5) {
-              return firstSentence
-            }
-          }
-          
-          // 如果第一句过长，找逗号断句
-          if (text.length > maxLength) {
-            const commaEndings = /[,，]/
-            const commas = []
-            let match
-            const regex = new RegExp(commaEndings, 'g')
-            while ((match = regex.exec(text)) !== null) {
-              commas.push(match.index)
-            }
-            
-            // 找最后一个在maxLength内的逗号
-            for (let i = commas.length - 1; i >= 0; i--) {
-              const commaPos = commas[i]
-              if (commaPos < maxLength) {
-                const clause = text.slice(0, commaPos).trim()
-                if (clause.length >= 5) {
-                  return clause
-                }
-              }
-            }
-          }
-          
-          // 最后选择：直接省略
-          return text.slice(0, maxLength) + '...'
-        }
-        
-        shortDesc = findSmartBreak(shortDesc.trim(), 80) // 增加到80字符限制
-        
-        // 如果处理后为空或太短，使用原始描述
-        if (!shortDesc || shortDesc.length < 5) {
-          shortDesc = findSmartBreak(config.whenToUse, 80)
-        }
-        
-        return {
-          value: `run-agent-${config.agentType}`,
-          displayValue: `👤 run-agent-${config.agentType} :: ${shortDesc}`, // 人类图标 + run-agent前缀 + 简洁描述
-          type: 'agent' as const,
-          score: 85, // Lower than ask-models
-          metadata: config,
-        }
-      })
-      // Agents loaded successfully
-      setAgentSuggestions(suggestions)
-    }).catch((error) => {
-      console.warn('[useUnifiedCompletion] Failed to load agents:', error)
-      // No fallback - rely on dynamic loading only
-      setAgentSuggestions([])
-    })
-  }, [])
-
-  // Generate agent and model suggestions using fuzzy matching
-  const generateMentionSuggestions = useCallback((prefix: string): UnifiedSuggestion[] => {
-    // Combine agent and model suggestions
-    const allSuggestions = [...agentSuggestions, ...modelSuggestions]
-    
-    if (!prefix) {
-      // Show all suggestions when prefix is empty (for single @)
-      return allSuggestions.sort((a, b) => {
-        // Ask models first (higher score), then agents
-        if (a.type === 'ask' && b.type === 'agent') return -1
-        if (a.type === 'agent' && b.type === 'ask') return 1
-        return b.score - a.score
-      })
-    }
-    
-    // Use fuzzy matching for intelligent completion
-    const candidates = allSuggestions.map(s => s.value)
-    const matches = matchCommands(candidates, prefix)
-    
-    // Create result mapping with fuzzy scores
-    const fuzzyResults = matches
-      .map(match => {
-        const suggestion = allSuggestions.find(s => s.value === match.command)!
-        return {
-          ...suggestion,
-          score: match.score // Use fuzzy match score instead of simple scoring
-        }
-      })
-      .sort((a, b) => {
-        // Ask models first (for equal scores), then agents
-        if (a.type === 'ask' && b.type === 'agent') return -1
-        if (a.type === 'agent' && b.type === 'ask') return 1
-        return b.score - a.score
-      })
-    
-    return fuzzyResults
-  }, [agentSuggestions, modelSuggestions])
-
-  // Unix-style path completion - preserves user input semantics
-  const generateFileSuggestions = useCallback((prefix: string, isAtReference: boolean = false): UnifiedSuggestion[] => {
-    try {
-      const cwd = getCwd()
-      
-      // Parse user input preserving original format
-      const userPath = prefix || '.'
-      const isAbsolutePath = userPath.startsWith('/')
-      const isHomePath = userPath.startsWith('~')
-      
-      // Resolve search directory - but keep user's path format for output
-      let searchPath: string
-      if (isHomePath) {
-        searchPath = userPath.replace('~', process.env.HOME || '')
-      } else if (isAbsolutePath) {
-        searchPath = userPath
-      } else {
-        searchPath = resolve(cwd, userPath)
-      }
-      
-      // Determine search directory and filename filter
-      // If path ends with '/', treat it as directory navigation
-      const endsWithSlash = userPath.endsWith('/')
-      const searchStat = existsSync(searchPath) ? statSync(searchPath) : null
-      
-      let searchDir: string
-      let nameFilter: string
-      
-      if (endsWithSlash || searchStat?.isDirectory()) {
-        // User is navigating into a directory or path ends with /
-        searchDir = searchPath
-        nameFilter = ''
-      } else {
-        // User might be typing a partial filename
-        searchDir = dirname(searchPath)
-        nameFilter = basename(searchPath)
-      }
-      
-      if (!existsSync(searchDir)) return []
-      
-      // Get directory entries with filter
-      const showHidden = nameFilter.startsWith('.') || userPath.includes('/.')
-      const entries = readdirSync(searchDir)
-        .filter(entry => {
-          // Filter hidden files unless user explicitly wants them
-          if (!showHidden && entry.startsWith('.')) return false
-          // Filter by name if there's a filter
-          if (nameFilter && !entry.toLowerCase().startsWith(nameFilter.toLowerCase())) return false
-          return true
-        })
-        .sort((a, b) => {
-          // Sort directories first, then files
-          const aPath = join(searchDir, a)
-          const bPath = join(searchDir, b)
-          const aIsDir = statSync(aPath).isDirectory()
-          const bIsDir = statSync(bPath).isDirectory()
-          
-          if (aIsDir && !bIsDir) return -1
-          if (!aIsDir && bIsDir) return 1
-          
-          // Within same type, sort alphabetically
-          return a.toLowerCase().localeCompare(b.toLowerCase())
-        })
-        .slice(0, 25)  // Show more entries for better visibility
-      
-      return entries.map(entry => {
-        const entryPath = join(searchDir, entry)
-        const isDir = statSync(entryPath).isDirectory()
-        const icon = isDir ? '📁' : '📄'
-        
-        // Unix-style path building - preserve user's original path format
-        let value: string
-        
-        if (userPath.includes('/')) {
-          // User typed path with separators - maintain structure
-          if (endsWithSlash) {
-            // User explicitly ended with / - they're inside the directory
-            value = userPath + entry + (isDir ? '/' : '')
-          } else if (searchStat?.isDirectory()) {
-            // Path is a directory but doesn't end with / - add separator
-            value = userPath + '/' + entry + (isDir ? '/' : '')
-          } else {
-            // User is completing a filename - replace basename
-            const userDir = userPath.includes('/') ? userPath.substring(0, userPath.lastIndexOf('/')) : ''
-            value = userDir ? userDir + '/' + entry + (isDir ? '/' : '') : entry + (isDir ? '/' : '')
-          }
-        } else {
-          // User typed simple name - check if it's an existing directory
-          if (searchStat?.isDirectory()) {
-            // Existing directory - navigate into it
-            value = userPath + '/' + entry + (isDir ? '/' : '')
-          } else {
-            // Simple completion at current level
-            value = entry + (isDir ? '/' : '')
-          }
-        }
-        
-        return {
-          value,
-          displayValue: `${icon} ${entry}${isDir ? '/' : ''}`,
-          type: 'file' as const,
-          score: isDir ? 80 : 70,
-        }
-      })
-    } catch {
-      return []
-    }
-  }, [])
-
-  // Unified smart matching - single algorithm with different weights
-  const calculateMatchScore = useCallback((suggestion: UnifiedSuggestion, prefix: string): number => {
-    const lowerPrefix = prefix.toLowerCase()
-    const value = suggestion.value.toLowerCase()
-    const displayValue = suggestion.displayValue.toLowerCase()
-    
-    let matchFound = false
-    let score = 0
-    
-    // Check for actual matches first
-    if (value.startsWith(lowerPrefix)) {
-      matchFound = true
-      score = 100  // Highest priority
-    } else if (value.includes(lowerPrefix)) {
-      matchFound = true
-      score = 95  
-    } else if (displayValue.includes(lowerPrefix)) {
-      matchFound = true
-      score = 90
-    } else {
-      // Word boundary matching for compound names like "general" -> "run-agent-general-purpose"
-      const words = value.split(/[-_]/)
-      if (words.some(word => word.startsWith(lowerPrefix))) {
-        matchFound = true
-        score = 93
-      } else {
-        // Acronym matching (last resort)
-        const acronym = words.map(word => word[0]).join('')
-        if (acronym.startsWith(lowerPrefix)) {
-          matchFound = true
-          score = 88
-        }
-      }
-    }
-    
-    // Only return score if we found a match
-    if (!matchFound) return 0
-    
-    // Type preferences (small bonus)
-    if (suggestion.type === 'ask') score += 2
-    if (suggestion.type === 'agent') score += 1
-    
-    return score
-  }, [])
-
-  // Generate smart mention suggestions without data pollution
-  const generateSmartMentionSuggestions = useCallback((prefix: string, sourceContext: 'file' | 'agent' = 'file'): UnifiedSuggestion[] => {
-    if (!prefix || prefix.length < 2) return []
-    
-    const allSuggestions = [...agentSuggestions, ...modelSuggestions]
-    
-    return allSuggestions
-      .map(suggestion => {
-        const matchScore = calculateMatchScore(suggestion, prefix)
-        if (matchScore === 0) return null
-        
-        // Clean transformation without data pollution
-        return {
-          ...suggestion,
-          score: matchScore,
-          isSmartMatch: true,
-          originalContext: sourceContext,
-          // Only modify display for clarity, keep value clean
-          displayValue: `🎯 ${suggestion.displayValue}`
-        }
-      })
-      .filter(Boolean)
-      .sort((a, b) => b.score - a.score)
-      .slice(0, 5)
-  }, [agentSuggestions, modelSuggestions, calculateMatchScore])
-
-  // Generate all suggestions based on context
-  const generateSuggestions = useCallback((context: CompletionContext): UnifiedSuggestion[] => {
-    switch (context.type) {
-      case 'command':
-        return generateCommandSuggestions(context.prefix)
-      case 'agent': {
-        // @ reference: combine mentions and files with clean priority
-        const mentionSuggestions = generateMentionSuggestions(context.prefix)
-        const fileSuggestions = generateFileSuggestions(context.prefix, true) // isAtReference=true
-        
-        // Apply weights for @ context (agents/models should be prioritized but files visible)
-        const weightedSuggestions = [
-          ...mentionSuggestions.map(s => ({
-            ...s,
-            // In @ context, agents/models get high priority
-            weightedScore: s.score + 150
-          })),
-          ...fileSuggestions.map(s => ({
-            ...s,
-            // Files get lower priority but still visible
-            weightedScore: s.score + 10 // Small boost to ensure visibility
-          }))
-        ]
-        
-        // Sort by weighted score - no artificial limits
-        return weightedSuggestions
-          .sort((a, b) => b.weightedScore - a.weightedScore)
-          .map(({ weightedScore, ...suggestion }) => suggestion)
-          // No limit or very generous limit (e.g., 30 items)
-      }
-      case 'file': {
-        // For normal input, try to match everything intelligently
-        const fileSuggestions = generateFileSuggestions(context.prefix, false)
-        const unixSuggestions = generateUnixCommandSuggestions(context.prefix)
-        
-        // IMPORTANT: Also try to match agents and models WITHOUT requiring @
-        // This enables smart matching for inputs like "gp5", "daoqi", etc.
-        const mentionMatches = generateMentionSuggestions(context.prefix)
-          .map(s => ({
-            ...s,
-            isSmartMatch: true,
-            // Show that @ will be added when selected
-            displayValue: `\u2192 ${s.displayValue}` // Arrow to indicate it will transform
-          }))
-        
-        // Apply source-based priority weights with special handling for exact matches
-        // Priority order: Exact Unix > Unix commands > agents/models > files
-        const weightedSuggestions = [
-          ...unixSuggestions.map(s => ({
-            ...s,
-            // Unix commands get boost, but exact matches get huge boost
-            sourceWeight: s.score >= 10000 ? 5000 : 200, // Exact match gets massive boost
-            weightedScore: s.score >= 10000 ? s.score + 5000 : s.score + 200
-          })),
-          ...mentionMatches.map(s => ({
-            ...s,
-            // Agents/models get medium priority boost (but less to avoid overriding exact Unix)
-            sourceWeight: 50,
-            weightedScore: s.score + 50
-          })),
-          ...fileSuggestions.map(s => ({
-            ...s,
-            // Files get no boost (baseline)
-            sourceWeight: 0,
-            weightedScore: s.score
-          }))
-        ]
-        
-        // Sort by weighted score and deduplicate
-        const seen = new Set<string>()
-        const deduplicatedResults = weightedSuggestions
-          .sort((a, b) => b.weightedScore - a.weightedScore)
-          .filter(item => {
-            // Filter out duplicates based on value
-            if (seen.has(item.value)) return false
-            seen.add(item.value)
-            return true
-          })
-          .map(({ weightedScore, sourceWeight, ...suggestion }) => suggestion) // Remove weight fields
-          // No limit - show all relevant matches
-        
-        return deduplicatedResults
-      }
-      default:
-        return []
-    }
-  }, [generateCommandSuggestions, generateMentionSuggestions, generateFileSuggestions, generateUnixCommandSuggestions, generateSmartMentionSuggestions])
-
-
-  // Complete with a suggestion - 支持万能@引用 + slash命令自动执行
-  const completeWith = useCallback((suggestion: UnifiedSuggestion, context: CompletionContext) => {
-    let completion: string
-    
-    if (context.type === 'command') {
-      completion = `/${suggestion.value} `
-    } else if (context.type === 'agent') {
-      // 🚀 万能@引用：根据建议类型决定补全格式
-      if (suggestion.type === 'agent') {
-        completion = `@${suggestion.value} ` // 代理补全
-      } else if (suggestion.type === 'ask') {
-        completion = `@${suggestion.value} ` // Ask模型补全
-      } else {
-        // File reference in @mention context - no space for directories to allow expansion
-        const isDirectory = suggestion.value.endsWith('/')
-        completion = `@${suggestion.value}${isDirectory ? '' : ' '}` // 文件夹不加空格，文件加空格
-      }
-    } else {
-      // Regular file completion OR smart mention matching
-      if (suggestion.isSmartMatch) {
-        // Smart mention - add @ prefix and space
-        completion = `@${suggestion.value} `
-      } else {
-        // Regular file completion - no space for directories to allow expansion
-        const isDirectory = suggestion.value.endsWith('/')
-        completion = suggestion.value + (isDirectory ? '' : ' ')
-      }
-    }
-    
-    // Special handling for absolute paths in file completion
-    // When completing an absolute path, we should replace the entire current word/path
-    let actualEndPos: number
-    
-    if (context.type === 'file' && suggestion.value.startsWith('/') && !suggestion.isSmartMatch) {
-      // For absolute paths, find the end of the current path/word
-      let end = context.startPos
-      while (end < input.length && input[end] !== ' ' && input[end] !== '\n') {
-        end++
-      }
-      actualEndPos = end
-    } else {
-      // Original logic for other cases
-      const currentWord = input.slice(context.startPos)
-      const nextSpaceIndex = currentWord.indexOf(' ')
-      actualEndPos = nextSpaceIndex === -1 ? input.length : context.startPos + nextSpaceIndex
-    }
-    
-    const newInput = input.slice(0, context.startPos) + completion + input.slice(actualEndPos)
-    onInputChange(newInput)
-    setCursorOffset(context.startPos + completion.length)
-    
-    // Don't auto-execute slash commands - let user press Enter to submit
-    // This gives users a chance to add arguments or modify the command
-    
-    // Completion applied
-  }, [input, onInputChange, setCursorOffset, onSubmit, commands])
-
-  // Partial complete to common prefix
-  const partialComplete = useCallback((prefix: string, context: CompletionContext) => {
-    const completion = context.type === 'command' ? `/${prefix}` :
-                      context.type === 'agent' ? `@${prefix}` :
-                      prefix
-    
-    const newInput = input.slice(0, context.startPos) + completion + input.slice(context.endPos)
-    onInputChange(newInput)
-    setCursorOffset(context.startPos + completion.length)
-  }, [input, onInputChange, setCursorOffset])
-
-
-  // Handle Tab key - simplified and unified
-  useInput((input_str, key) => {
-    if (!key.tab) return false
-    if (key.shift) return false
-    
-    const context = getWordAtCursor()
-    if (!context) return false
-    
-    // If menu is already showing, cycle through suggestions
-    if (state.isActive && state.suggestions.length > 0) {
-      const nextIndex = (state.selectedIndex + 1) % state.suggestions.length
-      const nextSuggestion = state.suggestions[nextIndex]
-      
-      if (state.context) {
-        // Calculate proper word boundaries
-        const currentWord = input.slice(state.context.startPos)
-        const wordEnd = currentWord.search(/\s/)
-        const actualEndPos = wordEnd === -1 
-          ? input.length 
-          : state.context.startPos + wordEnd
-        
-        // Apply appropriate prefix based on context type and suggestion type
-        let preview: string
-        if (state.context.type === 'command') {
-          preview = `/${nextSuggestion.value}`
-        } else if (state.context.type === 'agent') {
-          // For @mentions, always add @ prefix
-          preview = `@${nextSuggestion.value}`
-        } else if (nextSuggestion.isSmartMatch) {
-          // Smart match from normal input - add @ prefix
-          preview = `@${nextSuggestion.value}`
-        } else {
-          preview = nextSuggestion.value
-        }
-        
-        // Apply preview
-        const newInput = input.slice(0, state.context.startPos) + 
-                         preview + 
-                         input.slice(actualEndPos)
-        
-        onInputChange(newInput)
-        setCursorOffset(state.context.startPos + preview.length)
-        
-        // Update state
-        updateState({
-          selectedIndex: nextIndex,
-          preview: {
-            isActive: true,
-            originalInput: input,
-            wordRange: [state.context.startPos, state.context.startPos + preview.length]
-          }
-        })
-      }
-      return true
-    }
-    
-    // Generate new suggestions
-    const currentSuggestions = generateSuggestions(context)
-    
-    if (currentSuggestions.length === 0) {
-      return false // Let Tab pass through
-    } else if (currentSuggestions.length === 1) {
-      // Single match: complete immediately
-      completeWith(currentSuggestions[0], context)
-      return true
-    } else {
-      // Show menu and apply first suggestion
-      activateCompletion(currentSuggestions, context)
-      
-      // Immediately apply first suggestion as preview
-      const firstSuggestion = currentSuggestions[0]
-      const currentWord = input.slice(context.startPos)
-      const wordEnd = currentWord.search(/\s/)
-      const actualEndPos = wordEnd === -1 
-        ? input.length 
-        : context.startPos + wordEnd
-        
-      let preview: string
-      if (context.type === 'command') {
-        preview = `/${firstSuggestion.value}`
-      } else if (context.type === 'agent') {
-        preview = `@${firstSuggestion.value}`
-      } else if (firstSuggestion.isSmartMatch) {
-        // Smart match from normal input - add @ prefix
-        preview = `@${firstSuggestion.value}`
-      } else {
-        preview = firstSuggestion.value
-      }
-      
-      const newInput = input.slice(0, context.startPos) + 
-                       preview + 
-                       input.slice(actualEndPos)
-      
-      onInputChange(newInput)
-      setCursorOffset(context.startPos + preview.length)
-      
-      updateState({
-        preview: {
-          isActive: true,
-          originalInput: input,
-          wordRange: [context.startPos, context.startPos + preview.length]
-        }
-      })
-      
-      return true
-    }
-  })
-
-  // Handle navigation keys - simplified and unified  
-  useInput((inputChar, key) => {
-    // Enter key - confirm selection and end completion (always add space)
-    if (key.return && state.isActive && state.suggestions.length > 0) {
-      const selectedSuggestion = state.suggestions[state.selectedIndex]
-      if (selectedSuggestion && state.context) {
-        // For Enter key, always add space even for directories to indicate completion end
-        let completion: string
-        
-        if (state.context.type === 'command') {
-          completion = `/${selectedSuggestion.value} `
-        } else if (state.context.type === 'agent') {
-          if (selectedSuggestion.type === 'agent') {
-            completion = `@${selectedSuggestion.value} `
-          } else if (selectedSuggestion.type === 'ask') {
-            completion = `@${selectedSuggestion.value} `
-          } else {
-            // File reference in @mention context - always add space on Enter
-            completion = `@${selectedSuggestion.value} `
-          }
-        } else if (selectedSuggestion.isSmartMatch) {
-          // Smart match from normal input - add @ prefix
-          completion = `@${selectedSuggestion.value} `
-        } else {
-          // Regular file completion - always add space on Enter
-          completion = selectedSuggestion.value + ' '
-        }
-        
-        // Apply completion with forced space
-        const currentWord = input.slice(state.context.startPos)
-        const nextSpaceIndex = currentWord.indexOf(' ')
-        const actualEndPos = nextSpaceIndex === -1 ? input.length : state.context.startPos + nextSpaceIndex
-        
-        const newInput = input.slice(0, state.context.startPos) + completion + input.slice(actualEndPos)
-        onInputChange(newInput)
-        setCursorOffset(state.context.startPos + completion.length)
-      }
-      resetCompletion()
-      return true
-    }
-    
-    if (!state.isActive || state.suggestions.length === 0) return false
-    
-    // Arrow key navigation with preview
-    const handleNavigation = (newIndex: number) => {
-      const preview = state.suggestions[newIndex].value
-      
-      if (state.preview?.isActive && state.context) {
-        const newInput = input.slice(0, state.context.startPos) + 
-                         preview + 
-                         input.slice(state.preview.wordRange[1])
-        
-        onInputChange(newInput)
-        setCursorOffset(state.context.startPos + preview.length)
-        
-        updateState({
-          selectedIndex: newIndex,
-          preview: {
-            ...state.preview,
-            wordRange: [state.context.startPos, state.context.startPos + preview.length]
-          }
-        })
-      } else {
-        updateState({ selectedIndex: newIndex })
-      }
-    }
-    
-    if (key.downArrow) {
-      const nextIndex = (state.selectedIndex + 1) % state.suggestions.length
-      handleNavigation(nextIndex)
-      return true
-    }
-    
-    if (key.upArrow) {
-      const nextIndex = state.selectedIndex === 0 
-        ? state.suggestions.length - 1 
-        : state.selectedIndex - 1
-      handleNavigation(nextIndex)
-      return true
-    }
-    
-    // Space key - complete and potentially continue for directories
-    if (inputChar === ' ' && state.isActive && state.suggestions.length > 0) {
-      const selectedSuggestion = state.suggestions[state.selectedIndex]
-      const isDirectory = selectedSuggestion.value.endsWith('/')
-      
-      if (!state.context) return false
-      
-      // Apply completion if needed
-      const currentWordAtContext = input.slice(state.context.startPos, 
-        state.context.startPos + selectedSuggestion.value.length)
-      
-      if (currentWordAtContext !== selectedSuggestion.value) {
-        completeWith(selectedSuggestion, state.context)
-      }
-      
-      resetCompletion()
-      
-      if (isDirectory) {
-        // Continue completion for directories
-        setTimeout(() => {
-          const newContext = {
-            ...state.context,
-            prefix: selectedSuggestion.value,
-            endPos: state.context.startPos + selectedSuggestion.value.length
-          }
-          
-          const newSuggestions = generateSuggestions(newContext)
-          
-          if (newSuggestions.length > 0) {
-            activateCompletion(newSuggestions, newContext)
-          } else {
-            updateState({
-              emptyDirMessage: `Directory is empty: ${selectedSuggestion.value}`
-            })
-            setTimeout(() => updateState({ emptyDirMessage: '' }), 3000)
-          }
-        }, 50)
-      }
-      
-      return true
-    }
-    
-    // Right arrow key - same as space but different semantics
-    if (key.rightArrow) {
-      const selectedSuggestion = state.suggestions[state.selectedIndex]
-      const isDirectory = selectedSuggestion.value.endsWith('/')
-      
-      if (!state.context) return false
-      
-      // Apply completion
-      const currentWordAtContext = input.slice(state.context.startPos, 
-        state.context.startPos + selectedSuggestion.value.length)
-      
-      if (currentWordAtContext !== selectedSuggestion.value) {
-        completeWith(selectedSuggestion, state.context)
-      }
-      
-      resetCompletion()
-      
-      if (isDirectory) {
-        // Continue for directories
-        setTimeout(() => {
-          const newContext = {
-            ...state.context,
-            prefix: selectedSuggestion.value,
-            endPos: state.context.startPos + selectedSuggestion.value.length
-          }
-          
-          const newSuggestions = generateSuggestions(newContext)
-          
-          if (newSuggestions.length > 0) {
-            activateCompletion(newSuggestions, newContext)
-          } else {
-            updateState({
-              emptyDirMessage: `Directory is empty: ${selectedSuggestion.value}`
-            })
-            setTimeout(() => updateState({ emptyDirMessage: '' }), 3000)
-          }
-        }, 50)
-      }
-      
-      return true
-    }
-    
-    if (key.escape) {
-      // Restore original text if in preview mode
-      if (state.preview?.isActive && state.context) {
-        onInputChange(state.preview.originalInput)
-        setCursorOffset(state.context.startPos + state.context.prefix.length)
-      }
-      
-      resetCompletion()
-      return true
-    }
-    
-    return false
-  })
-
-  // Handle delete/backspace keys - unified state management
-  useInput((input_str, key) => {
-    if (key.backspace || key.delete) {
-      if (state.isActive) {
-        resetCompletion()
-        // Smart suppression based on input complexity
-        const suppressionTime = input.length > 10 ? 200 : 100
-        updateState({ 
-          suppressUntil: Date.now() + suppressionTime
-        })
-        return true
-      }
-    }
-    return false
-  })
-
-  // Input tracking with ref to avoid infinite loops
-  const lastInputRef = useRef('')
-  
-  // Smart auto-triggering with cycle prevention
-  useEffect(() => {
-    // Prevent infinite loops by using ref
-    if (lastInputRef.current === input) return
-    
-    const inputLengthChange = Math.abs(input.length - lastInputRef.current.length)
-    const isHistoryNavigation = (
-      inputLengthChange > 10 || // Large content change
-      (inputLengthChange > 5 && !input.includes(lastInputRef.current.slice(-5))) // Different content
-    ) && input !== lastInputRef.current
-    
-    // Update ref (no state update)
-    lastInputRef.current = input
-    
-    // Skip if in preview mode or suppressed
-    if (state.preview?.isActive || Date.now() < state.suppressUntil) {
-      return
-    }
-    
-    // Clear suggestions on history navigation
-    if (isHistoryNavigation && state.isActive) {
-      resetCompletion()
-      return
-    }
-    
-    const context = getWordAtCursor()
-    
-    if (context && shouldAutoTrigger(context)) {
-      const newSuggestions = generateSuggestions(context)
-      
-      if (newSuggestions.length === 0) {
-        resetCompletion()
-      } else if (newSuggestions.length === 1 && shouldAutoHideSingleMatch(newSuggestions[0], context)) {
-        resetCompletion() // Perfect match - hide
-      } else {
-        activateCompletion(newSuggestions, context)
-      }
-    } else if (state.context) {
-      // Check if context changed significantly
-      const contextChanged = !context ||
-        state.context.type !== context.type ||
-        state.context.startPos !== context.startPos ||
-        !context.prefix.startsWith(state.context.prefix)
-      
-      if (contextChanged) {
-        resetCompletion()
-      }
-    }
-  }, [input, cursorOffset])
-
-  // Smart triggering - only when it makes sense
-  const shouldAutoTrigger = useCallback((context: CompletionContext): boolean => {
-    switch (context.type) {
-      case 'command':
-        // Trigger immediately for slash commands
-        return true
-      case 'agent':
-        // Trigger immediately for agent references
-        return true  
-      case 'file':
-        // Be selective about file completion - avoid noise
-        const prefix = context.prefix
-        
-        // Always trigger for clear path patterns
-        if (prefix.startsWith('./') || prefix.startsWith('../') || 
-            prefix.startsWith('/') || prefix.startsWith('~') || 
-            prefix.includes('/')) {
-          return true
-        }
-        
-        // Trigger for single dot followed by something (like .g for .gitignore)
-        if (prefix.startsWith('.') && prefix.length >= 2) {
-          return true
-        }
-        
-        // Skip very short prefixes that are likely code
-        return false
-      default:
-        return false
-    }
-  }, [])
-
-  // Helper function to determine if single suggestion should be auto-hidden
-  const shouldAutoHideSingleMatch = useCallback((suggestion: UnifiedSuggestion, context: CompletionContext): boolean => {
-    // Extract the actual typed input from context
-    const currentInput = input.slice(context.startPos, context.endPos)
-    // Check if should auto-hide single match
-    
-    // For files: more intelligent matching
-    if (context.type === 'file') {
-      // Special case: if suggestion is a directory (ends with /), don't auto-hide 
-      // because user might want to continue navigating into it
-      if (suggestion.value.endsWith('/')) {
-        // Directory suggestion, keeping visible
-        return false 
-      }
-      
-      // Check exact match
-      if (currentInput === suggestion.value) {
-        // Exact match, hiding
-        return true
-      }
-      
-      // Check if current input is a complete file path and suggestion is just the filename
-      // e.g., currentInput: "src/tools/ThinkTool/ThinkTool.tsx", suggestion: "ThinkTool.tsx"
-      if (currentInput.endsWith('/' + suggestion.value) || currentInput.endsWith(suggestion.value)) {
-        // Path ends with suggestion, hiding
-        return true
-      }
-      
-      return false
-    }
-    
-    // For commands: check if /prefix exactly matches /command
-    if (context.type === 'command') {
-      const fullCommand = `/${suggestion.value}`
-      const matches = currentInput === fullCommand
-      // Check command match
-      return matches
-    }
-    
-    // For agents: check if @prefix exactly matches @agent-name
-    if (context.type === 'agent') {
-      const fullAgent = `@${suggestion.value}`
-      const matches = currentInput === fullAgent
-      // Check agent match
-      return matches
-    }
-    
-    return false
-  }, [input])
-
-  return {
-    suggestions,
-    selectedIndex,
-    isActive,
-    emptyDirMessage,
-  }
-}