第 27 章：跨越会话的记忆

// → src/services/extractMemories/extractMemories.ts（简化版）
export function initExtractMemories(): void {
  let lastMemoryMessageUuid: string | undefined
  let inProgress = false
  let turnsSinceLastExtraction = 0

  async function runExtraction({ context, appendSystemMessage, isTrailingRun }) {
    // 如果主 Agent 已经写了记忆，跳过
    if (hasMemoryWritesSince(messages, lastMemoryMessageUuid)) return

    // 扫描已有记忆文件，构建清单
    const existingMemories = formatMemoryManifest(
      await scanMemoryFiles(memoryDir, signal),
    )

    // 启动后台 Agent 执行提取
    const result = await runForkedAgent({
      promptMessages: [createUserMessage({ content: userPrompt })],
      cacheSafeParams,
      canUseTool,
      querySource: 'extract_memories',
      maxTurns: 5,  // 最多 5 轮，防止跑偏
    })
  }
}

// → src/memdir/memoryTypes.ts
export const MEMORY_TYPES = [
  'user',       // 用户画像
  'feedback',   // 行为反馈
  'project',    // 项目状态
  'reference',  // 外部参考
] as const

// → src/memdir/memdir.ts
export const MAX_ENTRYPOINT_LINES = 200
export const MAX_ENTRYPOINT_BYTES = 25_000

// → src/memdir/memdir.ts（简化版）
export function truncateEntrypointContent(raw: string): EntrypointTruncation {
  return {
    content: truncated +
      `\n\n> WARNING: MEMORY.md is ${reason}. ` +
      `Keep index entries to one line under ~200 chars; ` +
      `move detail into topic files.`,
  }
}

// → src/memdir/findRelevantMemories.ts（简化版）
export async function findRelevantMemories(
  query: string,        // 用户当前的问题
  memoryDir: string,    // 记忆目录路径
  signal: AbortSignal,
): Promise<RelevantMemory[]> {
  // 第一步：扫描所有记忆文件的 frontmatter
  const memories = await scanMemoryFiles(memoryDir, signal)

  // 第二步：让 AI 从所有记忆中选出最相关的 5 条
  const selectedFilenames = await selectRelevantMemories(
    query, memories, signal,
  )

  return selected  // 最多返回 5 条相关记忆
}

// → src/memdir/memoryAge.ts
export function memoryAgeDays(mtimeMs: number): number {
  return Math.max(0, Math.floor((Date.now() - mtimeMs) / 86_400_000))
}

export function memoryAge(mtimeMs: number): string {
  const d = memoryAgeDays(mtimeMs)
  if (d === 0) return 'today'
  if (d === 1) return 'yesterday'
  return `${d} days ago`
}

// → src/memdir/memoryAge.ts（简化版）
export function memoryFreshnessText(mtimeMs: number): string {
  const d = memoryAgeDays(mtimeMs)
  if (d <= 1) return ''
  return `This memory is ${d} days old. ` +
    `Memories are point-in-time observations, not live state — ` +
    `claims about code behavior or file:line citations may be outdated.`
}

// → src/services/SessionMemory/sessionMemory.ts（简化版）
export function shouldExtractMemory(messages: Message[]): boolean {
  const currentTokenCount = tokenCountWithEstimation(messages)

  if (!isSessionMemoryInitialized()) {
    if (!hasMetInitializationThreshold(currentTokenCount)) return false
    markSessionMemoryInitialized()
  }

  const hasMetTokenThreshold = hasMetUpdateThreshold(currentTokenCount)
  const hasMetToolCallThreshold =
    toolCallsSinceLastUpdate >= getToolCallsBetweenUpdates()

  // 两个条件满足其一，或最后一个 assistant 消息没有工具调用
  return (hasMetTokenThreshold && hasMetToolCallThreshold)
    || (hasMetTokenThreshold && !hasToolCallsInLastTurn)
}

// → Session 持久化的最小数据结构
interface SessionSnapshot {
  id: string
  startedAt: string
  lastActivityAt: string

  // 对话状态
  messages: Array<{
    role: "user" | "assistant"
    content: string | ContentBlockParam[]
  }>

  // 循环状态
  turnCount: number
  currentTurnStartedAt: string | null  // 如果在工具执行中被中断，记录当前 turn

  // 统计
  totalTokens: { input: number; output: number }
  sessionCost: number

  // 配置快照（用于恢复时验证兼容性）
  config: {
    model: string
    maxTurns: number
    maxTokensPerTurn: number
  }
}

// → Session 持久化为 JSON Lines
import { appendFileSync, readFileSync } from "fs"

class SessionStore {
  private path: string

  constructor(sessionId: string) {
    this.path = `./sessions/${sessionId}.jsonl`
  }

  // 增量追加（每 turn 结束后调用）
  appendTurn(turn: number, event: "turn_start" | "tool_call" | "tool_result" | "turn_end", data: unknown): void {
    const line = JSON.stringify({
      timestamp: new Date().toISOString(),
      turn,
      event,
      data,
    }) + "\n"
    appendFileSync(this.path, line)
  }

  // 恢复：读取所有行，重建 Session
  static load(sessionId: string): SessionSnapshot | null {
    const path = `./sessions/${sessionId}.jsonl`
    let content: string
    try {
      content = readFileSync(path, "utf-8")
    } catch {
      return null  // Session 不存在
    }

    const lines = content.trim().split("\n")
    const messages: SessionSnapshot["messages"] = []
    let lastTurn = 0
    let totalInput = 0
    let totalOutput = 0

    for (const line of lines) {
      const entry = JSON.parse(line)
      lastTurn = Math.max(lastTurn, entry.turn)

      if (entry.event === "tool_result") {
        messages.push(/* 从 data 重建 tool_result */)
      }

      if (entry.data?.usage) {
        totalInput += entry.data.usage.input_tokens ?? 0
        totalOutput += entry.data.usage.output_tokens ?? 0
      }
    }

    return {
      id: sessionId,
      messages,
      turnCount: lastTurn,
      totalTokens: { input: totalInput, output: totalOutput },
      // ...
    }
  }
}

static load(sessionId: string): SessionSnapshot | null {
  const lines = content.trim().split("\n")

  // 丢弃最后一行如果不完整
  if (lines.length > 0) {
    try { JSON.parse(lines[lines.length - 1]) }
    catch {
      console.warn(`Session ${sessionId}: 最后一行损坏，已丢弃`)
      lines.pop()
    }
  }

  // 从剩余行重建...
}

const SESSION_MIGRATIONS: Record<number, (old: any) => any> = {
  // v1 → v2：新增 totalTokens 字段
  1: (old) => ({ ...old, totalTokens: { input: 0, output: 0 } }),

  // v2 → v3：config 从字符串变成对象
  2: (old) => ({
    ...old,
    config: typeof old.config === "string"
      ? JSON.parse(old.config)
      : old.config,
  }),
}

function migrateSession(data: any, fromVersion: number, toVersion: number): any {
  let current = data
  for (let v = fromVersion; v < toVersion; v++) {
    if (SESSION_MIGRATIONS[v]) {
      current = SESSION_MIGRATIONS[v](current)
    }
  }
  return current
}

console.log('[DEBUG] Memory extraction triggered, existing:', existingMemories.length)