@shareai-lab/kode 1.0.9

package/src/utils/ask.tsx

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

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

@@ -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
+}