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: search memory files and skills from ⌘K

Corey Chiu0183822f8864
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4578ccb..853fef3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
# Changelog
+## [Unreleased]
+
+- New: ⌘K / Ctrl+K searches your memory files and skills too, each in its own tab next to sessions; press Tab to switch. The Memory and Skills pages get the same search box in the sidebar
+
## [0.10.1] — 2026-10-23
- 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)
diff --git a/DESIGN.md b/DESIGN.md
index 629787e..7c3afe1 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -129,7 +129,7 @@ macOS 不设置横跨三栏的自定义 header。主窗口透明标题栏高 44p
### 资料库侧栏
- 侧栏顶端按红绿灯、`Wake` 标题和搜索框的可见边界做光学对齐:标题容器上留 4px、下留 16px。窗口控制区和品牌行各高 44px,合计 88px。Memory 页把这个标题换成 "Memory"(顶上就说明现在管的是什么,2026-09-21 用户定,不另加模式标题行)。
-- 顶部是唯一的全文搜索入口,文案 "Search sessions",右侧显示 `⌘K`;Search/All Sessions/Starred 固定不随滚动。Memory 页不画这个搜索框(它搜的是会话;⌘K 照常可用),导航紧接标题、直接从 All Memory 开始(补同高空白让行位置不跳的做法试过,用户定不要)。
+- 顶部是唯一的全文搜索入口,右侧显示 `⌘K`;Search/All Sessions/Starred 固定不随滚动。会话、Memory、Skills 三页都画它(2026-10-24 起):点它与 `⌘K` 打开同一个面板、停在当前页那一栏,文案因此按页点名——"Search sessions" / "Search memory" / "Search skills"(此前 Memory 页不画这个框,因为它只搜会话)。
- 搜索行必须有防溢出结构:标签文字 `flex_1 + min_w_0 + truncate`,图标与 `⌘K` 徽标显式 `flex_shrink_0`。裸文字子元素的最小宽度被内容锁死,侧栏一窄就会把右侧元素挤出边界裁掉。
- 侧栏搜索入口与 Filter 来源搜索共用 `ui::search_field_frame`:32px 高、8px 主题圆角、secondary 填充、10px 水平留白、13px 搜索图标和 Caption 字阶。局部搜索在同一外壳内放无外观的 Input,不叠加默认细边框输入框。
- **行分两级**(侧栏纵向层级的来源,不得拉平):主导航 All Sessions/Starred 32px 行高 + Body 14;分组展开项(agent/项目)26px 行高 + Caption 12 + 整行右移 `SUB_INDENT` 12px 表达从属。
@@ -205,9 +205,12 @@ emoji 不再承担界面或正文结构图标职责。
- 面板宽 680px,距窗口顶部 72px。
- 大尺寸无外框搜索输入置顶。
-- 未输入与无结果状态高 250px;结果列表高 460px。
-- 结果行使用品牌图标、标题、项目与时间、单行片段。
-- 搜索始终覆盖全部会话;页脚左侧显示“搜索范围:全部会话”,右侧显示 `↑↓`、`↩`、`esc` 键盘路径。
+- 一个面板搜三类,在面板里分栏(用户 2026-10-24 定,不在每页各放一个搜索框):输入框下面一行 Sessions / Memory / Skills 栏头,有查询时各带命中数(会话取 60 条、记忆 30 条,取满写成 "60+");每次输入三栏同时搜。栏头是纯文字:当前栏前景色 + 底下一条 2px 的前景色线,其余 muted、悬停变前景色——不用带框的分段控件。输入行与栏头同在一个头部,底下一条 hairline 与结果隔开。
+- 打开时停在当前页那一栏(会话页与 Insights 是 Sessions);`Tab` / `Shift-Tab` 换栏、两头循环,也可以点栏头。换栏选中第一条、回到顶部。
+- 未输入与无结果状态高 250px;结果列表高 460px。未输入时各栏说自己搜什么;这一栏没有、别的栏有时,无结果的说明改成提示按 Tab 过去。
+- 结果行三栏同一个形制:品牌图标(skill 是命中那一处的归属图标,共享目录是 layers)、标题、右端"项目 · 时间"(skill 是"归属 +另有几方 · 时间")、单行片段(没有说明的 skill 写它装在哪)。
+- 打开命中:会话定位到命中消息;记忆落到 Memory 页的 All Memory、选中它并钉在列表顶上(上面紧挨的组头一起露出);skill 落到 Skills 页的 All Skills、选中它、阅读面显示命中的那一处。
+- 三栏都覆盖全部(不受侧栏筛选影响);页脚左侧按栏写“范围:全部会话 / 全部记忆文件 / 全部技能”,右侧显示 `⇥`、`↑↓`、`↩`、`esc` 键盘路径。
- 指针回调中不得同步派发新的键盘事件。需要关闭旧浮层或转移输入焦点时,应通过对应组件 API 或延迟到下一事件周期处理,避免在 AppKit `mouseUp` 路径里重入 GPUI 事件分发;打开搜索面板前必须让 Root 先保存原焦点,关闭后 `⌘K` 才能继续生效。
### Insights
diff --git a/README.md b/README.md
index 8e0b01d..6b72730 100644
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@ Your agent history is scattered across `~/.claude`, `~/.codex` and many other fo
- **Pick up where any agent left off** — every new Claude Code or Codex session starts knowing where your agents left off in the project, and can read any earlier session. [Install the plugin](#claude-code-and-codex-plugins)
- **One place for every session** — grouped by agent and project, sub-agents under their parent, updated live as your agents write
-- **Full-text search** (⌘K / Ctrl+K) — every title and transcript, CJK and code (`useEffect(`) included; jumps straight to the match
+- **Full-text search** (⌘K / Ctrl+K) — every title and transcript, CJK and code (`useEffect(`) included; jumps straight to the match. Memory files and skills are one Tab away
- **Transcript view** — chat bubbles, inline images, collapsible tool calls, thinking, syntax highlighting
- **One-click resume** — back in your terminal (Terminal, iTerm, Warp, Ghostty, Kooky…) or in Claude / Codex Desktop, in the right project folder
- **Manage** — star, pin, export to Markdown, hand a session to another agent, delete to the Trash
diff --git a/crates/wake-core/src/db.rs b/crates/wake-core/src/db.rs
index 081c3ad..1b0f7fd 100644
--- a/crates/wake-core/src/db.rs
+++ b/crates/wake-core/src/db.rs
@@ -1,4 +1,5 @@
use crate::models::*;
+use crate::text::{fts_terms, highlight_all, make_snippet};
use anyhow::{Context as _, Result};
use rusqlite::{params, Connection, OptionalExtension};
use std::collections::HashMap;
@@ -2559,7 +2560,8 @@ impl Store {
}
/// 记忆全文搜索(标题 + 正文),与会话搜索同一套分词(`Terms`,记忆没有两字组表);命中按
- /// bm25 排、snippet 取自正文。筛选同 list_memories
+ /// bm25 排、snippet 取自正文。筛选同 list_memories;命中行与列表行一样不带正文(片段已经
+ /// 取好,要正文按 key 另取)
pub fn search_memories(&self, q: &str, f: &MemoryFilter) -> Result<Vec<MemoryHit>> {
let segs = fts_terms(q);
if segs.is_empty() {
@@ -2593,18 +2595,22 @@ impl Store {
all_args.extend(filter_args);
all_args.push(Box::new(limit));
let conn = self.read.lock().unwrap();
- let hits = conn
+ let docs: Vec<MemoryDoc> = conn
.prepare_cached(&sql)?
.query_map(
rusqlite::params_from_iter(all_args.iter().map(|b| b.as_ref())),
- |r| {
- let doc = row_to_memory(r)?;
- let snippet = make_snippet(&doc.body, &segs);
- Ok(MemoryHit { doc, snippet })
- },
+ row_to_memory,
)?
.collect::<rusqlite::Result<_>>()?;
- Ok(hits)
+ // 片段在放开读锁之后取:几十万字的 CLAUDE.md 开窗也要时间,UI 线程的查询别排在它后面
+ drop(conn);
+ Ok(docs
+ .into_iter()
+ .map(|mut doc| {
+ let snippet = make_snippet(&std::mem::take(&mut doc.body), &segs);
+ MemoryHit { doc, snippet }
+ })
+ .collect())
}
pub fn agent_counts(&self) -> Result<HashMap<String, i64>> {
@@ -3770,11 +3776,6 @@ fn escape_like(s: &str) -> String {
.replace('_', "\\_")
}
-/// 搜索串按空白切成词项(会话搜索与记忆搜索同一套分词)
-fn fts_terms(q: &str) -> Vec<&str> {
- q.split_whitespace().filter(|s| !s.is_empty()).collect()
-}
-
/// 检索词按能走哪个索引分组(issue #79)。trigram 的 FTS 表对不到 3 个字符的词 MATCH 不出东西:
/// 三字及以上的走它;恰好两个中日韩字符的走正文的两字组表(`messages_cjk`,`bigrams` 为假时——
/// 标题、记忆没有这张表,或它眼下用不了——归进 `short`);剩下的单字、`js` 这类两个字符的词只能
@@ -3927,101 +3928,6 @@ fn like_filter(cols: &[&str], terms: &[&str]) -> (String, Vec<Box<dyn rusqlite::
(sql, args)
}
-/// 命中片段:以最早出现的检索词为锚,前 40 / 后 80 字符开窗,窗口里每个检索词的每次
-/// 出现都高亮(相邻、重叠的并成一段)。会话正文与记忆的 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 mark_terms(text: &str, segs: &[&str], window: Option<(usize, usize)>) -> String {
- // 大小写按字符折叠,正文与词项同一个取法、对齐 FTS 的 trigram:它把 ΟΣΟΣ / οσος / οσοσ
- // 当成同一个词。整串 to_lowercase 会把词尾的 Σ 变成 ς(希腊文词尾 sigma 规则),逐字符的
- // 正文那边是 σ,两边就对不上;ς 也并成 σ
- let fold = |c: char| c.to_lowercase().map(|c| if c == 'ς' { 'σ' } else { c });
- let chars: Vec<char> = text.chars().collect();
- let mut lower: Vec<char> = Vec::with_capacity(chars.len());
- let mut origin: Vec<usize> = Vec::with_capacity(chars.len());
- for (i, &c) in chars.iter().enumerate() {
- for lc in fold(c) {
- lower.push(lc);
- origin.push(i);
- }
- }
- // 每个词项的每次出现,换算成原文的字符区间 [start, end)
- let mut spans: Vec<(usize, usize)> = Vec::new();
- for seg in segs {
- let needle: Vec<char> = seg.chars().flat_map(fold).collect();
- if needle.is_empty() {
- continue;
- }
- let mut i = 0;
- while i + needle.len() <= lower.len() {
- if lower[i..i + needle.len()] == needle[..] {
- spans.push((origin[i], origin[i + needle.len() - 1] + 1));
- i += needle.len();
- } else {
- i += 1;
- }
- }
- }
- spans.sort_unstable();
- let Some(&(anchor_start, anchor_end)) = spans.first() else {
- 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 mut marks: Vec<(usize, usize)> = Vec::new();
- for &(s, e) in &spans {
- if s >= end {
- break;
- }
- let e = e.min(end);
- match marks.last_mut() {
- Some(last) if s <= last.1 => last.1 = last.1.max(e),
- _ => marks.push((s, e)),
- }
- }
- let mut out = String::new();
- if start > 0 {
- out.push('…');
- }
- let mut cursor = start;
- for (s, e) in marks {
- out.extend(&chars[cursor..s]);
- out.push(HL_OPEN);
- out.extend(&chars[s..e]);
- out.push(HL_CLOSE);
- cursor = e;
- }
- out.extend(&chars[cursor..end]);
- if end < chars.len() {
- out.push('…');
- }
- out
-}
-
/// (current, longest) 连续活跃天数。`daily` 须按日期升序(insights 的
/// SQL 保证)。current 从 today 往回数;今天尚无活动时允许从昨天起算
/// (GitHub 惯例:一天没结束不清零),更早断档即为 0。
@@ -4126,66 +4032,4 @@ mod tests {
assert!(t.unindexed());
assert_eq!(t.short, ["部署", "js"]);
}
-
- /// 把哨兵换成方括号,断言好写好读
- fn shown(s: &str) -> String {
- s.replace(HL_OPEN, "[").replace(HL_CLOSE, "]")
- }
-
- #[test]
- fn snippet_windows_around_the_first_hit_and_marks_every_term() {
- let text = format!(
- "{}先说二维码,再说 useEffect( 的挂载,最后又提到二维码。{}",
- "前文".repeat(40),
- "后文".repeat(80)
- );
- let s = shown(&make_snippet(&text, &["二维码", "useeffect("]));
- assert!(
- s.starts_with('…') && s.ends_with('…'),
- "长文两头都要省略:{s}"
- );
- assert!(
- s.contains("先说[二维码],再说 [useEffect(] 的挂载,最后又提到[二维码]"),
- "窗口里每个词的每次出现都标上,大小写按原文:{s}"
- );
- // 前 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]
- fn snippet_merges_overlapping_terms_and_falls_back_to_the_start() {
- assert_eq!(shown(&make_snippet("xabcdx", &["abc", "bcd"])), "x[abcd]x");
- let plain = "没有命中的长文本".repeat(30);
- let s = make_snippet(&plain, &["二维码"]);
- assert_eq!(s.chars().count(), 120, "找不到词就给开头 120 字");
- assert!(!s.contains(HL_OPEN));
- }
-
- #[test]
- fn snippet_survives_case_mappings_that_change_length() {
- // Ω/İ/K 小写后字符数或字节数会变,按原文字符下标切才不会 panic 或错位
- let s = shown(&make_snippet(
- "İstanbul Ωmega KELVIN 二维码",
- &["ωmega", "kelvin"],
- ));
- assert_eq!(s, "İstanbul [Ωmega] [KELVIN] 二维码");
- let s = shown(&make_snippet("İİİ二维码", &["二维码"]));
- assert_eq!(s, "İİİ[二维码]");
- }
-
- /// 希腊文词尾的 sigma:FTS 的 trigram 把 ΟΣΟΣ / οσος / οσοσ 当成同一个词,片段也得认得出——
- /// 整串小写会把查询词尾的 Σ 变成 ς,逐字符小写的正文那边却是 σ
- #[test]
- fn snippet_folds_greek_final_sigma_like_the_index() {
- let text = format!("{} ΟΣΟΣ τέλος", "α".repeat(200));
- for query in ["ΟΣΟΣ", "οσος", "οσοσ"] {
- let s = shown(&make_snippet(&text, &[query]));
- assert!(s.contains("[ΟΣΟΣ]"), "{query}: {s}");
- }
- assert!(shown(&make_snippet("τέλος οσος", &["ΟΣΟΣ"])).contains("[οσος]"));
- }
}
diff --git a/crates/wake-core/src/models.rs b/crates/wake-core/src/models.rs
index 517584f..98f4475 100644
--- a/crates/wake-core/src/models.rs
+++ b/crates/wake-core/src/models.rs
@@ -1049,7 +1049,8 @@ impl MemoryFilter {
}
}
-/// 记忆搜索的一条命中(snippet 带 HL_OPEN/HL_CLOSE 高亮哨兵,与会话命中同款)
+/// 记忆搜索的一条命中(snippet 带 HL_OPEN/HL_CLOSE 高亮哨兵,与会话命中同款)。`doc` 与列表行
+/// 一样不带正文(`body` 是空串),要读正文按 key 另取
#[derive(Debug, Clone)]
pub struct MemoryHit {
pub doc: MemoryDoc,
diff --git a/crates/wake-core/src/skills.rs b/crates/wake-core/src/skills.rs
index 06852c7..65a5ba6 100644
--- a/crates/wake-core/src/skills.rs
+++ b/crates/wake-core/src/skills.rs
@@ -24,6 +24,7 @@
use crate::adapters::parse_utils::{mtime_ms, project_name_of};
use crate::adapters::{self, AgentAdapter};
use crate::models::AgentId;
+use crate::text;
use sha2::{Digest, Sha256};
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
use std::io::ErrorKind;
@@ -112,6 +113,15 @@ pub struct Skill {
pub plugin: bool,
/// 最近改过的那处(`installs` 下标,平局取靠前的);列表的说明与阅读面默认显示它
pub newest: usize,
+ /// 折叠过大小写的名字与各处说明(`descriptions` 与 `installs` 一一对应):搜索拿它比,
+ /// 扫描时折一次,不必每次输入把几百份说明再折一遍
+ folded: FoldedSkill,
+}
+
+#[derive(Debug, Clone)]
+struct FoldedSkill {
+ name: String,
+ descriptions: Vec<String>,
}
impl Skill {
@@ -126,6 +136,13 @@ impl Skill {
// installs 先按归属排,相邻去重就是各方
let mut owners: Vec<SkillOwner> = installs.iter().map(|i| i.owner).collect();
owners.dedup();
+ let folded = FoldedSkill {
+ name: text::fold_case(&name),
+ descriptions: installs
+ .iter()
+ .map(|i| text::fold_case(&i.description))
+ .collect(),
+ };
Self {
copies: installs
.iter()
@@ -141,6 +158,7 @@ impl Skill {
.any(|i| matches!(i.scope, SkillScope::Plugin { .. })),
owners,
newest,
+ folded,
name,
installs,
}
@@ -222,6 +240,78 @@ impl SkillScan {
projects,
}
}
+
+ /// 按名字找回一个 skill:重扫后下标会变,界面记的是名字
+ pub fn index_of(&self, name: &str) -> Option<usize> {
+ self.skills.iter().position(|s| s.name == name)
+ }
+
+ /// 按名字与说明找 skill(⌘K 面板的 Skills 栏;SKILL.md 正文不搜):与会话、记忆同一套分词,
+ /// 每个词都得出现在名字或某一处安装的说明里,大小写折叠与片段的高亮同一个取法。排序:词全在
+ /// 名字里的在前,其中名字越短越靠前(名字恰好就是查询的排第一);其余按名字里缺几个词;同档
+ /// 按名字
+ pub fn search(&self, q: &str) -> Vec<SkillHit> {
+ let terms = text::fts_terms(q);
+ if terms.is_empty() {
+ return Vec::new();
+ }
+ let needles: Vec<String> = terms.iter().map(|t| text::fold_case(t)).collect();
+ let mut ranked: Vec<((usize, usize), SkillHit)> = Vec::new();
+ for (ix, skill) in self.skills.iter().enumerate() {
+ let folded = &skill.folded;
+ let described = |i: usize, needle: &str| folded.descriptions[i].contains(needle);
+ // 名字里没有的词,都得在某一处的说明里
+ let unnamed: Vec<&str> = needles
+ .iter()
+ .map(String::as_str)
+ .filter(|needle| !folded.name.contains(needle))
+ .collect();
+ if !unnamed
+ .iter()
+ .all(|needle| (0..skill.installs.len()).any(|i| described(i, needle)))
+ {
+ continue;
+ }
+ // 显示、打开哪一处(片段也取自它):名字里没有的那些词,说明里凑得最齐的那一处;一样齐的
+ // 取最近改过的那份,再按排序在前的。只看"有没有命中",搜 staging cluster 会落到只写着
+ // staging 的最新那份上(Codex review 2026-10-25)
+ let covered = |i: usize| unnamed.iter().filter(|needle| described(i, needle)).count();
+ let (mut install, mut best) = (skill.newest, covered(skill.newest));
+ for i in 0..skill.installs.len() {
+ let n = covered(i);
+ if n > best {
+ (install, best) = (i, n);
+ }
+ }
+ let length = if unnamed.is_empty() {
+ skill.name.chars().count()
+ } else {
+ 0
+ };
+ ranked.push((
+ (unnamed.len(), length),
+ SkillHit {
+ skill: ix,
+ install,
+ snippet: text::make_snippet(&skill.installs[install].description, &terms),
+ },
+ ));
+ }
+ // 稳定排序:同档保持 skills 的顺序,即按名字
+ ranked.sort_by_key(|(rank, _)| *rank);
+ ranked.into_iter().map(|(_, hit)| hit).collect()
+ }
+}
+
+/// skill 搜索的一条命中(`SkillScan::search`)
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SkillHit {
+ /// `SkillScan::skills` 的下标
+ pub skill: usize,
+ /// 片段取自哪一处安装的说明(`Skill::installs` 的下标),打开时显示的也是它
+ pub install: usize,
+ /// 说明的片段,带 HL_OPEN / HL_CLOSE 高亮;没有说明是空串
+ pub snippet: String,
}
/// 项目根的显示名(与会话、记忆的项目名同一个取法)
@@ -864,6 +954,103 @@ pub fn scan_in(
#[cfg(test)]
mod tests {
use super::*;
+ use crate::models::{HL_CLOSE, HL_OPEN};
+
+ fn install(owner: SkillOwner, name: &str, description: &str, updated_at: i64) -> SkillInstall {
+ let path = PathBuf::from(format!("/skills/{owner:?}/{name}"));
+ SkillInstall {
+ owner,
+ scope: SkillScope::User,
+ real_path: path.clone(),
+ path,
+ linked: false,
+ content_hash: 0,
+ name: name.to_string(),
+ description: description.to_string(),
+ updated_at,
+ }
+ }
+
+ /// 与 `scan_in` 收尾一样按名字排
+ fn scan_of(skills: Vec<Vec<SkillInstall>>) -> SkillScan {
+ let mut skills: Vec<Skill> = skills
+ .into_iter()
+ .map(|installs| Skill::new(installs[0].name.clone(), installs))
+ .collect();
+ skills.sort_by_key(|s| s.name.to_lowercase());
+ SkillScan {
+ skills,
+ errors: Vec::new(),
+ }
+ }
+
+ fn names(scan: &SkillScan, q: &str) -> Vec<String> {
+ scan.search(q)
+ .iter()
+ .map(|h| scan.skills[h.skill].name.clone())
+ .collect()
+ }
+
+ #[test]
+ fn search_puts_name_matches_first_and_the_closest_name_on_top() {
+ let claude = SkillOwner::Agent(AgentId::ClaudeCode);
+ let scan = scan_of(vec![
+ vec![install(claude, "writer", "Use to Review drafts", 1)],
+ vec![install(claude, "plan-eng-review", "Engineering plan", 1)],
+ vec![install(claude, "review", "Pre-landing review", 1)],
+ vec![install(claude, "code-review:code-review", "", 1)],
+ vec![install(claude, "deploy", "Ship it", 1)],
+ ]);
+ assert_eq!(
+ names(&scan, "REVIEW"),
+ [
+ "review",
+ "plan-eng-review",
+ "code-review:code-review",
+ "writer"
+ ],
+ "词全在名字里的按名字长短,只在说明里的垫底;大小写不论"
+ );
+ // 每个词都得出现在名字或说明里
+ assert_eq!(names(&scan, "review drafts"), ["writer"]);
+ assert_eq!(names(&scan, "review plan"), ["plan-eng-review"]);
+ assert!(scan.search(" ").is_empty());
+ assert!(scan.search("kubernetes").is_empty());
+ }
+
+ #[test]
+ fn search_snippets_come_from_the_install_that_matched() {
+ let codex = SkillOwner::Agent(AgentId::Codex);
+ let scan = scan_of(vec![vec![
+ install(
+ SkillOwner::Shared,
+ "deploy",
+ "Ship to the staging cluster",
+ 1,
+ ),
+ install(codex, "deploy", "Ship it", 2),
+ ]]);
+ let skill = &scan.skills[0];
+ // 最近改过的那份(Codex 的)说明里没有这个词:片段取自有命中的那份
+ let hit = &scan.search("staging")[0];
+ assert_eq!(skill.installs[hit.install].owner, SkillOwner::Shared);
+ assert!(hit.snippet.contains(&format!("{HL_OPEN}staging{HL_CLOSE}")));
+ // 只在名字里命中:片段是最近那份的说明,不标
+ let hit = &scan.search("deploy")[0];
+ assert_eq!(hit.install, skill.newest);
+ assert_eq!(hit.snippet, "Ship it");
+ // 两处都提到 staging,只有旧的那份还写着 cluster:两个词一起搜,落在旧的那份上
+ let scan = scan_of(vec![vec![
+ install(SkillOwner::Shared, "deploy", "Ship to staging cluster", 1),
+ install(codex, "deploy", "Deploy to staging", 2),
+ ]]);
+ let hit = &scan.search("staging cluster")[0];
+ assert_eq!(
+ scan.skills[0].installs[hit.install].owner,
+ SkillOwner::Shared
+ );
+ assert!(hit.snippet.contains(&format!("{HL_OPEN}cluster{HL_CLOSE}")));
+ }
#[test]
fn a_star_segment_expands_to_every_subdirectory() {
diff --git a/crates/wake-core/src/text.rs b/crates/wake-core/src/text.rs
index 850d159..01b6f52 100644
--- a/crates/wake-core/src/text.rs
+++ b/crates/wake-core/src/text.rs
@@ -1,5 +1,8 @@
//! 跨数据层与 UI 共用的文本小工具。wake crate 的 `format::one_line` 转发到
-//! 这里——同一条"折行截断"规则只写一次(曾在两个 crate 各有一份、同名不同义)
+//! 这里——同一条"折行截断"规则只写一次(曾在两个 crate 各有一份、同名不同义)。
+//! 搜索命中的片段与高亮也在这里:会话、记忆(db.rs)与 skill(skills.rs)三处共用
+
+use crate::models::{HL_CLOSE, HL_OPEN};
/// 折成一行:空白压成单空格,超过 `max_chars` 个字符截断并加 `…`
/// (按字符数计,CJK 安全)
@@ -20,6 +23,175 @@ pub fn plural(n: i64) -> &'static str {
}
}
+/// 检索用的大小写折叠,逐字符:正文与检索词同一个取法、对齐 FTS 的 trigram——它把
+/// ΟΣΟΣ / οσος / οσοσ 当成同一个词。整串 to_lowercase 会把词尾的 Σ 变成 ς(希腊文词尾
+/// sigma 规则),逐字符的正文那边是 σ,两边就对不上;ς 也并成 σ
+fn fold(c: char) -> impl Iterator<Item = char> {
+ c.to_lowercase().map(|c| if c == 'ς' { 'σ' } else { c })
+}
+
+/// 整串按 `fold` 折叠。两个折叠后的串之间的子串关系就是高亮认的那些位置(UTF-8 下按字节找
+/// 子串等于按字符找),skill 搜索拿它比
+pub(crate) fn fold_case(s: &str) -> String {
+ s.chars().flat_map(fold).collect()
+}
+
+/// 搜索串按空白切成词项:会话、记忆与 skill 三处搜索同一套分词
+pub(crate) fn fts_terms(q: &str) -> Vec<&str> {
+ q.split_whitespace().collect()
+}
+
+/// 命中片段:以最早出现的检索词为锚,前 40 / 后 80 字符开窗,窗口里每个检索词的每次
+/// 出现都高亮(相邻、重叠的并成一段)。会话正文、记忆(FTS / LIKE 两条路径)与 skill 的
+/// 说明共用这一个;标题不开窗(`highlight_all`)。FTS5 的 snippet() 按词元数开窗,trigram
+/// 分词下一个词元是三个字符的滑窗,16 个词元只露出十几个字,看不出命中在说什么
+pub(crate) fn make_snippet(text: &str, segs: &[&str]) -> String {
+ mark_terms(text, segs, Some((40, 80)))
+}
+
+/// 整段原样、每个检索词的每次出现都高亮,不开窗。标题命中用它:标题短,三条标题路径(只有三字
+/// 以上的词、另带短词、全是短词)同一个取法,同一个标题不因查询里有没有短词显示得不一样
+pub(crate) fn highlight_all(text: &str, segs: &[&str]) -> String {
+ mark_terms(text, segs, None)
+}
+
+/// 逐字符往后折叠的正文:`chars` 是读过的原文字符,`lower` 是它们折叠后的字符,`origin[i]` 是
+/// `lower[i]` 来自 `chars` 的第几个
+struct Folding<'a> {
+ rest: std::str::Chars<'a>,
+ chars: Vec<char>,
+ lower: Vec<char>,
+ origin: Vec<usize>,
+ /// 原文读完了
+ done: bool,
+}
+
+impl<'a> Folding<'a> {
+ fn new(text: &'a str) -> Self {
+ Self {
+ rest: text.chars(),
+ chars: Vec::new(),
+ lower: Vec::new(),
+ origin: Vec::new(),
+ done: false,
+ }
+ }
+
+ /// 读到原文的前 `n` 个字符(不够就读完)
+ fn read_to(&mut self, n: usize) {
+ while self.chars.len() < n {
+ let Some(c) = self.rest.next() else {
+ self.done = true;
+ return;
+ };
+ for lc in fold(c) {
+ self.lower.push(lc);
+ self.origin.push(self.chars.len());
+ }
+ self.chars.push(c);
+ }
+ }
+
+ /// 每个检索词在读过的那一段里的每次出现(各词各自从左往右、不重叠地找),换算成原文的
+ /// 字符区间 [start, end),排好序
+ fn spans(&self, needles: &[Vec<char>]) -> Vec<(usize, usize)> {
+ let lower = &self.lower;
+ let mut spans = Vec::new();
+ for needle in needles {
+ let mut i = 0;
+ while i + needle.len() <= lower.len() {
+ if lower[i..i + needle.len()] == needle[..] {
+ spans.push((self.origin[i], self.origin[i + needle.len() - 1] + 1));
+ i += needle.len();
+ } else {
+ i += 1;
+ }
+ }
+ }
+ spans.sort_unstable();
+ spans
+ }
+}
+
+/// `make_snippet` 与 `highlight_all` 的本体,`window` 是锚点前后各留多少字符。
+///
+/// 全程按**字符**下标走:逐字符小写并记下每个小写字符来自原文第几个字符——小写
+/// 不保长(Ω→ω、İ→i̇、K→k 字节数与字符数都会变),拿小写串里的字节偏移去切原文正是
+/// 2026-09-21 review 复现的 panic(⌘K 逐字键入 CJK 查询必经此路,后台线程 panic
+/// 直接 abort 整个 app)。
+///
+/// 开窗时只折叠用得着的开头一段:先折一段,最早的命中与窗口末尾都落在里面就停,不够再加倍往后
+/// 折。记忆正文里有几十万字的 CLAUDE.md,⌘K 每次输入要给 30 份记忆取片段,整篇折叠一次要
+/// 5–12 ms、分配十几 MB;命中靠前的只用折几百个字符
+fn mark_terms(text: &str, segs: &[&str], window: Option<(usize, usize)>) -> String {
+ let needles: Vec<Vec<char>> = segs
+ .iter()
+ .map(|seg| seg.chars().flat_map(fold).collect::<Vec<char>>())
+ .filter(|needle| !needle.is_empty())
+ .collect();
+ let longest = needles.iter().map(Vec::len).max().unwrap_or(0);
+ let mut folding = Folding::new(text);
+ let mut want = window.map_or(usize::MAX, |(before, after)| (before + after).max(256));
+ let spans = loop {
+ folding.read_to(want);
+ let spans = folding.spans(&needles);
+ let Some((_, after)) = window else {
+ break spans;
+ };
+ // 窗口末尾之后再多折一个最长词:开头在窗口里、跨过末尾的命中才找得全;再多一个字符,才知道
+ // 后面还有没有(省略号)。比最早那个开头还早的命中,也一定在这一段里收尾
+ let need = spans
+ .first()
+ .map_or(usize::MAX, |&(_, end)| end + after + longest + 1);
+ if folding.done || folding.chars.len() >= need {
+ break spans;
+ }
+ want = need.max(want.saturating_mul(2));
+ };
+ let chars = &folding.chars;
+ let Some(&(anchor_start, anchor_end)) = spans.first() else {
+ 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 mut marks: Vec<(usize, usize)> = Vec::new();
+ for &(s, e) in &spans {
+ if s >= end {
+ break;
+ }
+ let e = e.min(end);
+ match marks.last_mut() {
+ Some(last) if s <= last.1 => last.1 = last.1.max(e),
+ _ => marks.push((s, e)),
+ }
+ }
+ let mut out = String::new();
+ if start > 0 {
+ out.push('…');
+ }
+ let mut cursor = start;
+ for (s, e) in marks {
+ out.extend(&chars[cursor..s]);
+ out.push(HL_OPEN);
+ out.extend(&chars[s..e]);
+ out.push(HL_CLOSE);
+ cursor = e;
+ }
+ out.extend(&chars[cursor..end]);
+ if end < chars.len() {
+ out.push('…');
+ }
+ out
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -37,4 +209,188 @@ mod tests {
assert_eq!(plural(0), "s");
assert_eq!(plural(2), "s");
}
+
+ /// 把哨兵换成方括号,断言好写好读
+ fn shown(s: &str) -> String {
+ s.replace(HL_OPEN, "[").replace(HL_CLOSE, "]")
+ }
+
+ #[test]
+ fn snippet_windows_around_the_first_hit_and_marks_every_term() {
+ let text = format!(
+ "{}先说二维码,再说 useEffect( 的挂载,最后又提到二维码。{}",
+ "前文".repeat(40),
+ "后文".repeat(80)
+ );
+ let s = shown(&make_snippet(&text, &["二维码", "useeffect("]));
+ assert!(
+ s.starts_with('…') && s.ends_with('…'),
+ "长文两头都要省略:{s}"
+ );
+ assert!(
+ s.contains("先说[二维码],再说 [useEffect(] 的挂载,最后又提到[二维码]"),
+ "窗口里每个词的每次出现都标上,大小写按原文:{s}"
+ );
+ // 前 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]
+ fn snippet_merges_overlapping_terms_and_falls_back_to_the_start() {
+ assert_eq!(shown(&make_snippet("xabcdx", &["abc", "bcd"])), "x[abcd]x");
+ let plain = "没有命中的长文本".repeat(30);
+ let s = make_snippet(&plain, &["二维码"]);
+ assert_eq!(s.chars().count(), 120, "找不到词就给开头 120 字");
+ assert!(!s.contains(HL_OPEN));
+ }
+
+ #[test]
+ fn snippet_survives_case_mappings_that_change_length() {
+ // Ω/İ/K 小写后字符数或字节数会变,按原文字符下标切才不会 panic 或错位
+ let s = shown(&make_snippet(
+ "İstanbul Ωmega KELVIN 二维码",
+ &["ωmega", "kelvin"],
+ ));
+ assert_eq!(s, "İstanbul [Ωmega] [KELVIN] 二维码");
+ let s = shown(&make_snippet("İİİ二维码", &["二维码"]));
+ assert_eq!(s, "İİİ[二维码]");
+ }
+
+ /// 希腊文词尾的 sigma:FTS 的 trigram 把 ΟΣΟΣ / οσος / οσοσ 当成同一个词,片段也得认得出——
+ /// 整串小写会把查询词尾的 Σ 变成 ς,逐字符小写的正文那边却是 σ
+ #[test]
+ fn snippet_folds_greek_final_sigma_like_the_index() {
+ let text = format!("{} ΟΣΟΣ τέλος", "α".repeat(200));
+ for query in ["ΟΣΟΣ", "οσος", "οσοσ"] {
+ let s = shown(&make_snippet(&text, &[query]));
+ assert!(s.contains("[ΟΣΟΣ]"), "{query}: {s}");
+ }
+ assert!(shown(&make_snippet("τέλος οσος", &["ΟΣΟΣ"])).contains("[οσος]"));
+ }
+
+ /// 折叠后按子串比,认的就是高亮标得出来的那些
+ #[test]
+ fn folded_strings_match_where_the_highlight_does() {
+ let found = |text: &str, term: &str| fold_case(text).contains(&fold_case(term));
+ assert!(found("İstanbul Ωmega KELVIN", "ωMEGA"));
+ assert!(found("İstanbul Ωmega \u{212A}ELVIN", "kelvin"));
+ assert!(found("τέλος ΟΣΟΣ", "οσος"));
+ assert!(found("部署脚本", "署脚"));
+ assert!(!found("deploy", "deploys"));
+ for (text, term) in [("İstanbul Ωmega", "ωmega"), ("τέλος ΟΣΟΣ", "οσοσ")] {
+ assert!(
+ shown(&highlight_all(text, &[term])).contains('['),
+ "{text} / {term}"
+ );
+ }
+ }
+
+ /// 开窗时只折开头一段的写法,与整篇折叠、找出全部出现再开窗的原写法逐字相同。字母表里
+ /// 专挑小写后变长或变形的字符(İ、K 开尔文号、Σ / ς、ß)
+ #[test]
+ fn windowed_marking_matches_folding_the_whole_text() {
+ fn whole_text(text: &str, segs: &[&str], window: Option<(usize, usize)>) -> String {
+ let chars: Vec<char> = text.chars().collect();
+ let mut lower = Vec::new();
+ let mut origin = Vec::new();
+ for (i, &c) in chars.iter().enumerate() {
+ for lc in fold(c) {
+ lower.push(lc);
+ origin.push(i);
+ }
+ }
+ let mut spans: Vec<(usize, usize)> = Vec::new();
+ for seg in segs {
+ let needle: Vec<char> = seg.chars().flat_map(fold).collect();
+ let mut i = 0;
+ while !needle.is_empty() && i + needle.len() <= lower.len() {
+ if lower[i..i + needle.len()] == needle[..] {
+ spans.push((origin[i], origin[i + needle.len() - 1] + 1));
+ i += needle.len();
+ } else {
+ i += 1;
+ }
+ }
+ }
+ spans.sort_unstable();
+ let Some(&(anchor_start, anchor_end)) = spans.first() else {
+ 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 mut marks: Vec<(usize, usize)> = Vec::new();
+ for &(s, e) in &spans {
+ if s >= end {
+ break;
+ }
+ let e = e.min(end);
+ match marks.last_mut() {
+ Some(last) if s <= last.1 => last.1 = last.1.max(e),
+ _ => marks.push((s, e)),
+ }
+ }
+ let mut out = String::new();
+ if start > 0 {
+ out.push('…');
+ }
+ let mut cursor = start;
+ for (s, e) in marks {
+ out.extend(&chars[cursor..s]);
+ out.push(HL_OPEN);
+ out.extend(&chars[s..e]);
+ out.push(HL_CLOSE);
+ cursor = e;
+ }
+ out.extend(&chars[cursor..end]);
+ if end < chars.len() {
+ out.push('…');
+ }
+ out
+ }
+
+ const ALPHABET: [char; 14] = [
+ 'a', 'b', 'A', 'B', 'İ', 'i', 'Σ', 'σ', 'ς', '\u{212A}', 'k', 'ß', '二', ' ',
+ ];
+ let mut seed: u64 = 0x2545_F491_4F6C_DD1D;
+ let mut below = |n: usize| {
+ seed ^= seed << 13;
+ seed ^= seed >> 7;
+ seed ^= seed << 17;
+ (seed % n as u64) as usize
+ };
+ for _ in 0..3000 {
+ let mut text = String::new();
+ for _ in 0..below(900) {
+ text.push(ALPHABET[below(ALPHABET.len())]);
+ }
+ let mut terms: Vec<String> = Vec::new();
+ for _ in 0..1 + below(3) {
+ let mut term = String::new();
+ for _ in 0..1 + below(4) {
+ term.push(ALPHABET[below(ALPHABET.len())]);
+ }
+ terms.push(term);
+ }
+ let segs: Vec<&str> = terms.iter().map(String::as_str).collect();
+ for window in [Some((40, 80)), Some((0, 3)), Some((5, 0)), None] {
+ assert_eq!(
+ mark_terms(&text, &segs, window),
+ whole_text(&text, &segs, window),
+ "{text:?} {segs:?} {window:?}"
+ );
+ }
+ }
+ }
}
diff --git a/crates/wake/locales/zh-Hans.json b/crates/wake/locales/zh-Hans.json
index e7aca61..a1da1d5 100644
--- a/crates/wake/locales/zh-Hans.json
+++ b/crates/wake/locales/zh-Hans.json
@@ -536,5 +536,15 @@
"Couldn't read {} location": "{} 处位置读不出",
"Couldn't read {} locations": "{} 处位置读不出",
"and {} more": "还有 {} 处",
- "plugin": "插件"
+ "plugin": "插件",
+ "Search memory": "搜索记忆",
+ "Search skills": "搜索技能",
+ "Scope: all memory files": "范围:全部记忆文件",
+ "Scope: all skills": "范围:全部技能",
+ "⇥ next tab": "⇥ 下一栏",
+ "Search memory files": "搜索记忆文件",
+ "Matches the titles and text of the notes your agents keep.": "匹配 agent 记下的笔记的标题与正文。",
+ "Search installed skills": "搜索已装的技能",
+ "Matches skill names and descriptions.": "匹配技能的名字与说明。",
+ "Other tabs have results. Press Tab to switch.": "别的栏有结果,按 Tab 切过去。"
}
diff --git a/crates/wake/src/main.rs b/crates/wake/src/main.rs
index e91f87a..b53e746 100644
--- a/crates/wake/src/main.rs
+++ b/crates/wake/src/main.rs
@@ -26,8 +26,8 @@ use gpui_component::Root;
use i18n::t;
use main_window::MainWindow;
use workbench::{
- OpenAbout, OpenSettings, OpenUpdates, PaletteDown, PaletteUp, RefreshSessions, ToggleSearch,
- Workbench, KEY_CONTEXT, PALETTE_CONTEXT,
+ OpenAbout, OpenSettings, OpenUpdates, PaletteDown, PaletteNextTab, PalettePrevTab, PaletteUp,
+ RefreshSessions, ToggleSearch, Workbench, KEY_CONTEXT, PALETTE_CONTEXT,
};
actions!(
@@ -214,6 +214,10 @@ fn key_bindings() -> Vec<KeyBinding> {
// ⌘K 面板:焦点在搜索输入框,↑↓ 冒泡到面板容器挪选中
KeyBinding::new("up", PaletteUp, Some(PALETTE_CONTEXT)),
KeyBinding::new("down", PaletteDown, Some(PALETTE_CONTEXT)),
+ // Tab / Shift-Tab 换栏(Sessions / Memory / Skills)。比 gpui-component 的 Root 挪焦点
+ // 的 tab 绑定深一层,在面板里先到
+ KeyBinding::new("tab", PaletteNextTab, Some(PALETTE_CONTEXT)),
+ KeyBinding::new("shift-tab", PalettePrevTab, Some(PALETTE_CONTEXT)),
];
// 界面缩放(全局,键位表在 ui_zoom,与设置页的提示同源)
keys.extend(ui_zoom::key_bindings());
diff --git a/crates/wake/src/workbench.rs b/crates/wake/src/workbench.rs
index 55630d5..2eea120 100644
--- a/crates/wake/src/workbench.rs
+++ b/crates/wake/src/workbench.rs
@@ -56,6 +56,7 @@ use wake_core::models::Role as MessageRole;
use wake_core::models::*;
use wake_core::scanner::{run_scan, ScanEvents, ScanProgress};
use wake_core::services::{exporter, terminal};
+use wake_core::skills::{SkillHit, SkillScan};
use wake_core::watcher::{start_watcher, SessionWatcher};
use crate::format::{
@@ -76,7 +77,9 @@ actions!(
OpenUpdates,
OpenAbout,
PaletteUp,
- PaletteDown
+ PaletteDown,
+ PaletteNextTab,
+ PalettePrevTab
]
);
@@ -877,11 +880,7 @@ impl ListDelegate for SessionsDelegate {
.gap(ICON_TEXT_GAP)
.text_size(FONT_LABEL)
.text_color(theme.muted_foreground)
- .child(
- img(s.agent.brand_icon(theme.mode.is_dark()))
- .size(zpx(15.))
- .flex_shrink_0(),
- )
+ .child(brand_img(s.agent, zpx(15.), theme.mode.is_dark()))
.child(badge(
s.project_name.clone(),
theme.muted,
@@ -1424,21 +1423,329 @@ mod session_group_tests {
// ---------------- 搜索面板 delegate ----------------
+/// ⌘K 面板的三栏:一个面板搜会话、记忆与 skill,在面板里按类分(用户 2026-10-24 定,不在
+/// 每页各放一个搜索框)。每次输入三栏同时搜,栏头带命中数;打开时停在当前页对应的那一栏
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SearchTab {
+ Sessions,
+ Memory,
+ Skills,
+}
+
+impl SearchTab {
+ /// 按声明序排,下标就是 `as usize`
+ const ALL: [SearchTab; 3] = [SearchTab::Sessions, SearchTab::Memory, SearchTab::Skills];
+
+ /// 当前页对应的那一栏:打开面板时停在这里,侧栏搜索框也照它点名(Insights 的数字都是会话派生的)
+ fn for_page(page: Page) -> Self {
+ match page {
+ Page::Memory => SearchTab::Memory,
+ Page::Skills => SearchTab::Skills,
+ Page::Sessions | Page::Insights => SearchTab::Sessions,
+ }
+ }
+
+ fn label(self) -> &'static str {
+ match self {
+ SearchTab::Sessions => t("Sessions"),
+ SearchTab::Memory => t("Memory"),
+ SearchTab::Skills => t("Skills"),
+ }
+ }
+
+ /// 侧栏搜索框的文案
+ fn prompt(self) -> &'static str {
+ match self {
+ SearchTab::Sessions => t("Search sessions"),
+ SearchTab::Memory => t("Search memory"),
+ SearchTab::Skills => t("Search skills"),
+ }
+ }
+
+ /// 页脚左侧的范围说明:三栏都搜全部,不受侧栏筛选影响
+ fn scope(self) -> &'static str {
+ match self {
+ SearchTab::Sessions => t("Scope: all sessions"),
+ SearchTab::Memory => t("Scope: all memory files"),
+ SearchTab::Skills => t("Scope: all skills"),
+ }
+ }
+
+ /// Tab / Shift-Tab:后一栏 / 前一栏,两头循环
+ fn step(self, forward: bool) -> Self {
+ let n = Self::ALL.len();
+ Self::ALL[(self as usize + if forward { 1 } else { n - 1 }) % n]
+ }
+}
+
+/// 会话栏(消息级命中)与记忆栏各取多少条;取满了栏头写成 "60+"
+const PALETTE_SESSION_LIMIT: i64 = 60;
+const PALETTE_MEMORY_LIMIT: i64 = 30;
+
+/// skill 栏的命中,连同它们按下标指着的那一份扫描:命中在后台对某一份扫描算,算完之前
+/// Workbench 可能已经换了新的,拿旧下标去读新扫描会对不上
+#[derive(Default)]
+struct SkillResults {
+ scan: Arc<SkillScan>,
+ hits: Vec<SkillHit>,
+}
+
+impl SkillResults {
+ fn search(scan: Arc<SkillScan>, q: &str) -> Self {
+ Self {
+ hits: scan.search(q),
+ scan,
+ }
+ }
+}
+
+/// 打开一条命中要去哪
+enum PaletteTarget {
+ Session {
+ key: String,
+ seq: i64,
+ },
+ Memory(String),
+ /// skill 按名字找回(重扫后下标会变),`dir` 是命中的那一处安装
+ Skill {
+ name: String,
+ dir: PathBuf,
+ },
+}
+
pub struct SearchDelegate {
- pub hits: Vec<SearchHit>,
- pub degraded: bool,
- /// 查询本身失败(库读不出、FTS 表达式报错)。与"没有结果"分开显示,
- /// 否则用户会以为真的没讨论过
- error: Option<String>,
+ tab: SearchTab,
+ /// 后台搜回来的原样存:命中(会话的另带 degraded:一个能走索引的词都没有),或查询本身失败的
+ /// 错误(库读不出、FTS 表达式报错)——与"没有结果"分开显示,否则用户会以为真的没讨论过
+ sessions: Result<(Vec<SearchHit>, bool), String>,
+ memory: Result<Vec<MemoryHit>, String>,
+ /// skill 不进索引库:每次查询对 Workbench 最近一次扫到的那份(与 Skills 页同一份)现搜,与
+ /// 会话、记忆一起在后台(多半几十微秒,一个字母的查询半毫秒);新的扫描经 `set_skill_scan`
+ /// 换进来
+ skills: SkillResults,
store: Arc<Store>,
last_query: String,
}
+impl SearchDelegate {
+ fn new(store: Arc<Store>) -> Self {
+ Self {
+ tab: SearchTab::Sessions,
+ sessions: Ok(Default::default()),
+ memory: Ok(Vec::new()),
+ skills: SkillResults::default(),
+ store,
+ last_query: String::new(),
+ }
+ }
+
+ fn session_hits(&self) -> &[SearchHit] {
+ match &self.sessions {
+ Ok((hits, _)) => hits,
+ Err(_) => &[],
+ }
+ }
+
+ fn memory_hits(&self) -> &[MemoryHit] {
+ self.memory.as_deref().unwrap_or_default()
+ }
+
+ fn count(&self, tab: SearchTab) -> usize {
+ match tab {
+ SearchTab::Sessions => self.session_hits().len(),
+ SearchTab::Memory => self.memory_hits().len(),
+ SearchTab::Skills => self.skills.hits.len(),
+ }
+ }
+
+ /// 栏头的命中数:取满上限的写成 "60+"(后面可能还有)
+ fn count_label(&self, tab: SearchTab) -> String {
+ let n = self.count(tab);
+ let limit = match tab {
+ SearchTab::Sessions => Some(PALETTE_SESSION_LIMIT),
+ SearchTab::Memory => Some(PALETTE_MEMORY_LIMIT),
+ SearchTab::Skills => None,
+ };
+ if limit.is_some_and(|limit| n as i64 >= limit) {
+ format!("{n}+")
+ } else {
+ n.to_string()
+ }
+ }
+
+ /// 查询清空(点清除钮 / 删光):结果已知,不必走一趟后台
+ fn clear(&mut self) {
+ self.sessions = Ok(Default::default());
+ self.memory = Ok(Vec::new());
+ self.skills.hits.clear();
+ self.last_query.clear();
+ }
+
+ /// 换了一份 skill 扫描(⌘K 补的第一次扫描、Skills 页的重扫):按新的那份重搜当前的查询
+ fn set_skill_scan(&mut self, scan: Arc<SkillScan>) {
+ self.skills = SkillResults::search(scan, &self.last_query);
+ }
+
+ fn target(&self, row: usize) -> Option<PaletteTarget> {
+ match self.tab {
+ SearchTab::Sessions => self
+ .session_hits()
+ .get(row)
+ .map(|h| PaletteTarget::Session {
+ key: h.session.key.clone(),
+ seq: h.seq,
+ }),
+ SearchTab::Memory => self
+ .memory_hits()
+ .get(row)
+ .map(|h| PaletteTarget::Memory(h.doc.key.clone())),
+ SearchTab::Skills => {
+ let hit = self.skills.hits.get(row)?;
+ let skill = self.skills.scan.skills.get(hit.skill)?;
+ Some(PaletteTarget::Skill {
+ name: skill.name.clone(),
+ dir: skill.installs.get(hit.install)?.path.clone(),
+ })
+ }
+ }
+ }
+
+ /// 这一栏第 `row` 条命中画成一行
+ fn row(&self, row: usize, dark: bool) -> Option<PaletteRow> {
+ Some(match self.tab {
+ SearchTab::Sessions => {
+ let h = self.session_hits().get(row)?;
+ PaletteRow {
+ lead: brand_img(h.session.agent, zpx(15.), dark).into_any_element(),
+ title: h.session.title.clone().into(),
+ host: h.session.host.clone(),
+ place: h.session.project_name.clone(),
+ time: h.timestamp.unwrap_or(0),
+ snippet: h.snippet.clone(),
+ }
+ }
+ SearchTab::Memory => {
+ let h = self.memory_hits().get(row)?;
+ PaletteRow {
+ lead: brand_img(h.doc.agent, zpx(15.), dark).into_any_element(),
+ title: h.doc.title.clone().into(),
+ host: h.doc.host.clone(),
+ place: memory::memory_group_label(&h.doc).to_string(),
+ time: h.doc.updated_at,
+ snippet: h.snippet.clone(),
+ }
+ }
+ SearchTab::Skills => {
+ let h = self.skills.hits.get(row)?;
+ let skill = self.skills.scan.skills.get(h.skill)?;
+ let install = skill.installs.get(h.install)?;
+ // 命中的那一处归谁,另有几方装着它写 +N
+ let others = skill.owners.len().saturating_sub(1);
+ let owner = skills::owner_label(install.owner);
+ PaletteRow {
+ lead: skills::owner_icon(install.owner, zpx(15.), dark),
+ title: skill.name.clone().into(),
+ host: String::new(),
+ place: if others > 0 {
+ format!("{owner} +{others}")
+ } else {
+ owner.to_string()
+ },
+ time: install.updated_at,
+ // 没有说明的 skill,第二行写它装在哪,比空着一行有用
+ snippet: if h.snippet.is_empty() {
+ tilde_path(&install.path.to_string_lossy())
+ } else {
+ h.snippet.clone()
+ },
+ }
+ }
+ })
+ }
+}
+
+/// agent 的品牌图(原色 PNG),不随行收缩
+fn brand_img(agent: AgentId, size: impl Into<Pixels>, dark: bool) -> Img {
+ img(agent.brand_icon(dark))
+ .size(size.into())
+ .flex_shrink_0()
+}
+
+/// ⌘K 面板的一行,三栏同一个形制:品牌图 + 标题,右端 @host 与"归属 · 时间"(悬停看完整
+/// 日期);第二行是带高亮的片段
+struct PaletteRow {
+ lead: AnyElement,
+ title: SharedString,
+ host: String,
+ /// 会话与记忆是项目,skill 是装在哪
+ place: String,
+ time: i64,
+ snippet: String,
+}
+
+impl PaletteRow {
+ fn render(self, ix: usize, theme: &gpui_component::Theme) -> ListItem {
+ let time: SharedString = smart_time(self.time).into();
+ let time_tooltip: SharedString = abs_date(self.time).into();
+ let snippet = self
+ .snippet
+ .replace(HL_OPEN, "「")
+ .replace(HL_CLOSE, "」")
+ .replace('\n', " ");
+ // ListItem 无默认 margin,行块与内容区同宽(胶囊边对齐 Scope 行/
+ // 输入行);块内文字缩进保持组件默认(px_3)+ 内容 px_2
+ ListItem::new(ix).rounded(theme.radius).child(
+ v_flex()
+ .w_full()
+ .px(SPACE_SM)
+ .py(SPACE_SM)
+ .gap(zpx(6.))
+ .child(
+ h_flex()
+ .gap(ICON_TEXT_GAP)
+ .text_size(FONT_CAPTION)
+ .child(self.lead)
+ .child(
+ div()
+ .min_w_0()
+ .font_medium()
+ .text_color(theme.foreground)
+ .truncate()
+ .child(self.title),
+ )
+ .child(div().flex_1())
+ .when(!self.host.is_empty(), |this| {
+ this.child(host_badge(&self.host, theme))
+ })
+ .child(
+ div()
+ .id(("search-hit-time", ix))
+ .flex_shrink_0()
+ .text_size(FONT_CAPTION)
+ .text_color(theme.muted_foreground)
+ .child(format!("{} · {}", self.place, time))
+ .tooltip(move |window, cx| {
+ gpui_component::tooltip::Tooltip::new(time_tooltip.clone())
+ .build(window, cx)
+ }),
+ ),
+ )
+ .child(
+ div()
+ .text_size(FONT_CAPTION)
+ .text_color(theme.muted_foreground)
+ .truncate()
+ .child(snippet),
+ ),
+ )
+ }
+}
+
impl ListDelegate for SearchDelegate {
type Item = ListItem;
fn items_count(&self, _section: usize, _cx: &App) -> usize {
- self.hits.len()
+ self.count(self.tab)
}
fn render_item(
@@ -1447,69 +1754,10 @@ impl ListDelegate for SearchDelegate {
_window: &mut Window,
cx: &mut Context<ListState<Self>>,
) -> Option<Self::Item> {
- let h = self.hits.get(ix.row)?;
let theme = cx.theme();
- let timestamp = h.timestamp.unwrap_or(0);
- let hit_time: SharedString = smart_time(timestamp).into();
- let hit_time_tooltip: SharedString = abs_date(timestamp).into();
- let snippet = h
- .snippet
- .replace(HL_OPEN, "「")
- .replace(HL_CLOSE, "」")
- .replace('\n', " ");
Some(
- // ListItem 无默认 margin,行块与内容区同宽(胶囊边对齐 Scope 行/
- // 输入行);块内文字缩进保持组件默认(px_3)+ 内容 px_2
- ListItem::new(ix.row).rounded(theme.radius).child(
- v_flex()
- .w_full()
- .px(SPACE_SM)
- .py(SPACE_SM)
- .gap(zpx(6.))
- .child(
- h_flex()
- .gap(ICON_TEXT_GAP)
- .text_size(FONT_CAPTION)
- .child(
- img(h.session.agent.brand_icon(theme.mode.is_dark()))
- .size(zpx(15.))
- .flex_shrink_0(),
- )
- .child(
- div()
- .min_w_0()
- .font_medium()
- .text_color(theme.foreground)
- .truncate()
- .child(h.session.title.clone()),
- )
- .child(div().flex_1())
- .when(!h.session.host.is_empty(), |this| {
- this.child(host_badge(&h.session.host, &theme))
- })
- .child(
- div()
- .id(("search-hit-time", ix.row))
- .flex_shrink_0()
- .text_size(FONT_CAPTION)
- .text_color(theme.muted_foreground)
- .child(format!("{} · {}", h.session.project_name, hit_time))
- .tooltip(move |window, cx| {
- gpui_component::tooltip::Tooltip::new(
- hit_time_tooltip.clone(),
- )
- .build(window, cx)
- }),
- ),
- )
- .child(
- div()
- .text_size(FONT_CAPTION)
- .text_color(theme.muted_foreground)
- .truncate()
- .child(snippet),
- ),
- ),
+ self.row(ix.row, theme.mode.is_dark())?
+ .render(ix.row, theme),
)
}
@@ -1521,6 +1769,7 @@ impl ListDelegate for SearchDelegate {
) {
}
+ /// 三栏一起在后台搜,一起回填(栏头的数一起变)
fn perform_search(
&mut self,
query: &str,
@@ -1530,21 +1779,34 @@ impl ListDelegate for SearchDelegate {
let q = query.to_string();
self.last_query = q.clone();
let store = self.store.clone();
+ let skill_scan = self.skills.scan.clone();
let bg = cx.background_spawn(async move {
- if q.trim().is_empty() {
- Ok((Vec::new(), false))
- } else {
- store
- .search(&q, &[], None, 60)
- .map_err(|e| format!("{e:#}"))
- }
+ let error = |e: anyhow::Error| format!("{e:#}");
+ let sessions = store
+ .search(&q, &[], None, PALETTE_SESSION_LIMIT)
+ .map_err(error);
+ let memory = store
+ .search_memories(
+ &q,
+ &MemoryFilter {
+ limit: PALETTE_MEMORY_LIMIT,
+ ..Default::default()
+ },
+ )
+ .map_err(error);
+ (sessions, memory, SkillResults::search(skill_scan, &q))
});
cx.spawn_in(window, async move |this, cx| {
- let result = bg.await;
+ let (sessions, memory, skills) = bg.await;
this.update(cx, |state, cx| {
let d = state.delegate_mut();
- d.error = result.as_ref().err().cloned();
- (d.hits, d.degraded) = result.unwrap_or_default();
+ d.sessions = sessions;
+ d.memory = memory;
+ // 搜的时候 skill 扫描换了代(⌘K 补的第一次扫描正好扫完):这份是按旧的算的,
+ // set_skill_scan 已按新的重搜过,别拿旧的盖回去
+ if Arc::ptr_eq(&skills.scan, &d.skills.scan) {
+ d.skills = skills;
+ }
cx.notify();
})
.ok();
@@ -1559,17 +1821,33 @@ impl ListDelegate for SearchDelegate {
cx: &mut Context<ListState<Self>>,
) -> impl IntoElement {
let theme = cx.theme();
- // 还没输入给提示,查询失败说失败(与"没有结果"分开,否则用户以为真的没讨论过)
- let card = if self.last_query.trim().is_empty() {
- Some((
- "icons/search.svg",
- t("Search full conversation text"),
- SharedString::from(t("Matches natural language and code, like \"useEffect(\".")),
- ))
+ // 还没输入给这一栏搜什么,查询失败说失败(与"没有结果"分开,否则用户以为真的没讨论过)
+ let error = match self.tab {
+ SearchTab::Sessions => self.sessions.as_ref().err(),
+ SearchTab::Memory => self.memory.as_ref().err(),
+ SearchTab::Skills => None,
+ };
+ let card = if self.last_query.is_empty() {
+ let (glyph, title, caption) = match self.tab {
+ SearchTab::Sessions => (
+ "icons/search.svg",
+ t("Search full conversation text"),
+ t("Matches natural language and code, like \"useEffect(\"."),
+ ),
+ SearchTab::Memory => (
+ "icons/file-text.svg",
+ t("Search memory files"),
+ t("Matches the titles and text of the notes your agents keep."),
+ ),
+ SearchTab::Skills => (
+ "icons/puzzle.svg",
+ t("Search installed skills"),
+ t("Matches skill names and descriptions."),
+ ),
+ };
+ Some((glyph, title, SharedString::from(caption)))
} else {
- self.error
- .as_ref()
- .map(|error| ("icons/info.svg", t("Search failed"), error.clone().into()))
+ error.map(|error| ("icons/info.svg", t("Search failed"), error.clone().into()))
};
if let Some((glyph, title, caption)) = card {
return v_flex()
@@ -1578,6 +1856,10 @@ impl ListDelegate for SearchDelegate {
.justify_center()
.child(empty_state(glyph, zpx(48.), zpx(22.), title, caption, cx));
}
+ // 这一栏没有、别的栏有:说一声按 Tab 过去,别让人以为整个都没搜到
+ let elsewhere = SearchTab::ALL
+ .iter()
+ .any(|&tab| tab != self.tab && self.count(tab) > 0);
v_flex()
.h(zpx(250.))
.w_full()
@@ -1592,11 +1874,11 @@ impl ListDelegate for SearchDelegate {
.font_medium()
.child(crate::tf!("No results for \"{}\"", self.last_query)),
)
- .child(
- div()
- .text_size(FONT_CAPTION)
- .child(t("Try a different or shorter query.")),
- )
+ .child(div().text_size(FONT_CAPTION).child(if elsewhere {
+ t("Other tabs have results. Press Tab to switch.")
+ } else {
+ t("Try a different or shorter query.")
+ }))
}
fn render_section_header(
@@ -1605,7 +1887,7 @@ impl ListDelegate for SearchDelegate {
_window: &mut Window,
cx: &mut Context<ListState<Self>>,
) -> Option<impl IntoElement> {
- if !self.degraded {
+ if self.tab != SearchTab::Sessions || !matches!(self.sessions, Ok((_, true))) {
return None;
}
Some(
@@ -1621,6 +1903,86 @@ impl ListDelegate for SearchDelegate {
}
}
+/// 选中当前栏的第一条、回到顶部:换栏与搜完回填都这样
+fn select_first_hit(
+ state: &mut ListState<SearchDelegate>,
+ window: &mut Window,
+ cx: &mut Context<ListState<SearchDelegate>>,
+) {
+ let d = state.delegate();
+ let has_hits = d.count(d.tab) > 0;
+ state.set_selected_index(has_hits.then(IndexPath::default), window, cx);
+ // scroll_to_item 自带 notify,列表随之重绘
+ state.scroll_to_item(IndexPath::default(), ScrollStrategy::Top, window, cx);
+}
+
+/// 换到 ⌘K 面板的某一栏。打开面板、点栏头与 Tab 键共用
+fn select_palette_tab(
+ list: &Entity<ListState<SearchDelegate>>,
+ tab: SearchTab,
+ window: &mut Window,
+ cx: &mut App,
+) {
+ list.update(cx, |state, cx| {
+ state.delegate_mut().tab = tab;
+ select_first_hit(state, window, cx);
+ });
+}
+
+/// ⌘K 面板输入行下的栏头:Sessions / Memory / Skills,有查询时各带命中数。纯文字:当前栏前景色、
+/// 底下一条 2px 的线,其余 muted、悬停变前景色——不用带框的分段控件(侧栏底部工具条那次用户
+/// 否过带框的)。点了栏头焦点回到输入框:点过结果行的话焦点在列表上,换了栏要能接着打字
+fn palette_tabs(
+ list: &Entity<ListState<SearchDelegate>>,
+ input: &Entity<InputState>,
+ cx: &App,
+) -> impl IntoElement {
+ let theme = cx.theme();
+ let delegate = list.read(cx).delegate();
+ let has_query = !delegate.last_query.is_empty();
+ h_flex().gap(SPACE_LG).children(SearchTab::ALL.map(|tab| {
+ let active = tab == delegate.tab;
+ let list = list.clone();
+ let input = input.clone();
+ v_flex()
+ .id(("palette-tab", tab as usize))
+ .cursor_pointer()
+ .on_click(move |_, window, cx| {
+ select_palette_tab(&list, tab, window, cx);
+ input.update(cx, |st, cx| st.focus(window, cx));
+ })
+ .child(
+ h_flex()
+ .h(zpx(28.))
+ .gap(SPACE_XS)
+ .text_size(FONT_CAPTION)
+ .font_medium()
+ .text_color(if active {
+ theme.foreground
+ } else {
+ theme.muted_foreground
+ })
+ .when(!active, |label| {
+ label.hover(|s| s.text_colored(theme.foreground, FONT_CAPTION))
+ })
+ .child(tab.label())
+ .when(has_query, |label| {
+ label.child(
+ div()
+ .text_color(theme.muted_foreground)
+ .child(delegate.count_label(tab)),
+ )
+ }),
+ )
+ .child(
+ div()
+ .h(zpx(2.))
+ .w_full()
+ .when(active, |bar| bar.bg(theme.foreground)),
+ )
+ }))
+}
+
// ---------------- 详情状态 ----------------
fn visible_git_branch(branch: Option<&str>) -> Option<&str> {
@@ -2625,18 +2987,7 @@ impl Workbench {
.searchable(false)
});
let palette_list = cx.new(|cx| {
- ListState::new(
- SearchDelegate {
- hits: Vec::new(),
- degraded: false,
- error: None,
- store: store.clone(),
- last_query: String::new(),
- },
- window,
- cx,
- )
- .searchable(false)
+ ListState::new(SearchDelegate::new(store.clone()), window, cx).searchable(false)
});
let palette_input = cx.new(|cx| {
InputState::new(window, cx).placeholder(t("Search everything — prose or code"))
@@ -4802,12 +5153,21 @@ impl Workbench {
window.close_dialog(cx);
return;
}
+ // 停在当前页对应的那一栏;skill 在后台重扫一次(扫完命中自己补上)
+ select_palette_tab(
+ &self.palette_list,
+ SearchTab::for_page(self.page),
+ window,
+ cx,
+ );
+ self.rescan_skills_for_search(cx);
let list = self.palette_list.clone();
let input = self.palette_input.clone();
let this = cx.entity();
open_closable_dialog(window, cx, 680., move |dialog, window, cx| {
let theme = cx.theme();
let has_query = input.read(cx).text().len() > 0;
+ let tab = list.read(cx).delegate().tab;
// 输入框尺寸;清除钮的 suffix 补偿 margin 从它派生,改档自动跟随
let input_size = gpui_component::Size::Large;
dialog
@@ -4817,7 +5177,7 @@ impl Workbench {
.close_button(false)
.child(
v_flex()
- // ↑↓ 在 Input 内不被消费,冒泡到这里走 main.rs 的
+ // ↑↓ 与 Tab 在 Input 内不被消费,冒泡到这里走 main.rs 的
// PALETTE_CONTEXT 键位(Input 拆出 List 后原生 List 绑定够不着)
.key_context(PALETTE_CONTEXT)
.relative()
@@ -4833,6 +5193,18 @@ impl Workbench {
wb.palette_move(1, window, cx)
},
))
+ .on_action(window.listener_for(
+ &this,
+ |wb: &mut Self, _: &PaletteNextTab, window, cx| {
+ wb.step_palette_tab(true, window, cx)
+ },
+ ))
+ .on_action(window.listener_for(
+ &this,
+ |wb: &mut Self, _: &PalettePrevTab, window, cx| {
+ wb.step_palette_tab(false, window, cx)
+ },
+ ))
// 定高 + 列表 flex_1:输入行/footer 尺寸变化时列表自适应,
// 不用手工重算列表高度
// 放大后不超出窗口:顶距与上下留白之外的高度都给它,列表跟着缩
@@ -4841,7 +5213,8 @@ impl Workbench {
.min(window.viewport_size().height - PALETTE_TOP - SPACE_XXL * 2.))
.gap(SPACE_MD)
.child(
- div()
+ // 输入行与栏头同在一个头部里,底下一条 hairline 与结果隔开
+ v_flex()
.flex_shrink_0()
.px(SPACE_SM)
.border_b_1()
@@ -4895,7 +5268,8 @@ impl Workbench {
})
.p_0()
.appearance(false),
- ),
+ )
+ .child(palette_tabs(&list, &input, cx)),
)
.child(
List::new(&list)
@@ -4914,10 +5288,11 @@ impl Workbench {
.justify_between()
.text_size(FONT_LABEL)
.text_color(theme.muted_foreground)
- .child(t("Scope: all sessions"))
+ .child(tab.scope())
.child(
h_flex()
.gap(SPACE_MD)
+ .child(t("⇥ next tab"))
.child(t("↑↓ navigate"))
.child(t("↩ open"))
.child(t("esc close")),
@@ -4950,10 +5325,7 @@ impl Workbench {
if q.is_empty() {
self._palette_search_task = None;
self.palette_list.update(cx, |state, cx| {
- let d = state.delegate_mut();
- d.hits = Vec::new();
- d.degraded = false;
- d.last_query = String::new();
+ state.delegate_mut().clear();
state.set_selected_index(None, window, cx);
cx.notify();
});
@@ -4967,17 +5339,8 @@ impl Workbench {
self._palette_search_task = Some(cx.spawn_in(window, async move |this, cx| {
task.await;
this.update_in(cx, |this, window, cx| {
- this.palette_list.update(cx, |state, cx| {
- let has_hits = !state.delegate().hits.is_empty();
- state.set_selected_index(has_hits.then(IndexPath::default), window, cx);
- // scroll_to_item 自带 notify,列表随之重绘
- state.scroll_to_item(
- IndexPath::default(),
- ScrollStrategy::Top,
- window,
- cx,
- );
- });
+ this.palette_list
+ .update(cx, |state, cx| select_first_hit(state, window, cx));
})
.ok();
}));
@@ -4995,18 +5358,17 @@ impl Workbench {
}
}
- /// 打开第 row 条搜索命中(回车与鼠标点击共用),定位到命中消息
+ /// 打开当前栏第 row 条搜索命中(回车与鼠标点击共用):会话定位到命中消息,记忆与 skill
+ /// 落到各自的页、选中它
fn open_palette_hit(&mut self, row: usize, window: &mut Window, cx: &mut Context<Self>) {
- let hit = self
- .palette_list
- .read(cx)
- .delegate()
- .hits
- .get(row)
- .map(|h| (h.session.key.clone(), h.seq));
- if let Some((key, seq)) = hit {
- window.close_dialog(cx);
- self.open_detail(&key, Some(seq), window, cx);
+ let Some(target) = self.palette_list.read(cx).delegate().target(row) else {
+ return;
+ };
+ window.close_dialog(cx);
+ match target {
+ PaletteTarget::Session { key, seq } => self.open_detail(&key, Some(seq), window, cx),
+ PaletteTarget::Memory(key) => self.reveal_memory(key, cx),
+ PaletteTarget::Skill { name, dir } => self.reveal_skill(&name, dir, cx),
}
}
@@ -5014,7 +5376,8 @@ impl Workbench {
/// 按 row 平移——SearchDelegate 单 section,section 恒 0
fn palette_move(&mut self, delta: i64, window: &mut Window, cx: &mut Context<Self>) {
self.palette_list.update(cx, |state, cx| {
- let n = state.delegate().hits.len() as i64;
+ let d = state.delegate();
+ let n = d.count(d.tab) as i64;
if n == 0 {
return;
}
@@ -5026,6 +5389,12 @@ impl Workbench {
});
}
+ /// ⌘K 面板 Tab / Shift-Tab:后一栏 / 前一栏
+ fn step_palette_tab(&mut self, forward: bool, window: &mut Window, cx: &mut Context<Self>) {
+ let tab = self.palette_list.read(cx).delegate().tab.step(forward);
+ select_palette_tab(&self.palette_list, tab, window, cx);
+ }
+
// ---------- 详情 ----------
fn copy_session_path(&mut self, cx: &mut Context<Self>) {
@@ -5164,10 +5533,7 @@ impl Workbench {
if let Some(seq) = detail.jump_seq {
if let Some(ix) = messages.iter().position(|m| m.seq >= seq) {
detail.jump_seq = Some(messages[ix].seq);
- detail.msg_list.scroll_to(gpui::ListOffset {
- item_ix: ix,
- offset_in_item: px(0.),
- });
+ pin_list_row(&detail.msg_list, ix);
}
}
detail.transcript = Rc::new(messages);
@@ -5956,8 +6322,9 @@ impl Workbench {
.pr(SIDEBAR_EDGE * 2.)
.text_color(theme.foreground),
)
- // 导航按页切换:Memory 页是记忆的导航(All Memory / Agents / Projects,按记忆
- // 计数),其余是会话的(搜索框 + All Sessions / Starred + Agents / Projects)
+ // 搜索框三页都有(⌘K 同一个面板),下面的导航按页切换:Memory / Skills 页是各自的
+ // 导航(按记忆文件 / skill 计数),其余是会话的
+ .child(self.render_sidebar_search(cx))
.child(match self.page {
Page::Memory => self.render_memory_nav(cx),
Page::Skills => self.render_skills_nav(cx),
@@ -6008,47 +6375,45 @@ impl Workbench {
)
}
- /// 会话导航(Insights 页也画它——点任何一行都回会话列表):搜索框(搜的是会话,
- /// ⌘K 同一条路)、All Sessions / Starred 两行,再接 Agents / Projects 两组
- fn render_sessions_nav(&self, all_active: bool, cx: &Context<Self>) -> AnyElement {
+ /// 侧栏顶部的搜索框,三页都画:点它与 ⌘K 是同一个面板,面板停在当前页那一栏,所以
+ /// 文案按页点名(用户 2026-10-24 定)
+ fn render_sidebar_search(&self, cx: &Context<Self>) -> Div {
let theme = cx.theme();
+ let label = SearchTab::for_page(self.page).prompt();
+ div().flex_shrink_0().px(SIDEBAR_EDGE).pb(SPACE_MD).child(
+ h_flex().gap(SPACE_SM).child(
+ search_field_frame(cx)
+ .id("sidebar-search")
+ .flex_1()
+ .min_w_0()
+ .cursor_pointer()
+ .active(|s| {
+ s.bg(theme.secondary_active)
+ .text_colored(theme.foreground, FONT_CAPTION)
+ })
+ .on_click(cx.listener(|this, _, window, cx| {
+ this.toggle_search(&ToggleSearch, window, cx)
+ }))
+ .child(icon("icons/search.svg").with_size(zpx(13.)).flex_shrink_0())
+ // flex_1 + min_w_0 + truncate:空间不足时压文案,右侧的 ⌘K
+ // 提示不被挤出侧栏
+ .child(div().flex_1().min_w_0().truncate().child(label))
+ .child(
+ div()
+ .flex_shrink_0()
+ .text_size(FONT_LABEL)
+ .child(search_key_hint()),
+ ),
+ ),
+ )
+ }
+
+ /// 会话导航(Insights 页也画它——点任何一行都回会话列表):All Sessions / Starred 两行,再接
+ /// Agents / Projects 两组
+ fn render_sessions_nav(&self, all_active: bool, cx: &Context<Self>) -> AnyElement {
v_flex()
.flex_1()
.min_h_0()
- .child(
- div().flex_shrink_0().px(SIDEBAR_EDGE).pb(SPACE_MD).child(
- h_flex().gap(SPACE_SM).child(
- search_field_frame(cx)
- .id("sidebar-search")
- .flex_1()
- .min_w_0()
- .cursor_pointer()
- .active(|s| {
- s.bg(theme.secondary_active)
- .text_colored(theme.foreground, FONT_CAPTION)
- })
- .on_click(cx.listener(|this, _, window, cx| {
- this.toggle_search(&ToggleSearch, window, cx)
- }))
- .child(icon("icons/search.svg").with_size(zpx(13.)).flex_shrink_0())
- // flex_1 + min_w_0 + truncate:空间不足时压文案,右侧的 ⌘K
- // 提示不被挤出侧栏
- .child(
- div()
- .flex_1()
- .min_w_0()
- .truncate()
- .child(t("Search sessions")),
- )
- .child(
- div()
- .flex_shrink_0()
- .text_size(FONT_LABEL)
- .child(search_key_hint()),
- ),
- ),
- ),
- )
.child(
v_flex()
.flex_shrink_0()
@@ -7502,12 +7867,7 @@ impl Workbench {
.into_any_element(),
);
}
- lead.push(
- img(meta.agent.brand_icon(theme.mode.is_dark()))
- .size(zpx(15.))
- .flex_shrink_0()
- .into_any_element(),
- );
+ lead.push(brand_img(meta.agent, zpx(15.), theme.mode.is_dark()).into_any_element());
lead.push(
div()
.flex_shrink_0()
@@ -9918,19 +10278,23 @@ fn library_list(
.into_any_element()
}
+/// 把第 `row` 行钉到列表顶上:搜索命中的跳转都这样(会话正文里的那条消息、记忆、skill)
+fn pin_list_row(state: &gpui::ListState, row: usize) {
+ state.scroll_to(gpui::ListOffset {
+ item_ix: row,
+ offset_in_item: Pixels::ZERO,
+ });
+}
+
/// 列表整段换成 `new_len` 行:重载保滚动位置,`to_top` 回到顶部。splice 整段会把落在段内的
/// 滚动锚点归零(gpui 只保段外的锚点),所以先记下再恢复
fn replace_list_rows(state: &gpui::ListState, old_len: usize, new_len: usize, to_top: bool) {
- let top = if to_top {
- gpui::ListOffset {
- item_ix: 0,
- offset_in_item: px(0.),
- }
- } else {
- state.logical_scroll_top()
- };
+ let top = (!to_top).then(|| state.logical_scroll_top());
state.splice(0..old_len, new_len);
- state.scroll_to(top);
+ match top {
+ Some(top) => state.scroll_to(top),
+ None => pin_list_row(state, 0),
+ }
}
/// 阅读面头部右端的 Reveal / Copy path,与路径、更新时间两行元信息(记忆与 Skills 阅读面
diff --git a/crates/wake/src/workbench/memory.rs b/crates/wake/src/workbench/memory.rs
index c3a8d9d..9be4bd8 100644
--- a/crates/wake/src/workbench/memory.rs
+++ b/crates/wake/src/workbench/memory.rs
@@ -64,6 +64,8 @@ pub(super) struct MemoryState {
/// 有 `syncing` 守着就不会重叠,不必再攥着句柄
pub(super) syncing: bool,
sync_pending: bool,
+ /// ⌘K 打开的那一份:下一次重载落定后选中它、滚到它那一行
+ reveal: Option<String>,
}
impl MemoryState {
@@ -89,6 +91,7 @@ impl Default for MemoryState {
body_task: None,
syncing: false,
sync_pending: false,
+ reveal: None,
}
}
}
@@ -105,6 +108,18 @@ impl Workbench {
self.memory.scope_changed = true;
}
+ /// ⌘K 打开一条记忆命中:落到 Memory 页的 All Memory(哪一份都列得出来),重载落定后选中它、
+ /// 把它那一行滚到顶上(会话命中也是钉顶)
+ pub(super) fn reveal_memory(&mut self, key: String, cx: &mut Context<Self>) {
+ self.memory.reveal = Some(key);
+ if self.page == Page::Memory {
+ self.set_memory_scope(MemoryNav::All, cx);
+ } else {
+ // 切页清筛选、重载(`show_page` → refresh → reload_memories)
+ self.show_page(Page::Memory, cx);
+ }
+ }
+
/// 侧栏导航行的唯一写入点(与会话侧栏的 set_scope 同形)
fn set_memory_scope(&mut self, nav: MemoryNav, cx: &mut Context<Self>) {
self.memory.nav = nav;
@@ -225,6 +240,8 @@ impl Workbench {
self.memory.load_task = Some(cx.spawn(async move |this, cx| {
let loaded = task.await;
this.update(cx, |this, cx| {
+ // 读失败也收掉:留着的话,之后哪一次重载都会突然跳过去选中它
+ let reveal = this.memory.reveal.take();
if let Ok((mut docs, counts)) = loaded {
this.memory.counts = counts;
// 用户记忆对每个项目都成立、没有"发生时间"的意义,像会话列表的 Pinned
@@ -258,11 +275,17 @@ impl Workbench {
let after = selected.as_deref().and_then(|k| stamp(&docs, k));
this.memory.docs = docs;
this.memory.rows = rows;
- match (selected, after) {
- (Some(key), Some(now)) if before != Some(now) => {
+ let revealed = reveal.and_then(|key| Some((this.memory_row_of(&key)?, key)));
+ match (revealed, selected, after) {
+ // ⌘K 打开的那一份:选中它,它那一行(连同上面的组头)滚到顶上
+ (Some((row, key)), ..) => {
+ pin_list_row(&this.memory.list, row);
this.select_memory(key, cx);
}
- (Some(_), Some(_)) => {}
+ (None, Some(key), Some(now)) if before != Some(now) => {
+ this.select_memory(key, cx);
+ }
+ (None, Some(_), Some(_)) => {}
_ => {
this.memory.selected = None;
this.memory.loaded = None;
@@ -279,6 +302,20 @@ impl Workbench {
}));
}
+ /// 一份记忆在列表里的行;紧挨着它的上一行是组头时给组头,滚到顶上时连组头一起露出来
+ fn memory_row_of(&self, key: &str) -> Option<usize> {
+ let rows = &self.memory.rows;
+ let docs = &self.memory.docs;
+ let row = rows
+ .iter()
+ .position(|r| matches!(r, MemoryRow::Doc(di) if docs[*di].key == key))?;
+ Some(if row > 0 && matches!(rows[row - 1], MemoryRow::Group(_)) {
+ row - 1
+ } else {
+ row
+ })
+ }
+
fn select_memory(&mut self, key: String, cx: &mut Context<Self>) {
let Some(path) = self
.memory
@@ -436,11 +473,7 @@ impl Workbench {
.gap(ICON_TEXT_GAP)
.text_size(FONT_LABEL)
.text_color(theme.muted_foreground)
- .child(
- img(d.agent.brand_icon(theme.mode.is_dark()))
- .size(zpx(15.))
- .flex_shrink_0(),
- )
+ .child(brand_img(d.agent, zpx(15.), theme.mode.is_dark()))
// 项目徽章与会话行同款(muted 胶囊;用户级 / 没归属的也用组头同一套
// 文案),用户 2026-09-21 定:组头说明了也要挂,和会话列表看起来一致
.child(badge(
@@ -490,10 +523,7 @@ impl Workbench {
doc.project_path.clone()
};
let mut lead: Vec<AnyElement> = vec![
- img(doc.agent.brand_icon(dark))
- .size(zpx(15.))
- .flex_shrink_0()
- .into_any_element(),
+ brand_img(doc.agent, zpx(15.), dark).into_any_element(),
div()
.flex_shrink_0()
.child(doc.agent.display_name())
@@ -532,9 +562,9 @@ impl Workbench {
reader_pane("memory-reader", header, content, &theme)
}
- /// Memory 页的侧栏导航,替换会话导航(搜索框、All Sessions / Starred、Agents /
- /// Projects):All Memory / User memory 两行,再接 Agents / Projects 两组
- /// (`sidebar_groups`,与会话侧栏同一套组件、同一个单选模型)按记忆文件计数
+ /// Memory 页的侧栏导航,替换会话导航(All Sessions / Starred、Agents / Projects):
+ /// All Memory / User memory 两行,再接 Agents / Projects 两组(`sidebar_groups`,与会话
+ /// 侧栏同一套组件、同一个单选模型)按记忆文件计数
pub(super) fn render_memory_nav(&self, cx: &Context<Self>) -> AnyElement {
let counts = &self.memory.counts;
let nav = &self.memory.nav;
@@ -657,8 +687,8 @@ fn memory_display_path(d: &MemoryDoc) -> String {
}
}
-/// 组头 / 归属徽章的文案:项目名;用户级记忆一组、没有项目的一组
-fn memory_group_label(d: &MemoryDoc) -> SharedString {
+/// 组头 / 归属徽章的文案:项目名;用户级记忆一组、没有项目的一组(⌘K 面板的记忆行也用它)
+pub(super) fn memory_group_label(d: &MemoryDoc) -> SharedString {
match d.group() {
MemoryGroup::User => t("User memory").into(),
MemoryGroup::Unknown => t("Unknown project").into(),
diff --git a/crates/wake/src/workbench/skills.rs b/crates/wake/src/workbench/skills.rs
index 53b2fe9..ceed8da 100644
--- a/crates/wake/src/workbench/skills.rs
+++ b/crates/wake/src/workbench/skills.rs
@@ -35,7 +35,8 @@ struct LoadedSkill {
}
pub(super) struct SkillsState {
- scan: SkillScan,
+ /// ⌘K 面板的 Skills 栏共用这一份(`SearchDelegate::set_skill_scan`)
+ scan: Arc<SkillScan>,
counts: SkillCounts,
/// 当前筛选下列表里的 skill(`scan.skills` 的下标),交 gpui::list 虚拟化
rows: Vec<usize>,
@@ -55,7 +56,7 @@ pub(super) struct SkillsState {
impl Default for SkillsState {
fn default() -> Self {
Self {
- scan: SkillScan::default(),
+ scan: Arc::default(),
counts: SkillCounts::default(),
rows: Vec::new(),
list: gpui::ListState::new(0, gpui::ListAlignment::Top, zpx(200.)),
@@ -112,25 +113,22 @@ fn default_install(skill: &Skill, nav: &SkillNav) -> usize {
.unwrap_or(skill.newest)
}
-/// 归属的显示名:共享目录叫 Shared(译),agent 是产品名(不译)
-fn owner_label(owner: SkillOwner) -> &'static str {
+/// 归属的显示名:共享目录叫 Shared(译),agent 是产品名(不译)。⌘K 面板的 skill 行也用
+pub(super) fn owner_label(owner: SkillOwner) -> &'static str {
match owner {
SkillOwner::Shared => t("Shared"),
SkillOwner::Agent(agent) => agent.display_name(),
}
}
-/// 归属的图标:agent 是品牌图(原色),共享目录是 layers 线条图标
-fn owner_icon(owner: SkillOwner, size: Pixels, dark: bool) -> AnyElement {
+/// 归属的图标:agent 是品牌图(原色),共享目录是 layers 线条图标。⌘K 面板的 skill 行也用
+pub(super) fn owner_icon(owner: SkillOwner, size: Pixels, dark: bool) -> AnyElement {
match owner {
SkillOwner::Shared => icon("icons/layers.svg")
.with_size(size)
.flex_shrink_0()
.into_any_element(),
- SkillOwner::Agent(agent) => img(agent.brand_icon(dark))
- .size(size)
- .flex_shrink_0()
- .into_any_element(),
+ SkillOwner::Agent(agent) => brand_img(agent, size, dark).into_any_element(),
}
}
@@ -148,10 +146,34 @@ impl Workbench {
/// 一次——装了新 skill 进页就看得到。会话扫描的事件不触发重扫(skill 与会话无关)
pub(super) fn enter_skills(&mut self, cx: &mut Context<Self>) {
self.skills.nav = SkillNav::All;
- self.apply_skill_rows(true, cx);
+ self.apply_skill_rows(true, None, cx);
+ self.start_skill_scan(None, cx);
+ }
+
+ /// 打开 ⌘K 面板:后台重扫一次 skill,扫完命中自己补上。与进 Skills 页同一个规矩——要看的时候
+ /// 就扫(有缓存时几毫秒);只扫一次的话,装了新 skill、改了 location 之后面板一直搜旧的
+ /// (Codex review 2026-10-25)
+ pub(super) fn rescan_skills_for_search(&mut self, cx: &mut Context<Self>) {
self.start_skill_scan(None, cx);
}
+ /// ⌘K 打开一条 skill 命中:落到 Skills 页的 All Skills,选中它、显示命中的那一处(`dir`),
+ /// 把它那一行滚到顶上(会话命中也是钉顶)
+ pub(super) fn reveal_skill(&mut self, name: &str, dir: PathBuf, cx: &mut Context<Self>) {
+ if self.page == Page::Skills {
+ self.set_skill_scope(SkillNav::All, cx);
+ } else {
+ self.show_page(Page::Skills, cx);
+ }
+ let Some(ix) = self.skills.scan.index_of(name) else {
+ return;
+ };
+ if let Some(row) = self.skills.rows.iter().position(|&r| r == ix) {
+ pin_list_row(&self.skills.list, row);
+ }
+ self.select_skill(ix, Some(dir), cx);
+ }
+
/// roster 换代(location 增删、停用):skill 目录从它推,页开着就重扫;没开着下次进页本来
/// 就会扫
pub(super) fn rescan_open_skills(&mut self, cx: &mut Context<Self>) {
@@ -163,7 +185,7 @@ impl Workbench {
/// 侧栏导航行的唯一写入点:不重扫,按已有结果重新筛、回顶部
fn set_skill_scope(&mut self, nav: SkillNav, cx: &mut Context<Self>) {
self.skills.nav = nav;
- self.apply_skill_rows(true, cx);
+ self.apply_skill_rows(true, None, cx);
}
/// 侧栏 Starred 式的行:点当前项回到 All,否则切到它
@@ -208,13 +230,22 @@ impl Workbench {
let (scan, counts) = task.await;
this.update(cx, |this, cx| {
let state = &mut this.skills;
- let selected = state.selected_skill().map(|s| s.name.clone());
+ // 选中的那个与阅读面显示的那一处,换了扫描按名字与目录找回(在换之前记下:
+ // 下标指的是旧扫描)
+ let (selected, shown_dir) = state.selected_skill().map_or((None, None), |s| {
+ let shown = s.installs.get(state.shown).map(|i| i.path.clone());
+ (Some(s.name.clone()), shown)
+ });
state.scanning = false;
state.counts = counts;
- state.scan = scan;
- state.selected =
- selected.and_then(|name| state.scan.skills.iter().position(|s| s.name == name));
- this.apply_skill_rows(false, cx);
+ state.scan = Arc::new(scan);
+ state.selected = selected.and_then(|name| state.scan.index_of(&name));
+ let scan = state.scan.clone();
+ this.palette_list.update(cx, |list, cx| {
+ list.delegate_mut().set_skill_scan(scan);
+ cx.notify();
+ });
+ this.apply_skill_rows(false, shown_dir, cx);
})
.ok();
if let Some((window, note)) = done {
@@ -225,9 +256,15 @@ impl Workbench {
}
/// 按当前筛选重排列表;选中项还在就留着,否则落到第一个。重扫(`to_top` 为假)保滚动
- /// 位置、显示的那处按路径找回(文件变了重读正文);换筛选回顶部,显示的那处按新筛选
+ /// 位置、显示的那处按 `shown_dir` 找回(文件变了重读正文;调用方在换扫描之前记下——正文
+ /// 还没读回来时 `loaded` 是空的,拿它找会退回默认那处);换筛选回顶部,显示的那处按新筛选
/// 重新挑(点了 Codex 就换成 Codex 那份,Codex review 2026-10-15)
- fn apply_skill_rows(&mut self, to_top: bool, cx: &mut Context<Self>) {
+ fn apply_skill_rows(
+ &mut self,
+ to_top: bool,
+ shown_dir: Option<PathBuf>,
+ cx: &mut Context<Self>,
+ ) {
let state = &mut self.skills;
let rows: Vec<usize> = state
.scan
@@ -240,14 +277,7 @@ impl Workbench {
replace_list_rows(&state.list, state.rows.len(), rows.len(), to_top);
state.rows = rows;
match state.selected.filter(|ix| state.rows.contains(ix)) {
- Some(ix) => {
- let shown_dir = state
- .loaded
- .as_ref()
- .filter(|_| !to_top)
- .map(|l| l.dir.clone());
- self.select_skill(ix, shown_dir, cx);
- }
+ Some(ix) => self.select_skill(ix, shown_dir, cx),
None => {
state.selected = None;
state.loaded = None;