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

package/src/utils/fuzzyMatcher.ts

@@ -1,328 +0,0 @@
-/**
- * Input Method Inspired Fuzzy Matching Algorithm
- * 
- * Multi-algorithm weighted scoring system inspired by:
- * - Sogou/Baidu Pinyin input method algorithms
- * - Double-pinyin abbreviation matching
- * - Terminal completion best practices (fzf, zsh, fish)
- * 
- * Designed specifically for command/terminal completion scenarios
- * where users type abbreviations like "nde" expecting "node"
- */
-
-export interface MatchResult {
-  score: number
-  algorithm: string  // Which algorithm contributed most to the score
-  confidence: number // 0-1 confidence level
-}
-
-export interface FuzzyMatcherConfig {
-  // Algorithm weights (must sum to 1.0)
-  weights: {
-    prefix: number      // Direct prefix matching ("nod" → "node")
-    substring: number   // Substring matching ("ode" → "node") 
-    abbreviation: number // Key chars matching ("nde" → "node")
-    editDistance: number // Typo tolerance ("noda" → "node")
-    popularity: number  // Common command boost
-  }
-  
-  // Scoring parameters
-  minScore: number           // Minimum score threshold
-  maxEditDistance: number    // Maximum edits allowed
-  popularCommands: string[]  // Commands to boost
-}
-
-const DEFAULT_CONFIG: FuzzyMatcherConfig = {
-  weights: {
-    prefix: 0.35,       // Strong weight for prefix matching
-    substring: 0.20,    // Good for partial matches  
-    abbreviation: 0.30, // Key for "nde"→"node" cases
-    editDistance: 0.10, // Typo tolerance
-    popularity: 0.05    // Slight bias for common commands
-  },
-  minScore: 10,  // Lower threshold for better matching
-  maxEditDistance: 2,
-  popularCommands: [
-    'node', 'npm', 'git', 'ls', 'cd', 'cat', 'grep', 'find', 'cp', 'mv',
-    'python', 'java', 'docker', 'curl', 'wget', 'vim', 'nano'
-  ]
-}
-
-export class FuzzyMatcher {
-  private config: FuzzyMatcherConfig
-
-  constructor(config: Partial<FuzzyMatcherConfig> = {}) {
-    this.config = { ...DEFAULT_CONFIG, ...config }
-    
-    // Normalize weights to sum to 1.0
-    const weightSum = Object.values(this.config.weights).reduce((a, b) => a + b, 0)
-    if (Math.abs(weightSum - 1.0) > 0.01) {
-      Object.keys(this.config.weights).forEach(key => {
-        this.config.weights[key as keyof typeof this.config.weights] /= weightSum
-      })
-    }
-  }
-
-  /**
-   * Calculate fuzzy match score for a candidate against a query
-   */
-  match(candidate: string, query: string): MatchResult {
-    const text = candidate.toLowerCase()
-    const pattern = query.toLowerCase()
-
-    // Quick perfect match exits
-    if (text === pattern) {
-      return { score: 1000, algorithm: 'exact', confidence: 1.0 }
-    }
-    if (text.startsWith(pattern)) {
-      return { 
-        score: 900 + (10 - pattern.length), 
-        algorithm: 'prefix-exact', 
-        confidence: 0.95 
-      }
-    }
-
-    // Run all algorithms
-    const scores = {
-      prefix: this.prefixScore(text, pattern),
-      substring: this.substringScore(text, pattern), 
-      abbreviation: this.abbreviationScore(text, pattern),
-      editDistance: this.editDistanceScore(text, pattern),
-      popularity: this.popularityScore(text)
-    }
-
-    // Weighted combination
-    const rawScore = Object.entries(scores).reduce((total, [algorithm, score]) => {
-      const weight = this.config.weights[algorithm as keyof typeof this.config.weights]
-      return total + (score * weight)
-    }, 0)
-
-    // Length penalty (prefer shorter commands)
-    const lengthPenalty = Math.max(0, text.length - 6) * 1.5
-    const finalScore = Math.max(0, rawScore - lengthPenalty)
-
-    // Determine primary algorithm and confidence
-    const maxAlgorithm = Object.entries(scores).reduce((max, [alg, score]) => 
-      score > max.score ? { algorithm: alg, score } : max, 
-      { algorithm: 'none', score: 0 }
-    )
-
-    const confidence = Math.min(1.0, finalScore / 100)
-
-    return {
-      score: finalScore,
-      algorithm: maxAlgorithm.algorithm,
-      confidence
-    }
-  }
-
-  /**
-   * Algorithm 1: Prefix Matching (like pinyin prefix)
-   * Handles cases like "nod" → "node"
-   */
-  private prefixScore(text: string, pattern: string): number {
-    if (!text.startsWith(pattern)) return 0
-    
-    // Score based on prefix length vs total length
-    const coverage = pattern.length / text.length
-    return 100 * coverage
-  }
-
-  /**
-   * Algorithm 2: Substring Matching (like pinyin contains)  
-   * Handles cases like "ode" → "node", "py3" → "python3"
-   */
-  private substringScore(text: string, pattern: string): number {
-    // Direct substring match
-    const index = text.indexOf(pattern)
-    if (index !== -1) {
-      // Earlier position and better coverage = higher score
-      const positionFactor = Math.max(0, 10 - index) / 10
-      const coverageFactor = pattern.length / text.length
-      return 80 * positionFactor * coverageFactor
-    }
-    
-    // Special handling for numeric suffixes (py3 → python3)
-    // Check if pattern ends with a number and try prefix match + number
-    const numMatch = pattern.match(/^(.+?)(\d+)$/)
-    if (numMatch) {
-      const [, prefix, num] = numMatch
-      // Check if text starts with prefix and ends with the same number
-      if (text.startsWith(prefix) && text.endsWith(num)) {
-        // Good match for patterns like "py3" → "python3"
-        const coverageFactor = pattern.length / text.length
-        return 70 * coverageFactor + 20 // Bonus for numeric suffix match
-      }
-    }
-    
-    return 0
-  }
-
-  /**
-   * Algorithm 3: Abbreviation Matching (key innovation)
-   * Handles cases like "nde" → "node", "pyt3" → "python3", "gp5" → "gpt-5"
-   */
-  private abbreviationScore(text: string, pattern: string): number {
-    let score = 0
-    let textPos = 0
-    let perfectStart = false
-    let consecutiveMatches = 0
-    let wordBoundaryMatches = 0
-    
-    // Split text by hyphens to handle word boundaries better
-    const textWords = text.split('-')
-    const textClean = text.replace(/-/g, '').toLowerCase()
-    
-    for (let i = 0; i < pattern.length; i++) {
-      const char = pattern[i]
-      let charFound = false
-      
-      // Try to find in clean text (no hyphens)
-      for (let j = textPos; j < textClean.length; j++) {
-        if (textClean[j] === char) {
-          charFound = true
-          
-          // Check if this character is at a word boundary in original text
-          let originalPos = 0
-          let cleanPos = 0
-          for (let k = 0; k < text.length; k++) {
-            if (text[k] === '-') continue
-            if (cleanPos === j) {
-              originalPos = k
-              break
-            }
-            cleanPos++
-          }
-          
-          // Consecutive character bonus
-          if (j === textPos) {
-            consecutiveMatches++
-          } else {
-            consecutiveMatches = 1
-          }
-          
-          // Position-sensitive scoring
-          if (i === 0 && j === 0) {
-            score += 50  // Perfect first character
-            perfectStart = true
-          } else if (originalPos === 0 || text[originalPos - 1] === '-') {
-            score += 35  // Word boundary match
-            wordBoundaryMatches++
-          } else if (j <= 2) {
-            score += 20  // Early position
-          } else if (j <= 6) {
-            score += 10  // Mid position  
-          } else {
-            score += 5   // Late position
-          }
-          
-          // Consecutive character bonus
-          if (consecutiveMatches > 1) {
-            score += consecutiveMatches * 5
-          }
-          
-          textPos = j + 1
-          break
-        }
-      }
-      
-      if (!charFound) return 0 // Invalid abbreviation
-    }
-    
-    // Critical bonuses
-    if (perfectStart) score += 30
-    if (wordBoundaryMatches >= 2) score += 25  // Multiple word boundaries
-    if (textPos <= textClean.length * 0.8) score += 15  // Compact abbreviation
-    
-    // Special bonus for number matching at end
-    const lastPatternChar = pattern[pattern.length - 1]
-    const lastTextChar = text[text.length - 1]
-    if (/\d/.test(lastPatternChar) && lastPatternChar === lastTextChar) {
-      score += 25
-    }
-    
-    return score
-  }
-
-  /**
-   * Algorithm 4: Edit Distance (typo tolerance)
-   * Handles cases like "noda" → "node"
-   */
-  private editDistanceScore(text: string, pattern: string): number {
-    if (pattern.length > text.length + this.config.maxEditDistance) return 0
-    
-    // Simplified Levenshtein distance  
-    const dp: number[][] = []
-    const m = pattern.length
-    const n = text.length
-    
-    // Initialize DP table
-    for (let i = 0; i <= m; i++) {
-      dp[i] = []
-      for (let j = 0; j <= n; j++) {
-        if (i === 0) dp[i][j] = j
-        else if (j === 0) dp[i][j] = i
-        else {
-          const cost = pattern[i-1] === text[j-1] ? 0 : 1
-          dp[i][j] = Math.min(
-            dp[i-1][j] + 1,     // deletion
-            dp[i][j-1] + 1,     // insertion
-            dp[i-1][j-1] + cost // substitution
-          )
-        }
-      }
-    }
-    
-    const distance = dp[m][n]
-    if (distance > this.config.maxEditDistance) return 0
-    
-    return Math.max(0, 30 - distance * 10)
-  }
-
-  /**
-   * Algorithm 5: Command Popularity (like frequency in input method)
-   * Boost common commands that users frequently type
-   */
-  private popularityScore(text: string): number {
-    if (this.config.popularCommands.includes(text)) {
-      return 40
-    }
-    
-    // Short commands are often more commonly used
-    if (text.length <= 5) return 10
-    
-    return 0
-  }
-
-  /**
-   * Batch match multiple candidates and return sorted results
-   */
-  matchMany(candidates: string[], query: string): Array<{candidate: string, result: MatchResult}> {
-    return candidates
-      .map(candidate => ({ 
-        candidate, 
-        result: this.match(candidate, query) 
-      }))
-      .filter(item => item.result.score >= this.config.minScore)
-      .sort((a, b) => b.result.score - a.result.score)
-  }
-}
-
-// Export convenience functions
-export const defaultMatcher = new FuzzyMatcher()
-
-export function matchCommand(command: string, query: string): MatchResult {
-  return defaultMatcher.match(command, query)
-}
-
-// Import the advanced matcher
-import { matchManyAdvanced } from './advancedFuzzyMatcher'
-
-export function matchCommands(commands: string[], query: string): Array<{command: string, score: number}> {
-  // Use the advanced matcher for better results
-  return matchManyAdvanced(commands, query, 5) // Lower threshold for better matching
-    .map(item => ({ 
-      command: item.candidate, 
-      score: item.score 
-    }))
-}

