{"type":"message","message":{"role":"user","content":"帮我写一个 Python 爬虫"}}
{"type":"message","message":{"role":"assistant","content":"可以，我先确认目标网站和字段。"}}
{"type":"tool_call","tool":"bash","input":{"command":"python crawler.py"}}

async function buildSessionEntry(filePath: string) {
  const raw = await fs.readFile(filePath, "utf-8");
  const lines = raw.split("\n").filter(Boolean);

  const messages: string[] = [];

  for (const line of lines) {
    const record = JSON.parse(line);

    if (record.type !== "message") continue;

    const role = record.message?.role;
    const content = record.message?.content;

    if (role === "user") {
      messages.push(`User: ${content}`);
    }

    if (role === "assistant") {
      messages.push(`Assistant: ${content}`);
    }
  }

  const content = messages.join("\n");

  return {
    path: filePath,
    hash: hashText(content),
    content,
  };
}

# 用户长期偏好

- 回复尽量简洁，先给结论，再给细节。
- 代码示例优先使用 TypeScript 和 Python。
- 默认把提醒发送到 Telegram。

# Session: 2026-01-10 08:00 UTC

## Summary

用户希望设置每日健身提醒，并补充了每周训练安排。

## Key Points

- 每天下午 3 点提醒健身。
- 周一练胸，周三练背，周五练腿。
- 提醒渠道优先使用 Telegram。

## Action Items

- [x] 设置每日 15:00 健身提醒。
- [ ] 后续可继续补充具体训练动作。

- 我的默认工作目录是 ~/workspace/acme。
- 周报固定在每周五 18:00 前发送。
- 和我讨论数据库时，优先考虑 PostgreSQL。

const MEMORY_FLUSH_PROMPT = [
  "Pre-compaction memory flush.",
  "Store durable memories now in memory/YYYY-MM-DD.md.",
  "If nothing should be stored, reply with SILENT.",
].join(" ");

async function buildFileEntry(absPath: string) {
  const stat = await fs.stat(absPath);
  const content = await fs.readFile(absPath, "utf-8");

  return {
    path: toRelativeMemoryPath(absPath),
    absPath,
    mtime: stat.mtimeMs,
    size: stat.size,
    hash: hashText(content),
  };
}

const oldRecord = db
  .prepare("SELECT hash FROM files WHERE path = ? AND source = ?")
  .get(entry.path, "memory");

if (oldRecord?.hash === entry.hash && !needsFullReindex) {
  return; // 文件没变，不重新索引
}

await indexFile(entry);

function chunkMarkdown(content: string, options = { tokens: 400, overlap: 80 }) {
  const maxChars = options.tokens * 4;
  const overlapChars = options.overlap * 4;

  const lines = content.split("\n");
  const chunks: Array<{
    startLine: number;
    endLine: number;
    text: string;
    hash: string;
  }> = [];

  let buffer: Array<{ line: string; lineNo: number }> = [];
  let size = 0;

  function flush() {
    if (buffer.length === 0) return;

    const text = buffer.map(item => item.line).join("\n");

    chunks.push({
      startLine: buffer[0].lineNo,
      endLine: buffer[buffer.length - 1].lineNo,
      text,
      hash: hashText(text),
    });

    buffer = keepTailByChars(buffer, overlapChars);
    size = buffer.reduce((sum, item) => sum + item.line.length + 1, 0);
  }

  for (let i = 0; i < lines.length; i++) {
    const line = lines[i];

    if (size + line.length > maxChars && buffer.length > 0) {
      flush();
    }

    buffer.push({ line, lineNo: i + 1 });
    size += line.length + 1;
  }

  flush();

  return chunks;
}

const cachedVectors = loadEmbeddingCache(chunks.map(chunk => chunk.hash));

const missingChunks = chunks.filter(chunk => !cachedVectors.has(chunk.hash));

const newVectors = await embeddingProvider.embedBatch(
  missingChunks.map(chunk => chunk.text)
);

saveEmbeddingCache(newVectors);

CREATE TABLE files (
  path TEXT PRIMARY KEY,
  source TEXT NOT NULL,
  hash TEXT NOT NULL,
  mtime INTEGER NOT NULL,
  size INTEGER NOT NULL
);

CREATE TABLE chunks (
  id TEXT PRIMARY KEY,
  path TEXT NOT NULL,
  source TEXT NOT NULL,
  start_line INTEGER,
  end_line INTEGER,
  hash TEXT NOT NULL,
  model TEXT NOT NULL,
  text TEXT NOT NULL,
  embedding TEXT NOT NULL,
  updated_at INTEGER
);

