@shareai-lab/kode 1.0.71 → 1.0.75

package/src/utils/advancedFuzzyMatcher.ts

@@ -0,0 +1,290 @@
+/**
+ * Advanced Fuzzy Matching Algorithm
+ * 
+ * Inspired by:
+ * - Chinese Pinyin input methods (Sogou, Baidu)
+ * - IDE intelligent completion (VSCode, IntelliJ)
+ * - Terminal fuzzy finders (fzf, peco)
+ * 
+ * Key features:
+ * - Hyphen-aware matching (dao → dao-qi-harmony)
+ * - Numeric suffix matching (py3 → python3)
+ * - Abbreviation matching (dq → dao-qi)
+ * - Subsequence matching
+ * - Word boundary bonus
+ */
+
+export interface MatchResult {
+  score: number
+  matched: boolean
+  algorithm: string
+}
+
+export class AdvancedFuzzyMatcher {
+  /**
+   * Main matching function - combines multiple algorithms
+   */
+  match(candidate: string, query: string): MatchResult {
+    // Normalize inputs
+    const text = candidate.toLowerCase()
+    const pattern = query.toLowerCase()
+    
+    // Quick exact match - give HUGE score for exact matches
+    if (text === pattern) {
+      return { score: 10000, matched: true, algorithm: 'exact' }
+    }
+    
+    // Try all algorithms and combine scores
+    const algorithms = [
+      this.exactPrefixMatch(text, pattern),
+      this.hyphenAwareMatch(text, pattern),
+      this.wordBoundaryMatch(text, pattern),
+      this.abbreviationMatch(text, pattern),
+      this.numericSuffixMatch(text, pattern),
+      this.subsequenceMatch(text, pattern),
+      this.fuzzySegmentMatch(text, pattern),
+    ]
+    
+    // Get best score
+    let bestScore = 0
+    let bestAlgorithm = 'none'
+    
+    for (const result of algorithms) {
+      if (result.score > bestScore) {
+        bestScore = result.score
+        bestAlgorithm = result.algorithm
+      }
+    }
+    
+    return {
+      score: bestScore,
+      matched: bestScore > 10,
+      algorithm: bestAlgorithm
+    }
+  }
+  
+  /**
+   * Exact prefix matching
+   */
+  private exactPrefixMatch(text: string, pattern: string): { score: number; algorithm: string } {
+    if (text.startsWith(pattern)) {
+      const coverage = pattern.length / text.length
+      // Higher base score for prefix matches to prioritize them
+      return { score: 1000 + coverage * 500, algorithm: 'prefix' }
+    }
+    return { score: 0, algorithm: 'prefix' }
+  }
+  
+  /**
+   * Hyphen-aware matching (dao → dao-qi-harmony-designer)
+   * Treats hyphens as optional word boundaries
+   */
+  private hyphenAwareMatch(text: string, pattern: string): { score: number; algorithm: string } {
+    // Split by hyphens and try to match
+    const words = text.split('-')
+    
+    // Check if pattern matches the beginning of hyphenated words
+    if (words[0].startsWith(pattern)) {
+      const coverage = pattern.length / words[0].length
+      return { score: 300 + coverage * 100, algorithm: 'hyphen-prefix' }
+    }
+    
+    // Check if pattern matches concatenated words (ignoring hyphens)
+    const concatenated = words.join('')
+    if (concatenated.startsWith(pattern)) {
+      const coverage = pattern.length / concatenated.length
+      return { score: 250 + coverage * 100, algorithm: 'hyphen-concat' }
+    }
+    
+    // Check if pattern matches any word start
+    for (let i = 0; i < words.length; i++) {
+      if (words[i].startsWith(pattern)) {
+        return { score: 200 - i * 10, algorithm: 'hyphen-word' }
+      }
+    }
+    
+    return { score: 0, algorithm: 'hyphen' }
+  }
+  
+  /**
+   * Word boundary matching (dq → dao-qi)
+   * Matches characters at word boundaries
+   */
+  private wordBoundaryMatch(text: string, pattern: string): { score: number; algorithm: string } {
+    const words = text.split(/[-_\s]+/)
+    let patternIdx = 0
+    let score = 0
+    let matched = false
+    
+    for (const word of words) {
+      if (patternIdx >= pattern.length) break
+      
+      if (word[0] === pattern[patternIdx]) {
+        score += 50 // Bonus for word boundary match
+        patternIdx++
+        matched = true
+        
+        // Try to match more characters in this word
+        for (let i = 1; i < word.length && patternIdx < pattern.length; i++) {
+          if (word[i] === pattern[patternIdx]) {
+            score += 20
+            patternIdx++
+          }
+        }
+      }
+    }
+    
+    if (matched && patternIdx === pattern.length) {
+      return { score, algorithm: 'word-boundary' }
+    }
+    
+    return { score: 0, algorithm: 'word-boundary' }
+  }
+  
+  /**
+   * Abbreviation matching (nde → node, daoqi → dao-qi)
+   */
+  private abbreviationMatch(text: string, pattern: string): { score: number; algorithm: string } {
+    let textIdx = 0
+    let patternIdx = 0
+    let score = 0
+    let lastMatchIdx = -1
+    
+    while (patternIdx < pattern.length && textIdx < text.length) {
+      if (text[textIdx] === pattern[patternIdx]) {
+        // Calculate position score
+        const gap = lastMatchIdx === -1 ? 0 : textIdx - lastMatchIdx - 1
+        
+        if (textIdx === 0) {
+          score += 50 // First character match
+        } else if (lastMatchIdx >= 0 && gap === 0) {
+          score += 30 // Consecutive match
+        } else if (text[textIdx - 1] === '-' || text[textIdx - 1] === '_') {
+          score += 40 // Word boundary match
+        } else {
+          score += Math.max(5, 20 - gap * 2) // Distance penalty
+        }
+        
+        lastMatchIdx = textIdx
+        patternIdx++
+      }
+      textIdx++
+    }
+    
+    if (patternIdx === pattern.length) {
+      // Bonus for compact matches
+      const spread = lastMatchIdx / pattern.length
+      if (spread <= 3) score += 50
+      else if (spread <= 5) score += 30
+      
+      return { score, algorithm: 'abbreviation' }
+    }
+    
+    return { score: 0, algorithm: 'abbreviation' }
+  }
+  
+  /**
+   * Numeric suffix matching (py3 → python3, np18 → node18)
+   */
+  private numericSuffixMatch(text: string, pattern: string): { score: number; algorithm: string } {
+    // Check if pattern has numeric suffix
+    const patternMatch = pattern.match(/^(.+?)(\d+)$/)
+    if (!patternMatch) return { score: 0, algorithm: 'numeric' }
+    
+    const [, prefix, suffix] = patternMatch
+    
+    // Check if text ends with same number
+    if (!text.endsWith(suffix)) return { score: 0, algorithm: 'numeric' }
+    
+    // Check if prefix matches start of text
+    const textWithoutSuffix = text.slice(0, -suffix.length)
+    if (textWithoutSuffix.startsWith(prefix)) {
+      const coverage = prefix.length / textWithoutSuffix.length
+      return { score: 200 + coverage * 100, algorithm: 'numeric-suffix' }
+    }
+    
+    // Check abbreviation match for prefix
+    const abbrevResult = this.abbreviationMatch(textWithoutSuffix, prefix)
+    if (abbrevResult.score > 0) {
+      return { score: abbrevResult.score + 50, algorithm: 'numeric-abbrev' }
+    }
+    
+    return { score: 0, algorithm: 'numeric' }
+  }
+  
+  /**
+   * Subsequence matching - characters appear in order
+   */
+  private subsequenceMatch(text: string, pattern: string): { score: number; algorithm: string } {
+    let textIdx = 0
+    let patternIdx = 0
+    let score = 0
+    
+    while (patternIdx < pattern.length && textIdx < text.length) {
+      if (text[textIdx] === pattern[patternIdx]) {
+        score += 10
+        patternIdx++
+      }
+      textIdx++
+    }
+    
+    if (patternIdx === pattern.length) {
+      // Penalty for spread
+      const spread = textIdx / pattern.length
+      score = Math.max(10, score - spread * 5)
+      return { score, algorithm: 'subsequence' }
+    }
+    
+    return { score: 0, algorithm: 'subsequence' }
+  }
+  
+  /**
+   * Fuzzy segment matching (dao → dao-qi-harmony)
+   * Matches segments flexibly
+   */
+  private fuzzySegmentMatch(text: string, pattern: string): { score: number; algorithm: string } {
+    // Remove hyphens and underscores for matching
+    const cleanText = text.replace(/[-_]/g, '')
+    const cleanPattern = pattern.replace(/[-_]/g, '')
+    
+    // Check if clean pattern is a prefix of clean text
+    if (cleanText.startsWith(cleanPattern)) {
+      const coverage = cleanPattern.length / cleanText.length
+      return { score: 150 + coverage * 100, algorithm: 'fuzzy-segment' }
+    }
+    
+    // Check if pattern appears anywhere in clean text
+    const index = cleanText.indexOf(cleanPattern)
+    if (index !== -1) {
+      const positionPenalty = index * 5
+      return { score: Math.max(50, 100 - positionPenalty), algorithm: 'fuzzy-contains' }
+    }
+    
+    return { score: 0, algorithm: 'fuzzy-segment' }
+  }
+}
+
+// Export singleton instance and helper functions
+export const advancedMatcher = new AdvancedFuzzyMatcher()
+
+export function matchAdvanced(candidate: string, query: string): MatchResult {
+  return advancedMatcher.match(candidate, query)
+}
+
+export function matchManyAdvanced(
+  candidates: string[], 
+  query: string,
+  minScore: number = 10
+): Array<{ candidate: string; score: number; algorithm: string }> {
+  return candidates
+    .map(candidate => {
+      const result = advancedMatcher.match(candidate, query)
+      return {
+        candidate,
+        score: result.score,
+        algorithm: result.algorithm
+      }
+    })
+    .filter(item => item.score >= minScore)
+    .sort((a, b) => b.score - a.score)
+}