package/src/utils/generators.ts

@@ -1,62 +0,0 @@
-const NO_VALUE = Symbol('NO_VALUE')
-
-export async function lastX<A>(as: AsyncGenerator<A>): Promise<A> {
-  let lastValue: A | typeof NO_VALUE = NO_VALUE
-  for await (const a of as) {
-    lastValue = a
-  }
-  if (lastValue === NO_VALUE) {
-    throw new Error('No items in generator')
-  }
-  return lastValue
-}
-
-type QueuedGenerator<A> = {
-  done: boolean | void
-  value: A | void
-  generator: AsyncGenerator<A, void>
-  promise: Promise<QueuedGenerator<A>>
-}
-
-// Run all generators concurrently up to a concurrency cap, yielding values as they come in
-export async function* all<A>(
-  generators: AsyncGenerator<A, void>[],
-  concurrencyCap = Infinity,
-): AsyncGenerator<A, void> {
-  const next = (generator: AsyncGenerator<A, void>) => {
-    const promise: Promise<QueuedGenerator<A>> = generator
-      .next()
-      .then(({ done, value }) => ({
-        done,
-        value,
-        generator,
-        promise,
-      }))
-    return promise
-  }
-  const waiting = [...generators]
-  const promises = new Set<Promise<QueuedGenerator<A>>>()
-
-  // Start initial batch up to concurrency cap
-  while (promises.size < concurrencyCap && waiting.length > 0) {
-    const gen = waiting.shift()!
-    promises.add(next(gen))
-  }
-
-  while (promises.size > 0) {
-    const { done, value, generator, promise } = await Promise.race(promises)
-    promises.delete(promise)
-
-    if (!done) {
-      promises.add(next(generator))
-      // TODO: Clean this up
-      if (value !== undefined) {
-        yield value as A
-      }
-    } else if (waiting.length > 0) {
-      // Start a new generator when one finishes
-      const nextGen = waiting.shift()!
-      promises.add(next(nextGen))
-    }
-  }
-}

