pi-session-peek 0.3.1 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.4.0
+
+- Search syntax: `"exact phrase"` (whitespace inside the quotes matches any whitespace, including line breaks), `a|b` for either, `-word` to exclude, `name:` / `dir:` (`cwd:`) / `user:` / `ai:` (`assistant:`) to limit a term to one field, and `/regex/` for JavaScript regular expressions. Prefixes stack (`-user:"not now"`), quotes escape everything else, and an invalid regex falls back to plain text.
+- The preview highlights and counts only positive terms, and `user:` / `ai:` terms only inside messages of that role. `name:` / `dir:` terms never touch the conversation.
+- Lines containing a character whose lowercase form has a different length (for example `İ`) are now highlighted too. Before, the whole line was skipped.
+
 ## 0.3.1
 
 - `scanSessions` is now async: directory walking and file reads go through `fs/promises` with bounded concurrency, so opening `/peek` with hundreds of sessions no longer blocks the TUI.

package/README.md

@@ -14,6 +14,7 @@ Search your [pi](https://pi.dev) session history by what was actually said, read
 - Renders the conversation with pi's own Markdown renderer, so headings, code blocks with syntax highlighting, tables and lists look the same as in the main transcript.
 - Filters as you type across conversation text, session name and working directory. Tool call arguments and results are excluded, so a keyword only matches sessions that actually discussed it.
 - Requires every space-separated keyword to match, and shows a snippet around the first hit in the list.
+- Understands `"exact phrases"`, `either|or`, `-exclude`, `name:` / `dir:` / `user:` / `ai:` prefixes and `/regex/`.
 - Limits results to recently active sessions with `@7d`, `@24h`, `@2w` or `@1m`.
 - Highlights every hit in the preview and jumps between them with `Ctrl+N` / `Ctrl+P`.
 - Resumes with `Enter`, forks into a new session with `Ctrl+O`, renames with `Ctrl+R`, deletes with `Ctrl+D`.
@@ -58,7 +59,7 @@ In TUI mode, run `/peek` and start typing. Press `Enter` on a session to continu
 
 | Key | Action |
 | --- | --- |
-| type | Filter. Space-separated words must all match; `@7d` and friends limit by time. |
+| type | Filter. Space-separated words must all match; see [Search syntax](#-search-syntax) for phrases, `-exclude`, prefixes, regex and `@7d`. |
 | `Tab` | Current directory tree ↔ all projects |
 | `↑` `↓` | Select session |
 | `PgUp` `PgDn` | Scroll preview by a page |
@@ -73,13 +74,21 @@ In TUI mode, run `/peek` and start typing. Press `Enter` on a session to continu
 
 ## 🔎 Search syntax
 
-The filter is case-insensitive and matches anywhere in the text.
+The filter is case-insensitive and matches anywhere in the text. Whitespace separates terms, and every term must be satisfied.
 
 | Input | Meaning |
 | --- | --- |
-| `token undefined` | Sessions containing both `token` and `undefined` |
+| `token undefined` | Sessions containing both `token` and `undefined`, in any order and any message |
+| `"token undefined"` | The exact phrase. Whitespace inside the quotes matches any run of whitespace, including a line break. |
+| `vue\|react` | Sessions containing `vue` or `react` |
+| `-draft` | Sessions that do not contain `draft` anywhere (messages, name or directory) |
+| `name:auth` | Session name only. `dir:` or `cwd:` for the working directory. |
+| `user:deploy` | Only the messages you wrote. `ai:` or `assistant:` for the replies. |
+| `/\bfoo\d+\b/` | JavaScript regular expression, case-insensitive, `^` and `$` match line boundaries. Use `\s` instead of a space. |
 | `@7d` | Sessions active in the last 7 days. Units: `h`, `d`, `w`, `m` (30 days). |
-| `token @2w` | Both combined |
+| `-user:"not now" ai:/todo\|fixme/ @2w` | Prefixes stack, and everything combines |
+
+Quotes are the escape hatch: `"-foo"`, `"a|b"`, `"name:x"` and `"/x/"` search for those characters literally. A regex that fails to compile is searched as plain text. Only positive terms are highlighted in the preview, and `name:` / `dir:` terms never touch the conversation, so `name:auth` alone shows the full conversation with no highlights.
 
 The search index holds user and assistant messages, the session name and the working directory. It does not hold tool call arguments or tool results.
 
@@ -139,13 +148,16 @@ One-time setup on npmjs.com: package settings → Trusted Publisher → GitHub A
 To cut a release:
 
 ```bash
-# 1. move the "## Unreleased" entries in CHANGELOG.md under the new version and commit
-# 2. bump the version, commit and tag in one go (patch / minor / major)
-npm version patch -m "chore: release %s"
+# 1. write the release notes under "## Unreleased" in CHANGELOG.md and commit them
+#    (npm version refuses to run with uncommitted changes to tracked files)
+# 2. bump the version (patch / minor / major)
+npm version patch
 # 3. push the commit together with the tag; CI does the rest
 git push --follow-tags
 ```
 
+`npm version` first checks that the working tree is clean and stops with `Git working directory not clean.` otherwise, so everything, including `CHANGELOG.md`, has to be committed before the bump. Untracked files are fine. It then runs the hooks declared in `package.json`: `preversion` checks that `CHANGELOG.md` has a non-empty `## Unreleased` section and runs `npm run check`, aborting the bump before anything is touched if either fails; `version` runs `scripts/release-changelog.mjs`, which renames `## Unreleased` to the new version and stages the file. npm then commits `package.json`, the lockfile and `CHANGELOG.md` as `chore: release X.Y.Z` (message set in `.npmrc`) and tags it `vX.Y.Z`.
+
 ## 📄 License
 
 MIT. See [`LICENSE`](./LICENSE).

package/README.zh-CN.md

@@ -14,6 +14,7 @@
 - 右栏用 pi 自己的 Markdown 渲染器画，标题、带语法高亮的代码块、表格、列表和主界面里的对话一个样子。
 - 边打字边过滤，搜的是对话正文、会话名和工作目录。工具调用的参数和结果不进索引，所以只会命中真正讨论过这个词的会话。
 - 空格分隔多个关键词，全部命中才显示；列表里直接显示第一个命中处的片段。
+- 支持 `"精确短语"`、`a|b` 任一命中、`-排除`、`name:` / `dir:` / `user:` / `ai:` 限定范围，以及 `/正则/`。
 - `@7d`、`@24h`、`@2w`、`@1m` 只看最近活动过的会话。
 - 预览里所有命中都高亮，`Ctrl+N` / `Ctrl+P` 在命中间跳。
 - `Enter` 进入会话，`Ctrl+O` 分叉成新会话，`Ctrl+R` 重命名，`Ctrl+D` 删除。
@@ -58,7 +59,7 @@ pi 扩展以你的用户权限运行，只装信得过的包。
 
 | 按键 | 作用 |
 | --- | --- |
-| 打字 | 过滤。空格分隔的词都要命中；`@7d` 等限定时间。 |
+| 打字 | 过滤。空格分隔的词都要命中；短语、`-排除`、前缀、正则和 `@7d` 见[搜索语法](#-搜索语法)。 |
 | `Tab` | 当前目录树 ↔ 全部项目 |
 | `↑` `↓` | 选会话 |
 | `PgUp` `PgDn` | 预览翻页 |
@@ -73,13 +74,21 @@ pi 扩展以你的用户权限运行，只装信得过的包。
 
 ## 🔎 搜索语法
 
-大小写不敏感，匹配文本中任意位置。
+大小写不敏感，匹配文本中任意位置。空白分隔多个词，每个词都要满足。
 
 | 输入 | 含义 |
 | --- | --- |
-| `token undefined` | 同时包含 `token` 和 `undefined` 的会话 |
+| `token undefined` | 同时包含 `token` 和 `undefined` 的会话，顺序不限，可以在不同的消息里 |
+| `"token undefined"` | 精确短语。引号里的空白可以匹配正文里的任意一段空白，包括换行 |
+| `vue\|react` | 包含 `vue` 或 `react` 的会话 |
+| `-draft` | 哪里都不含 `draft` 的会话（消息、会话名、目录都算） |
+| `name:auth` | 只在会话名里找。`dir:` 或 `cwd:` 只看工作目录 |
+| `user:deploy` | 只看你发的消息。`ai:` 或 `assistant:` 只看回复 |
+| `/\bfoo\d+\b/` | JavaScript 正则，大小写不敏感，`^` 和 `$` 匹配行首行尾。空格用 `\s` 代替 |
 | `@7d` | 最近 7 天活动过的会话。单位：`h` 小时、`d` 天、`w` 周、`m` 月（按 30 天算） |
-| `token @2w` | 两者组合 |
+| `-user:"not now" ai:/todo\|fixme/ @2w` | 前缀可以叠加，所有条件一起组合 |
+
+引号是万能转义：`"-foo"`、`"a|b"`、`"name:x"`、`"/x/"` 都按字面搜这些字符。正则写错了就当普通文字搜。预览里只高亮正向的词，`name:` / `dir:` 的词不碰对话正文，所以只输入 `name:auth` 时右栏显示完整对话、没有高亮。
 
 索引里有用户和助手的消息、会话名、工作目录。没有工具调用的参数和结果。
 
@@ -139,13 +148,16 @@ npm 侧需要一次性配置：包设置 → Trusted Publisher → GitHub Action
 发一个版本：
 
 ```bash
-# 1. 把 CHANGELOG.md 里 "## Unreleased" 下的条目挪到新版本号下面，提交
-# 2. 升版本号、提交、打 tag 一步完成（patch / minor / major）
-npm version patch -m "chore: release %s"
+# 1. 把这版的更新说明写在 CHANGELOG.md 的 "## Unreleased" 下面，并提交
+#    （npm version 遇到已跟踪文件有未提交改动会直接拒绝）
+# 2. 升版本号（patch / minor / major）
+npm version patch
 # 3. 提交和 tag 一起推上去，剩下的交给 CI
 git push --follow-tags
 ```
 
+`npm version` 一上来先检查 git 工作区是否干净，不干净就报 `Git working directory not clean.` 退出，所以 `CHANGELOG.md` 在内的所有改动都要先提交（未跟踪的文件不影响）。然后才跑 `package.json` 里声明的钩子：`preversion` 先确认 `CHANGELOG.md` 里有非空的 `## Unreleased` 段落，再跑 `npm run check`，任一不通过就在改动任何文件之前中止；`version` 跑 `scripts/release-changelog.mjs`，把 `## Unreleased` 改成新版本号并 `git add`。然后 npm 把 `package.json`、lockfile 和 `CHANGELOG.md` 一起提交成 `chore: release X.Y.Z`（提交信息定义在 `.npmrc`），并打上 `vX.Y.Z` 的 tag。
+
 ## 📄 许可证
 
 MIT，见 [`LICENSE`](./LICENSE)。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-session-peek",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Pi extension: search session history in a two-pane picker with full conversation preview, then resume or fork.",
   "type": "module",
   "license": "MIT",
@@ -40,6 +40,8 @@
     "test": "node --import tsx --test \"test/**/*.test.ts\"",
     "check": "npm run typecheck && npm test",
     "screenshot": "node --import tsx scripts/screenshot.mjs",
+    "preversion": "node scripts/release-changelog.mjs --check && npm run check",
+    "version": "node scripts/release-changelog.mjs",
     "prepublishOnly": "npm run check"
   },
   "peerDependencies": {

package/src/i18n.ts

@@ -14,7 +14,7 @@ const zh = {
   forked: "已分叉为新会话 {file}",
   forkFailed: "分叉失败：{error}",
   switchCancelled: "切换会话已取消",
-  searchPlaceholder: "关键词过滤（空格分隔=同时命中；@7d 限定近 7 天）",
+  searchPlaceholder: "过滤：空格=都要命中  \"短语\"  a|b  -排除  name:/dir:/user:/ai:  /正则/  @7d",
   renamePlaceholder: "新会话名（Enter 确认 / Esc 取消，留空取消）",
   title: "🔍 会话搜索预览",
   scopeLabel: "  范围[Tab]: ",
@@ -54,7 +54,7 @@ const en: Record<keyof typeof zh, string> = {
   forked: "Forked into new session {file}",
   forkFailed: "Fork failed: {error}",
   switchCancelled: "Session switch cancelled",
-  searchPlaceholder: "Filter (space = all words must match; @7d = last 7 days)",
+  searchPlaceholder: "Filter: space=AND  \"phrase\"  a|b  -exclude  name:/dir:/user:/ai:  /regex/  @7d",
   renamePlaceholder: "New session name (Enter to confirm, Esc to cancel, empty = cancel)",
   title: "🔍 Session search",
   scopeLabel: "  Scope[Tab]: ",

package/src/peek-component.ts

@@ -10,7 +10,7 @@ import {
   type MarkdownTheme,
 } from "@earendil-works/pi-tui";
 import { msg } from "./i18n.ts";
-import { anyKw, highlight, kwRegExps, lineHasKw, matchesSession, parseQuery, snippet, type ParsedQuery } from "./query.ts";
+import { anyMatch, highlight, lineHasMatch, matchesSession, parseQuery, roleTerms, snippet, type ParsedQuery } from "./query.ts";
 import type { PeekMsg, PeekSession } from "./sessions.ts";
 import { fmtTime, normPath, padEndVisible } from "./text.ts";
 
@@ -86,14 +86,11 @@ export class PeekComponent implements Component, Focusable {
   // keepSelection：尽量保持原来选中的会话，重命名后用
   private refilter(keepSelection = false): void {
     const prev = keepSelection ? this.filtered[this.selected] : undefined;
-    const { kws, since } = this.query();
+    const { terms, since } = this.query();
     let out = this.all;
     if (this.scope === "current") out = out.filter((s) => this.inCurrentTree(s));
     if (since) out = out.filter((s) => s.mtime >= since);
-    if (kws.length) {
-      const res = kwRegExps(kws);
-      out = out.filter((s) => matchesSession(s, res));
-    }
+    if (terms.length) out = out.filter((s) => matchesSession(s, terms));
     this.filtered = out;
     const idx = prev ? out.indexOf(prev) : -1;
     this.selected = idx >= 0 ? idx : keepSelection ? Math.min(this.selected, Math.max(0, out.length - 1)) : 0;
@@ -274,7 +271,8 @@ export class PeekComponent implements Component, Focusable {
   // 左栏，每个会话两行
   private buildList(height: number, lw: number): string[] {
     const t = this.theme;
-    const { kws } = this.query();
+    const rt = roleTerms(this.query().terms); // 排除词和 name: / cwd: 不在正文里高亮
+    const hasBody = rt.user.length > 0 || rt.assistant.length > 0;
     const visible = Math.max(1, Math.floor(height / 2));
     if (this.selected < this.listOffset) this.listOffset = this.selected;
     if (this.selected >= this.listOffset + visible) {
@@ -292,15 +290,15 @@ export class PeekComponent implements Component, Focusable {
       const sel = idx === this.selected;
       const time = fmtTime(s.time);
       const cwdTail = s.cwd.replace(/\\/g, "/").split("/").slice(-2).join("/");
-      // 有关键词时显示命中的消息数
-      const hitBadge = kws.length
-        ? ` ·${s.msgs.reduce((n, m) => n + (anyKw(m.text.toLowerCase(), kws) ? 1 : 0), 0)}`
+      // 有正文关键词时显示命中的消息数
+      const hitBadge = hasBody
+        ? ` ·${s.msgs.reduce((n, m) => n + (anyMatch(m.text, rt[m.role]) ? 1 : 0), 0)}`
         : "";
       const l1 = `${sel ? "›" : " "} ${time} ${cwdTail}${hitBadge}`;
-      // 第二行：有关键词时显示命中片段，否则显示首条消息
-      const snip = snippet(s.msgs, kws, lw);
+      // 第二行：有正文关键词时显示命中片段，否则显示首条消息
+      const snip = hasBody ? snippet(s.msgs, rt, lw) : undefined;
       const l2 = snip !== undefined
-        ? `  ${highlight(snip, kws, t)}`
+        ? `  ${highlight(snip.text, rt[snip.role], t)}`
         : `  ${s.first}${s.name ? `  [${s.name}]` : ""}`;
       if (sel) {
         rows.push(t.bg("selectedBg", padEndVisible(t.fg("accent", truncateToWidth(l1, lw)), lw)));
@@ -361,7 +359,8 @@ export class PeekComponent implements Component, Focusable {
     );
     lines.push("");
 
-    const { kws } = this.query();
+    const rt = roleTerms(this.query().terms);
+    const hasBody = rt.user.length > 0 || rt.assistant.length > 0;
     const MAX_MSGS = 500;
     const truncated = s.msgs.length > MAX_MSGS;
     const msgs = truncated ? s.msgs.slice(-MAX_MSGS) : s.msgs;
@@ -369,8 +368,8 @@ export class PeekComponent implements Component, Focusable {
       lines.push(t.fg("dim", msg("truncated", { n: MAX_MSGS })));
       lines.push("");
     }
-    if (kws.length && !msgs.some((m) => anyKw(m.text.toLowerCase(), kws))) {
-      const inTruncated = truncated && s.msgs.some((m) => anyKw(m.text.toLowerCase(), kws));
+    if (hasBody && !msgs.some((m) => anyMatch(m.text, rt[m.role]))) {
+      const inTruncated = truncated && s.msgs.some((m) => anyMatch(m.text, rt[m.role]));
       lines.push(
         t.fg(
           "warning",
@@ -387,7 +386,8 @@ export class PeekComponent implements Component, Focusable {
     };
 
     for (const m of msgs) {
-      const isMatch = kws.length > 0 && anyKw(m.text.toLowerCase(), kws);
+      const terms = rt[m.role]; // user: 的词只在用户消息里高亮，ai: 的只在 AI 回复里
+      const isMatch = terms.length > 0 && anyMatch(m.text, terms);
       const head = lines.length;
       if (m.role === "user") {
         lines.push(
@@ -399,8 +399,8 @@ export class PeekComponent implements Component, Focusable {
       // 先渲染再高亮：往 markdown 源码里插转义码会把链接、代码块的语法弄坏
       const before = this.matchLines.length;
       for (const l of this.renderMsg(m, rw)) {
-        if (isMatch && lineHasKw(l, kws)) this.matchLines.push(lines.length);
-        lines.push(isMatch ? highlight(l, kws, t) : l);
+        if (isMatch && lineHasMatch(l, terms)) this.matchLines.push(lines.length);
+        lines.push(isMatch ? highlight(l, terms, t) : l);
       }
       // 关键词被折行拆开时哪一行都找不到，退回到消息标题行，别把这条消息漏掉
       if (isMatch && this.matchLines.length === before) this.matchLines.push(head);

package/src/query.ts

@@ -1,63 +1,165 @@
 import { msg, type MsgKey } from "./i18n.ts";
 import type { PeekMsg, PeekSession } from "./sessions.ts";
 
-// 搜索框语法：空格分隔多个词，都要命中；@7d / @24h / @2w / @1m 限定最近活动时间
+// 搜索框语法。空白分隔多个词，全部满足才算（AND）。每个词可以是：
+//   foo            子串，大小写不敏感
+//   "foo bar"      短语，引号里的一段空白匹配正文里任意一段空白（含换行）
+//   a|b            任一命中（OR）；要搜字面的 | 就加引号
+//   /re/           正则（JS 语法，自动带 i 和 m 标志，不能含空白，用 \s 代替）；写错了按普通文字搜
+//   -foo           排除：命中的会话不显示。--foo 还是普通词，要搜以 - 开头的词就加引号
+//   name:foo       只在会话名里找；cwd: / dir: 只看工作目录；user: / ai:（assistant:）只看对应角色的消息
+//   @7d            只看最近 7 天活动过的会话，单位 h / d / w / m
+// 前缀可以叠：-user:"foo bar"。引号是万能转义："-foo"、"a|b"、"name:x"、"/x/" 都按字面搜
+
+export type Field = "any" | "name" | "cwd" | "user" | "assistant";
+
+export interface Term {
+  re: RegExp; // 带 g 和 i，直接在原文上匹配（不再把正文转小写：个别字符小写后长度会变，高亮位置就对不上）；用之前先把 lastIndex 归零
+  negate: boolean;
+  field: Field;
+}
 
 export interface ParsedQuery {
-  kws: string[];
+  terms: Term[];
   since: number; // 毫秒时间戳，0 表示不限
   sinceLabel: string;
 }
 
 const TIME_UNIT_MS: Record<string, number> = { h: 3600e3, d: 86400e3, w: 7 * 86400e3, m: 30 * 86400e3 };
 const TIME_UNIT_LABEL: Record<string, MsgKey> = { h: "unitH", d: "unitD", w: "unitW", m: "unitM" };
+const FIELD_ALIAS: Record<string, Field> = { name: "name", cwd: "cwd", dir: "cwd", user: "user", ai: "assistant", assistant: "assistant" };
+
+// 按空白切分；带引号的词（前面可以有 - 和 name: 之类的前缀）里的空白不切，引号不闭合就一直到结尾。
+// 引号只在词首算，foo"bar 是普通词
+const TOKEN_RE = /-?(?:(?:name|cwd|dir|user|ai|assistant):)?"[^"]*"?|\S+/gi;
+const FIELD_RE = /^(name|cwd|dir|user|ai|assistant):/i;
+
+const escapeRe = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+// 单个词 → Term；空词（只剩前缀、空引号）返回 undefined。单个 - 是普通词
+function parseTerm(raw: string): Term | undefined {
+  let s = raw;
+  let negate = false;
+  if (s.length > 1 && s[0] === "-" && s[1] !== "-") {
+    negate = true;
+    s = s.slice(1);
+  }
+  let field: Field = "any";
+  const f = FIELD_RE.exec(s);
+  if (f) {
+    field = FIELD_ALIAS[f[1].toLowerCase()];
+    s = s.slice(f[0].length);
+  }
+  let re: RegExp;
+  if (s.startsWith('"')) {
+    const body = (s.length > 1 && s.endsWith('"') ? s.slice(1, -1) : s.slice(1)).trim();
+    if (!body) return undefined;
+    re = new RegExp(escapeRe(body.toLowerCase()).replace(/\s+/g, "\\s+"), "gi");
+  } else if (s.length >= 3 && s.startsWith("/") && s.endsWith("/")) {
+    try {
+      re = new RegExp(s.slice(1, -1), "gim");
+    } catch {
+      re = new RegExp(escapeRe(s.toLowerCase()), "gi");
+    }
+  } else {
+    // 长的放前面：a|ab 在同一位置时高亮取长的那个，和多个词的行为一致
+    const parts = s.toLowerCase().split("|").filter(Boolean).sort((a, b) => b.length - a.length);
+    if (!parts.length) return undefined;
+    re = new RegExp(parts.map(escapeRe).join("|"), "gi");
+  }
+  return { re, negate, field };
+}
 
-// "foo bar @7d" → kws = [foo, bar]，since = 7 天前
+// "foo bar @7d" → terms = [foo, bar]，since = 7 天前
 export function parseQuery(q: string): ParsedQuery {
-  const kws: string[] = [];
+  const terms: Term[] = [];
+  const seen = new Set<string>();
   let since = 0;
   let sinceLabel = "";
-  for (const tok of q.toLowerCase().split(/\s+/)) {
-    if (!tok) continue;
-    const m = /^@(\d+)([hdwm])$/.exec(tok);
+  for (const tok of q.match(TOKEN_RE) ?? []) {
+    const m = /^@(\d+)([hdwm])$/i.exec(tok);
     if (m) {
       const n = Number(m[1]);
+      const unit = m[2].toLowerCase();
       if (n > 0) {
-        since = Date.now() - n * TIME_UNIT_MS[m[2]];
-        sinceLabel = msg("since", { n, unit: msg(TIME_UNIT_LABEL[m[2]]) });
+        since = Date.now() - n * TIME_UNIT_MS[unit];
+        sinceLabel = msg("since", { n, unit: msg(TIME_UNIT_LABEL[unit]) });
       }
       continue;
     }
-    if (!kws.includes(tok)) kws.push(tok);
+    const t = parseTerm(tok);
+    if (!t) continue;
+    const key = `${t.negate ? "-" : "+"}${t.field}:${t.re.source}`; // 同一个词打两遍只算一次（普通词已转小写，正则原样）
+    if (seen.has(key)) continue;
+    seen.add(key);
+    terms.push(t);
   }
-  return { kws, since, sinceLabel };
+  return { terms, since, sinceLabel };
 }
 
-// 关键词转成不区分大小写的正则，列表过滤用。正文不预存小写副本，直接在原文上匹配
-export function kwRegExps(kws: string[]): RegExp[] {
-  return kws.map((k) => new RegExp(k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i"));
+// 从 from 起找第一个非空命中。g 标志的正则复用前要设 lastIndex，否则从上次命中的位置接着找；
+// 空匹配（如 /a*/ 对上空串）跳过：既不算命中，也免得高亮循环原地打转
+function execFrom(re: RegExp, s: string, from: number): RegExpExecArray | null {
+  re.lastIndex = from;
+  let m = re.exec(s);
+  while (m && !m[0].length) {
+    if (m.index >= s.length) return null;
+    re.lastIndex = m.index + 1;
+    m = re.exec(s);
+  }
+  return m;
 }
 
-// 每个关键词都要在会话名、cwd 或某条消息里出现
-export function matchesSession(s: PeekSession, res: RegExp[]): boolean {
-  return res.every((re) => re.test(s.name) || re.test(s.cwd) || s.msgs.some((m) => re.test(m.text)));
+function hit(re: RegExp, s: string): boolean {
+  return execFrom(re, s, 0) !== null;
 }
 
-// 单条消息用：命中任意一个关键词就算
-export function anyKw(lower: string, kws: string[]): boolean {
-  for (const k of kws) if (lower.includes(k)) return true;
-  return false;
+function termHits(s: PeekSession, t: Term): boolean {
+  switch (t.field) {
+    case "name":
+      return hit(t.re, s.name);
+    case "cwd":
+      return hit(t.re, s.cwd);
+    case "user":
+    case "assistant":
+      return s.msgs.some((m) => m.role === t.field && hit(t.re, m.text));
+    default:
+      return hit(t.re, s.name) || hit(t.re, s.cwd) || s.msgs.some((m) => hit(t.re, m.text));
+  }
+}
+
+// 每个词都要满足：普通词在会话名、cwd 或某条消息里出现，排除词则哪里都不出现；带前缀的只看对应的地方。
+// 正文不预存小写副本，直接在原文上用不区分大小写的正则匹配
+export function matchesSession(s: PeekSession, terms: Term[]): boolean {
+  return terms.every((t) => termHits(s, t) !== t.negate);
 }
 
-// 最早出现的关键词；同一位置取最长的那个
-function nextMatch(lower: string, kws: string[], i: number): [number, number] {
+// 单段文字用：命中任意一个词就算
+export function anyMatch(text: string, terms: Term[]): boolean {
+  return terms.some((t) => hit(t.re, text));
+}
+
+export interface RoleTerms {
+  user: Term[];
+  assistant: Term[];
+}
+
+// 正文里要高亮、计命中的词，按消息角色分开：排除词不算，name: / cwd: 不算，user: / ai: 只给对应角色
+export function roleTerms(terms: Term[]): RoleTerms {
+  const pick = (role: PeekMsg["role"]) => terms.filter((t) => !t.negate && (t.field === "any" || t.field === role));
+  return { user: pick("user"), assistant: pick("assistant") };
+}
+
+// 从 from 起最早的命中 [位置, 长度]；同一位置取最长的
+function nextMatch(text: string, terms: Term[], from: number): [number, number] {
   let best = -1;
   let len = 0;
-  for (const k of kws) {
-    const j = lower.indexOf(k, i);
-    if (j !== -1 && (best === -1 || j < best || (j === best && k.length > len))) {
-      best = j;
-      len = k.length;
+  for (const t of terms) {
+    const m = execFrom(t.re, text, from);
+    if (!m) continue;
+    if (best === -1 || m.index < best || (m.index === best && m[0].length > len)) {
+      best = m.index;
+      len = m[0].length;
     }
   }
   return [best, len];
@@ -106,17 +208,17 @@ function applySgr(st: Sgr, seq: string): void {
   }
 }
 
-// 渲染后的一行（可带 ANSI）里有没有关键词，预览按行记命中用
-export function lineHasKw(line: string, kws: string[]): boolean {
-  return kws.length > 0 && anyKw(line.replace(ESC_RE, "").toLowerCase(), kws);
+// 渲染后的一行（可带 ANSI）里有没有命中，预览按行记命中用
+export function lineHasMatch(line: string, terms: Term[]): boolean {
+  return terms.length > 0 && anyMatch(line.replace(ESC_RE, ""), terms);
 }
 
-// 在一行文字里高亮关键词，返回带 ANSI 的字符串。
+// 在一行文字里高亮命中，返回带 ANSI 的字符串。
 // 输入可以是已经渲染过、带样式的行：转义序列不参与匹配也不会被切断；高亮结束时把原来的
 // 前景色 / 粗体 / 下划线恢复回去，所以放在标题、链接等样式里面也不会把后面的文字弄丢样式。
 // 不用主题自带的 searchMatchBg：dark/light 主题里它和 selectedBg 同色，看不出来
-export function highlight(line: string, kws: string[], theme: any): string {
-  if (!kws.length || !line) return line;
+export function highlight(line: string, terms: Term[], theme: any): string {
+  if (!terms.length || !line) return line;
 
   // 拆成可见文本和转义序列两类片段
   const segs: { text: string; esc: boolean }[] = [];
@@ -130,12 +232,10 @@ export function highlight(line: string, kws: string[], theme: any): string {
 
   let visible = "";
   for (const s of segs) if (!s.esc) visible += s.text;
-  const lower = visible.toLowerCase();
-  if (lower.length !== visible.length) return line; // 个别字符小写后长度会变，位置对不上就不高亮
 
   const ranges: [number, number][] = [];
   for (let i = 0; ; ) {
-    const [j, len] = nextMatch(lower, kws, i);
+    const [j, len] = nextMatch(visible, terms, i);
     if (j === -1) break;
     ranges.push([j, j + len]);
     i = j + len;
@@ -188,15 +288,22 @@ export function highlight(line: string, kws: string[], theme: any): string {
   return out;
 }
 
+export interface Snippet {
+  text: string;
+  role: PeekMsg["role"]; // 片段来自哪个角色的消息，高亮时用该角色的词
+}
+
 // 左栏用：第一个命中处前后截一段。没有消息命中时返回 undefined，调用方退回首条消息
-export function snippet(msgs: PeekMsg[], kws: string[], width: number): string | undefined {
-  if (!kws.length) return undefined;
+export function snippet(msgs: PeekMsg[], rt: RoleTerms, width: number): Snippet | undefined {
   for (const m of msgs) {
-    const flat = m.text.replace(/\s+/g, " ");
-    const [j] = nextMatch(flat.toLowerCase(), kws, 0);
+    const terms = rt[m.role];
+    if (!terms.length) continue;
+    // 在原文上找命中，正则的 ^ / $ 才能和列表过滤时对得上；截出来的那段再把换行和连续空白压成一个空格
+    const [j] = nextMatch(m.text, terms, 0);
     if (j === -1) continue;
     const start = Math.max(0, j - Math.floor(width / 3));
-    return (start > 0 ? "…" : "") + flat.slice(start, start + width);
+    const flat = m.text.slice(start, j + width).replace(/\s+/g, " ");
+    return { text: (start > 0 ? "…" : "") + flat.slice(0, width), role: m.role };
   }
   return undefined;
 }