@shareai-lab/kode 1.1.13 → 1.1.16

package/src/utils/ask.tsx

@@ -1,99 +0,0 @@
-import { last } from 'lodash-es'
-import { Command } from '../commands'
-import { getSystemPrompt } from '../constants/prompts'
-import { getContext } from '../context'
-import { getTotalCost } from '../cost-tracker'
-import { Message, query } from '../query'
-import { CanUseToolFn } from '../hooks/useCanUseTool'
-import { Tool } from '../Tool'
-import { getModelManager } from '../utils/model'
-import { setCwd } from './state'
-import { getMessagesPath, overwriteLog } from './log'
-import { createUserMessage } from './messages'
-
-type Props = {
-  commands: Command[]
-  safeMode?: boolean
-  hasPermissionsToUseTool: CanUseToolFn
-  messageLogName: string
-  prompt: string
-  cwd: string
-  tools: Tool[]
-  verbose?: boolean
-}
-
-// Sends a single prompt to the Claude API and returns the response.
-// Assumes that claude is being used non-interactively -- will not
-// ask the user for permissions or further input.
-export async function ask({
-  commands,
-  safeMode,
-  hasPermissionsToUseTool,
-  messageLogName,
-  prompt,
-  cwd,
-  tools,
-  verbose = false,
-}: Props): Promise<{
-  resultText: string
-  totalCost: number
-  messageHistoryFile: string
-}> {
-  await setCwd(cwd)
-  const message = createUserMessage(prompt)
-  const messages: Message[] = [message]
-
-  const [systemPrompt, context, model] = await Promise.all([
-    getSystemPrompt(),
-    getContext(),
-    getModelManager().getModelName('main'),
-  ])
-
-  for await (const m of query(
-    messages,
-    systemPrompt,
-    context,
-    hasPermissionsToUseTool,
-    {
-      options: {
-        commands,
-        tools,
-        verbose,
-        safeMode,
-        forkNumber: 0,
-        messageLogName: 'unused',
-        maxThinkingTokens: 0,
-      },
-      abortController: new AbortController(),
-      messageId: undefined,
-      readFileTimestamps: {},
-      setToolJSX: () => {}, // No-op function for non-interactive use
-    },
-  )) {
-    messages.push(m)
-  }
-
-  const result = last(messages)
-  if (!result || result.type !== 'assistant') {
-    throw new Error('Expected content to be an assistant message')
-  }
-  if (result.message.content[0]?.type !== 'text') {
-    throw new Error(
-      `Expected first content item to be text, but got ${JSON.stringify(
-        result.message.content[0],
-        null,
-        2,
-      )}`,
-    )
-  }
-
-  // Write log that can be retrieved with `claude log`
-  const messageHistoryFile = getMessagesPath(messageLogName, 0, 0)
-  overwriteLog(messageHistoryFile, messages)
-
-  return {
-    resultText: result.message.content[0].text,
-    totalCost: getTotalCost(),
-    messageHistoryFile,
-  }
-}

package/src/utils/auth.ts

@@ -1,13 +0,0 @@
-import { USE_BEDROCK, USE_VERTEX } from './model'
-import { getGlobalConfig } from './config'
-
-export function isAnthropicAuthEnabled(): boolean {
-  return false
-  // return !(USE_BEDROCK || USE_VERTEX)
-}
-
-export function isLoggedInToAnthropic(): boolean {
-  return false
-  // const config = getGlobalConfig()
-  // return !!config.primaryApiKey
-}

package/src/utils/autoCompactCore.ts

@@ -1,223 +0,0 @@
-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
-}