package/src/utils/git.ts

@@ -1,92 +0,0 @@
-import { memoize } from 'lodash-es'
-import { execFileNoThrow } from './execFileNoThrow'
-
-export const getIsGit = memoize(async (): Promise<boolean> => {
-  const { code } = await execFileNoThrow('git', [
-    'rev-parse',
-    '--is-inside-work-tree',
-  ])
-  return code === 0
-})
-
-export const getHead = async (): Promise<string> => {
-  const { stdout } = await execFileNoThrow('git', ['rev-parse', 'HEAD'])
-  return stdout.trim()
-}
-
-export const getBranch = async (): Promise<string> => {
-  const { stdout } = await execFileNoThrow(
-    'git',
-    ['rev-parse', '--abbrev-ref', 'HEAD'],
-    undefined,
-    undefined,
-    false,
-  )
-  return stdout.trim()
-}
-
-export const getRemoteUrl = async (): Promise<string | null> => {
-  // This might fail if there is no remote called origin
-  const { stdout, code } = await execFileNoThrow(
-    'git',
-    ['remote', 'get-url', 'origin'],
-    undefined,
-    undefined,
-    false,
-  )
-  return code === 0 ? stdout.trim() : null
-}
-
-export const getIsHeadOnRemote = async (): Promise<boolean> => {
-  const { code } = await execFileNoThrow(
-    'git',
-    ['rev-parse', '@{u}'],
-    undefined,
-    undefined,
-    false,
-  )
-  return code === 0
-}
-
-export const getIsClean = async (): Promise<boolean> => {
-  const { stdout } = await execFileNoThrow(
-    'git',
-    ['status', '--porcelain'],
-    undefined,
-    undefined,
-    false,
-  )
-  return stdout.trim().length === 0
-}
-
-export interface GitRepoState {
-  commitHash: string
-  branchName: string
-  remoteUrl: string | null
-  isHeadOnRemote: boolean
-  isClean: boolean
-}
-
-export async function getGitState(): Promise<GitRepoState | null> {
-  try {
-    const [commitHash, branchName, remoteUrl, isHeadOnRemote, isClean] =
-      await Promise.all([
-        getHead(),
-        getBranch(),
-        getRemoteUrl(),
-        getIsHeadOnRemote(),
-        getIsClean(),
-      ])
-
-    return {
-      commitHash,
-      branchName,
-      remoteUrl,
-      isHeadOnRemote,
-      isClean,
-    }
-  } catch (_) {
-    // Fail silently - git state is best effort
-    return null
-  }
-}

