pi-lazy-panel 0.1.0

package/src/data/search.ts

@@ -0,0 +1,183 @@
+/**
+ * Search query parsing and matching.
+ *
+ * Supports GitHub-style qualifiers in addition to free text:
+ *   name:FilmRecall  model:opus  path:FilmRecall  tag:scan  role:user
+ *   after:2026-09-01  before:2026-09-20
+ *
+ * Pure functions only — no I/O, no UI.
+ *
+ * Free text only looks at what identifies a row — its name / title / label —
+ * so a bare word never matches invisible or repetitive fields (the home
+ * directory, the model id, the role); those need their qualifier. Every
+ * free-text token (case-insensitive) must appear, the qualifiers narrow
+ * further, and a qualifier a pane has no field for is ignored:
+ *   - tree rows (`matchTreeRow`, the tree pane and the tree dialog): tokens in
+ *     `label + text`; `tag:` narrows to labels, `role:` to the role,
+ *     `after:` / `before:` to the entry time; `name:` / `model:` / `path:`
+ *     are ignored
+ *   - session rows (`matchSessionRow`, the sessions pane): tokens in
+ *     `name + preview` (what the row's title shows); `name:` narrows to the
+ *     name, `model:` / `path:` are the only way to match the model and the
+ *     working directory (`path:` accepts the full cwd or its `~` form),
+ *     `after:` / `before:` bound the last update; `tag:` / `role:` are ignored
+ *   - content lines (`matchesTokens` on the rendered line): tokens only, no
+ *     qualifier applies
+ * `findMatchRanges` locates the tokens in a piece of text so the panes can
+ * highlight them.
+ *
+ * 三个面板和树对话框共用这里的解析 / 匹配；对话框只用 parseSearchQuery + matchTreeRow。
+ * 普通词只搜 名称 / 标题 / label；模型、路径、角色、时间都要加限定词。
+ */
+
+import type { SearchQuery, SessionRow, TreeRow } from "../types.ts";
+import { shortenPath } from "../utils/format.ts";
+
+/** Qualifiers `parseSearchQuery` understands, in `key:value` form. */
+const QUALIFIERS = new Set(["name", "model", "path", "tag", "role", "after", "before"]);
+
+/**
+ * Parse raw input typed after `/` into a structured query: whitespace-separated
+ * tokens, `key:value` for a known qualifier (the last one wins), everything
+ * else joined back into `text`. An unparsable date is kept as text.
+ */
+export function parseSearchQuery(raw: string): SearchQuery {
+	const query: SearchQuery = { text: "" };
+	const words: string[] = [];
+	for (const token of raw.trim().split(/\s+/).filter(Boolean)) {
+		const colon = token.indexOf(":");
+		const key = colon > 0 ? token.slice(0, colon).toLowerCase() : "";
+		const value = colon > 0 ? token.slice(colon + 1) : "";
+		if (!QUALIFIERS.has(key) || !value) {
+			words.push(token);
+			continue;
+		}
+		if (key === "after" || key === "before") {
+			const date = parseDate(value);
+			if (!date) {
+				words.push(token);
+				continue;
+			}
+			query[key] = date;
+			continue;
+		}
+		query[key as "name" | "model" | "path" | "tag" | "role"] = value;
+	}
+	query.text = words.join(" ");
+	return query;
+}
+
+/** `2026-09-01` → local midnight of that day; anything `Date` cannot parse → undefined. */
+function parseDate(value: string): Date | undefined {
+	const m = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(value);
+	const date = m ? new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3])) : new Date(value);
+	return Number.isNaN(date.getTime()) ? undefined : date;
+}
+
+/** Free-text tokens of a query, lower-cased (empty when the query has no text). */
+export function searchTokens(query: SearchQuery): string[] {
+	return query.text.toLowerCase().split(/\s+/).filter(Boolean);
+}
+
+/** Does `text` contain every token (case-insensitive)? An empty token list matches anything. */
+export function matchesTokens(text: string, tokens: string[]): boolean {
+	if (tokens.length === 0) return true;
+	const haystack = text.toLowerCase();
+	return tokens.every((t) => haystack.includes(t));
+}
+
+/** Does `value` contain `needle`, case-insensitively? A missing value never does. */
+function containsCI(value: string | undefined, needle: string): boolean {
+	return (value ?? "").toLowerCase().includes(needle.toLowerCase());
+}
+
+/**
+ * Does a session row satisfy the query? Free text: every token is contained in
+ * `name preview` — the text the row's title is made of. The model and the
+ * working directory are deliberately left out: a bare word would otherwise
+ * match a fragment of the home directory (`he` in `/home/cheng`) or of the
+ * model id (`us` in `opus`) on every session, invisibly. `model:` / `path:`
+ * reach those fields on purpose (`path:` matches the full cwd or its `~` form),
+ * `name:` needs the name to contain the value, `after:` / `before:` bound the
+ * last update. `tag:` only means something for tree rows and is ignored.
+ *
+ * SESSIONS 面板的匹配：普通词只看 名称 + 首条消息预览（标题那一行的内容）；
+ * 模型和路径只通过 model: / path: 匹配，避免家目录、模型名里的碎片让所有会话都命中。
+ */
+export function matchSessionRow(row: SessionRow, query: SearchQuery): boolean {
+	if (query.name !== undefined && !containsCI(row.name, query.name)) return false;
+	if (query.model !== undefined && !containsCI(row.model, query.model)) return false;
+	if (query.path !== undefined && !containsCI(row.cwd, query.path) && !containsCI(shortenPath(row.cwd), query.path)) return false;
+	if (query.after !== undefined && row.updatedAt < query.after.getTime()) return false;
+	if (query.before !== undefined && row.updatedAt >= query.before.getTime()) return false;
+	return matchesTokens(`${row.name ?? ""} ${row.preview}`, searchTokens(query));
+}
+
+/**
+ * Does a tree row satisfy the query? Free text: every token is contained in
+ * `label text`; `tag:` needs a label containing it, `role:` a role containing
+ * it (`user`, `assistant`, `system`, `tool`); `after:` / `before:` bound the
+ * entry time. Session-only qualifiers are ignored. Unlike pi's /tree, the role
+ * is not part of the free-text haystack (`us` would hit every user row).
+ *
+ * TREE 的匹配：普通词只看 label + 正文；角色要用 role:，标签可用 tag: 单独限定。
+ */
+export function matchTreeRow(row: TreeRow, query: SearchQuery): boolean {
+	if (query.tag !== undefined && !containsCI(row.label, query.tag)) return false;
+	if (query.role !== undefined && !containsCI(row.role, query.role)) return false;
+	if (query.after !== undefined && row.timestamp < query.after.getTime()) return false;
+	if (query.before !== undefined && row.timestamp >= query.before.getTime()) return false;
+	return matchesTokens(`${row.label ?? ""} ${row.text}`, searchTokens(query));
+}
+
+/**
+ * Everything worth highlighting on a matching row: the free-text tokens plus the
+ * values of the text qualifiers (`name:` / `model:` / `path:` / `tag:` /
+ * `role:`), so a `model:opus` hit lights up "opus" in the row. Dates have no
+ * text to mark.
+ */
+export function highlightTerms(query: SearchQuery): string[] {
+	const out = searchTokens(query);
+	for (const value of [query.name, query.model, query.path, query.tag, query.role]) {
+		if (value) out.push(value);
+	}
+	return out;
+}
+
+/** A half-open range of code units inside a string (`start` inclusive, `end` exclusive). */
+export interface MatchRange {
+	start: number;
+	end: number;
+}
+
+/**
+ * Where the `terms` occur in `text` (case-insensitive, every occurrence),
+ * merged when they overlap or touch and sorted by position, as code-unit
+ * ranges into `text`. Used to highlight matches; empty terms are skipped.
+ *
+ * 命中位置：每个词在文本里的所有出现（不区分大小写），重叠 / 相邻的段合并，按位置排序。
+ */
+export function findMatchRanges(text: string, terms: string[]): MatchRange[] {
+	const found: MatchRange[] = [];
+	for (const term of terms) {
+		if (!term) continue;
+		// 用正则的 i / u 标志做大小写无关匹配，位置直接落在原文上，不会被 toLowerCase 改变长度的字符带偏。
+		const re = new RegExp(escapeRegExp(term), "giu");
+		for (const m of text.matchAll(re)) {
+			if (m[0].length === 0) break;
+			found.push({ start: m.index, end: m.index + m[0].length });
+		}
+	}
+	found.sort((a, b) => a.start - b.start || a.end - b.end);
+	const out: MatchRange[] = [];
+	for (const r of found) {
+		const last = out[out.length - 1];
+		if (last && r.start <= last.end) last.end = Math.max(last.end, r.end);
+		else out.push({ ...r });
+	}
+	return out;
+}
+
+function escapeRegExp(text: string): string {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/src/data/sessions.ts

@@ -0,0 +1,148 @@
+/**
+ * Sessions data adapter.
+ *
+ * Read-only bridge between pi's `SessionManager.list()` / `listAll()` and the
+ * `SessionRow` shape used by the sessions pane. No UI code here.
+ */
+
+import { resolve } from "node:path";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import type { ListScope, SessionRow, SessionSortMode } from "../types.ts";
+import { singleLine } from "../utils/format.ts";
+
+export interface ListSessionsOptions {
+	cwd: string;
+	scope: ListScope;
+}
+
+/** List sessions for the given scope. */
+export async function listSessions(options: ListSessionsOptions): Promise<SessionRow[]> {
+	const infos =
+		options.scope === "all" ? await SessionManager.listAll() : await SessionManager.list(options.cwd);
+
+	return infos.map((info) => {
+		const row: SessionRow = {
+			file: info.path,
+			id: info.id,
+			cwd: info.cwd,
+			preview: singleLine(info.firstMessage),
+			createdAt: info.created.getTime(),
+			updatedAt: info.modified.getTime(),
+			messageCount: info.messageCount,
+		};
+		if (info.name) row.name = info.name;
+		if (info.parentSessionPath) row.parentFile = info.parentSessionPath;
+		const model = readLastModel(info.path);
+		if (model) row.model = model;
+		return row;
+	});
+}
+
+/**
+ * Model id of the last `model_change` entry in the session file, if any.
+ * `SessionInfo` does not carry it, so we do one cheap read of the file.
+ */
+function readLastModel(file: string): string | undefined {
+	try {
+		const manager = SessionManager.open(file);
+		let model: string | undefined;
+		for (const entry of manager.getEntries()) {
+			if (entry.type === "model_change") model = entry.modelId;
+		}
+		return model;
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Index of the row whose file is `sessionFile` (paths compared after `resolve`,
+ * same rule as `isCurrentSession`), or -1. Used to put the cursor on pi's
+ * current session when the panel opens.
+ */
+export function findSessionIndex(rows: SessionRow[], sessionFile: string | undefined): number {
+	if (!sessionFile) return -1;
+	const target = resolve(sessionFile);
+	return rows.findIndex((row) => resolve(row.file) === target);
+}
+
+/**
+ * Return a sorted copy of the rows.
+ *
+ *   recent    last update, newest first (the default)
+ *   created   creation time, newest first
+ *   title     by the title the pane shows (name, else first-message preview), A–Z
+ *             case-insensitive; English (ASCII) before CJK, empty sessions last,
+ *             ties by recency
+ *   threaded  forks indented under their parent (pi's /resume), roots by recency
+ */
+export function sortSessions(rows: SessionRow[], mode: SessionSortMode): SessionRow[] {
+	const byRecent = (a: SessionRow, b: SessionRow) => b.updatedAt - a.updatedAt;
+	switch (mode) {
+		case "recent":
+			return [...rows].sort(byRecent);
+		case "created":
+			return [...rows].sort((a, b) => b.createdAt - a.createdAt || byRecent(a, b));
+		case "title":
+			return [...rows].sort((a, b) => compareTitles(a, b) || byRecent(a, b));
+		case "threaded":
+			return sortThreaded(rows, byRecent);
+	}
+}
+
+/** The title the sessions pane prints for a row: its name, else the first-message preview. */
+export function sessionTitle(row: SessionRow): string {
+	return row.name?.trim() || row.preview.trim();
+}
+
+/**
+ * 按面板上显示的标题比较（所见即所排）：没起名字的会话用首条消息预览参与排序，
+ * 而不是一律排到后面；只有既没名字也没预览的空会话才落到最后。
+ * 英文（ASCII）标题排在中文等非 ASCII 标题之前，组内再各自不分大小写 A–Z，
+ * 避免在中文 locale 下 localeCompare 把中文排到英文前面。
+ */
+function compareTitles(a: SessionRow, b: SessionRow): number {
+	const at = sessionTitle(a);
+	const bt = sessionTitle(b);
+	if (at && bt) return titleGroup(at) - titleGroup(bt) || at.localeCompare(bt, undefined, { sensitivity: "base" });
+	if (at) return -1;
+	if (bt) return 1;
+	return 0;
+}
+
+/** 分组键：首字符是 ASCII（英文/数字/符号）为 0 排前，其余（中文等）为 1 排后。 */
+function titleGroup(title: string): number {
+	return (title.codePointAt(0) ?? 0) < 0x80 ? 0 : 1;
+}
+
+/**
+ * Threaded: roots ordered by recency, each followed (depth-first) by the
+ * sessions forked from it. Rows whose parent is unknown are treated as roots.
+ */
+function sortThreaded(rows: SessionRow[], cmp: (a: SessionRow, b: SessionRow) => number): SessionRow[] {
+	const byFile = new Map(rows.map((r) => [r.file, r]));
+	const children = new Map<string, SessionRow[]>();
+	const roots: SessionRow[] = [];
+	for (const row of rows) {
+		const parent = row.parentFile;
+		if (parent && byFile.has(parent) && parent !== row.file) {
+			const list = children.get(parent) ?? [];
+			list.push(row);
+			children.set(parent, list);
+		} else {
+			roots.push(row);
+		}
+	}
+	const out: SessionRow[] = [];
+	const seen = new Set<string>();
+	const visit = (row: SessionRow, depth: number) => {
+		if (seen.has(row.file)) return;
+		seen.add(row.file);
+		out.push({ ...row, threadDepth: depth });
+		for (const child of (children.get(row.file) ?? []).sort(cmp)) visit(child, depth + 1);
+	};
+	for (const root of roots.sort(cmp)) visit(root, 0);
+	// Defensive: rows in a parent cycle never became reachable from a root.
+	for (const row of [...rows].sort(cmp)) visit(row, 0);
+	return out;
+}

package/src/data/tree-fold.ts

@@ -0,0 +1,163 @@
+/**
+ * Folding and filtering of tree rows (the `z` key of the pane and the tree
+ * dialog, the dialog's search, `⊞` in its guide lines).
+ *
+ * The unit of folding is a branch segment, as in pi's own /tree: a row can be
+ * folded when it starts a segment — its parent has several children, or it is
+ * one of several roots — and it has children of its own. Folding hides every
+ * descendant. Unlike pi, a lone root is not foldable (that would hide the whole
+ * tree), so a linear conversation has nothing to fold and nothing to mark.
+ *
+ * Pure functions over pre-order `TreeRow[]` (parents precede children, see
+ * ./tree.ts); the panel keeps the folded ids in its state, the pane and the
+ * dialog only ever see the rows that survive `applyTreeFold`. `filterTreeRows`
+ * is the generic "drop rows, keep a forest" step behind the tree filters and
+ * the dialog's search.
+ *
+ * 折叠的单位是"分支段"：父节点有多个子节点的那个子节点（或多根时的根）且自己有后代
+ * 才能折叠，折叠后隐藏它的全部后代。默认把不在活动分支上的段都折起来。
+ */
+
+import type { TreeRow } from "../types.ts";
+
+/**
+ * Keep the rows `keep` accepts, re-parenting each survivor to its nearest kept
+ * ancestor (the tree filters and the dialog's search both go through here).
+ * Rows that end up unchanged are returned as-is.
+ *
+ * 过滤掉中间节点后，子节点挂到最近一个保留下来的祖先上，树线才画得出来。
+ */
+export function filterTreeRows(rows: TreeRow[], keep: (row: TreeRow) => boolean): TreeRow[] {
+	// rows 是先序排列的，父节点一定先于子节点出现，所以一遍就能算出新的 parentId。
+	const nearestKept = new Map<string, string | undefined>();
+	const out: TreeRow[] = [];
+	for (const r of rows) {
+		const parent = r.parentId ? nearestKept.get(r.parentId) : undefined;
+		if (!keep(r)) {
+			nearestKept.set(r.entryId, parent);
+			continue;
+		}
+		nearestKept.set(r.entryId, r.entryId);
+		if (parent === r.parentId) out.push(r);
+		else {
+			const { parentId: _dropped, ...rest } = r;
+			out.push(parent ? { ...rest, parentId: parent } : rest);
+		}
+	}
+	return out;
+}
+
+/** Children of every row keyed by parent id (`undefined` = roots), in row order. A parent that is not a row counts as none. */
+export function treeChildren(rows: TreeRow[]): Map<string | undefined, TreeRow[]> {
+	const ids = new Set(rows.map((r) => r.entryId));
+	const children = new Map<string | undefined, TreeRow[]>();
+	for (const r of rows) {
+		const key = r.parentId !== undefined && ids.has(r.parentId) ? r.parentId : undefined;
+		const list = children.get(key);
+		if (list) list.push(r);
+		else children.set(key, [r]);
+	}
+	return children;
+}
+
+/** Rows that start a branch segment: children of a node with several children, or the roots when there are several. */
+export function forkChildIds(rows: TreeRow[], children = treeChildren(rows)): Set<string> {
+	const out = new Set<string>();
+	for (const kids of children.values()) {
+		if (kids.length > 1) for (const k of kids) out.add(k.entryId);
+	}
+	return out;
+}
+
+/** Segment starts that have descendants — the rows `z` can fold. */
+export function foldableIds(rows: TreeRow[]): Set<string> {
+	const children = treeChildren(rows);
+	const out = new Set<string>();
+	for (const id of forkChildIds(rows, children)) {
+		if (children.get(id)?.length) out.add(id);
+	}
+	return out;
+}
+
+/** Fold state a freshly loaded tree opens with: every foldable row off the active branch. */
+export function defaultFolded(rows: TreeRow[]): Set<string> {
+	const foldable = foldableIds(rows);
+	const out = new Set<string>();
+	for (const r of rows) {
+		if (foldable.has(r.entryId) && !r.onActiveBranch) out.add(r.entryId);
+	}
+	return out;
+}
+
+/**
+ * Rows still shown once the descendants of every folded row are hidden. Ids in
+ * `folded` that are not foldable (stale after a reload) are ignored.
+ */
+export function applyTreeFold(rows: TreeRow[], folded: ReadonlySet<string>): TreeRow[] {
+	if (folded.size === 0) return rows;
+	const foldable = foldableIds(rows);
+	const hidden = new Set<string>();
+	const out: TreeRow[] = [];
+	// rows 是先序的：父节点先出现，所以看父节点是否被折叠 / 已隐藏就能一遍算完。
+	for (const r of rows) {
+		const parent = r.parentId;
+		if (parent !== undefined && (hidden.has(parent) || (folded.has(parent) && foldable.has(parent)))) {
+			hidden.add(r.entryId);
+			continue;
+		}
+		out.push(r);
+	}
+	return out;
+}
+
+/**
+ * Row `z` acts on when the cursor is on `entryId`: the row itself when it is
+ * foldable, otherwise the nearest foldable ancestor (the head of the segment
+ * the row is in); `undefined` on the trunk of a single-root tree, where nothing
+ * folds.
+ */
+export function foldTarget(rows: TreeRow[], entryId: string): string | undefined {
+	const foldable = foldableIds(rows);
+	const parents = new Map(rows.map((r) => [r.entryId, r.parentId]));
+	let id: string | undefined = entryId;
+	while (id !== undefined && parents.has(id)) {
+		if (foldable.has(id)) return id;
+		id = parents.get(id);
+	}
+	return undefined;
+}
+
+/**
+ * Index in `rows` of `entryId`, or of its nearest ancestor (walking `tree`,
+ * the full pre-order rows) that is still listed, or the last row when nothing
+ * on its path is (pi's `findNearestVisibleIndex`). Used to keep the dialog
+ * cursor sensible when a search / filter / fold hides the row it was on.
+ */
+export function nearestListedIndex(rows: TreeRow[], tree: TreeRow[], entryId: string | undefined): number {
+	if (rows.length === 0) return 0;
+	const index = new Map(rows.map((r, i) => [r.entryId, i]));
+	const parents = new Map(tree.map((r) => [r.entryId, r.parentId]));
+	let id = entryId;
+	while (id !== undefined) {
+		const i = index.get(id);
+		if (i !== undefined) return i;
+		id = parents.get(id);
+	}
+	return rows.length - 1;
+}
+
+/**
+ * Folded ancestors of `entryId` in `rows` (the full tree): unfolding these
+ * makes the row visible again, e.g. when the tree dialog closes on a row the
+ * pane keeps inside a folded branch.
+ */
+export function foldedAncestors(rows: TreeRow[], entryId: string, folded: ReadonlySet<string>): string[] {
+	const parents = new Map(rows.map((r) => [r.entryId, r.parentId]));
+	const out: string[] = [];
+	let id = parents.get(entryId);
+	while (id !== undefined) {
+		if (folded.has(id)) out.push(id);
+		id = parents.get(id);
+	}
+	return out;
+}