Skip to content

armgit / Wake

Public Imported from GitHub
0

All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.

Rust

feat: fast two-character CJK search (#79)

Corey Chiuaba10d577676
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c1a7679..dd26f07 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,7 @@
## [Unreleased]
- New: MiMo Code sessions are indexed from its local database (`~/.local/share/mimocode/mimocode.db`, read-only) — titles, models, thinking, tool calls and token counts included. Sub-agents are listed under the session that started them, and the tool call that started one opens it. A session you imported into MiMo Code from Claude Code, Codex or OpenCode is listed only once you continue it there, and only the new part is indexed. Open In continues a session with `mimo --session` in its project directory. Not mirrored from remote hosts, since the database also holds MiMo Code's sign-in tokens (#77, thanks @lin-code-world)
+- Update: Two-character Chinese, Japanese and Korean words such as 部署 now search fast and rank by relevance, alone or mixed with other words like `部署 docker` (#79, thanks @yifengingit)
## [0.10.0] — 2026-10-23
diff --git a/PRODUCT.md b/PRODUCT.md
index 4a3a825..59eb990 100644
--- a/PRODUCT.md
+++ b/PRODUCT.md
@@ -28,7 +28,7 @@ Corey 本人(独立开发者,主力工具 Claude Code 与 Codex,中文为主)。
## Capabilities and Constraints
-已实现:二十四家 adapter、FTS5 trigram 搜索(<3 码点 LIKE 降级)、**搜索跳转定位**(2026-08-18:⌘K 命中直达详情页对应消息并高亮,seq 契约保证)、详情页逐消息渲染(气泡/工具折叠簇/thinking/tree-sitter 高亮;2026-08-17 由整篇 markdown 方案升级)、恢复/收藏/置顶/导出/删除(废纸篓+墓碑)、**子代理即子会话**(2026-10-12:各家 agent 派出去的子代理一律作为子会话挂在派它的会话下;Claude Code、Cursor、CodeBuddy / WorkBuddy、Qoder、Kimi Code 放在会话目录里的子代理转录也各自入库,能单独搜索、打开,Claude Code 的 Workflow 步骤同样;列表最多两层嵌套(原件 → 分支 → 分支派的子代理);详情页里派活的工具调用上有"打开子代理会话"、子会话头部有回到父会话的链接,对得上派活调用的家才有按钮;子代理随父会话一起删除,Claude Code 的分支不随原件删;子代理不能单独恢复,不给 Open In)、文件监听增量、Insights 统计页(0.3.0:活跃热力图与 streak、时段/星期/月份分布、Agents·Projects·Models 三榜单按 sessions/tokens/prompts 切换;2026-09-03 加 Last 7 days 周对比行与 Over time 近 53 周按 agent 堆叠的每周 prompts 趋势图;口径=主线用户消息,agent 派出去的子会话不算会话与提问、token 照算(2026-10-12),规格见 DESIGN.md)、Updates 页与 macOS Wake 菜单手动检查 GitHub 最新正式版并打开 Release 页更新(不后台联网、不自动替换应用包)、测试套件(adapter 契约、DB 往返、scanner 回归 + CI 三平台 + pre-commit,合成 fixture)、三端桌面(macOS 主平台;Linux/Windows experimental,终端恢复/废纸篓·回收站/剪贴板按平台原生实现,发版 CI 自动出六产物)、窗口记忆(0.3.6:记住所在屏幕/屏内位置/最大化/全屏,重启与 Dock 重开都回到原处,Settings 开在主窗所在屏)、完整 macOS 菜单栏(0.3.6:标准 Edit/Window 菜单、⌘W、Window → Main Window,主窗关闭后 About/Settings/Updates 仍可用)、导出 Markdown 与保存图片走系统「另存为」并记住上次目录(0.3.6,issue #25)、远程 host(0.4.0,issue #21:Settings → Remote hosts 配 SSH 目标,rsync 白名单镜像会话数据到本地缓存后与本地会话同列同搜,`@host` 徽章标识;阶段 1 只读——不动远端文件、远程会话禁删,resume 以 Copy SSH command 形态提供;分期计划见 CLAUDE.md「远程 host」节)、**MCP 接入**(0.5.0:随应用打包的只读 `wake-mcp` stdio server,四个工具 wake_search / wake_list_sessions / wake_get_session / wake_list_projects,Claude Code / Codex / Cursor 等任何 MCP 客户端可搜历史、按项目列会话、分页读转录;Settings → Connect 展示路径与可复制配置片段,只展示不代写别家配置;零 LLM、零网络、不写库;完整参考 docs/mcp.md)、**命令行与 Skill**(0.6.0:并排打包的只读 `wake-cli`,四个子命令 search / sessions / show / projects 加 setup,给"能跑 shell 但不说 MCP"的 agent 和真人用——它不新写查询逻辑,argv 翻成 JSON 喂同一批工具,输出与 MCP 客户端看到的**逐字节相同**(仅 CLI 末尾补一个换行)并由测试卡住,所以文档只需描述一份格式;`skills/wake/SKILL.md` 是可一行安装的 skill(`npx skills add iAmCorey/Wake`),用触发条件而非名词解释写 description,让 agent 自己想得起来去翻会话历史;完整参考 docs/cli.md;0.6.3 加 `wake-cli index`——装了 Wake 却从没启动过时,agent 自己跑一条就能把索引建起来继续干活,而不是停下来问人。它**只建不存在的索引**,已有的库原样交给 GUI:扫描落在旁边的临时库、扫完才原子占位,所以被中途杀掉可重试、撞上 GUI 首扫就退让;2026-09-22 加 `wake-cli refresh`,issue #43:app 不开时增量刷新已有索引,给靠 MCP / CLI 用 Wake、只在浏览时开 app 的人用 launch agent / systemd timer 定时跑,Wake 开着窗或还有扫描在写就退让——GUI 与两个写命令共用一把索引写锁,锁跟 Workbench 与写线程走、关窗即放,GUI 启动会等正在跑的 refresh 收尾)、Connect 页四区块(0.6.1:MCP server / MCP clients / Command line / Skill,每个面的第一块挂自己的文档链接)、**记忆可见层**(2026-09-17 起,只读:把各家 agent 自己写下的记忆——Claude Code 的按项目 auto-memory、Codex 的 memories 与逐会话摘要、ZCode 的按项目记忆——按项目聚合;GUI 的 Memory 页是侧栏底部的整页目的地,侧栏在这一页换成按记忆计数的 All Memory / Agents / Projects 导航;MCP 加第五个工具 `wake_list_memories`,`wake_get_session` 认 `wake://memory/…` 引用现场读文件,`wake_search` 末尾附记忆命中;CLI 加 `memories`;记忆的项目归属按它挂的会话在读时解析,永远跟着索引走。二期(2026-09-21)把用户写给 agent 的指令文件也收进来:各家 home 里的 CLAUDE.md / AGENTS.md(与 `rules/*.rules`)/ GEMINI.md,以及已索引项目根下的 CLAUDE.md / AGENTS.md / GEMINI.md / `.cursor/rules` / `.cursorrules` / `.kiro/steering` / `.github/copilot-instructions.md`,与记忆同列同搜、不另作区分;Settings 加 Memory locations 页,与 Session locations 同形制:逐来源开关、添加自定义目录或文件、Restore defaults。不编辑、不同步、不删除——写别家数据破铁律,要改一个 Reveal 就到;也不做"把会话自动写成记忆")、**Skills 只读总览**(2026-10-15,issue #62:各家 agent 把 skill 各自收在自己的目录里,同一个 skill 在几家各装一份、慢慢改得不一样,没处看全。Skills 页是侧栏底部的第四个整页目的地:按名字列出本机所有 skill——各家的用户级目录、多家共读的 `~/.agents/skills`、已索引项目里的项目级目录、Claude Code 插件自带的——每个 skill 标出装在哪几家、几份真实拷贝、哪些是符号链接、拷贝之间 SKILL.md 有没有分叉;侧栏是 All Skills / Duplicated / Agents(共享目录排第一)/ Projects;阅读面先列各处位置(点一处看那一份、标出与它相同还是不同、逐处 Reveal),再渲染 SKILL.md。只读:不安装、不拷贝、不链接、不同步、不删除——跨 agent 装同一份交给 `npx skills add`,Wake 只在有多份拷贝时提一句;不进索引库、不进 MCP / CLI(agent 本来就读自己的 skill))。后续边界(2026-09-07 定):摘要层(需 LLM、opt-in、明示会把会话正文发给用户配置的端点)只在 MCP 接入有真实使用之后再做;Timeline / Profile 一类视图建立在摘要之上;不做 ChatGPT / Claude.ai 导出导入主线、不做实体本体与知识图谱、不做 Chrome 扩展注入。
+已实现:二十四家 adapter、FTS5 trigram 搜索(2026-10-23 起正文另有中日韩两字组索引:两字中文词走索引、按相关度排,混合查询里的短词只在候选里过滤,只剩单字或 `js` 这类两字符词时才 LIKE 降级,issue #79)、**搜索跳转定位**(2026-08-18:⌘K 命中直达详情页对应消息并高亮,seq 契约保证)、详情页逐消息渲染(气泡/工具折叠簇/thinking/tree-sitter 高亮;2026-08-17 由整篇 markdown 方案升级)、恢复/收藏/置顶/导出/删除(废纸篓+墓碑)、**子代理即子会话**(2026-10-12:各家 agent 派出去的子代理一律作为子会话挂在派它的会话下;Claude Code、Cursor、CodeBuddy / WorkBuddy、Qoder、Kimi Code 放在会话目录里的子代理转录也各自入库,能单独搜索、打开,Claude Code 的 Workflow 步骤同样;列表最多两层嵌套(原件 → 分支 → 分支派的子代理);详情页里派活的工具调用上有"打开子代理会话"、子会话头部有回到父会话的链接,对得上派活调用的家才有按钮;子代理随父会话一起删除,Claude Code 的分支不随原件删;子代理不能单独恢复,不给 Open In)、文件监听增量、Insights 统计页(0.3.0:活跃热力图与 streak、时段/星期/月份分布、Agents·Projects·Models 三榜单按 sessions/tokens/prompts 切换;2026-09-03 加 Last 7 days 周对比行与 Over time 近 53 周按 agent 堆叠的每周 prompts 趋势图;口径=主线用户消息,agent 派出去的子会话不算会话与提问、token 照算(2026-10-12),规格见 DESIGN.md)、Updates 页与 macOS Wake 菜单手动检查 GitHub 最新正式版并打开 Release 页更新(不后台联网、不自动替换应用包)、测试套件(adapter 契约、DB 往返、scanner 回归 + CI 三平台 + pre-commit,合成 fixture)、三端桌面(macOS 主平台;Linux/Windows experimental,终端恢复/废纸篓·回收站/剪贴板按平台原生实现,发版 CI 自动出六产物)、窗口记忆(0.3.6:记住所在屏幕/屏内位置/最大化/全屏,重启与 Dock 重开都回到原处,Settings 开在主窗所在屏)、完整 macOS 菜单栏(0.3.6:标准 Edit/Window 菜单、⌘W、Window → Main Window,主窗关闭后 About/Settings/Updates 仍可用)、导出 Markdown 与保存图片走系统「另存为」并记住上次目录(0.3.6,issue #25)、远程 host(0.4.0,issue #21:Settings → Remote hosts 配 SSH 目标,rsync 白名单镜像会话数据到本地缓存后与本地会话同列同搜,`@host` 徽章标识;阶段 1 只读——不动远端文件、远程会话禁删,resume 以 Copy SSH command 形态提供;分期计划见 CLAUDE.md「远程 host」节)、**MCP 接入**(0.5.0:随应用打包的只读 `wake-mcp` stdio server,四个工具 wake_search / wake_list_sessions / wake_get_session / wake_list_projects,Claude Code / Codex / Cursor 等任何 MCP 客户端可搜历史、按项目列会话、分页读转录;Settings → Connect 展示路径与可复制配置片段,只展示不代写别家配置;零 LLM、零网络、不写库;完整参考 docs/mcp.md)、**命令行与 Skill**(0.6.0:并排打包的只读 `wake-cli`,四个子命令 search / sessions / show / projects 加 setup,给"能跑 shell 但不说 MCP"的 agent 和真人用——它不新写查询逻辑,argv 翻成 JSON 喂同一批工具,输出与 MCP 客户端看到的**逐字节相同**(仅 CLI 末尾补一个换行)并由测试卡住,所以文档只需描述一份格式;`skills/wake/SKILL.md` 是可一行安装的 skill(`npx skills add iAmCorey/Wake`),用触发条件而非名词解释写 description,让 agent 自己想得起来去翻会话历史;完整参考 docs/cli.md;0.6.3 加 `wake-cli index`——装了 Wake 却从没启动过时,agent 自己跑一条就能把索引建起来继续干活,而不是停下来问人。它**只建不存在的索引**,已有的库原样交给 GUI:扫描落在旁边的临时库、扫完才原子占位,所以被中途杀掉可重试、撞上 GUI 首扫就退让;2026-09-22 加 `wake-cli refresh`,issue #43:app 不开时增量刷新已有索引,给靠 MCP / CLI 用 Wake、只在浏览时开 app 的人用 launch agent / systemd timer 定时跑,Wake 开着窗或还有扫描在写就退让——GUI 与两个写命令共用一把索引写锁,锁跟 Workbench 与写线程走、关窗即放,GUI 启动会等正在跑的 refresh 收尾)、Connect 页四区块(0.6.1:MCP server / MCP clients / Command line / Skill,每个面的第一块挂自己的文档链接)、**记忆可见层**(2026-09-17 起,只读:把各家 agent 自己写下的记忆——Claude Code 的按项目 auto-memory、Codex 的 memories 与逐会话摘要、ZCode 的按项目记忆——按项目聚合;GUI 的 Memory 页是侧栏底部的整页目的地,侧栏在这一页换成按记忆计数的 All Memory / Agents / Projects 导航;MCP 加第五个工具 `wake_list_memories`,`wake_get_session` 认 `wake://memory/…` 引用现场读文件,`wake_search` 末尾附记忆命中;CLI 加 `memories`;记忆的项目归属按它挂的会话在读时解析,永远跟着索引走。二期(2026-09-21)把用户写给 agent 的指令文件也收进来:各家 home 里的 CLAUDE.md / AGENTS.md(与 `rules/*.rules`)/ GEMINI.md,以及已索引项目根下的 CLAUDE.md / AGENTS.md / GEMINI.md / `.cursor/rules` / `.cursorrules` / `.kiro/steering` / `.github/copilot-instructions.md`,与记忆同列同搜、不另作区分;Settings 加 Memory locations 页,与 Session locations 同形制:逐来源开关、添加自定义目录或文件、Restore defaults。不编辑、不同步、不删除——写别家数据破铁律,要改一个 Reveal 就到;也不做"把会话自动写成记忆")、**Skills 只读总览**(2026-10-15,issue #62:各家 agent 把 skill 各自收在自己的目录里,同一个 skill 在几家各装一份、慢慢改得不一样,没处看全。Skills 页是侧栏底部的第四个整页目的地:按名字列出本机所有 skill——各家的用户级目录、多家共读的 `~/.agents/skills`、已索引项目里的项目级目录、Claude Code 插件自带的——每个 skill 标出装在哪几家、几份真实拷贝、哪些是符号链接、拷贝之间 SKILL.md 有没有分叉;侧栏是 All Skills / Duplicated / Agents(共享目录排第一)/ Projects;阅读面先列各处位置(点一处看那一份、标出与它相同还是不同、逐处 Reveal),再渲染 SKILL.md。只读:不安装、不拷贝、不链接、不同步、不删除——跨 agent 装同一份交给 `npx skills add`,Wake 只在有多份拷贝时提一句;不进索引库、不进 MCP / CLI(agent 本来就读自己的 skill))。后续边界(2026-09-07 定):摘要层(需 LLM、opt-in、明示会把会话正文发给用户配置的端点)只在 MCP 接入有真实使用之后再做;Timeline / Profile 一类视图建立在摘要之上;不做 ChatGPT / Claude.ai 导出导入主线、不做实体本体与知识图谱、不做 Chrome 扩展注入。
约束:对 agent 数据目录只读;绝不写 Codex 的 SQLite;不读凭证;GPUI 无 SF Symbols(图标用 lucide SVG 自备)。
已支持二十四家 agent:Claude Code、Codex(0.6.6 起排除可识别的内部线程:guardian auto-review、`/review`、compaction、memory consolidation 与用户会话同树,adapter 文件边界按首行 session_meta 的 source / thread_source 认出即不枚举;老格式或读不出的首行保守放行,`codex exec --thread-source` 打了标签的自动化线程照常收录,issue #30。`spawn_agent` 子代理是其中唯一的例外,issue #42:那是用户自己派出去的活,收录后挂在派它的会话下面、以任务名为标题,fork 进来的父线程历史折成一条不入库的占位,父会话的对话不会被索引两遍)、Qoder CLI(`~/.qoder/projects` JSONL,active-leaf 分支恢复、tool result 回挂、`QODER_CONFIG_DIR`)、Copilot CLI、Cursor(CLI 转录 + 0.6.7 起 IDE Chat/Composer 历史,PR #32:`globalStorage/state.vscdb` 明文 KV 库,composerData 给顺序、bubbleId 行给正文;转录带正文的会话归转录源,库只补转录缺失或只剩 turn_ended 空壳的会话;库里多数老会话没存工作区路径,落 Unknown project)、OpenCode(含 OpenCode 2 next,stable 的 `opencode.db` 与 next 的 `opencode-next.db` 同时扫描;逐会话兼容 `message+part`、真实 `session+session_message` 及早期 `session_v2` schema;preview 会话标 opencode2 徽章;2026-10-12 起 task 工具派出的子代理会话也收录,挂在派它的会话下)、Kiro、Gemini CLI(2026-08-17 P1 五家落地)+ Pi、Oh My Pi、Grok Build、Kimi Code、Antigravity(2026-08-19 对齐 kooky 内置 roster,起初只有 `antigravity-cli` 会话索引里的元数据卡片——正文是加密 .pb;2026-10-08 起读新版本桌面端与 IDE 写在 `~/.gemini/antigravity/brain`、`~/.gemini/antigravity-ide/brain` 的明文转录(2026-10-19 起也读 CLI 写在 `~/.gemini/antigravity-cli/brain` 的那份,PR #71 @dingtwo;之前 CLI 会话只剩卡片),含工具输出、模型与用户贴图,IDE 会话挂 via 徽章,同一会话转录与卡片按 id 只出一份、没有转录的仍列卡片;显示名由 Antigravity CLI 改为 Antigravity;2026-10-12 起索引里记了父会话的子会话挂在父会话下。格式取自 PR #52 @iroha3 对真实数据的整理,CLI 那份由 PR #71 @dingtwo 用真实转录核过;本机 brain 目录还没有转录,未经真机验证)+ DeepSeek Harness(dsh,2026-08-20,zstd 事件日志透明解压;格式由源码推断,当天用户跑出真实会话完成首验;2026-10-11 起委派出去的子代理会话也收录,挂在派它的会话下、以任务名为标题,issue #63,fork 出来的会话开头复制的父会话历史折成一条,token 只算自己的)+ Hermes Agent(2026-09-03,多档案 state.db,无 cwd 故 project 留空)、OpenClaw(2026-09-03,两代存储同扫;2026-10-12 起派生的子代理与面板上开的子会话挂在父会话下;本机零会话,格式由源码推断未经真机验证)、CodeBuddy(2026-09-14,issue #27:`~/.codebuddy/projects` 的 Responses 形 JSONL,custom / ai / topic 三级标题,`CODEBUDDY_CONFIG_DIR`;本机零会话,格式由官方 CLI 文档与三家第三方实现交叉推断、未经真机验证)、WorkBuddy(同日,CodeBuddy 的孪生实例:同一解析核心,`~/.workbuddy/projects`、`WORKBUDDY_CONFIG_DIR`;桌面 app 无 CLI,不提供 resume;同构只有 cc-switch 一家佐证)、ZCode(2026-09-21:Z.ai 的 GLM-5.3 官方 harness,桌面 app;运行时是 OpenCode 衍生物——`~/.zcode/cli/db/db.sqlite` 的 session/message/part 与 OpenCode v1 同形、part 解码复用,但 session 表没有 model/tokens 列故另起一家;`v2/tasks-index.sqlite` 只借 deleted / migration_source 两个过滤位;照桌面端自己的分法列:任务列表里的 interactive / fork / workflow_parent 顶层列出,辅助对话、子代理与工作流的子会话挂在父任务下(2026-10-12);分叉开头从父任务复制来的历史折成一条,辅助对话以首条提问为标题;`semantics.transcriptVisibility == hidden` 与用户消息 `origin != real_user` 归 Meta、compact_summary 折成一条、字段缺席放行;`ZCODE_STORAGE_DIR`;桌面 app 无 CLI、`zcode://` 没有按会话打开的深链,不提供 resume;本机 3.14.0 真会话首验通过,同日开源(Apache-2.0)后语义全部按源码核对)、Craft Agents(2026-09-24,issue #44:Craft Docs 的开源桌面 app,自己不带引擎——Anthropic 连接跑 Claude Agent SDK、其余连接(ChatGPT / Codex 订阅、Copilot、Google)跑 Pi SDK,另记一份给用户看的 `~/.craft-agent/workspaces/<工作区>/sessions/<id>/session.jsonl`,Wake 读这一份;子任务与分支挂回原会话,分支从父会话复制来的那段折成一条;Claude 连接在 `~/.claude/projects` 留下的引擎副本由通用的"认领"机制藏掉,原件还在才藏;工作区可建在任意位置,但登记表带 server token 不读,别处的工作区走 Session locations;桌面 app 无 CLI,不提供 resume;本机 0.13.5 真会话首验通过,ChatGPT 与 Claude 连接各一条)、Devin(2026-09-24,issue #46:`~/.local/share/devin/cli/sessions.db` 单库两表,message_nodes 森林按 `main_chain_id` 叶子沿 `parent_node_id` 取主链,hidden 会话与零正文不列,逐消息 `generation_model` 与 `metrics` 按主链累计;`XDG_DATA_HOME`;`devin --resume <id>` 按 cwd 分桶 resume;格式按本机真库验证)、Kilo Code(2026-10-07,issue #59:一家两源——2026-04 起的新版 VS Code 扩展、`kilo` CLI 与 JetBrains 插件是 OpenCode 分支,三端共用 `~/.local/share/kilo/kilo.db`,表与 OpenCode 同形、按 OpenCode 的孪生实例读,子代理会话同样挂在父会话下;session_message 里只有实验开关零星双写的 shell 一类记录时读 message + part(OpenCode 同一条规则);旧版扩展(Roo / Cline 系)每个任务一个目录,在各个 VS Code 系编辑器的 `globalStorage/kilocode.kilo-code/tasks` 里,正文是 Anthropic 消息数组,`<task>` / `<feedback>` / `<answer>` 才是人打的字、编辑器快照丢掉,旧任务用新版导入时给的 `ses_migrated_` id,导入过的那份 kilo.db 胜出;新版 `kilo --session` 在原项目目录续,旧任务没有 Open In、也不实时监听(任务目录里有整份 checkpoints 影子仓库);kilo.db 里同库存着凭证,远程只同步 vscode-server 下的旧任务;本机零会话,新版的表结构按源码的建库语句核过,数据形状由源码推断、未经真机验证)、Grok Bot(2026-10-11:xAI 的常驻 agent,桌面 app 由 Cursor 出品,bot 跑在云端电脑上,对话也存在那里;本机只有桌面端的滚动缓存 `<userData>/sand-client-persistence`——每个对话只留最近 200 条、最多 24 个对话、7 天没写过的被 app 自己清掉。用户定"跟着缓存走":缓存里有的对话出完整消息(你的话、bot 的话、群聊里标出是哪个 bot、bot 之间互发的消息、提问卡片与你的回答、邮件草稿、审批),被清出缓存的退成侧栏列表里的一张卡片(描述 + 最后一条预览),不会从 Wake 里消失;对话本体在云端,删除只隐藏、不动缓存文件;没有命令行,不提供 resume;不做远程同步;格式按 0.68.1 的 app 源码与本机 14 个真实对话核对)、MiMo Code(2026-10-23,issue #77:小米 MiMo 团队的终端 coding agent,OpenCode 分支,`~/.local/share/mimocode/mimocode.db` 的 session / message / part 三表与 OpenCode v1 同形、正文解码复用,但 session 表没有 model / tokens 列故另起一家;一个会话里有好几条道——主线、同会话的子代理、peer 子会话自己那条——会话照 MiMo 自己的界面显示其中一条,其余的子代理道各成一条子会话(标题是派活时的说明,派活的工具调用能跳过去);peer 子会话与旁问同样挂在父会话下,运行时自己派的 checkpoint-writer / dream / distill 不列;从 Claude Code、Codex、OpenCode 导入的会话只在 MiMo 里接着聊过才列、导入的那段折成一条;fork 开头复制来的历史折成一条;`mimo --session` 在原项目目录续;库里同时存着登录 token,不做远程同步;本机零会话,格式由源码推断、未经真机验证)。做不了的:Windsurf/Trae 加密,Amp/Factory(Droid)/Warp 云端无本地数据,Reasonix 本机零会话格式未实测。
diff --git a/crates/wake-core/src/db.rs b/crates/wake-core/src/db.rs
index 6f6f382..081c3ad 100644
--- a/crates/wake-core/src/db.rs
+++ b/crates/wake-core/src/db.rs
@@ -254,6 +254,25 @@ CREATE TABLE IF NOT EXISTS claimed_sessions (
/// main 时还没有这几条,跑过那时构建的库已经戳着它,所以另起一档
pub const FTS_FORMAT: &str = "19";
+/// 正文里中日韩字符的两字组索引(issue #79):trigram 对两个字的词 MATCH 不出东西,而中文最常搜的
+/// 恰恰是两字词。只收有两个以上相连中日韩字符的行,文本是 `cjk_bigrams` 切好、空格隔开的两字组,
+/// rowid = messages.id;只存索引不存内容,删改按 rowid(contentless_delete)。文本里只有中日韩字符与
+/// 空格,ascii 分词器按空格切出的词与 unicode61 一模一样,写入快两成。与 messages_fts 同在
+/// `replace_units` 里维护;建表与换代在 open_conn(见 `CJK_FORMAT`)
+const CJK_DDL: &str = r#"
+CREATE VIRTUAL TABLE IF NOT EXISTS messages_cjk USING fts5(
+ text,
+ content='', contentless_delete=1,
+ tokenize="ascii"
+);
+"#;
+
+/// 两字组表的切法版本:哪些字算中日韩(`is_cjk`)、怎么切(`cjk_pairs`)、怎么建表(`CJK_DDL`)。改了
+/// 就换个值——GUI 开库时整张表重建,扫描收尾的维护从头补(`Store::backfill_cjk`);只读的 MCP / CLI
+/// 看到库里记的版本与自己的不一样就不用这张表,两字词照旧逐条 LIKE。`FTS_FORMAT` 管会话怎么变成
+/// 单元,这里管单元怎么变成这张表的行:单元没变,换代用不着重解析
+const CJK_FORMAT: &str = "1";
+
/// FTS 压缩的节奏(见 `Store::compact_fts`):距上次压缩满一天、或从没压过才压。没有记录
/// 就算到期——老库升级后、新建库首轮扫描收尾各压一次;`FTS_FORMAT` 换代时 open_conn 把
/// 记录清掉,换代的全量重写收尾也一定压
@@ -313,14 +332,7 @@ fn open_conn(path: &Path) -> Result<Connection> {
// FTS 派生规则换代:库里记的版本与 FTS_FORMAT 不一致且已有会话 → 挂 fts_reindex
// 旗子,下一轮扫描把全部文件重解析一遍(增量按 mtime/size 跳过的也重来),否则
// 旧行会按旧规则一直留着,直到用户手动全量刷新(Codex review 2026-09-14)
- let stored_format: Option<String> = conn
- .query_row(
- "SELECT value FROM schema_meta WHERE key = 'fts_format'",
- [],
- |r| r.get(0),
- )
- .optional()?;
- if stored_format.as_deref() != Some(FTS_FORMAT) {
+ if read_meta(&conn, "fts_format")?.as_deref() != Some(FTS_FORMAT) {
if sessions_existed {
conn.execute(
"INSERT OR REPLACE INTO schema_meta(key, value) VALUES ('fts_reindex', '1')",
@@ -335,6 +347,25 @@ fn open_conn(path: &Path) -> Result<Connection> {
params![FTS_FORMAT],
)?;
}
+ // 两字组表:库里记的切法版本与 CJK_FORMAT 不一样(老库首开还没有这张表,或换了切法 / 分词器)
+ // 就整张表重建,已有的消息由扫描收尾的维护补进去(`Store::backfill_cjk`,cjk_backfill 记补到哪条
+ // messages.id)。补齐之前搜索不用它——表里只有之后写入的行,两字词照旧逐条 LIKE。全新的库没有
+ // 消息可补,只记版本
+ if read_meta(&conn, "cjk_format")?.as_deref() != Some(CJK_FORMAT) {
+ let tx = conn.transaction()?;
+ tx.execute_batch(&format!("DROP TABLE IF EXISTS messages_cjk;{CJK_DDL}"))?;
+ if sessions_existed {
+ tx.execute(
+ "INSERT OR REPLACE INTO schema_meta(key, value) VALUES ('cjk_backfill', '0')",
+ [],
+ )?;
+ }
+ tx.execute(
+ "INSERT OR REPLACE INTO schema_meta(key, value) VALUES ('cjk_format', ?1)",
+ params![CJK_FORMAT],
+ )?;
+ tx.commit()?;
+ }
// host 迁移(2026-09-01 远程会话加列;空串 = 本地)。老库首扫时既有行
// 全部落 '',与远程装饰器生产的非空 host 天然分域,无需回填
if !table_has_column(&conn, "sessions", "host")? {
@@ -392,9 +423,20 @@ fn open_conn(path: &Path) -> Result<Connection> {
/// 一次 GUI 侧的加表就让旁路二进制对所有老库拒开
const NEWEST_COLUMN: (&str, &str) = ("memories", "source");
/// 最近一次迁移加的、只读读者会查的表(wake_list_memories 读 memories),与
-/// NEWEST_COLUMN 同一用途、同一维护规矩
+/// NEWEST_COLUMN 同一用途、同一维护规矩。可有可无的加速表不算:两字组表(messages_cjk)由只读读者
+/// 在查询时按库里记的切法版本判断能不能用(`cjk_index_ready`),用不了就照旧逐条 LIKE,不该因此拒开老库
const NEWEST_TABLE: &str = "memories";
+/// schema_meta 里的一个值(开库时的迁移判断与 `Store::meta_value` 共用)
+fn read_meta(conn: &Connection, key: &str) -> rusqlite::Result<Option<String>> {
+ conn.query_row(
+ "SELECT value FROM schema_meta WHERE key = ?1",
+ params![key],
+ |r| r.get(0),
+ )
+ .optional()
+}
+
fn table_exists(conn: &Connection, table: &str) -> Result<bool> {
Ok(conn.query_row(
"SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type IN ('table','view') AND name = ?1)",
@@ -918,14 +960,7 @@ impl Store {
/// schema_meta 里的一个值;没有、或读不出都给 None
fn meta_value(&self, key: &str) -> Option<String> {
- let conn = self.read.lock().unwrap();
- conn.query_row(
- "SELECT value FROM schema_meta WHERE key = ?1",
- params![key],
- |r| r.get(0),
- )
- .optional()
- .unwrap_or(None)
+ read_meta(&self.read.lock().unwrap(), key).unwrap_or(None)
}
/// schema_meta 里的一次性旗子(升级后要补做的事),做完由 scanner 清掉
@@ -967,7 +1002,7 @@ impl Store {
.is_none_or(|at| now.saturating_sub(at) >= FTS_COMPACT_EVERY_MS)
}
- /// 把三张 FTS 表各自的段合并成一棵 b-tree,顺带丢掉删除标记。会话每重写一次
+ /// 把四张 FTS 表各自的段合并成一棵 b-tree,顺带丢掉删除标记。会话每重写一次
/// (watcher 的增量、`FTS_FORMAT` 换代的全量重解析)都只追加新段与删除标记,automerge
/// 收不回大段里的旧版本:本机实测 661 MB 的库里 557 MB 是 messages_fts 的段,压完
/// 87 MB,多词查询从 10–20 ms 降到 0.4–2 ms。
@@ -979,7 +1014,7 @@ impl Store {
// 防御上限:持续有写入时合并也终会收敛,这里只防万一卡在循环里(250 页一块,
// 一万块远超任何真实索引)
const MAX_CHUNKS: usize = 10_000;
- for table in ["messages_fts", "titles_fts", "memories_fts"] {
+ for table in ["messages_fts", "messages_cjk", "titles_fts", "memories_fts"] {
let sql = format!("INSERT INTO {table}({table}, rank) VALUES ('merge', ?1)");
let mut pages = -FTS_MERGE_PAGES;
for _ in 0..MAX_CHUNKS {
@@ -1001,6 +1036,48 @@ impl Store {
Ok(())
}
+ /// 老库升级或换了切法之后(见 `CJK_FORMAT`)把已有的消息补进两字组表(`messages_cjk`;open_conn
+ /// 重建表时挂 cjk_backfill,值是补到哪条 messages.id)。按 id 分块,每块一个写事务、块之间放开
+ /// 写锁,监听的增量写入照常插队;中途退出下次接着补。补完撤掉旗子,搜索才开始用这张表
+ pub fn backfill_cjk(&self) -> Result<()> {
+ // 一块 2000 行,本机正文平均每行两百多字,一块的写锁持有在几十毫秒以内
+ const ROWS: i64 = 2000;
+ let Some(mut after) = self
+ .meta_value("cjk_backfill")
+ .and_then(|v| v.parse::<i64>().ok())
+ else {
+ return Ok(());
+ };
+ loop {
+ let mut conn = self.write.lock().unwrap();
+ let tx = conn.transaction()?;
+ let rows: Vec<(i64, String)> = tx
+ .prepare_cached("SELECT id, text FROM messages WHERE id > ?1 ORDER BY id LIMIT ?2")?
+ .query_map(params![after, ROWS], |r| Ok((r.get(0)?, r.get(1)?)))?
+ .collect::<rusqlite::Result<_>>()?;
+ let Some(&(last, _)) = rows.last() else {
+ tx.execute("DELETE FROM schema_meta WHERE key = 'cjk_backfill'", [])?;
+ tx.commit()?;
+ return Ok(());
+ };
+ {
+ let mut cjk = CjkRows::new(&tx)?;
+ for (id, text) in &rows {
+ // 之后写入的行已经由 replace_units 带进表里了:先删再写
+ cjk.forget(*id, text)?;
+ cjk.put(*id, text)?;
+ }
+ }
+ // 整库重建会把旗子撤掉:这时 UPDATE 什么都不改,剩下的行照样补完(都是幂等的)
+ tx.execute(
+ "UPDATE schema_meta SET value = ?1 WHERE key = 'cjk_backfill'",
+ params![last.to_string()],
+ )?;
+ tx.commit()?;
+ after = last;
+ }
+ }
+
/// 压缩后空闲页占到三成、且至少 64 MiB 才 VACUUM,把文件真正缩回去(Settings → Data
/// 显示的占用随之下降)。VACUUM 持写锁重写整个文件(本机 161 MB 约 1 秒),所以只在
/// 确有大块空闲时做;做完把 WAL 截断,否则 WAL 文件会停在整库那么大
@@ -1760,8 +1837,11 @@ impl Store {
pub fn rebuild_all(&self) -> Result<()> {
let conn = self.write.lock().unwrap();
+ // 两字组表清空后,之后写进来的行都带着两字组,没补完的回填也就不用补了
conn.execute_batch(
"DELETE FROM messages; DELETE FROM messages_fts; DELETE FROM titles_fts;
+ INSERT INTO messages_cjk(messages_cjk) VALUES ('delete-all');
+ DELETE FROM schema_meta WHERE key = 'cjk_backfill';
DELETE FROM memories; DELETE FROM memories_fts; DELETE FROM wake_lookups;
DELETE FROM sessions;",
)?;
@@ -2478,7 +2558,7 @@ impl Store {
Ok(stmt.query_row(params![key], row_to_memory).optional()?)
}
- /// 记忆全文搜索(标题 + 正文),与会话搜索同一套分词与 <3 码点降级规则;命中按
+ /// 记忆全文搜索(标题 + 正文),与会话搜索同一套分词(`Terms`,记忆没有两字组表);命中按
/// bm25 排、snippet 取自正文。筛选同 list_memories
pub fn search_memories(&self, q: &str, f: &MemoryFilter) -> Result<Vec<MemoryHit>> {
let segs = fts_terms(q);
@@ -2487,31 +2567,29 @@ impl Store {
}
let limit = if f.limit > 0 { f.limit } else { 20 };
let (filter_sql, filter_args) = memory_filter(f);
- // FTS 与 LIKE 降级只差 SQL 与前导参数。片段取自正文、在 make_snippet 里开窗(FTS5 的
+ // 三字以上的词走 memories_fts、按 bm25 排,其余的词在候选里 LIKE;只有短词才整条按时间扫
+ // (记忆没有两字组表,几百份,扫得起)。片段取自正文、在 make_snippet 里开窗(FTS5 的
// snippet() 在 trigram 下只露十几个字);只在标题里命中的,正文里找不到词,给正文开头
- let (sql, mut all_args): (String, Vec<Box<dyn rusqlite::ToSql>>) =
- if !needs_like_fallback(&segs) {
- (
- format!(
- "SELECT {MEMORY_COLS}
- FROM memories_fts JOIN memories m ON m.id = memories_fts.rowid
- {MEMORY_SESSION_JOIN}
- WHERE memories_fts MATCH ?{filter_sql}
- ORDER BY bm25(memories_fts) LIMIT ?"
- ),
- vec![Box::new(fts_match_expr(&segs))],
- )
- } else {
- (
- format!(
- "SELECT {MEMORY_COLS} FROM memories m {MEMORY_SESSION_JOIN}
- WHERE {}{filter_sql}
- ORDER BY m.updated_at DESC LIMIT ?",
- like_where(&["m.title", "m.body"], segs.len())
- ),
- like_args(&segs, 2),
- )
- };
+ let terms = Terms::split(&segs, false);
+ let (like_sql, like_args) = like_filter(&["m.title", "m.body"], &terms.short);
+ let mut all_args: Vec<Box<dyn rusqlite::ToSql>> = Vec::new();
+ let sql = if terms.unindexed() {
+ format!(
+ "SELECT {MEMORY_COLS} FROM memories m {MEMORY_SESSION_JOIN}
+ WHERE 1 = 1{like_sql}{filter_sql}
+ ORDER BY m.updated_at DESC LIMIT ?"
+ )
+ } else {
+ all_args.push(Box::new(fts_match_expr(&terms.trigram)));
+ format!(
+ "SELECT {MEMORY_COLS}
+ FROM memories_fts JOIN memories m ON m.id = memories_fts.rowid
+ {MEMORY_SESSION_JOIN}
+ WHERE memories_fts MATCH ?{like_sql}{filter_sql}
+ ORDER BY bm25(memories_fts) LIMIT ?"
+ )
+ };
+ all_args.extend(like_args);
all_args.extend(filter_args);
all_args.push(Box::new(limit));
let conn = self.read.lock().unwrap();
@@ -2808,7 +2886,8 @@ impl Store {
Ok(data)
}
- /// 全文搜索:trigram MATCH(每段 ≥3 码点)或 LIKE 降级。返回 (hits, degraded)
+ /// 全文搜索(词怎么分组、各走哪个索引见 `Terms`)。返回 (hits, degraded):degraded = 一个能走
+ /// 索引的词都没有,整条退回了按时间的逐条 LIKE
pub fn search(
&self,
q: &str,
@@ -2836,7 +2915,6 @@ impl Store {
if segs.is_empty() {
return Ok((Vec::new(), false));
}
- let degraded = needs_like_fallback(&segs);
let limit = if f.limit > 0 { f.limit } else { 60 };
// 近因加权:bm25 是负数、越小越相关,乘上 (1 + W / (1 + 距今天数 / H)) 让
// 新会话的命中"更负"。W = 1、H = 30 天:今天的会话 ×2、一个月前 ×1.5、
@@ -2878,37 +2956,52 @@ impl Store {
}
v
};
- // FTS 的 MATCH 表达式(正文与标题两张表共用)
- let match_expr = fts_match_expr(&segs);
-
let conn = self.read.lock().unwrap();
+ // 正文按能走哪个索引分词(`Terms`);两字组表用不了时(还没补齐、切法版本对不上)两字词照旧 LIKE
+ let terms = Terms::split(&segs, cjk_index_ready(&conn)?);
+ let degraded = terms.unindexed();
- // 正文命中:FTS 与 LIKE 降级只差 SQL 与前导参数;片段都取原文在 make_snippet 里开窗
+ // 正文命中:由三字以上的词(没有就由两字词)取候选、按它的 bm25 排,其余的词在候选里过滤;
+ // 一个能走索引的词都没有才退回按时间的 LIKE 扫描。片段都取原文在 make_snippet 里开窗
// (FTS5 的 snippet() 在 trigram 下只露十几个字)
- let (sql, mut all_args): (String, Vec<Box<dyn rusqlite::ToSql>>) = if !degraded {
- (
- format!(
- "SELECT m.session_key, m.seq, m.sidechain_id, m.role, m.ts, m.text
- FROM messages_fts
- JOIN messages m ON m.id = messages_fts.rowid
- JOIN sessions s ON s.key = m.session_key
- WHERE messages_fts MATCH ?{filter_sql}
- ORDER BY bm25(messages_fts) * {RECENCY_BOOST} LIMIT ?"
- ),
- vec![Box::new(match_expr.clone())],
+ let (like_sql, like_args) = like_filter(&["m.text"], &terms.short);
+ let mut all_args: Vec<Box<dyn rusqlite::ToSql>> = Vec::new();
+ let sql = if degraded {
+ format!(
+ "SELECT m.session_key, m.seq, m.sidechain_id, m.role, m.ts, m.text
+ FROM messages m JOIN sessions s ON s.key = m.session_key
+ WHERE 1 = 1{like_sql}{filter_sql}
+ ORDER BY m.ts DESC LIMIT ?"
)
} else {
- (
+ // 取候选的表与它的词;有三字以上的词时,两字词另在两字组表里过滤
+ let (fts, driver, cjk_filter): (&str, &[&str], &[&str]) = if terms.trigram.is_empty() {
+ ("messages_cjk", &terms.bigram, &[])
+ } else {
+ ("messages_fts", &terms.trigram, &terms.bigram)
+ };
+ all_args.push(Box::new(fts_match_expr(driver)));
+ let cjk_sql = if cjk_filter.is_empty() {
+ String::new()
+ } else {
+ all_args.push(Box::new(fts_match_expr(cjk_filter)));
+ // 一元 `+` 不能去:没有它 SQLite 把这个 IN 交给 FTS5 当 rowid 约束,列表里每一项各探
+ // 一次索引(本机 37–1246 ms);有它就是每扫出一个候选当场查一下,还在读 messages 那一行
+ // 之前(`部署 the` 9.7 → 2.0 ms)
format!(
- "SELECT m.session_key, m.seq, m.sidechain_id, m.role, m.ts, m.text
- FROM messages m JOIN sessions s ON s.key = m.session_key
- WHERE {}{filter_sql}
- ORDER BY m.ts DESC LIMIT ?",
- like_where(&["m.text"], segs.len())
- ),
- like_args(&segs, 1),
+ " AND +{fts}.rowid IN (SELECT rowid FROM messages_cjk WHERE messages_cjk MATCH ?)"
+ )
+ };
+ format!(
+ "SELECT m.session_key, m.seq, m.sidechain_id, m.role, m.ts, m.text
+ FROM {fts}
+ JOIN messages m ON m.id = {fts}.rowid
+ JOIN sessions s ON s.key = m.session_key
+ WHERE {fts} MATCH ?{cjk_sql}{like_sql}{filter_sql}
+ ORDER BY bm25({fts}) * {RECENCY_BOOST} LIMIT ?"
)
};
+ all_args.extend(like_args);
all_args.extend(filter_args(f));
if !degraded {
all_args.push(Box::new(now));
@@ -2934,51 +3027,42 @@ impl Store {
// 标题命中:独立的 titles_fts。排在正文命中之前——词出现在标题里是最强的
// 相关性信号;role 记 "title"、seq 记 0,跳转落到会话开头(标题没有对应的
- // 转录行,不伪造 seq)
- let mut title_raw: Vec<(String, String)> = Vec::new();
- if !degraded {
- let sql = format!(
- "SELECT t.key, highlight(titles_fts, 1, ?, ?)
- FROM titles_fts t JOIN sessions s ON s.key = t.key
- WHERE titles_fts MATCH ?{filter_sql}
- ORDER BY bm25(titles_fts) * {RECENCY_BOOST} LIMIT ?"
- );
- let mut stmt = conn.prepare_cached(&sql)?;
- let mut all_args: Vec<Box<dyn rusqlite::ToSql>> = vec![
- Box::new(HL_OPEN.to_string()),
- Box::new(HL_CLOSE.to_string()),
- Box::new(match_expr),
- ];
- all_args.extend(filter_args(f));
- all_args.push(Box::new(now));
- all_args.push(Box::new(limit));
- let rows = stmt.query_map(
- rusqlite::params_from_iter(all_args.iter().map(|b| b.as_ref())),
- |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)),
- )?;
- for r in rows {
- title_raw.push(r?);
- }
- } else {
- let like_where = like_where(&["s.title"], segs.len());
- let sql = format!(
+ // 转录行,不伪造 seq)。标题没有两字组表(几千行,LIKE 扫得起):三字以上的词走
+ // titles_fts,其余的词在候选里 LIKE;只有短词时按更新时间扫。三条路都给整个标题、
+ // 每个词都标(highlight_all)
+ let title_terms = Terms::split(&segs, false);
+ let (like_sql, like_args) = like_filter(&["s.title"], &title_terms.short);
+ let mut title_args: Vec<Box<dyn rusqlite::ToSql>> = Vec::new();
+ let title_sql = if title_terms.unindexed() {
+ format!(
"SELECT s.key, s.title FROM sessions s
- WHERE {like_where}{filter_sql}
+ WHERE 1 = 1{like_sql}{filter_sql}
ORDER BY s.updated_at DESC LIMIT ?"
- );
- let mut stmt = conn.prepare_cached(&sql)?;
- let mut all_args = like_args(&segs, 1);
- all_args.extend(filter_args(f));
- all_args.push(Box::new(limit));
- let rows = stmt.query_map(
- rusqlite::params_from_iter(all_args.iter().map(|b| b.as_ref())),
- |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)),
- )?;
- for r in rows {
- let (key, title) = r?;
- title_raw.push((key, make_snippet(&title, &segs)));
- }
+ )
+ } else {
+ title_args.push(Box::new(fts_match_expr(&title_terms.trigram)));
+ format!(
+ "SELECT t.key, s.title FROM titles_fts t JOIN sessions s ON s.key = t.key
+ WHERE titles_fts MATCH ?{like_sql}{filter_sql}
+ ORDER BY bm25(titles_fts) * {RECENCY_BOOST} LIMIT ?"
+ )
+ };
+ title_args.extend(like_args);
+ title_args.extend(filter_args(f));
+ if !title_terms.unindexed() {
+ title_args.push(Box::new(now));
}
+ title_args.push(Box::new(limit));
+ let title_raw: Vec<(String, String)> = conn
+ .prepare_cached(&title_sql)?
+ .query_map(
+ rusqlite::params_from_iter(title_args.iter().map(|b| b.as_ref())),
+ |r| {
+ let title: String = r.get(1)?;
+ Ok((r.get(0)?, highlight_all(&title, &segs)))
+ },
+ )?
+ .collect::<rusqlite::Result<_>>()?;
// 补齐 session meta:按会话只查一次(一个会话常占几十行命中),语句走
// prepare_cached——Connection::query_row 每次都是裸 prepare
@@ -3548,12 +3632,14 @@ fn replace_units(tx: &rusqlite::Transaction<'_>, key: &str, units: &[IndexUnit])
&& *text == u.text
})
.count();
+ let mut cjk = CjkRows::new(tx)?;
if let Some((first_stale, ..)) = existing.get(keep) {
let mut fts_del = tx.prepare_cached(
"INSERT INTO messages_fts(messages_fts, rowid, text) VALUES ('delete', ?1, ?2)",
)?;
for (id, .., text) in &existing[keep..] {
fts_del.execute(params![id, text])?;
+ cjk.forget(*id, text)?;
}
tx.prepare_cached("DELETE FROM messages WHERE session_key = ?1 AND id >= ?2")?
.execute(params![key, first_stale])?;
@@ -3571,7 +3657,9 @@ fn replace_units(tx: &rusqlite::Transaction<'_>, key: &str, units: &[IndexUnit])
u.timestamp,
u.text
])?;
- ins_fts.execute(params![tx.last_insert_rowid(), u.text])?;
+ let id = tx.last_insert_rowid();
+ ins_fts.execute(params![id, u.text])?;
+ cjk.put(id, &u.text)?;
}
Ok(())
}
@@ -3687,12 +3775,126 @@ fn fts_terms(q: &str) -> Vec<&str> {
q.split_whitespace().filter(|s| !s.is_empty()).collect()
}
-/// 有词项短于 3 码点就走 LIKE 子串扫描——trigram 分词对更短的词无能为力
-fn needs_like_fallback(segs: &[&str]) -> bool {
- segs.iter().any(|s| s.chars().count() < 3)
+/// 检索词按能走哪个索引分组(issue #79)。trigram 的 FTS 表对不到 3 个字符的词 MATCH 不出东西:
+/// 三字及以上的走它;恰好两个中日韩字符的走正文的两字组表(`messages_cjk`,`bigrams` 为假时——
+/// 标题、记忆没有这张表,或它眼下用不了——归进 `short`);剩下的单字、`js` 这类两个字符的词只能
+/// 逐条 LIKE。有能走索引的词时由它取候选、按它的 bm25 排,其余的词在候选里过滤;一个都没有才
+/// 整条退回按时间的 LIKE 扫描
+#[derive(Default)]
+struct Terms<'a> {
+ trigram: Vec<&'a str>,
+ bigram: Vec<&'a str>,
+ short: Vec<&'a str>,
+}
+
+impl<'a> Terms<'a> {
+ fn split(segs: &[&'a str], bigrams: bool) -> Self {
+ let mut terms = Terms::default();
+ for &seg in segs {
+ if seg.chars().count() >= 3 {
+ terms.trigram.push(seg);
+ } else if bigrams && cjk_pairs(seg).next() == Some(seg) {
+ // 整个词就是一对相连的中日韩字符:两字组表里的一个词
+ terms.bigram.push(seg);
+ } else {
+ terms.short.push(seg);
+ }
+ }
+ terms
+ }
+
+ /// 一个能走索引的词都没有:整条退回 LIKE 扫描
+ fn unindexed(&self) -> bool {
+ self.trigram.is_empty() && self.bigram.is_empty()
+ }
+}
+
+/// 两字组表收的字符:汉字(含扩展区、兼容区)、假名、谚文——词与词之间不空格,两个字就是一个常用词。
+/// 只认字母类(假名区里的 `・` 是标点,unicode61 也拿它当分隔)
+fn is_cjk(c: char) -> bool {
+ matches!(
+ u32::from(c),
+ 0x3040..=0x30FF | 0x3400..=0x4DBF | 0x4E00..=0x9FFF | 0xAC00..=0xD7AF | 0xF900..=0xFAFF
+ | 0x20000..=0x323AF
+ ) && c.is_alphabetic()
+}
+
+/// 文本里每一对相连的中日韩字符,相互重叠(`部署脚本` → 部署、署脚、脚本),切的是原文。两字组表
+/// 怎么切只有这一处:写入(`cjk_bigrams`)、删行前的判断(`CjkRows::forget`)与查询分组(两字词
+/// 恰好是一对)都从它取
+fn cjk_pairs(text: &str) -> impl Iterator<Item = &str> {
+ // 上一个字符是中日韩字符时,它在原文里的起点
+ let mut prev: Option<usize> = None;
+ text.char_indices().filter_map(move |(i, c)| {
+ if !is_cjk(c) {
+ prev = None;
+ return None;
+ }
+ let pair = prev.map(|p| &text[p..i + c.len_utf8()]);
+ prev = Some(i);
+ pair
+ })
+}
+
+/// 两字组表里一行的文本:`cjk_pairs` 用空格隔开(分词器按空格切出的一个词就是一个两字组),别的
+/// 字符都丢掉。没有两个相连的中日韩字符给 None:这一行不进两字组表
+fn cjk_bigrams(text: &str) -> Option<String> {
+ let mut out = String::new();
+ for pair in cjk_pairs(text) {
+ if !out.is_empty() {
+ out.push(' ');
+ }
+ out.push_str(pair);
+ }
+ (!out.is_empty()).then_some(out)
+}
+
+/// 两字组表一条消息的增删,`replace_units` 与 `Store::backfill_cjk` 共用。表不存内容,删一行只认
+/// rowid;同一个 rowid 再插一次 SQLite 不报错,旧词却留在索引里——所以写之前,这个 rowid 要么从没
+/// 进过表,要么先 `forget` 过
+struct CjkRows<'c> {
+ del: rusqlite::CachedStatement<'c>,
+ ins: rusqlite::CachedStatement<'c>,
}
-/// FTS5 的 MATCH 表达式:每个词项加引号(内部引号翻倍)、AND 连接。三张 FTS 表共用,
+impl<'c> CjkRows<'c> {
+ fn new(conn: &'c Connection) -> rusqlite::Result<Self> {
+ Ok(Self {
+ del: conn.prepare_cached("DELETE FROM messages_cjk WHERE rowid = ?1")?,
+ ins: conn.prepare_cached("INSERT INTO messages_cjk(rowid, text) VALUES (?1, ?2)")?,
+ })
+ }
+
+ /// 删掉一条消息的两字组。`text` 是它入库时的正文:没有一对相连中日韩字符的从没进过表,不删——
+ /// 先看一眼比删一个不在表里的 rowid 便宜好几倍
+ fn forget(&mut self, id: i64, text: &str) -> rusqlite::Result<()> {
+ if cjk_pairs(text).next().is_some() {
+ self.del.execute(params![id])?;
+ }
+ Ok(())
+ }
+
+ /// 写入一条消息的两字组(没有两字组的不写)
+ fn put(&mut self, id: i64, text: &str) -> rusqlite::Result<()> {
+ if let Some(bigrams) = cjk_bigrams(text) {
+ self.ins.execute(params![id, bigrams])?;
+ }
+ Ok(())
+ }
+}
+
+/// 两字组表能不能用:库里记的切法版本与这个二进制的一样(老库在新版 GUI 开过之前没有这张表、也
+/// 没有版本记录;只读的 MCP / CLI 不建表),也补齐了(补齐之前表里只有之后写入的行)。不能用时
+/// 两字词照旧逐条 LIKE
+fn cjk_index_ready(conn: &Connection) -> rusqlite::Result<bool> {
+ conn.prepare_cached(
+ "SELECT EXISTS(SELECT 1 FROM schema_meta WHERE key = 'cjk_format' AND value = ?1)
+ AND NOT EXISTS(SELECT 1 FROM schema_meta WHERE key = 'cjk_backfill')",
+ )?
+ .query_row(params![CJK_FORMAT], |r| r.get(0))
+}
+
+/// FTS5 的 MATCH 表达式:每个词项加引号(内部引号翻倍)、AND 连接。各 FTS 表共用,
/// 转义规则只此一处
fn fts_match_expr(segs: &[&str]) -> String {
segs.iter()
@@ -3701,9 +3903,11 @@ fn fts_match_expr(segs: &[&str]) -> String {
.join(" AND ")
}
-/// LIKE 降级路径的 WHERE:每个词项对每一列各一个 `LIKE ? ESCAPE '\'`(列之间 OR、
-/// 词项之间 AND),参数由 `like_args` 按同一顺序给。正文、标题、记忆三条降级路径共用
-fn like_where(cols: &[&str], terms: usize) -> String {
+/// 逐条 LIKE 的条件与参数,写成接在 WHERE 后面的 ` AND …`(与 `memory_filter` 等筛选片段同形;
+/// 没有词给空串):每个词对每一列各一个 `LIKE ? ESCAPE '\'`,列之间 OR、词之间 AND。有能走索引的
+/// 词时它在候选里过滤剩下的短词,一个都没有时它就是整条查询的条件(接在 `WHERE 1 = 1` 后面)。
+/// 正文、标题、记忆三处共用
+fn like_filter(cols: &[&str], terms: &[&str]) -> (String, Vec<Box<dyn rusqlite::ToSql>>) {
let per_term = cols
.iter()
.map(|c| format!("{c} LIKE ? ESCAPE '\\'"))
@@ -3714,35 +3918,36 @@ fn like_where(cols: &[&str], terms: usize) -> String {
} else {
per_term
};
- std::iter::repeat_n(per_term, terms)
- .collect::<Vec<_>>()
- .join(" AND ")
-}
-
-/// `like_where` 的参数:每个词项转义成 `%term%`,每列一份
-fn like_args(segs: &[&str], cols: usize) -> Vec<Box<dyn rusqlite::ToSql>> {
- segs.iter()
- .flat_map(|s| {
- let pat = format!("%{}%", escape_like(s));
- std::iter::repeat_n(pat, cols)
- })
+ let sql = terms.iter().map(|_| format!(" AND {per_term}")).collect();
+ let args = terms
+ .iter()
+ .flat_map(|t| std::iter::repeat_n(format!("%{}%", escape_like(t)), cols.len()))
.map(|pat| Box::new(pat) as Box<dyn rusqlite::ToSql>)
- .collect()
+ .collect();
+ (sql, args)
}
/// 命中片段:以最早出现的检索词为锚,前 40 / 后 80 字符开窗,窗口里每个检索词的每次
-/// 出现都高亮(相邻、重叠的并成一段)。会话正文与记忆的 FTS / LIKE 两条路径、标题的 LIKE
-/// 路径共用这一个(标题的 FTS 路径用 highlight() 给整个标题,标题短,不用开窗):FTS5 的
-/// snippet() 按词元数开窗,trigram 分词下一个词元是三个字符的滑窗,16 个词元只露出十几个
-/// 字,看不出命中在说什么。
+/// 出现都高亮(相邻、重叠的并成一段)。会话正文与记忆的 FTS / LIKE 两条路径共用这一个;
+/// 标题不开窗(`highlight_all`)。FTS5 的 snippet() 按词元数开窗,trigram 分词下一个词元是
+/// 三个字符的滑窗,16 个词元只露出十几个字,看不出命中在说什么
+fn make_snippet(text: &str, segs: &[&str]) -> String {
+ mark_terms(text, segs, Some((40, 80)))
+}
+
+/// 整段原样、每个检索词的每次出现都高亮,不开窗。标题命中用它:标题短,三条标题路径(只有三字
+/// 以上的词、另带短词、全是短词)同一个取法,同一个标题不因查询里有没有短词显示得不一样
+fn highlight_all(text: &str, segs: &[&str]) -> String {
+ mark_terms(text, segs, None)
+}
+
+/// `make_snippet` 与 `highlight_all` 的本体,`window` 是锚点前后各留多少字符。
///
/// 全程按**字符**下标走:逐字符小写并记下每个小写字符来自原文第几个字符——小写
/// 不保长(Ω→ω、İ→i̇、K→k 字节数与字符数都会变),拿小写串里的字节偏移去切原文正是
/// 2026-09-21 review 复现的 panic(⌘K 逐字键入 CJK 查询必经此路,后台线程 panic
/// 直接 abort 整个 app)
-fn make_snippet(text: &str, segs: &[&str]) -> String {
- const BEFORE: usize = 40;
- const AFTER: usize = 80;
+fn mark_terms(text: &str, segs: &[&str], window: Option<(usize, usize)>) -> String {
// 大小写按字符折叠,正文与词项同一个取法、对齐 FTS 的 trigram:它把 ΟΣΟΣ / οσος / οσοσ
// 当成同一个词。整串 to_lowercase 会把词尾的 Σ 变成 ς(希腊文词尾 sigma 规则),逐字符的
// 正文那边是 σ,两边就对不上;ς 也并成 σ
@@ -3775,10 +3980,18 @@ fn make_snippet(text: &str, segs: &[&str]) -> String {
}
spans.sort_unstable();
let Some(&(anchor_start, anchor_end)) = spans.first() else {
- return chars.iter().take(BEFORE + AFTER).collect();
+ return match window {
+ Some((before, after)) => chars.iter().take(before + after).collect(),
+ None => text.to_string(),
+ };
+ };
+ let (start, end) = match window {
+ Some((before, after)) => (
+ anchor_start.saturating_sub(before),
+ (anchor_end + after).min(chars.len()),
+ ),
+ None => (0, chars.len()),
};
- let start = anchor_start.saturating_sub(BEFORE);
- let end = (anchor_end + AFTER).min(chars.len());
let mut marks: Vec<(usize, usize)> = Vec::new();
for &(s, e) in &spans {
if s >= end {
@@ -3889,6 +4102,31 @@ pub fn default_db_path() -> std::path::PathBuf {
mod tests {
use super::*;
+ #[test]
+ fn cjk_bigrams_cover_every_pair_and_drop_everything_else() {
+ assert_eq!(cjk_bigrams("部署脚本").as_deref(), Some("部署 署脚 脚本"));
+ // 中日韩字符之外的都断开:单个的字不成对
+ assert_eq!(cjk_bigrams("用 docker 部署").as_deref(), Some("部署"));
+ assert_eq!(cjk_bigrams("ログ設定").as_deref(), Some("ログ グ設 設定"));
+ assert_eq!(cjk_bigrams("로그인").as_deref(), Some("로그 그인"));
+ // `・` 在假名区里但是标点
+ assert_eq!(cjk_bigrams("コー・ヒー").as_deref(), Some("コー ヒー"));
+ assert_eq!(cjk_bigrams("a 字 b"), None);
+ assert_eq!(cjk_bigrams("plain text"), None);
+ }
+
+ #[test]
+ fn terms_go_to_the_index_that_can_answer_them() {
+ let t = Terms::split(&["docker", "部署", "js", "锁", "ログ", "a部"], true);
+ assert_eq!(t.trigram, ["docker"]);
+ assert_eq!(t.bigram, ["部署", "ログ"]);
+ assert_eq!(t.short, ["js", "锁", "a部"]);
+ // 没有两字组表(标题、记忆,或还没补齐)时两字词只能 LIKE
+ let t = Terms::split(&["部署", "js"], false);
+ assert!(t.unindexed());
+ assert_eq!(t.short, ["部署", "js"]);
+ }
+
/// 把哨兵换成方括号,断言好写好读
fn shown(s: &str) -> String {
s.replace(HL_OPEN, "[").replace(HL_CLOSE, "]")
@@ -3912,6 +4150,10 @@ mod tests {
);
// 前 40 后 80 字符的窗口,再加两个省略号
assert!(s.chars().count() <= 40 + 80 + "二维码".chars().count() + 2 + 6);
+ // 标题那种不开窗的:整段原样,每次出现都标
+ let all = shown(&highlight_all(&text, &["二维码"]));
+ assert_eq!(all.replace(['[', ']'], ""), text);
+ assert_eq!(all.matches("[二维码]").count(), 2);
}
#[test]
diff --git a/crates/wake-core/src/mcp/tools.rs b/crates/wake-core/src/mcp/tools.rs
index d982008..60e8844 100644
--- a/crates/wake-core/src/mcp/tools.rs
+++ b/crates/wake-core/src/mcp/tools.rs
@@ -177,7 +177,7 @@ pub fn definitions_for(usage: Usage) -> Vec<Value> {
"inputSchema": {
"type": "object",
"properties": {
- "query": { "type": "string", "description": "Search terms. Terms shorter than 3 characters fall back to a slower substring scan." },
+ "query": { "type": "string", "description": "Search terms. Words of three or more characters and two-character Chinese, Japanese or Korean words use the index; a query made only of shorter terms (single characters, two-letter words like `js`) falls back to a slower substring scan." },
"project": project_param(),
"agents": agents_param(),
"since": since_param(),
@@ -810,7 +810,7 @@ fn search(ctx: &ToolContext, args: &Value) -> ToolResult {
if order.is_empty() {
out.push_str(&format!("No session matches `{query}`{scope}.\n"));
if degraded {
- out.push_str("Note: terms shorter than 3 characters use a substring scan; try a longer or more specific term.\n");
+ out.push_str("Note: none of these terms can use the index (single characters, two-letter words), so this was a substring scan; try a longer or more specific term.\n");
}
if memory.is_empty() {
out.push_str("Try fewer or different terms, drop the project/agent/since filters, or list sessions with wake_list_sessions.\n\n");
@@ -831,7 +831,7 @@ fn search(ctx: &ToolContext, args: &Value) -> ToolResult {
}
));
if degraded {
- out.push_str("Note: terms shorter than 3 characters use a slower substring scan.\n");
+ out.push_str("Note: none of these terms can use the index (single characters, two-letter words), so this was a slower substring scan, newest first.\n");
}
out.push('\n');
for (ix, key) in order.iter().take(shown).enumerate() {
diff --git a/crates/wake-core/src/scanner.rs b/crates/wake-core/src/scanner.rs
index d25ea60..bf41b9a 100644
--- a/crates/wake-core/src/scanner.rs
+++ b/crates/wake-core/src/scanner.rs
@@ -381,14 +381,18 @@ fn path_tombstoned(store: &Store, r: &SessionFileRef) -> bool {
}
}
-/// 扫描收尾的索引维护:到期才压缩 FTS(见 `Store::compact_fts`),压完有大块空闲再
-/// VACUUM。在扫描门外跑,自己一把门:前一次维护还没完就跳过,下一轮扫描照样到期再来。
+/// 扫描收尾的索引维护:老库升级后补两字组表(`Store::backfill_cjk`),到期才压缩 FTS(见
+/// `Store::compact_fts`),压完有大块空闲再 VACUUM。在扫描门外跑,自己一把门:前一次维护还没完就跳过,下一轮扫描照样到期再来。
/// 失败只记日志——维护做不成不影响这一轮扫描的结果
fn maintain_index(store: &Store) {
static MAINTENANCE: std::sync::Mutex<()> = std::sync::Mutex::new(());
let Ok(_maintaining) = MAINTENANCE.try_lock() else {
return;
};
+ // 老库升级后把已有的消息补进两字组表:有旗子就做,不等压缩的节奏(补齐之前两字词走 LIKE)
+ if let Err(e) = store.backfill_cjk() {
+ eprintln!("wake: filling the CJK word index failed: {e:#}");
+ }
let now = crate::db::now_ms();
if !store.fts_compaction_due(now) {
return;
diff --git a/crates/wake-core/tests/db_roundtrip.rs b/crates/wake-core/tests/db_roundtrip.rs
index f05bc32..caa166c 100644
--- a/crates/wake-core/tests/db_roundtrip.rs
+++ b/crates/wake-core/tests/db_roundtrip.rs
@@ -63,11 +63,240 @@ fn search_roundtrip_hits_correct_seq() {
let (hits, _) = store.search("useEffect(", &[], None, 10).unwrap();
assert_eq!(hits.len(), 1);
assert_eq!(hits[0].seq, 3);
+}
- // <3 码点降级 LIKE
- let (hits, degraded) = store.search("好的", &[], None, 10).unwrap();
- assert!(degraded, "2 码点应降级");
- assert_eq!(hits.len(), 1);
+/// 正文命中里的 seq(标题命中不算)
+fn body_seqs(hits: &[SearchHit]) -> Vec<i64> {
+ hits.iter()
+ .filter(|h| h.role != "title")
+ .map(|h| h.seq)
+ .collect()
+}
+
+/// 两个中日韩字符的词走两字组表、按相关度排(issue #79):原先整条退回 LIKE、按时间倒序,只提了
+/// 一次的新消息排在反复说它的老消息前面。日文、韩文同样走它;单字照旧 LIKE
+#[test]
+fn two_character_cjk_terms_rank_by_relevance() {
+ let (_dir, store) = temp_store();
+ let m = meta("claude-code:cjk", "发布");
+ store
+ .write_session(
+ &m,
+ m.updated_at,
+ &[
+ unit(0, Role::User, "部署,部署,还是部署"),
+ unit(
+ 1,
+ Role::Assistant,
+ "今天先把下周的发布计划过一遍,顺便确认部署窗口、回滚预案和值班的负责人,别的明天再说",
+ ),
+ unit(2, Role::Assistant, "没有这个词的回复"),
+ unit(3, Role::User, "ログの設定を変えた"),
+ unit(4, Role::User, "로그인 화면을 고쳤다"),
+ ],
+ )
+ .unwrap();
+ let (hits, degraded) = store.search("部署", &[], None, 10).unwrap();
+ assert!(!degraded);
+ assert_eq!(body_seqs(&hits), [0, 1], "反复说它的老消息排在前面");
+ for (q, seq) in [("ログ", 3), ("設定", 3), ("로그", 4)] {
+ let (hits, degraded) = store.search(q, &[], None, 10).unwrap();
+ assert!(!degraded, "{q}");
+ assert_eq!(body_seqs(&hits), [seq], "{q}");
+ }
+ let (hits, degraded) = store.search("署", &[], None, 10).unwrap();
+ assert!(degraded, "单字只能 LIKE");
+ assert_eq!(body_seqs(&hits), [1, 0], "LIKE 按时间倒序");
+}
+
+/// 混合查询不再整条降级(issue #79):三字以上的词取候选、按它排,两字中文词在两字组表里过滤,
+/// `js` 这类两个字符的词在候选里 LIKE;全是不能走索引的词才整条退回 LIKE。标题同样只拿短词过滤,
+/// 命中里每个词都高亮
+#[test]
+fn mixed_queries_only_narrow_with_their_short_terms() {
+ let (_dir, store) = temp_store();
+ let m = meta("claude-code:mix", "混合查询");
+ store
+ .write_session(
+ &m,
+ m.updated_at,
+ &[
+ unit(0, Role::User, "用 docker 部署服务"),
+ unit(1, Role::User, "docker compose 起不来"),
+ unit(2, Role::User, "部署脚本挂了"),
+ unit(3, Role::User, "在 docker 里跑 js 测试"),
+ ],
+ )
+ .unwrap();
+ let (hits, degraded) = store.search("部署 docker", &[], None, 10).unwrap();
+ assert!(!degraded);
+ assert_eq!(body_seqs(&hits), [0]);
+ let (hits, degraded) = store.search("docker js", &[], None, 10).unwrap();
+ assert!(!degraded);
+ assert_eq!(body_seqs(&hits), [3]);
+ let (hits, degraded) = store.search("js", &[], None, 10).unwrap();
+ assert!(degraded);
+ assert_eq!(body_seqs(&hits), [3]);
+
+ let t = meta("codex:title", "部署 deploy pipeline");
+ store.write_meta_only(&[(t, 1)]).unwrap();
+ let (hits, _) = store.search("部署 deploy", &[], None, 10).unwrap();
+ let title = hits.iter().find(|h| h.role == "title").expect("标题命中");
+ assert_eq!(title.session.key, "codex:title");
+ for word in ["部署", "deploy"] {
+ assert!(
+ title
+ .snippet
+ .contains(&format!("{HL_OPEN}{word}{HL_CLOSE}")),
+ "{}",
+ title.snippet
+ );
+ }
+}
+
+/// 两字组表跟着会话的改写与删除走:改写掉的尾部、删掉的会话、整库重建都不留旧行——留着的话
+/// 之后写入的消息沿用旧 rowid,旧词就会搜到新消息上。所以每次删完都写几条沿用这些 rowid 的
+/// 消息再搜(行删掉了、没有消息接它的 rowid 时,留下的旧词搜不出东西,断言什么也卡不住)
+#[test]
+fn the_cjk_index_follows_rewrites_and_deletes() {
+ let (_dir, store) = temp_store();
+ let m = meta("claude-code:rw", "改写");
+ store
+ .write_session(
+ &m,
+ m.updated_at,
+ &[
+ unit(0, Role::User, "部署服务"),
+ unit(1, Role::Assistant, "好的"),
+ ],
+ )
+ .unwrap();
+ store
+ .write_session(
+ &m,
+ m.updated_at + 1,
+ &[
+ unit(0, Role::User, "部署服务"),
+ unit(1, Role::Assistant, "上线了"),
+ ],
+ )
+ .unwrap();
+ assert!(store.search("好的", &[], None, 10).unwrap().0.is_empty());
+ assert_eq!(
+ body_seqs(&store.search("上线", &[], None, 10).unwrap().0),
+ [1]
+ );
+ assert_eq!(
+ body_seqs(&store.search("部署", &[], None, 10).unwrap().0),
+ [0]
+ );
+ store.remove_session(&m.key).unwrap();
+ let other = meta("claude-code:other", "另一场");
+ let others = [
+ unit(0, Role::User, "上线了"),
+ unit(1, Role::User, "回滚了"),
+ unit(2, Role::User, "收尾了"),
+ ];
+ store
+ .write_session(&other, other.updated_at, &others)
+ .unwrap();
+ assert!(store.search("部署", &[], None, 10).unwrap().0.is_empty());
+ store.remove_session(&other.key).unwrap();
+ store
+ .write_session(&m, m.updated_at + 2, &[unit(0, Role::User, "部署服务")])
+ .unwrap();
+ assert_eq!(
+ body_seqs(&store.search("部署", &[], None, 10).unwrap().0),
+ [0]
+ );
+ store.rebuild_all().unwrap();
+ store
+ .write_session(&other, other.updated_at, &others)
+ .unwrap();
+ assert!(store.search("部署", &[], None, 10).unwrap().0.is_empty());
+}
+
+/// 老库升级:只读的 MCP / CLI 不建两字组表,两字词照旧 LIKE;GUI 首开建表、挂回填旗子,补齐之前
+/// 照旧 LIKE(表里只有升级后写的行,不能因此少结果);补齐时与升级后写进来的行不冲突。换了切法
+/// (库里记的版本对不上)同样:只读读者不用这张表,GUI 开库时整张重建,按旧切法写进去的词不留
+#[test]
+fn older_databases_fill_the_cjk_index_before_searching_it() {
+ let dir = tempfile::tempdir().unwrap();
+ let path = dir.path().join("test.db");
+ {
+ let store = Store::open(&path).unwrap();
+ let m = meta("claude-code:old", "旧会话");
+ store
+ .write_session(
+ &m,
+ m.updated_at,
+ &[
+ unit(0, Role::User, "部署脚本挂了"),
+ unit(1, Role::Assistant, "先回滚部署"),
+ unit(2, Role::User, "plain text"),
+ ],
+ )
+ .unwrap();
+ }
+ rusqlite::Connection::open(&path)
+ .unwrap()
+ .execute_batch("DROP TABLE messages_cjk; DELETE FROM schema_meta WHERE key = 'cjk_format'")
+ .unwrap();
+ {
+ let ro = Store::open_read_only(&path).unwrap();
+ let (hits, degraded) = ro.search("部署", &[], None, 10).unwrap();
+ assert!(degraded);
+ assert_eq!(body_seqs(&hits), [1, 0]);
+ }
+ {
+ let store = Store::open(&path).unwrap();
+ let new = meta("claude-code:new", "新会话");
+ store
+ .write_session(&new, new.updated_at, &[unit(0, Role::User, "部署完成")])
+ .unwrap();
+ let (hits, degraded) = store.search("部署", &[], None, 10).unwrap();
+ assert!(degraded, "补齐之前照旧 LIKE");
+ assert_eq!(body_seqs(&hits).len(), 3);
+ store.backfill_cjk().unwrap();
+ let (hits, degraded) = store.search("部署", &[], None, 10).unwrap();
+ assert!(!degraded);
+ assert_eq!(body_seqs(&hits).len(), 3, "每行只进一次");
+ }
+
+ // 换了切法:表里留着按旧切法写的词——挂在一条按现在的切法没有两字组的消息上,补齐时逐行的
+ // 先删再写碰不到它,只有整张表重建才清得掉;库里记的是别的版本
+ let raw = rusqlite::Connection::open(&path).unwrap();
+ raw.execute(
+ "INSERT INTO messages_cjk(rowid, text) SELECT id, '旧词' FROM messages WHERE text = 'plain text'",
+ [],
+ )
+ .unwrap();
+ {
+ let ro = Store::open_read_only(&path).unwrap();
+ let (hits, _) = ro.search("旧词", &[], None, 10).unwrap();
+ assert_eq!(body_seqs(&hits), [2], "对照:旧词确实在表里");
+ }
+ raw.execute(
+ "UPDATE schema_meta SET value = 'older' WHERE key = 'cjk_format'",
+ [],
+ )
+ .unwrap();
+ drop(raw);
+ {
+ let ro = Store::open_read_only(&path).unwrap();
+ let (hits, degraded) = ro.search("旧词", &[], None, 10).unwrap();
+ assert!(degraded, "版本对不上,只读读者不用这张表");
+ assert!(hits.is_empty());
+ }
+ let store = Store::open(&path).unwrap();
+ store.backfill_cjk().unwrap();
+ let (hits, degraded) = store.search("旧词", &[], None, 10).unwrap();
+ assert!(!degraded);
+ assert!(hits.is_empty(), "整张表重建过,旧切法的词不留");
+ assert_eq!(
+ body_seqs(&store.search("部署", &[], None, 10).unwrap().0).len(),
+ 3
+ );
}
/// messages_fts 的段数据行数:FTS 每写一次都长新段,原样重写与压缩看的都是它
@@ -1519,9 +1748,9 @@ fn titles_are_searchable_and_tracked_with_the_session() {
.snippet
.contains(&format!("{HL_OPEN}部署脚本{HL_CLOSE}")));
- // 短词走 LIKE 降级,标题同样命中
+ // 两字词:正文走两字组表(这里正文没有它),标题没有两字组表、按 LIKE 照样命中
let (hits, degraded) = store.search("部署", &[], None, 10).unwrap();
- assert!(degraded);
+ assert!(!degraded);
assert_eq!(hits.len(), 1);
assert_eq!(hits[0].role, "title");
@@ -2000,6 +2229,18 @@ fn memories_replace_list_and_search() {
degraded.iter().any(|h| h.doc.key == b.key),
"<3 码点走 LIKE: {degraded:?}"
);
+ // 混合查询:三字以上的词走 memories_fts,短词只在候选里过滤
+ let hits = store
+ .search_memories("guard fi", &MemoryFilter::default())
+ .unwrap();
+ assert_eq!(
+ hits.iter().map(|h| h.doc.key.as_str()).collect::<Vec<_>>(),
+ [a.key.as_str()]
+ );
+ assert!(store
+ .search_memories("tabs fi", &MemoryFilter::default())
+ .unwrap()
+ .is_empty());
// b 变了、u 消失:替换后 b 是新正文,u 从列表与搜索里都不见
let mut b2 = b.clone();
diff --git a/docs/mcp.md b/docs/mcp.md
index 84b4232..d252584 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -180,7 +180,7 @@ All five tools are read-only and return Markdown text (`content[0].text`). Param
### `wake_search`
-Full-text search across every indexed session: titles, user prompts, assistant replies, tool names and tool inputs (tool outputs are not indexed). A title match is reported as `title` and its reference points at the start of the session. Terms are ANDed. CJK text and code substrings such as `useEffect(` both work; terms shorter than three characters fall back to a slower substring scan.
+Full-text search across every indexed session: titles, user prompts, assistant replies, tool names and tool inputs (tool outputs are not indexed). A title match is reported as `title` and its reference points at the start of the session. Terms are ANDed. CJK text and code substrings such as `useEffect(` both work. Words of three or more characters and two-character Chinese, Japanese or Korean words use the index; a query made only of shorter terms (single characters, two-letter words like `js`) falls back to a slower substring scan, newest first.
| Parameter | Type | Default | Notes |
|---|---|---|---|