@baique/pi-web-sky 0.1.35 → 0.1.36

package/lib/session-search.ts

@@ -0,0 +1,284 @@
+import { readFileSync } from "fs";
+import { getDb } from "./sqlite-db";
+import type { SessionInfo } from "./types";
+
+// ============================================================================
+// Session full-text search over a SQLite FTS5 (trigram) index.
+//
+// Key properties (verified locally):
+//  - trigram tokenizer matches CJK substrings, unlike unicode61 which treats a
+//    whole CJK run as one token.
+//  - queries shorter than 3 chars never match via MATCH -> LIKE fallback on
+//    the same FTS table, which is index-accelerated for trigram.
+//  - FTS5 MATCH syntax needs special chars escaped -> build a quoted phrase.
+//
+// Text is extracted from the .jsonl directly (lightweight parser, no SDK) so
+// this module stays loadable in plain-node unit tests.
+// ============================================================================
+
+const BODY_CAP = 256 * 1024;
+const TOOL_INPUT_CAP = 500;
+const BASH_OUTPUT_CAP = 4 * 1024;
+const TITLE_CAP = 200;
+
+interface SearchRow {
+  session_id: string;
+  titleMatch: number;
+  snip: string | null;
+}
+
+interface RawEntry {
+  type: string;
+  message?: {
+    role: string;
+    content?: unknown;
+    command?: string;
+    output?: string;
+  };
+  summary?: string;
+}
+
+export interface SearchResult {
+  session: SessionInfo;
+  titleMatch: boolean;
+  snippet: string;
+}
+
+function appendText(parts: string[], text: string, budgetLeft: () => number) {
+  const t = typeof text === "string" ? text.trim() : "";
+  if (!t) return;
+  const room = budgetLeft();
+  parts.push(t.length <= room ? t : t.slice(0, room));
+}
+
+function contentText(content: unknown, omitImages: boolean): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts: string[] = [];
+  for (const block of content) {
+    const b = block as { type?: string; text?: string; thinking?: string; toolCallId?: string; toolName?: string; input?: unknown };
+    if (!b || typeof b !== "object") continue;
+    if (b.type === "text" && typeof b.text === "string") parts.push(b.text);
+    else if (b.type === "thinking" && typeof b.thinking === "string") parts.push(b.thinking);
+    else if (b.type === "toolCall" && typeof b.toolName === "string") {
+      let input = "";
+      try {
+        input = JSON.stringify(b.input ?? {});
+      } catch {
+        input = "";
+      }
+      parts.push(`[tool:${b.toolName}] ${input.slice(0, TOOL_INPUT_CAP)}`);
+    } else if (b.type === "image") {
+      if (!omitImages) parts.push("[image]");
+    }
+  }
+  return parts.join("\n");
+}
+
+/**
+ * Extract searchable title + body from a session's jsonl file. Kept separate
+ * from indexing so tests can exercise extraction without touching the DB.
+ */
+export function extractSessionText(session: SessionInfo): { title: string; body: string } {
+  const title = (session.name || (session.firstMessage || "").slice(0, TITLE_CAP)).slice(0, 400);
+  const parts: string[] = [];
+  let size = 0;
+  const budgetLeft = () => BODY_CAP - size;
+  const push = (text: string) => {
+    if (size >= BODY_CAP) return;
+    const before = parts.length;
+    appendText(parts, text, budgetLeft);
+    size += parts.slice(before).join("\n").length;
+  };
+
+  let entries: RawEntry[] = [];
+  try {
+    entries = parseSessionFile(session.path);
+  } catch {
+    // Unreadable session (deleted mid-scan): index with empty body so it
+    // still appears in title-only search.
+  }
+  for (const entry of entries) {
+    if (entry.type === "message" && entry.message) {
+      const { role, content } = entry.message;
+      if (role === "user") push(contentText(content, false));
+      else if (role === "assistant") push(contentText(content, false));
+      else if (role === "toolResult") {
+        const text = contentText(content, true);
+        // Keep tool errors searchable, drop everything else once big.
+        push(text.length > 600 ? text.slice(0, 600) : text);
+      } else if (role === "bashExecution") {
+        if (typeof entry.message?.command === "string") push(`> ${entry.message.command}`);
+        if (typeof entry.message?.output === "string") push(entry.message.output.slice(0, BASH_OUTPUT_CAP));
+      }
+    } else if (entry.type === "compaction" && typeof entry.summary === "string") {
+      push(entry.summary);
+    } else if (entry.type === "custom_message") {
+      const content = (entry as unknown as { content?: unknown }).content;
+      if (typeof content === "string") push(content);
+    }
+  }
+  return { title, body: parts.join("\n") };
+}
+
+/** Lightweight per-line JSONL parse — only fields the search needs. */
+function parseSessionFile(path: string): RawEntry[] {
+  const text = readFileSync(path, "utf8");
+  const entries: RawEntry[] = [];
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line) as RawEntry;
+      if (entry && typeof entry.type === "string") entries.push(entry);
+    } catch {
+      // Skip malformed lines.
+    }
+  }
+  return entries;
+}
+
+/** Escape a user term into an FTS5 quoted-phrase token. */
+export function fuzzyQueryForTerm(q: string): string {
+  return `"${q.replace(/"/g, '""')}"`;
+}
+
+/**
+ * Bring the index in sync with the (optionally injected) session list:
+ * re-index changed/new sessions by modified-mtime, drop vanished ones.
+ * Returns whether any write happened this round (frontend "indexing" hint).
+ */
+export async function ensureSearchIndex(
+  sessionsOverride?: SessionInfo[],
+): Promise<{ indexing: boolean }> {
+  let sessions = sessionsOverride;
+  if (!sessions) {
+    const { listAllSessions } = await import("./session-reader");
+    sessions = await listAllSessions();
+  }
+  const db = getDb();
+
+  const stateRows = db.prepare("SELECT session_id, mtime FROM search_state").all() as {
+    session_id: string;
+    mtime: string;
+  }[];
+  const state = new Map(stateRows.map((r) => [r.session_id, r.mtime]));
+  const known = new Set<string>();
+  let changed = false;
+
+  const upsertState = db.prepare(
+    "INSERT INTO search_state (session_id, mtime, title) VALUES (?, ?, ?) " +
+      "ON CONFLICT(session_id) DO UPDATE SET mtime = excluded.mtime, title = excluded.title",
+  );
+  const insertFts = db.prepare(
+    "INSERT INTO session_search (session_id, title, body) VALUES (?, ?, ?)",
+  );
+  const deleteFts = db.prepare("DELETE FROM session_search WHERE session_id = ?");
+
+  for (const session of sessions) {
+    known.add(session.id);
+    if (state.get(session.id) === session.modified) continue;
+    const { title, body } = extractSessionText(session);
+    db.exec("BEGIN");
+    try {
+      deleteFts.run(session.id);
+      if (body || title) insertFts.run(session.id, title, body);
+      upsertState.run(session.id, session.modified, title);
+      db.exec("COMMIT");
+    } catch (error) {
+      db.exec("ROLLBACK");
+      throw error;
+    }
+    changed = true;
+  }
+  db.exec("BEGIN");
+  try {
+    for (const sessionId of state.keys()) {
+      if (!known.has(sessionId)) {
+        deleteFts.run(sessionId);
+        db.prepare("DELETE FROM search_state WHERE session_id = ?").run(sessionId);
+        changed = true;
+      }
+    }
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  }
+  return { indexing: changed };
+}
+
+/**
+ * Full-text search over all sessions. Queries of any length; ≥3 chars go
+ * through FTS5 trigram MATCH (CJK substring safe), shorter ones through LIKE.
+ * Results: title hits first, then most recently modified. `sessionsOverride`
+ * injects the session list (tests) instead of loading the real catalogue.
+ */
+export async function searchSessions(
+  q: string,
+  limit = 30,
+  sessionsOverride?: SessionInfo[],
+): Promise<{ indexing: boolean; results: SearchResult[] }> {
+  const query = q.trim();
+  if (!query) return { indexing: false, results: [] };
+  const sessions = sessionsOverride ?? (await loadAllSessions());
+  const indexed = await ensureSearchIndex(sessions);
+
+  const cap = Math.min(Math.max(limit, 1), 50);
+  const db = getDb();
+  const sessionsById = new Map(sessions.map((s) => [s.id, s]));
+
+  let rows: SearchRow[];
+  const titleIds = new Set<string>();
+  // 多关键字：空格分隔，全部命中（AND）。
+  // FTS5 trigram 对 1-2 字符词不可靠：任一词 <3 字符 → 整条退化为 LIKE 逐词 AND。
+  const terms = query.split(/\s+/).filter(Boolean);
+  const allLong = terms.every((term) => term.length >= 3);
+  if (allLong) {
+    // 每个词一个 FTS 短语，AND 组合（各词均为子串命中）
+    const phrase = terms.map(fuzzyQueryForTerm).join(" AND ");
+    rows = db
+      .prepare(
+        "SELECT session_id, ifnull(snippet(session_search, 2, '[', ']', '…', 12), '') AS snip " +
+          "FROM session_search WHERE session_search MATCH ? LIMIT ?",
+      )
+      .all(phrase, cap) as unknown as SearchRow[];
+    for (const r of db.prepare("SELECT session_id FROM session_search WHERE title MATCH ?").all(phrase) as { session_id: string }[]) {
+      titleIds.add(r.session_id);
+    }
+  } else {
+    // LIKE 逐词 AND：每个词 (title LIKE ? OR body LIKE ?)，组合成 AND
+    const where = terms.map(() => "(title LIKE ? OR body LIKE ?)").join(" AND ");
+    const params = terms.flatMap((term) => [`%${term}%`, `%${term}%`]);
+    rows = db
+      .prepare(`SELECT session_id, '' AS snip FROM session_search WHERE ${where} LIMIT ?`)
+      .all(...params, cap) as unknown as SearchRow[];
+    const titleWhere = terms.map(() => "title LIKE ?").join(" AND ");
+    const titleParams = terms.map((term) => `%${term}%`);
+    for (const r of db.prepare(`SELECT session_id FROM session_search WHERE ${titleWhere}`).all(...titleParams) as { session_id: string }[]) {
+      titleIds.add(r.session_id);
+    }
+  }
+
+  // Title hits first, then most recently modified.
+  const results: SearchResult[] = [];
+  for (const row of rows) {
+    const session = sessionsById.get(row.session_id);
+    if (!session) continue;
+    results.push({
+      session,
+      titleMatch: titleIds.has(row.session_id),
+      snippet: row.snip ?? "",
+    });
+  }
+  results.sort(
+    (a, b) =>
+      Number(b.titleMatch) - Number(a.titleMatch)
+      || b.session.modified.localeCompare(a.session.modified),
+  );
+  return { indexing: indexed.indexing, results };
+}
+
+async function loadAllSessions(): Promise<SessionInfo[]> {
+  const { listAllSessions } = await import("./session-reader");
+  return listAllSessions();
+}

