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

package/src/utils/advancedFuzzyMatcher.ts

@@ -1,290 +0,0 @@
-/**
- * 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

@@ -1,278 +0,0 @@
-/**
- * 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> {
-  // FSWatcher.close() is synchronous and does not accept a callback on Node 18/20
-  try {
-    for (const watcher of watchers) {
-      try {
-        watcher.close()
-      } catch (err) {
-        console.error('Failed to close file watcher:', err)
-      }
-    }
-  } finally {
-    watchers = []
-  }
-}

package/src/utils/agentStorage.ts

@@ -1,97 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs'
-import { join } from 'path'
-import { homedir } from 'os'
-import { randomUUID } from 'crypto'
-
-/**
- * Agent Storage Utilities
- * Provides file-based state isolation for different agents
- * Based on Kode's Agent ID architecture
- */
-
-/**
- * Get the kode config directory
- */
-function getConfigDirectory(): string {
-  return process.env.KODE_CONFIG_DIR ?? process.env.ANYKODE_CONFIG_DIR ?? join(homedir(), '.kode')
-}
-
-/**
- * Get the current session ID
- */
-function getSessionId(): string {
-  // This should be set when the session starts
-  return process.env.ANYKODE_SESSION_ID ?? 'default-session'
-}
-
-/**
- * Generate agent-specific file path
- * Pattern: ${sessionId}-agent-${agentId}.json
- * Stored in ~/.kode/ directory
- */
-export function getAgentFilePath(agentId: string): string {
-  const sessionId = getSessionId()
-  const filename = `${sessionId}-agent-${agentId}.json`
-  const configDir = getConfigDirectory()
-
-  // Ensure kode config directory exists
-  if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true })
-  }
-
-  return join(configDir, filename)
-}
-
-/**
- * Read agent-specific data from storage
- */
-export function readAgentData<T = any>(agentId: string): T | null {
-  const filePath = getAgentFilePath(agentId)
-
-  if (!existsSync(filePath)) {
-    return null
-  }
-
-  try {
-    const content = readFileSync(filePath, 'utf-8')
-    return JSON.parse(content) as T
-  } catch (error) {
-    console.error(`Failed to read agent data for ${agentId}:`, error)
-    return null
-  }
-}
-
-/**
- * Write agent-specific data to storage
- */
-export function writeAgentData<T = any>(agentId: string, data: T): void {
-  const filePath = getAgentFilePath(agentId)
-
-  try {
-    writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8')
-  } catch (error) {
-    console.error(`Failed to write agent data for ${agentId}:`, error)
-    throw error
-  }
-}
-
-/**
- * Get default agent ID if none is provided
- */
-export function getDefaultAgentId(): string {
-  return 'default'
-}
-
-/**
- * Resolve agent ID from context
- */
-export function resolveAgentId(agentId?: string): string {
-  return agentId || getDefaultAgentId()
-}
-
-/**
- * Generate a new unique Agent ID
- */
-export function generateAgentId(): string {
-  return randomUUID()
-}

package/src/utils/array.ts

@@ -1,3 +0,0 @@
-export function intersperse<A>(as: A[], separator: (index: number) => A): A[] {
-  return as.flatMap((a, i) => (i ? [separator(i), a] : [a]))
-}