内存与上下文

// memdir.ts 核心常量与逻辑
const ENTRYPOINT_NAME = 'MEMORY.md';
const MAX_ENTRYPOINT_LINES = 200;
const MAX_ENTRYPOINT_BYTES = 25000;

// 截断入口内容，保留最重要的信息
function truncateEntrypointContent(
  content: string
): string {
  const lines = content.split('\n');
  if (lines.length <= MAX_ENTRYPOINT_LINES &&
      Buffer.byteLength(content) <= MAX_ENTRYPOINT_BYTES) {
    return content;
  }

  // 优先保留最近添加的内存（文件末尾）
  let truncated = lines
    .slice(-MAX_ENTRYPOINT_LINES)
    .join('\n');

  // 字节数检查
  while (Buffer.byteLength(truncated) > MAX_ENTRYPOINT_BYTES) {
    const parts = truncated.split('\n');
    parts.shift(); // 移除最旧的一行
    truncated = parts.join('\n');
  }
  return truncated;
}

// 内存类型定义
type MemoryType = 'user' | 'feedback' | 'project' | 'reference';

interface MemoryEntry {
  type: MemoryType;
  content: string;
  timestamp: number;
  source: string;  // 来源标识
  relevanceScore?: number;
}

// findRelevantMemories: 语义搜索相关内存
async function findRelevantMemories(
  query: string,
  memories: MemoryEntry[],
  topK: number = 10
): Promise<MemoryEntry[]> {
  const scored = memories.map(m => ({
    ...m,
    relevanceScore: computeSimilarity(query, m.content)
  }));
  scored.sort((a, b) =>
    (b.relevanceScore || 0) - (a.relevanceScore || 0)
  );
  return scored.slice(0, topK);
}

// 压缩后恢复常量
const POST_COMPACT_MAX_FILES_TO_RESTORE = 5;
const POST_COMPACT_TOKEN_BUDGET = 50000;

// L1: snipCompact - 激进的旧消息移除
function snipCompact(
  messages: Message[],
  targetTokens: number
): Message[] {
  if (!isFeatureEnabled('HISTORY_SNIP')) {
    return messages;
  }
  // 从最旧的消息开始删除
  const result = [...messages];
  let currentTokens = countTokens(result);
  while (currentTokens > targetTokens && result.length > 2) {
    result.shift();
    currentTokens = countTokens(result);
  }
  return result;
}

// L2: microCompact - 轻量级工具结果裁剪（始终运行）
function microCompact(messages: Message[]): Message[] {
  return messages.map(msg => {
    if (msg.type !== 'tool_result') return msg;
    // 截断过长的工具输出
    if (msg.content.length > 10000) {
      return {
        ...msg,
        content: msg.content.slice(0, 5000)
          + '\n... [已截断] ...\n'
          + msg.content.slice(-2000)
      };
    }
    return msg;
  });
}

// L4: autoCompact - 使用分叉代理生成摘要
async function autoCompact(
  messages: Message[],
  context: CompactContext
): Promise<CompactResult> {
  // 启动子代理进行摘要
  const summary = await forkAgent({
    prompt: '请总结以下对话的关键信息...',
    messages: messages,
    maxTokens: 2000
  });

  // 压缩后恢复最近文件
  const recentFiles = getRecentlyAccessedFiles(messages)
    .slice(0, POST_COMPACT_MAX_FILES_TO_RESTORE);

  return {
    summary: summary,
    restoredFiles: recentFiles,
    tokenBudget: POST_COMPACT_TOKEN_BUDGET
  };
}

// sessionMemoryCompact.ts: 压缩后内存提取
async function sessionMemoryCompact(
  messages: Message[],
  existingMemories: MemoryEntry[]
): Promise<MemoryEntry[]> {
  // 使用 AI 提取值得记忆的信息
  const extracted = await extractMemories(messages);

  // 过滤重复内存
  const newMemories = extracted.filter(
    mem => !existingMemories.some(
      existing => isSimilar(existing.content, mem.content)
    )
  );

  // 写入 MEMORY.md
  const memoryContent = newMemories
    .map(m => formatMemoryEntry(m))
    .join('\n');

  await appendToMemoryFile(memoryContent);
  return [...existingMemories, ...newMemories];
}

// extractMemories: 智能记忆提取服务
async function extractMemories(
  messages: Message[]
): Promise<MemoryEntry[]> {
  const memories: MemoryEntry[] = [];

  // 提取用户纠正（feedback 类型）
  for (const msg of messages) {
    if (isUserCorrection(msg)) {
      memories.push({
        type: 'feedback',
        content: msg.content,
        timestamp: Date.now(),
        source: 'user_correction'
      });
    }
  }

  // 提取项目发现（project 类型）
  const projectInsights = await analyzeForInsights(
    messages
  );
  for (const insight of projectInsights) {
    memories.push({
      type: 'project',
      content: insight,
      timestamp: Date.now(),
      source: 'auto_extract'
    });
  }

  return memories;
}

// CLAUDE.md 多层加载
async function loadClaudeMd(): Promise<string> {
  const layers: string[] = [];

  // 企业级（最低优先级）
  const enterprise = await loadEnterpriseClaude();
  if (enterprise) layers.push(enterprise);

  // 用户级
  const user = await loadFile('~/.claude/CLAUDE.md');
  if (user) layers.push(user);

  // 项目级（最高优先级）
  const project = await loadFile('./CLAUDE.md');
  if (project) layers.push(project);

  return layers.join('\n---\n');
}