package/lib/session-stats.ts

@@ -0,0 +1,26 @@
+import type { SessionStatsInfo } from "@/lib/pi-types";
+
+/**
+ * 会话统计行：in | out | cache read | cache write | cost | context。
+ * 普通会话顶栏 Session info 按钮 tooltip 与看板统计弹层第一行共用同一格式，避免双实现。
+ */
+export function formatSessionStatsLine(
+  stats: SessionStatsInfo | null,
+  contextUsage: { percent: number | null; contextWindow: number; tokens: number | null } | null,
+  locale?: string,
+): string {
+  if (!stats) return "";
+  const tokens = stats.tokens;
+  const cost = stats.cost ?? 0;
+  const parts: string[] = [];
+  parts.push(`in: ${tokens.input.toLocaleString(locale)}`);
+  parts.push(`out: ${tokens.output.toLocaleString(locale)}`);
+  parts.push(`cache read: ${tokens.cacheRead.toLocaleString(locale)}`);
+  parts.push(`cache write: ${tokens.cacheWrite.toLocaleString(locale)}`);
+  if (cost > 0) parts.push(`cost: $${cost.toFixed(4)}`);
+  if (contextUsage?.contextWindow) {
+    const percent = contextUsage.percent;
+    parts.push(`context: ${percent !== null ? percent.toFixed(1) + "%" : "unknown"} of ${contextUsage.contextWindow.toLocaleString(locale)} tokens`);
+  }
+  return parts.join("  |  ");
+}

