@shareai-lab/kode 1.0.70 → 1.0.71

package/src/utils/autoCompactCore.ts

@@ -0,0 +1,223 @@
+import { Message } from '../query'
+import { countTokens } from './tokens'
+import { getMessagesGetter, getMessagesSetter } from '../messages'
+import { getContext } from '../context'
+import { getCodeStyle } from '../utils/style'
+import { clearTerminal } from '../utils/terminal'
+import { resetFileFreshnessSession } from '../services/fileFreshness'
+import { createUserMessage, normalizeMessagesForAPI } from '../utils/messages'
+import { queryLLM } from '../services/claude'
+import { selectAndReadFiles } from './fileRecoveryCore'
+import { addLineNumbers } from './file'
+import { getModelManager } from './model'
+
+/**
+ * Threshold ratio for triggering automatic context compression
+ * When context usage exceeds 92% of the model's limit, auto-compact activates
+ */
+const AUTO_COMPACT_THRESHOLD_RATIO = 0.92
+
+/**
+ * Retrieves the context length for the main model that should execute compression
+ * Uses ModelManager to get the current model's context length
+ */
+async function getCompressionModelContextLimit(): Promise<number> {
+  try {
+    // 🔧 Fix: Use ModelManager instead of legacy config
+    const modelManager = getModelManager()
+    const modelProfile = modelManager.getModel('main')
+
+    if (modelProfile?.contextLength) {
+      return modelProfile.contextLength
+    }
+
+    // Fallback to a reasonable default
+    return 200_000
+  } catch (error) {
+    return 200_000
+  }
+}
+
+const COMPRESSION_PROMPT = `Please provide a comprehensive summary of our conversation structured as follows:
+
+## Technical Context
+Development environment, tools, frameworks, and configurations in use. Programming languages, libraries, and technical constraints. File structure, directory organization, and project architecture.
+
+## Project Overview  
+Main project goals, features, and scope. Key components, modules, and their relationships. Data models, APIs, and integration patterns.
+
+## Code Changes
+Files created, modified, or analyzed during our conversation. Specific code implementations, functions, and algorithms added. Configuration changes and structural modifications.
+
+## Debugging & Issues
+Problems encountered and their root causes. Solutions implemented and their effectiveness. Error messages, logs, and diagnostic information.
+
+## Current Status
+What we just completed successfully. Current state of the codebase and any ongoing work. Test results, validation steps, and verification performed.
+
+## Pending Tasks
+Immediate next steps and priorities. Planned features, improvements, and refactoring. Known issues, technical debt, and areas needing attention.
+
+## User Preferences
+Coding style, formatting, and organizational preferences. Communication patterns and feedback style. Tool choices and workflow preferences.
+
+## Key Decisions
+Important technical decisions made and their rationale. Alternative approaches considered and why they were rejected. Trade-offs accepted and their implications.
+
+Focus on information essential for continuing the conversation effectively, including specific details about code, files, errors, and plans.`
+
+/**
+ * Calculates context usage thresholds based on the main model's capabilities
+ * Uses the main model context length since compression tasks require a capable model
+ */
+async function calculateThresholds(tokenCount: number) {
+  const contextLimit = await getCompressionModelContextLimit()
+  const autoCompactThreshold = contextLimit * AUTO_COMPACT_THRESHOLD_RATIO
+
+  return {
+    isAboveAutoCompactThreshold: tokenCount >= autoCompactThreshold,
+    percentUsed: Math.round((tokenCount / contextLimit) * 100),
+    tokensRemaining: Math.max(0, autoCompactThreshold - tokenCount),
+    contextLimit,
+  }
+}
+
+/**
+ * Determines if auto-compact should trigger based on token usage
+ * Uses the main model context limit since compression requires a capable model
+ */
+async function shouldAutoCompact(messages: Message[]): Promise<boolean> {
+  if (messages.length < 3) return false
+
+  const tokenCount = countTokens(messages)
+  const { isAboveAutoCompactThreshold } = await calculateThresholds(tokenCount)
+
+  return isAboveAutoCompactThreshold
+}
+
+/**
+ * Main entry point for automatic context compression
+ *
+ * This function is called before each query to check if the conversation
+ * has grown too large and needs compression. When triggered, it:
+ * - Generates a structured summary of the conversation using the main model
+ * - Recovers recently accessed files to maintain development context
+ * - Resets conversation state while preserving essential information
+ *
+ * Uses the main model for compression tasks to ensure high-quality summaries
+ *
+ * @param messages Current conversation messages
+ * @param toolUseContext Execution context with model and tool configuration
+ * @returns Updated messages (compressed if needed) and compression status
+ */
+export async function checkAutoCompact(
+  messages: Message[],
+  toolUseContext: any,
+): Promise<{ messages: Message[]; wasCompacted: boolean }> {
+  if (!(await shouldAutoCompact(messages))) {
+    return { messages, wasCompacted: false }
+  }
+
+  try {
+    const compactedMessages = await executeAutoCompact(messages, toolUseContext)
+
+    return {
+      messages: compactedMessages,
+      wasCompacted: true,
+    }
+  } catch (error) {
+    // Graceful degradation: if auto-compact fails, continue with original messages
+    // This ensures system remains functional even if compression encounters issues
+    console.error(
+      'Auto-compact failed, continuing with original messages:',
+      error,
+    )
+    return { messages, wasCompacted: false }
+  }
+}
+
+/**
+ * Executes the conversation compression process using the main model
+ *
+ * This function generates a comprehensive summary using the main model
+ * which is better suited for complex summarization tasks. It also
+ * automatically recovers important files to maintain development context.
+ */
+async function executeAutoCompact(
+  messages: Message[],
+  toolUseContext: any,
+): Promise<Message[]> {
+  const summaryRequest = createUserMessage(COMPRESSION_PROMPT)
+
+  const summaryResponse = await queryLLM(
+    normalizeMessagesForAPI([...messages, summaryRequest]),
+    [
+      'You are a helpful AI assistant tasked with creating comprehensive conversation summaries that preserve all essential context for continuing development work.',
+    ],
+    0,
+    toolUseContext.options.tools,
+    toolUseContext.abortController.signal,
+    {
+      safeMode: false,
+      model: 'main', // 使用模型指针，让queryLLM统一解析
+      prependCLISysprompt: true,
+    },
+  )
+
+  const content = summaryResponse.message.content
+  const summary =
+    typeof content === 'string'
+      ? content
+      : content.length > 0 && content[0]?.type === 'text'
+        ? content[0].text
+        : null
+
+  if (!summary) {
+    throw new Error(
+      'Failed to generate conversation summary - response did not contain valid text content',
+    )
+  }
+
+  summaryResponse.message.usage = {
+    input_tokens: 0,
+    output_tokens: summaryResponse.message.usage.output_tokens,
+    cache_creation_input_tokens: 0,
+    cache_read_input_tokens: 0,
+  }
+
+  // Automatic file recovery: preserve recently accessed development files
+  // This maintains coding context even after conversation compression
+  const recoveredFiles = await selectAndReadFiles()
+
+  const compactedMessages = [
+    createUserMessage(
+      'Context automatically compressed due to token limit. Essential information preserved.',
+    ),
+    summaryResponse,
+  ]
+
+  // Append recovered files to maintain development workflow continuity
+  // Files are prioritized by recency and importance, with strict token limits
+  if (recoveredFiles.length > 0) {
+    for (const file of recoveredFiles) {
+      const contentWithLines = addLineNumbers({
+        content: file.content,
+        startLine: 1,
+      })
+      const recoveryMessage = createUserMessage(
+        `**Recovered File: ${file.path}**\n\n\`\`\`\n${contentWithLines}\n\`\`\`\n\n` +
+          `*Automatically recovered (${file.tokens} tokens)${file.truncated ? ' [truncated]' : ''}*`,
+      )
+      compactedMessages.push(recoveryMessage)
+    }
+  }
+
+  // State cleanup to ensure fresh context after compression
+  // Mirrors the cleanup sequence from manual /compact command
+  getMessagesSetter()([])
+  getContext.cache.clear?.()
+  getCodeStyle.cache.clear?.()
+  resetFileFreshnessSession()
+
+  return compactedMessages
+}