package/src/utils/globalLogger.ts

@@ -1,77 +0,0 @@
-/**
- * 统一的全局日志系统
- * 普通模式：完全静默，零日志输出
- * 调试模式：详细日志输出
- */
-
-// 环境检测 - 只在明确的调试标志下才启用日志
-const isDebugMode = () => 
-  process.argv.includes('--debug') || 
-  process.argv.includes('--verbose') || 
-  process.env.NODE_ENV === 'development'
-
-// 全局日志开关 - 普通模式下完全关闭
-const LOGGING_ENABLED = isDebugMode()
-
-/**
- * 统一的日志接口
- * 普通模式下所有调用都是空操作
- */
-export const globalLogger = {
-  // 标准日志级别
-  debug: (...args: any[]) => {
-    if (LOGGING_ENABLED) console.debug(...args)
-  },
-  
-  info: (...args: any[]) => {
-    if (LOGGING_ENABLED) console.info(...args)
-  },
-  
-  warn: (...args: any[]) => {
-    if (LOGGING_ENABLED) console.warn(...args)
-  },
-  
-  error: (...args: any[]) => {
-    if (LOGGING_ENABLED) console.error(...args)
-  },
-  
-  log: (...args: any[]) => {
-    if (LOGGING_ENABLED) console.log(...args)
-  },
-  
-  // 兼容现有的console.log调用
-  console: (...args: any[]) => {
-    if (LOGGING_ENABLED) console.log(...args)
-  },
-
-  // 模型切换相关日志
-  modelSwitch: (message: string, data?: any) => {
-    if (LOGGING_ENABLED) {
-      console.log(`🔄 Model Switch: ${message}`, data ? data : '')
-    }
-  },
-
-  // API 相关日志
-  api: (message: string, data?: any) => {
-    if (LOGGING_ENABLED) {
-      console.log(`🌐 API: ${message}`, data ? data : '')
-    }
-  },
-
-  // 用户友好的状态日志 - 只在调试模式下显示
-  status: (message: string) => {
-    if (LOGGING_ENABLED) {
-      console.log(`ℹ️ ${message}`)
-    }
-  },
-
-  // 检查日志是否启用
-  isEnabled: () => LOGGING_ENABLED
-}
-
-// 兼容性：导出为默认console替代
-export const logger = globalLogger
-
-// 用于替换现有的console.log调用
-export const debugLog = globalLogger.console
-export const statusLog = globalLogger.status