package/lib/session-timing.test.mjs

@@ -0,0 +1,107 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, { tsconfigPaths: true });
+const { computeSessionTotalActiveMs } = await jiti.import("./session-timing.ts");
+
+const base = Date.parse("2026-01-01T00:00:00.000Z");
+const timestamp = (ms) => new Date(base + ms).toISOString();
+let nextId = 0;
+
+function entry(type, ms, extra = {}) {
+  return {
+    type,
+    id: String(++nextId),
+    parentId: null,
+    timestamp: timestamp(ms),
+    ...extra,
+  };
+}
+function message(role, ms, extra = {}) {
+  return entry("message", ms, { ...extra, message: { role, content: [] } });
+}
+
+test("empty or single-entry session yields zero", () => {
+  assert.equal(computeSessionTotalActiveMs([]), 0);
+  assert.equal(computeSessionTotalActiveMs([message("user", 1000)]), 0);
+});
+
+test("counts active gaps within a turn", () => {
+  const entries = [
+    message("user", 1000),
+    message("assistant", 4000),
+    message("toolResult", 7000),
+    message("assistant", 9000),
+  ];
+  assert.equal(computeSessionTotalActiveMs(entries), 8000);
+});
+
+test("drops human idle before the next user message", () => {
+  const entries = [
+    message("user", 0),
+    message("assistant", 3000),
+    message("user", 20000),
+    message("assistant", 23000),
+  ];
+  assert.equal(computeSessionTotalActiveMs(entries), 6000);
+});
+
+test("keeps compacted history and compaction time in append order", () => {
+  const entries = [
+    message("user", 0),
+    message("assistant", 3000),
+    message("user", 20000),
+    message("assistant", 25000),
+    entry("compaction", 27000),
+    message("assistant", 30000),
+  ];
+  assert.equal(computeSessionTotalActiveMs(entries), 13000);
+});
+
+test("counts work appended on every branch exactly once", () => {
+  const root = message("user", 0);
+  const shared = message("assistant", 2000, { parentId: root.id });
+  const branchAUser = message("user", 10000, { parentId: shared.id });
+  const branchAResult = message("assistant", 13000, { parentId: branchAUser.id });
+  const branchBUser = message("user", 20000, { parentId: shared.id });
+  const branchBResult = message("assistant", 24000, { parentId: branchBUser.id });
+  const entries = [root, shared, branchAUser, branchAResult, branchBUser, branchBResult];
+  assert.equal(computeSessionTotalActiveMs(entries), 9000);
+});
+
+test("treats user-initiated bash as a boundary", () => {
+  const entries = [
+    message("user", 0),
+    message("assistant", 2000),
+    message("bashExecution", 100000),
+    message("user", 110000),
+    message("assistant", 113000),
+  ];
+  assert.equal(computeSessionTotalActiveMs(entries), 5000);
+});
+
+test("ignores metadata without breaking the active interval", () => {
+  const entries = [
+    message("user", 0),
+    entry("model_change", 1000),
+    message("assistant", 4000),
+  ];
+  assert.equal(computeSessionTotalActiveMs(entries), 4000);
+});
+
+test("counts branch summaries and custom messages", () => {
+  const entries = [
+    message("user", 0),
+    entry("branch_summary", 2000),
+    entry("custom_message", 3000),
+    message("assistant", 5000),
+  ];
+  assert.equal(computeSessionTotalActiveMs(entries), 5000);
+});
+
+test("skips invalid timestamps and ignores negative gaps", () => {
+  const invalid = { ...message("assistant", 2000), timestamp: "invalid" };
+  const entries = [message("user", 5000), invalid, message("assistant", 3000)];
+  assert.equal(computeSessionTotalActiveMs(entries), 0);
+});