package/src/utils/autoUpdater.ts

@@ -0,0 +1,318 @@
+import { homedir } from 'os'
+import { join } from 'path'
+import {
+  existsSync,
+  mkdirSync,
+  appendFileSync,
+  readFileSync,
+  constants,
+  writeFileSync,
+  unlinkSync,
+  statSync,
+} from 'fs'
+import { platform } from 'process'
+import { execFileNoThrow } from './execFileNoThrow'
+import { logError } from './log'
+import { accessSync } from 'fs'
+import { CLAUDE_BASE_DIR } from './env'
+import { logEvent, getDynamicConfig } from '../services/statsig'
+import { lt } from 'semver'
+import { MACRO } from '../constants/macros'
+import { PRODUCT_COMMAND, PRODUCT_NAME } from '../constants/product'
+export type InstallStatus =
+  | 'success'
+  | 'no_permissions'
+  | 'install_failed'
+  | 'in_progress'
+
+export type AutoUpdaterResult = {
+  version: string | null
+  status: InstallStatus
+}
+
+export type VersionConfig = {
+  minVersion: string
+}
+
+/**
+ * Checks if the current version meets the minimum required version from Statsig config
+ * Terminates the process with an error message if the version is too old
+ */
+export async function assertMinVersion(): Promise<void> {
+  try {
+    const versionConfig = await getDynamicConfig<VersionConfig>(
+      'tengu_version_config',
+      { minVersion: '0.0.0' },
+    )
+
+    if (
+      versionConfig.minVersion &&
+      lt(MACRO.VERSION, versionConfig.minVersion)
+    ) {
+      console.error(`
+It looks like your version of ${PRODUCT_NAME} (${MACRO.VERSION}) needs an update.
+A newer version (${versionConfig.minVersion} or higher) is required to continue.
+
+To update, please run:
+    ${PRODUCT_COMMAND} update
+
+This will ensure you have access to the latest features and improvements.
+`)
+      process.exit(1)
+    }
+  } catch (error) {
+    logError(`Error checking minimum version: ${error}`)
+  }
+}
+
+// Lock file for auto-updater to prevent concurrent updates
+export const LOCK_FILE_PATH = join(CLAUDE_BASE_DIR, '.update.lock')
+const LOCK_TIMEOUT_MS = 5 * 60 * 1000 // 5 minute timeout for locks
+
+/**
+ * Attempts to acquire a lock for auto-updater
+ * @returns {boolean} true if lock was acquired, false if another process holds the lock
+ */
+function acquireLock(): boolean {
+  try {
+    // Ensure the base directory exists
+    if (!existsSync(CLAUDE_BASE_DIR)) {
+      mkdirSync(CLAUDE_BASE_DIR, { recursive: true })
+    }
+
+    // Check if lock file exists and is not stale
+    if (existsSync(LOCK_FILE_PATH)) {
+      const stats = statSync(LOCK_FILE_PATH)
+      const age = Date.now() - stats.mtimeMs
+
+      // If lock file is older than timeout, consider it stale
+      if (age < LOCK_TIMEOUT_MS) {
+        return false
+      }
+
+      // Lock is stale, we can take over
+      try {
+        unlinkSync(LOCK_FILE_PATH)
+      } catch (err) {
+        logError(`Failed to remove stale lock file: ${err}`)
+        return false
+      }
+    }
+
+    // Create lock file with current pid
+    writeFileSync(LOCK_FILE_PATH, `${process.pid}`, 'utf8')
+    return true
+  } catch (err) {
+    logError(`Failed to acquire lock: ${err}`)
+    return false
+  }
+}
+
+/**
+ * Releases the update lock if it's held by this process
+ */
+function releaseLock(): void {
+  try {
+    if (existsSync(LOCK_FILE_PATH)) {
+      const lockData = readFileSync(LOCK_FILE_PATH, 'utf8')
+      if (lockData === `${process.pid}`) {
+        unlinkSync(LOCK_FILE_PATH)
+      }
+    }
+  } catch (err) {
+    logError(`Failed to release lock: ${err}`)
+  }
+}
+
+export async function checkNpmPermissions(): Promise<{
+  hasPermissions: boolean
+  npmPrefix: string | null
+}> {
+  try {
+    const prefixResult = await execFileNoThrow('npm', [
+      '-g',
+      'config',
+      'get',
+      'prefix',
+    ])
+    if (prefixResult.code !== 0) {
+      logError('Failed to check npm permissions')
+      return { hasPermissions: false, npmPrefix: null }
+    }
+
+    const prefix = prefixResult.stdout.trim()
+
+    let testWriteResult = false
+    try {
+      accessSync(prefix, constants.W_OK)
+      testWriteResult = true
+    } catch {
+      testWriteResult = false
+    }
+
+    if (testWriteResult) {
+      return { hasPermissions: true, npmPrefix: prefix }
+    }
+
+    logError('Insufficient permissions for global npm install.')
+    return { hasPermissions: false, npmPrefix: prefix }
+  } catch (error) {
+    logError(`Failed to verify npm global install permissions: ${error}`)
+    return { hasPermissions: false, npmPrefix: null }
+  }
+}
+
+export async function setupNewPrefix(prefix: string): Promise<void> {
+  if (!acquireLock()) {
+    // Log the lock contention to statsig
+    logEvent('tengu_auto_updater_prefix_lock_contention', {
+      pid: String(process.pid),
+      currentVersion: MACRO.VERSION,
+      prefix,
+    })
+    throw new Error('Another process is currently setting up npm prefix')
+  }
+
+  try {
+    // Create directory if it doesn't exist
+    if (!existsSync(prefix)) {
+      mkdirSync(prefix, { recursive: true })
+    }
+
+    // Set npm prefix
+    const setPrefix = await execFileNoThrow('npm', [
+      '-g',
+      'config',
+      'set',
+      'prefix',
+      prefix,
+    ])
+
+    if (setPrefix.code !== 0) {
+      throw new Error(`Failed to set npm prefix: ${setPrefix.stderr}`)
+    }
+
+    // Update shell config files
+    const pathUpdate = `\n# npm global path\nexport PATH="${prefix}/bin:$PATH"\n`
+
+    if (platform === 'win32') {
+      // On Windows, update user PATH environment variable
+      const setxResult = await execFileNoThrow('setx', [
+        'PATH',
+        `${process.env.PATH};${prefix}`,
+      ])
+      if (setxResult.code !== 0) {
+        throw new Error(
+          `Failed to update PATH on Windows: ${setxResult.stderr}`,
+        )
+      }
+    } else {
+      // Unix-like systems
+      const shellConfigs = [
+        // Bash
+        join(homedir(), '.bashrc'),
+        join(homedir(), '.bash_profile'),
+        // Zsh
+        join(homedir(), '.zshrc'),
+        // Fish
+        join(homedir(), '.config', 'fish', 'config.fish'),
+      ]
+
+      for (const config of shellConfigs) {
+        if (existsSync(config)) {
+          try {
+            const content = readFileSync(config, 'utf8')
+            if (!content.includes(prefix)) {
+              if (config.includes('fish')) {
+                // Fish shell has different syntax
+                const fishPath = `\n# npm global path\nset -gx PATH ${prefix}/bin $PATH\n`
+                appendFileSync(config, fishPath)
+              } else {
+                appendFileSync(config, pathUpdate)
+              }
+
+              logEvent('npm_prefix_path_updated', {
+                configPath: config,
+              })
+            }
+          } catch (err) {
+            // Log but don't throw - continue with other configs
+            logEvent('npm_prefix_path_update_failed', {
+              configPath: config,
+              error:
+                err instanceof Error
+                  ? err.message.slice(0, 200)
+                  : String(err).slice(0, 200),
+            })
+            logError(`Failed to update shell config ${config}: ${err}`)
+          }
+        }
+      }
+    }
+  } finally {
+    releaseLock()
+  }
+}
+
+export function getDefaultNpmPrefix(): string {
+  return join(homedir(), '.npm-global')
+}
+
+export function getPermissionsCommand(npmPrefix: string): string {
+  const windowsCommand = `icacls "${npmPrefix}" /grant "%USERNAME%:(OI)(CI)F"`
+  const prefixPath = npmPrefix || '$(npm -g config get prefix)'
+  const unixCommand = `sudo chown -R $USER:$(id -gn) ${prefixPath} && sudo chmod -R u+w ${prefixPath}`
+
+  return platform === 'win32' ? windowsCommand : unixCommand
+}
+
+export async function getLatestVersion(): Promise<string | null> {
+  const abortController = new AbortController()
+  setTimeout(() => abortController.abort(), 5000)
+
+  const result = await execFileNoThrow(
+    'npm',
+    ['view', MACRO.PACKAGE_URL, 'version'],
+    abortController.signal,
+  )
+  if (result.code !== 0) {
+    return null
+  }
+  return result.stdout.trim()
+}
+
+export async function installGlobalPackage(): Promise<InstallStatus> {
+  if (!acquireLock()) {
+    logError('Another process is currently installing an update')
+    // Log the lock contention to statsig
+    logEvent('tengu_auto_updater_lock_contention', {
+      pid: String(process.pid),
+      currentVersion: MACRO.VERSION,
+    })
+    return 'in_progress'
+  }
+
+  try {
+    const { hasPermissions } = await checkNpmPermissions()
+    if (!hasPermissions) {
+      return 'no_permissions'
+    }
+
+    const installResult = await execFileNoThrow('npm', [
+      'install',
+      '-g',
+      MACRO.PACKAGE_URL,
+    ])
+    if (installResult.code !== 0) {
+      logError(
+        `Failed to install new version of claude: ${installResult.stdout} ${installResult.stderr}`,
+      )
+      return 'install_failed'
+    }
+
+    return 'success'
+  } finally {
+    // Ensure we always release the lock
+    releaseLock()
+  }
+}

