caching

缓存是性能优化的关键，Claude Code 使用多层缓存机制。

缓存层级

L1: 内存缓存 (最快)
  ↓
L2: 文件缓存 (快)
  ↓
L3: API 缓存 (Anthropic Prompt Caching)

内存缓存

System Prompt 缓存

const promptCache = new Map<string, string>();

async function getSystemPrompt(tools: Tool[]): Promise<string> {
  const key = hashTools(tools);
  
  if (promptCache.has(key)) {
    return promptCache.get(key);
  }
  
  const prompt = await buildSystemPrompt(tools);
  promptCache.set(key, prompt);
  
  return prompt;
}

工具结果缓存

const toolResultCache = new Map<string, ToolResult>();

async function executeTool(call: ToolCall): Promise<ToolResult> {
  const key = `${call.name}:${JSON.stringify(call.input)}`;
  
  if (toolResultCache.has(key)) {
    return toolResultCache.get(key);
  }
  
  const result = await tool.execute(call.input, context);
  toolResultCache.set(key, result);
  
  return result;
}

文件缓存

配置缓存

const CONFIG_CACHE_PATH = path.join(
  os.homedir(),
  '.claude-code',
  'cache',
  'config.json'
);

async function loadConfigWithCache(): Promise<Config> {
  // 检查缓存
  const cached = await readCache(CONFIG_CACHE_PATH);
  
  if (cached && !isStale(cached)) {
    return cached.data;
  }
  
  // 加载配置
  const config = await loadConfig();
  
  // 写入缓存
  await writeCache(CONFIG_CACHE_PATH, config);
  
  return config;
}

API 缓存

Anthropic Prompt Caching

const response = await anthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  system: [
    {
      type: 'text',
      text: STATIC_PROMPT,
      cache_control: { type: 'ephemeral' },
    },
    {
      type: 'text',
      text: dynamicPrompt,
    },
  ],
  messages: messages,
});

缓存失效

TTL (Time To Live)

interface CacheEntry<T> {
  data: T;
  timestamp: number;
  ttl: number;
}

function isStale<T>(entry: CacheEntry<T>): boolean {
  return Date.now() - entry.timestamp > entry.ttl;
}

依赖失效

// 文件修改时失效缓存
watchFiles(['config.json', '.kiro/**'], () => {
  configCache.clear();
  promptCache.clear();
});

缓存清理

LRU 策略

class LRUCache<K, V> {
  private cache = new Map<K, { value: V; lastAccess: number }>();
  
  constructor(private maxSize: number) {}
  
  get(key: K): V | undefined {
    const entry = this.cache.get(key);
    
    if (entry) {
      entry.lastAccess = Date.now();
      return entry.value;
    }
  }
  
  set(key: K, value: V): void {
    if (this.cache.size >= this.maxSize) {
      this.evictLRU();
    }
    
    this.cache.set(key, {
      value,
      lastAccess: Date.now(),
    });
  }
  
  private evictLRU(): void {
    let oldest = Infinity;
    let oldestKey: K;
    
    for (const [key, entry] of this.cache) {
      if (entry.lastAccess < oldest) {
        oldest = entry.lastAccess;
        oldestKey = key;
      }
    }
    
    this.cache.delete(oldestKey);
  }
}

下一步

• 了解 启动优化 的完整策略

• 探索 并发控制 的实现

• 查看 上下文管理 的压缩机制