package/lib/session-timing.ts

@@ -0,0 +1,45 @@
+interface TimingEntry {
+  type: string;
+  timestamp: string;
+  message?: { role?: string };
+}
+
+/**
+ * Estimate active wall-clock time from the append-only session log.
+ *
+ * Raw entries preserve compacted history and every executed branch exactly
+ * once. Gaps ending at user messages are treated as human idle. User-initiated
+ * bash entries are also boundaries because the log records only their finish
+ * time, so counting the incoming gap could include arbitrary human idle.
+ */
+export function computeSessionTotalActiveMs(entries: readonly TimingEntry[]): number {
+  let totalActiveMs = 0;
+  let previousTimestamp: number | undefined;
+
+  for (const entry of entries) {
+    if (!isTimingEntry(entry.type)) continue;
+
+    const timestamp = Date.parse(entry.timestamp);
+    if (!Number.isFinite(timestamp)) continue;
+
+    const role = entry.type === "message" ? entry.message?.role : undefined;
+    if (role === "user" || role === "bashExecution") {
+      previousTimestamp = timestamp;
+      continue;
+    }
+
+    if (previousTimestamp !== undefined && timestamp > previousTimestamp) {
+      totalActiveMs += timestamp - previousTimestamp;
+    }
+    previousTimestamp = timestamp;
+  }
+
+  return totalActiveMs;
+}
+
+function isTimingEntry(type: string): boolean {
+  return type === "message"
+    || type === "compaction"
+    || type === "branch_summary"
+    || type === "custom_message";
+}