@shareai-lab/kode 1.0.71 → 1.0.73

package/src/hooks/useUnifiedCompletion.ts

@@ -0,0 +1,1404 @@
+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 || 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((_, 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 (key.space && 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,
+  }
+}