package/src/utils/betas.ts

@@ -0,0 +1,20 @@
+import { memoize } from 'lodash-es'
+import { checkGate } from '../services/statsig'
+import {
+  GATE_TOKEN_EFFICIENT_TOOLS,
+  BETA_HEADER_TOKEN_EFFICIENT_TOOLS,
+  CLAUDE_CODE_20250219_BETA_HEADER,
+} from '../constants/betas.js'
+
+export const getBetas = memoize(async (): Promise<string[]> => {
+  const betaHeaders = [CLAUDE_CODE_20250219_BETA_HEADER]
+
+  if (process.env.USER_TYPE === 'ant' || process.env.SWE_BENCH) {
+    const useTokenEfficientTools = await checkGate(GATE_TOKEN_EFFICIENT_TOOLS)
+    if (useTokenEfficientTools) {
+      betaHeaders.push(BETA_HEADER_TOKEN_EFFICIENT_TOOLS)
+    }
+  }
+
+  return betaHeaders
+})

package/src/utils/browser.ts

@@ -0,0 +1,14 @@
+import { execFileNoThrow } from './execFileNoThrow'
+
+export async function openBrowser(url: string): Promise<boolean> {
+  const platform = process.platform
+  const command =
+    platform === 'win32' ? 'start' : platform === 'darwin' ? 'open' : 'xdg-open'
+
+  try {
+    const { code } = await execFileNoThrow(command, [url])
+    return code === 0
+  } catch (_) {
+    return false
+  }
+}