CREATE VIRTUAL TABLE chunks_vec USING vec0(
  id TEXT PRIMARY KEY,
  embedding FLOAT[1536]
);

CREATE VIRTUAL TABLE chunks_fts USING fts5(
  text,
  id UNINDEXED,
  path UNINDEXED,
  source UNINDEXED,
  model UNINDEXED,
  start_line UNINDEXED,
  end_line UNINDEXED,
  tokenize='porter unicode61'
);

async function searchMemory(query: string, options = { maxResults: 6, minScore: 0.35 }) {
  const cleaned = normalizeQuery(query);

  const keywordResults = await searchKeywordWithBM25(cleaned);
  const queryVector = await embedQuery(cleaned);
  const vectorResults = await searchVector(queryVector);

  const merged = mergeResults({
    vector: vectorResults,
    keyword: keywordResults,
    vectorWeight: 0.7,
    textWeight: 0.3,
  });

  return merged
    .filter(item => item.score >= options.minScore)
    .sort((a, b) => b.score - a.score)
    .slice(0, options.maxResults);
}

finalScore = 0.7 * vectorScore + 0.3 * keywordScore;

const memorySearchTool = {
  name: "memory_search",
  description:
    "Search MEMORY.md and memory/*.md before answering questions about prior work, decisions, dates, people, preferences, or todos.",
  parameters: {
    query: "string",
    maxResults: "number",
    minScore: "number",
  },
  async execute(params) {
    return manager.search(params.query, {
      maxResults: params.maxResults ?? 6,
      minScore: params.minScore ?? 0.35,
    });
  },
};

{
  "results": [
    {
      "path": "memory/2026-01-10.md",
      "startLine": 15,
      "endLine": 20,
      "score": 0.85,
      "snippet": "用户提到喜欢蓝色，尤其是天空蓝。",
      "source": "memory"
    },
    {
      "path": "MEMORY.md",
      "startLine": 5,
      "endLine": 8,
      "score": 0.72,
      "snippet": "颜色偏好：蓝色系。",
      "source": "memory"
    }
  ],
  "provider": "openai",
  "model": "text-embedding-3-small"
}

const memoryGetTool = {
  name: "memory_get",
  description:
    "Read selected lines from MEMORY.md or memory/*.md after memory_search.",
  parameters: {
    path: "string",
    from: "number",
    lines: "number",
  },
  async execute(params) {
    return manager.readFile({
      relPath: params.path,
      from: params.from,
      lines: params.lines,
    });
  },
};

{
  "path": "memory/2026-01-10.md",
  "text": "用户提到喜欢蓝色，尤其是天空蓝。\n在 UI 选择上偏好冷色调。"
}

cat >> MEMORY.md <<'EOF'

## Coding Preferences

- 生成代码时优先使用 TypeScript；只有用户明确要求时才使用 Python。
EOF

await writeFile("memory/2026-02-05.md", `
# User Preference

- 用户希望默认使用 TypeScript 生成代码。
- Python 只在用户明确要求时使用。
`);

function validateMemoryPath(relPath: string) {
  const isRelative = relPath.length > 0 && !path.isAbsolute(relPath);
  const noTraversal = !relPath.startsWith("..") && !relPath.includes("../");
  const isMarkdown = relPath.endsWith(".md");

  const allowed =
    relPath === "MEMORY.md" ||
    relPath === "memory.md" ||
    relPath.startsWith("memory/") ||
    isConfiguredExtraPath(relPath);

  if (!isRelative || !noTraversal || !isMarkdown || !allowed) {
    throw new Error("path required");
  }
}

请求 1 = System Prompt + 工具定义 + 用户消息 1
请求 2 = System Prompt + 工具定义 + 用户消息 1 + 回复 1 + 用户消息 2
请求 3 = System Prompt + 工具定义 + 更长历史 + 用户消息 3
...
达到阈值 = Memory Flush + Compaction

用户问题：我之前说过喜欢什么颜色？

memory_search 返回：
- memory/2026-01-10.md: 用户提到喜欢蓝色，尤其是天空蓝
- MEMORY.md: 颜色偏好：蓝色系

这些结果会进入上下文，再由模型生成最终回答。

用户：帮我查一下天气并发到 Telegram

1. web_search("天气")        -> 搜索结果进入上下文
2. memory_search("用户位置") -> 位置偏好进入上下文
3. message("telegram", ...) -> 发送结果和确认信息进入上下文