package/src/utils/agentLoader.ts

@@ -0,0 +1,284 @@
+/**
+ * Agent configuration loader
+ * Loads agent configurations from markdown files with YAML frontmatter
+ * Following Claude Code's agent system architecture
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync, watch, FSWatcher } from 'fs'
+import { join, resolve } from 'path'
+import { homedir } from 'os'
+import matter from 'gray-matter'
+import { getCwd } from './state'
+import { memoize } from 'lodash-es'
+
+// Track warned agents to avoid spam
+const warnedAgents = new Set<string>()
+
+export interface AgentConfig {
+  agentType: string          // Agent identifier (matches subagent_type)
+  whenToUse: string          // Description of when to use this agent  
+  tools: string[] | '*'      // Tool permissions
+  systemPrompt: string       // System prompt content
+  location: 'built-in' | 'user' | 'project'
+  color?: string            // Optional UI color
+  model_name?: string       // Optional model override
+}
+
+// Built-in general-purpose agent as fallback
+const BUILTIN_GENERAL_PURPOSE: AgentConfig = {
+  agentType: 'general-purpose',
+  whenToUse: 'General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks',
+  tools: '*',
+  systemPrompt: `You are a general-purpose agent. Given the user's task, use the tools available to complete it efficiently and thoroughly.
+
+When to use your capabilities:
+- Searching for code, configurations, and patterns across large codebases
+- Analyzing multiple files to understand system architecture  
+- Investigating complex questions that require exploring many files
+- Performing multi-step research tasks
+
+Guidelines:
+- For file searches: Use Grep or Glob when you need to search broadly. Use FileRead when you know the specific file path.
+- For analysis: Start broad and narrow down. Use multiple search strategies if the first doesn't yield results.
+- Be thorough: Check multiple locations, consider different naming conventions, look for related files.
+- Complete tasks directly using your capabilities.`,
+  location: 'built-in'
+}
+
+/**
+ * Parse tools field from frontmatter
+ */
+function parseTools(tools: any): string[] | '*' {
+  if (!tools) return '*'
+  if (tools === '*') return '*'
+  if (Array.isArray(tools)) {
+    // Ensure all items are strings and filter out non-strings
+    const filteredTools = tools.filter((t): t is string => typeof t === 'string')
+    return filteredTools.length > 0 ? filteredTools : '*'
+  }
+  if (typeof tools === 'string') {
+    return [tools]
+  }
+  return '*'
+}
+
+/**
+ * Scan a directory for agent configuration files
+ */
+async function scanAgentDirectory(dirPath: string, location: 'user' | 'project'): Promise<AgentConfig[]> {
+  if (!existsSync(dirPath)) {
+    return []
+  }
+
+  const agents: AgentConfig[] = []
+  
+  try {
+    const files = readdirSync(dirPath)
+    
+    for (const file of files) {
+      if (!file.endsWith('.md')) continue
+      
+      const filePath = join(dirPath, file)
+      const stat = statSync(filePath)
+      
+      if (!stat.isFile()) continue
+      
+      try {
+        const content = readFileSync(filePath, 'utf-8')
+        const { data: frontmatter, content: body } = matter(content)
+        
+        // Validate required fields
+        if (!frontmatter.name || !frontmatter.description) {
+          console.warn(`Skipping ${filePath}: missing required fields (name, description)`)
+          continue
+        }
+        
+        // Silently ignore deprecated 'model' field - no warnings by default
+        // Only warn if KODE_DEBUG_AGENTS environment variable is set
+        if (frontmatter.model && !frontmatter.model_name && !warnedAgents.has(frontmatter.name) && process.env.KODE_DEBUG_AGENTS) {
+          console.warn(`⚠️ Agent ${frontmatter.name}: 'model' field is deprecated and ignored. Use 'model_name' instead, or omit to use default 'task' model.`)
+          warnedAgents.add(frontmatter.name)
+        }
+        
+        // Build agent config
+        const agent: AgentConfig = {
+          agentType: frontmatter.name,
+          whenToUse: frontmatter.description.replace(/\\n/g, '\n'),
+          tools: parseTools(frontmatter.tools),
+          systemPrompt: body.trim(),
+          location,
+          ...(frontmatter.color && { color: frontmatter.color }),
+          // Only use model_name field, ignore deprecated 'model' field
+          ...(frontmatter.model_name && { model_name: frontmatter.model_name })
+        }
+        
+        agents.push(agent)
+      } catch (error) {
+        console.warn(`Failed to parse agent file ${filePath}:`, error)
+      }
+    }
+  } catch (error) {
+    console.warn(`Failed to scan directory ${dirPath}:`, error)
+  }
+  
+  return agents
+}
+
+/**
+ * Load all agent configurations
+ */
+async function loadAllAgents(): Promise<{
+  activeAgents: AgentConfig[]
+  allAgents: AgentConfig[]
+}> {
+  try {
+    // Scan both .claude and .kode directories in parallel
+    // Claude Code compatibility: support both ~/.claude/agents and ~/.kode/agents
+    const userClaudeDir = join(homedir(), '.claude', 'agents')
+    const userKodeDir = join(homedir(), '.kode', 'agents')
+    const projectClaudeDir = join(getCwd(), '.claude', 'agents')
+    const projectKodeDir = join(getCwd(), '.kode', 'agents')
+    
+    const [userClaudeAgents, userKodeAgents, projectClaudeAgents, projectKodeAgents] = await Promise.all([
+      scanAgentDirectory(userClaudeDir, 'user'),
+      scanAgentDirectory(userKodeDir, 'user'),
+      scanAgentDirectory(projectClaudeDir, 'project'),
+      scanAgentDirectory(projectKodeDir, 'project')
+    ])
+    
+    // Built-in agents (currently just general-purpose)
+    const builtinAgents = [BUILTIN_GENERAL_PURPOSE]
+    
+    // Apply priority override: built-in < .claude (user) < .kode (user) < .claude (project) < .kode (project)
+    const agentMap = new Map<string, AgentConfig>()
+    
+    // Add in priority order (later entries override earlier ones)
+    for (const agent of builtinAgents) {
+      agentMap.set(agent.agentType, agent)
+    }
+    for (const agent of userClaudeAgents) {
+      agentMap.set(agent.agentType, agent)
+    }
+    for (const agent of userKodeAgents) {
+      agentMap.set(agent.agentType, agent)
+    }
+    for (const agent of projectClaudeAgents) {
+      agentMap.set(agent.agentType, agent)
+    }
+    for (const agent of projectKodeAgents) {
+      agentMap.set(agent.agentType, agent)
+    }
+    
+    const activeAgents = Array.from(agentMap.values())
+    const allAgents = [...builtinAgents, ...userClaudeAgents, ...userKodeAgents, ...projectClaudeAgents, ...projectKodeAgents]
+    
+    return { activeAgents, allAgents }
+  } catch (error) {
+    console.error('Failed to load agents, falling back to built-in:', error)
+    return {
+      activeAgents: [BUILTIN_GENERAL_PURPOSE],
+      allAgents: [BUILTIN_GENERAL_PURPOSE]
+    }
+  }
+}
+
+// Memoized version for performance
+export const getActiveAgents = memoize(
+  async (): Promise<AgentConfig[]> => {
+    const { activeAgents } = await loadAllAgents()
+    return activeAgents
+  }
+)
+
+// Get all agents (both active and overridden)
+export const getAllAgents = memoize(
+  async (): Promise<AgentConfig[]> => {
+    const { allAgents } = await loadAllAgents()
+    return allAgents
+  }
+)
+
+// Clear cache when needed
+export function clearAgentCache() {
+  getActiveAgents.cache?.clear?.()
+  getAllAgents.cache?.clear?.()
+  getAgentByType.cache?.clear?.()
+  getAvailableAgentTypes.cache?.clear?.()
+}
+
+// Get a specific agent by type
+export const getAgentByType = memoize(
+  async (agentType: string): Promise<AgentConfig | undefined> => {
+    const agents = await getActiveAgents()
+    return agents.find(agent => agent.agentType === agentType)
+  }
+)
+
+// Get all available agent types for validation
+export const getAvailableAgentTypes = memoize(
+  async (): Promise<string[]> => {
+    const agents = await getActiveAgents()
+    return agents.map(agent => agent.agentType)
+  }
+)
+
+// File watcher for hot reload
+let watchers: FSWatcher[] = []
+
+/**
+ * Start watching agent configuration directories for changes
+ */
+export async function startAgentWatcher(onChange?: () => void): Promise<void> {
+  await stopAgentWatcher() // Clean up any existing watchers
+  
+  // Watch both .claude and .kode directories
+  const userClaudeDir = join(homedir(), '.claude', 'agents')
+  const userKodeDir = join(homedir(), '.kode', 'agents')
+  const projectClaudeDir = join(getCwd(), '.claude', 'agents')
+  const projectKodeDir = join(getCwd(), '.kode', 'agents')
+  
+  const watchDirectory = (dirPath: string, label: string) => {
+    if (existsSync(dirPath)) {
+      const watcher = watch(dirPath, { recursive: false }, async (eventType, filename) => {
+        if (filename && filename.endsWith('.md')) {
+          console.log(`🔄 Agent configuration changed in ${label}: ${filename}`)
+          clearAgentCache()
+          // Also clear any other related caches
+          getAllAgents.cache?.clear?.()
+          onChange?.()
+        }
+      })
+      watchers.push(watcher)
+    }
+  }
+  
+  // Watch all directories
+  watchDirectory(userClaudeDir, 'user/.claude')
+  watchDirectory(userKodeDir, 'user/.kode')
+  watchDirectory(projectClaudeDir, 'project/.claude')
+  watchDirectory(projectKodeDir, 'project/.kode')
+}
+
+/**
+ * Stop watching agent configuration directories
+ */
+export async function stopAgentWatcher(): Promise<void> {
+  const closePromises = watchers.map(watcher => 
+    new Promise<void>((resolve) => {
+      try {
+        watcher.close((err) => {
+          if (err) {
+            console.error('Failed to close file watcher:', err)
+          }
+          resolve()
+        })
+      } catch (error) {
+        console.error('Error closing watcher:', error)
+        resolve()
+      }
+    })
+  )
+  
+  await Promise.allSettled(closePromises)
+  watchers = []
+}

package/src/utils/ask.tsx

@@ -67,6 +67,7 @@ export async function ask({
       abortController: new AbortController(),
       messageId: undefined,
       readFileTimestamps: {},
+      setToolJSX: () => {}, // No-op function for non-interactive use
     },
   )) {
     messages.push(m)

package/src/utils/commands.ts

@@ -1,5 +1,5 @@
 import { memoize } from 'lodash-es'
-import { API_ERROR_MESSAGE_PREFIX } from '../services/claude'
+import { API_ERROR_MESSAGE_PREFIX, queryQuick } from '../services/claude'
 import { type ControlOperator, parse, ParseEntry } from 'shell-quote'
 import { PRODUCT_NAME } from '../constants/product'