package/src/utils/cleanup.ts

@@ -0,0 +1,72 @@
+import { promises as fs } from 'fs'
+import { join } from 'path'
+import { logError } from './log'
+import { CACHE_PATHS } from './log'
+
+const THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000
+
+export type CleanupResult = {
+  messages: number
+  errors: number
+}
+
+export function convertFileNameToDate(filename: string): Date {
+  const isoStr = filename
+    .split('.')[0]!
+    .replace(/T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z/, 'T$1:$2:$3.$4Z')
+  return new Date(isoStr)
+}
+
+export async function cleanupOldMessageFiles(): Promise<CleanupResult> {
+  const messagePath = CACHE_PATHS.messages()
+  const errorPath = CACHE_PATHS.errors()
+  const thirtyDaysAgo = new Date(Date.now() - THIRTY_DAYS_MS)
+  const deletedCounts: CleanupResult = { messages: 0, errors: 0 }
+
+  for (const path of [messagePath, errorPath]) {
+    try {
+      const files = await fs.readdir(path)
+
+      for (const file of files) {
+        try {
+          // Convert filename format where all ':.' were replaced with '-'
+          const timestamp = convertFileNameToDate(file)
+          if (timestamp < thirtyDaysAgo) {
+            await fs.unlink(join(path, file))
+            // Increment the appropriate counter
+            if (path === messagePath) {
+              deletedCounts.messages++
+            } else {
+              deletedCounts.errors++
+            }
+          }
+        } catch (error: unknown) {
+          // Log but continue processing other files
+          logError(
+            `Failed to process file ${file}: ${error instanceof Error ? error.message : String(error)}`,
+          )
+        }
+      }
+    } catch (error: unknown) {
+      // Ignore if directory doesn't exist
+      if (
+        error instanceof Error &&
+        'code' in error &&
+        error.code !== 'ENOENT'
+      ) {
+        logError(
+          `Failed to cleanup directory ${path}: ${error instanceof Error ? error.message : String(error)}`,
+        )
+      }
+    }
+  }
+
+  return deletedCounts
+}
+
+export function cleanupOldMessageFilesInBackground(): void {
+  const immediate = setImmediate(cleanupOldMessageFiles)
+
+  // Prevent the setImmediate from keeping the process alive
+  immediate.unref()
+}