package/src/utils/http.ts

@@ -1,10 +0,0 @@
-/**
- * HTTP utility constants and helpers
- */
-
-import { MACRO } from '../constants/macros'
-import { PRODUCT_COMMAND } from '../constants/product'
-
-// WARNING: We rely on `claude-cli` in the user agent for log filtering.
-// Please do NOT change this without making sure that logging also gets updated!
-export const USER_AGENT = `${PRODUCT_COMMAND}/${MACRO.VERSION} (${process.env.USER_TYPE})`

package/src/utils/imagePaste.ts

@@ -1,38 +0,0 @@
-import { execSync } from 'child_process'
-import { readFileSync } from 'fs'
-
-const SCREENSHOT_PATH = '/tmp/claude_cli_latest_screenshot.png'
-
-export const CLIPBOARD_ERROR_MESSAGE =
-  'No image found in clipboard. Use Cmd + Ctrl + Shift + 4 to copy a screenshot to clipboard.'
-
-export function getImageFromClipboard(): string | null {
-  if (process.platform !== 'darwin') {
-    // only support image paste on macOS for now
-    return null
-  }
-
-  try {
-    // Check if clipboard has image
-    execSync(`osascript -e 'the clipboard as «class PNGf»'`, {
-      stdio: 'ignore',
-    })
-
-    // Save the image
-    execSync(
-      `osascript -e 'set png_data to (the clipboard as «class PNGf»)' -e 'set fp to open for access POSIX file "${SCREENSHOT_PATH}" with write permission' -e 'write png_data to fp' -e 'close access fp'`,
-      { stdio: 'ignore' },
-    )
-
-    // Read the image and convert to base64
-    const imageBuffer = readFileSync(SCREENSHOT_PATH)
-    const base64Image = imageBuffer.toString('base64')
-
-    // Cleanup
-    execSync(`rm -f "${SCREENSHOT_PATH}"`, { stdio: 'ignore' })
-
-    return base64Image
-  } catch {
-    return null
-  }
-}

package/src/utils/json.ts

@@ -1,13 +0,0 @@
-import { logError } from './log'
-
-export function safeParseJSON(json: string | null | undefined): unknown {
-  if (!json) {
-    return null
-  }
-  try {
-    return JSON.parse(json)
-  } catch (e) {
-    logError(e)
-    return null
-  }
-}