opencode-history-search-v2 1.0.0

package/src/search/multiterm-sql.ts

@@ -0,0 +1,170 @@
+import { getDbPath, projectFilterParts, type ProjectFilter } from "../storage-sqlite";
+
+export interface MultitermSqlOptions {
+  limit: number;
+}
+
+export interface MultitermSqlResult {
+  sql: string;
+  binds: any[];
+}
+
+export interface MultitermSearchMatch {
+  sessionID: string;
+  sessionTitle: string;
+  timestamp: number;
+  projectDirectory: string;
+  termHits: Map<string, { partID: string; matchType: string; excerpt: string }>;
+}
+
+/**
+ * Multi-term AND search over OpenCode V2 history.
+ *
+ * V2 schema: sessions in `session_v2`, message content (including tool calls
+ * and file paths) embedded in `session_message.data`.
+ */
+
+export function buildMultitermSql(
+  terms: string[],
+  projectID: ProjectFilter,
+  options: MultitermSqlOptions,
+): MultitermSqlResult {
+  if (terms.length === 0) {
+    throw new Error("terms array must contain at least one term");
+  }
+
+  const conditions = terms
+    .map(
+      (_, i) =>
+        `MAX(CASE WHEN m.data LIKE ? ESCAPE '\\' OR s.title LIKE ? ESCAPE '\\' THEN 1 ELSE 0 END) AS match_${i}`,
+    )
+    .join(", ");
+
+  const having = terms
+    .map((_, i) => `match_${i} = 1`)
+    .join(" AND ");
+
+  const { clause, binds: projectBinds } = projectFilterParts(projectID);
+
+  const sql = `
+    SELECT s.id AS session_id, s.title, s.directory, s.time_updated, ${conditions}
+    FROM session_v2 s
+    JOIN session_message m ON m.session_id = s.id
+    WHERE 1=1
+      ${clause}
+    GROUP BY s.id
+    HAVING ${having}
+    ORDER BY s.time_updated DESC
+    LIMIT ${options.limit}
+  `.trim();
+
+  const binds: any[] = [];
+  for (const term of terms) {
+    const escaped = term.replace(/[%_\\]/g, "\\$&");
+    binds.push(`%${escaped}%`);
+    binds.push(`%${escaped}%`);
+  }
+  binds.push(...projectBinds);
+
+  return { sql, binds };
+}
+
+export async function searchMultiterm(
+  projectID: ProjectFilter,
+  terms: string[],
+  options?: { limit?: number },
+): Promise<MultitermSearchMatch[]> {
+  const { Database } = await import("bun:sqlite");
+  const dbPath = getDbPath();
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    const { sql, binds } = buildMultitermSql(terms, projectID, {
+      limit: options?.limit ?? 50,
+    });
+
+    type Row = {
+      session_id: string;
+      title: string | null;
+      directory: string;
+      time_updated: number;
+    };
+
+    const rows = db.query(sql).all(...binds) as Row[];
+
+    if (rows.length === 0) {
+      return [];
+    }
+
+    // Phase 2: load the matched sessions' messages once and locate a
+    // per-term excerpt (first occurrence, ±50 chars) in JavaScript.
+    const sessionIDs = rows.map((r) => r.session_id);
+    const placeholders = sessionIDs.map(() => "?").join(",");
+    const followRows = db
+      .query(
+        `SELECT session_id, id AS message_id, data
+         FROM session_message
+         WHERE session_id IN (${placeholders})
+           AND (type = 'user' OR type = 'assistant')
+         ORDER BY time_created ASC`,
+      )
+      .all(...sessionIDs) as Array<{
+      session_id: string;
+      message_id: string;
+      data: string;
+    }>;
+
+    const messagesBySession = new Map<string, Array<{ id: string; data: string }>>();
+    for (const row of followRows) {
+      if (!messagesBySession.has(row.session_id)) {
+        messagesBySession.set(row.session_id, []);
+      }
+      messagesBySession.get(row.session_id)!.push({ id: row.message_id, data: row.data });
+    }
+
+    const termHitsBySession = new Map<
+      string,
+      Map<string, { partID: string; matchType: string; excerpt: string }>
+    >();
+
+    for (const sessionID of sessionIDs) {
+      const sessionMap = new Map<
+        string,
+        { partID: string; matchType: string; excerpt: string }
+      >();
+      termHitsBySession.set(sessionID, sessionMap);
+
+      const messages = messagesBySession.get(sessionID) ?? [];
+      for (const message of messages) {
+        if (sessionMap.size >= terms.length) break;
+        const lower = message.data.toLowerCase();
+        for (const term of terms) {
+          if (sessionMap.size >= terms.length) break;
+          if (sessionMap.has(term)) continue;
+          const termLower = term.toLowerCase();
+          const idx = lower.indexOf(termLower);
+          if (idx === -1) continue;
+          const start = Math.max(0, idx - 50);
+          const end = Math.min(
+            message.data.length,
+            idx + termLower.length + 50,
+          );
+          sessionMap.set(term, {
+            partID: message.id,
+            matchType: "data",
+            excerpt: message.data.slice(start, end),
+          });
+        }
+      }
+    }
+
+    return rows.map((row) => ({
+      sessionID: row.session_id,
+      sessionTitle: row.title || "",
+      timestamp: row.time_updated,
+      projectDirectory: row.directory,
+      termHits: termHitsBySession.get(row.session_id) ?? new Map(),
+    }));
+  } finally {
+    db.close();
+  }
+}

package/src/storage-provider.ts

@@ -0,0 +1,70 @@
+import path from "path";
+import fs from "fs";
+import { getDataDir } from "./paths";
+import {
+  dbExists,
+  listSessionsSqlite,
+  listMessagesSqlite,
+  listPartsSqlite,
+  type ProjectFilter,
+} from "./storage-sqlite";
+import {
+  listSessions as listSessionsJSON,
+  listMessages as listMessagesJSON,
+  listParts as listPartsJSON,
+  getStorageDir,
+} from "./storage";
+import type { Session, Message, Part } from "./storage";
+
+// Evaluated per call (not at module load) so a database created after the
+// plugin loaded is picked up without a restart.
+function useSqlite(): boolean {
+  return dbExists();
+}
+
+/** True when the legacy JSON storage directory has any content at all. */
+export function jsonStorageExists(): boolean {
+  const dir = path.join(getDataDir(), "storage");
+  for (const sub of ["session", "message", "part"]) {
+    try {
+      if (fs.readdirSync(path.join(dir, sub)).length > 0) return true;
+    } catch {
+      // absent or unreadable, keep looking
+    }
+  }
+  return false;
+}
+
+export async function* listSessions(
+  projectID: ProjectFilter,
+): AsyncGenerator<Session> {
+  if (useSqlite()) {
+    yield* listSessionsSqlite(projectID);
+  } else {
+    // JSON fallback only understands a single project id.
+    yield* listSessionsJSON(Array.isArray(projectID) ? projectID[0] : projectID);
+  }
+}
+
+export async function* listMessages(
+  sessionID: string,
+  role?: "user" | "assistant",
+): AsyncGenerator<Message> {
+  if (useSqlite()) {
+    yield* listMessagesSqlite(sessionID, role);
+  } else {
+    yield* listMessagesJSON(sessionID, role);
+  }
+}
+
+export async function* listParts(messageID: string): AsyncGenerator<Part> {
+  if (useSqlite()) {
+    yield* listPartsSqlite(messageID);
+  } else {
+    yield* listPartsJSON(messageID);
+  }
+}
+
+export { getStorageDir };
+export type { Session, Message, Part };
+export type { ProjectFilter };

package/src/storage-sqlite.ts

@@ -0,0 +1,252 @@
+import { Database } from "bun:sqlite";
+import { getDbPath } from "./paths";
+import type { Session, Message, Part } from "./storage";
+
+export { getDbPath } from "./paths";
+
+/**
+ * OpenCode V2 SQLite backend.
+ *
+ * V2 stores live sessions in the `session_v2` and `session_message` tables of
+ * `~/.local/share/opencode/opencode.db`. The legacy V1 `session`/`message`/`part`
+ * tables are a frozen copy (pre-migration); `session_v2` already contains every
+ * legacy session id, so reading the V2 tables covers all eras.
+ *
+ * Message rows carry their parts inline:
+ *   user:      { time, text, files? }
+ *   assistant: { time, agent, model, content: [ {type:"text"|"tool"|"reasoning"|...} ] }
+ */
+
+/** A single project id, a list of project ids (e.g. current + legacy "global"),
+ *  or null for "all projects". */
+export type ProjectFilter = string | string[] | null;
+
+export function dbExists(): boolean {
+  try {
+    return Bun.file(getDbPath()).size > 0;
+  } catch {
+    return false;
+  }
+}
+
+function openDb(): Database {
+  const db = new Database(getDbPath(), { readonly: true });
+  // Schema-drift guard: if a future OpenCode renames the V2 tables, fail
+  // with an actionable message instead of a raw SQL error.
+  const tables = db
+    .query(
+      `SELECT name FROM sqlite_master
+       WHERE type = 'table' AND name IN ('session_v2', 'session_message')`,
+    )
+    .all() as Array<{ name: string }>;
+  if (tables.length < 2) {
+    db.close();
+    throw new Error(
+      `OpenCode history database at ${getDbPath()} does not contain the expected V2 tables (session_v2, session_message). This OpenCode version may use an unsupported schema.`,
+    );
+  }
+  return db;
+}
+
+/** Build a SQL project filter fragment plus its bind values. */
+export function projectFilterParts(
+  filter: ProjectFilter,
+  alias = "s",
+): { clause: string; binds: string[] } {
+  if (filter === null) return { clause: "", binds: [] };
+  const ids = Array.isArray(filter) ? filter : [filter];
+  const placeholders = ids.map(() => "?").join(", ");
+  return { clause: `AND ${alias}.project_id IN (${placeholders})`, binds: ids };
+}
+
+export async function* listSessionsSqlite(
+  projectID: ProjectFilter,
+  db?: Database,
+): AsyncGenerator<Session> {
+  const shouldClose = db === undefined;
+  const _db = db ?? openDb();
+  try {
+    const { clause, binds } = projectFilterParts(projectID);
+    const rows = _db
+      .query(
+        `SELECT s.id, s.project_id, s.title, s.directory, s.time_created, s.time_updated
+         FROM session_v2 s
+         WHERE 1=1 ${clause}
+         ORDER BY time_updated DESC`,
+      )
+      .all(...binds) as Array<{
+      id: string;
+      project_id: string;
+      title: string | null;
+      directory: string;
+      time_created: number;
+      time_updated: number;
+    }>;
+
+    for (const row of rows) {
+      yield {
+        id: row.id,
+        projectID: row.project_id,
+        title: row.title || "",
+        directory: row.directory,
+        time: { created: row.time_created, updated: row.time_updated },
+      };
+    }
+  } finally {
+    if (shouldClose) _db.close();
+  }
+}
+
+export async function* listMessagesSqlite(
+  sessionID: string,
+  role?: "user" | "assistant",
+  db?: Database,
+): AsyncGenerator<Message> {
+  const shouldClose = db === undefined;
+  const _db = db ?? openDb();
+  try {
+    const rows = _db
+      .query(
+        `SELECT id, session_id, type, seq, time_created, data
+         FROM session_message WHERE session_id = ?
+         ORDER BY seq ASC`,
+      )
+      .all(sessionID) as Array<{
+      id: string;
+      session_id: string;
+      type: string;
+      seq: number;
+      time_created: number;
+      data: string;
+    }>;
+
+    for (const row of rows) {
+      // Only user/assistant messages carry searchable conversation content.
+      // (idle, compaction, synthetic, system, agent-switched are skipped.)
+      if (row.type !== "user" && row.type !== "assistant") continue;
+      if (role && row.type !== role) continue;
+
+      let data: any;
+      try {
+        data = JSON.parse(row.data);
+      } catch {
+        continue;
+      }
+
+      yield {
+        id: row.id,
+        sessionID: row.session_id,
+        role: row.type,
+        agent: data.agent || "",
+        time: { created: row.time_created },
+      };
+    }
+  } finally {
+    if (shouldClose) _db.close();
+  }
+}
+
+/** Normalize a V2 tool part's `state.content` (string or structured) to text. */
+function toolOutputText(state: any): string {
+  if (state == null) return "";
+  if (typeof state.content === "string") return state.content;
+  if (state.content !== undefined) {
+    try {
+      return JSON.stringify(state.content);
+    } catch {
+      return "";
+    }
+  }
+  return "";
+}
+
+export async function* listPartsSqlite(
+  messageID: string,
+  db?: Database,
+): AsyncGenerator<Part> {
+  const shouldClose = db === undefined;
+  const _db = db ?? openDb();
+  try {
+    const row = _db
+      .query(
+        `SELECT id, session_id, type, data
+         FROM session_message WHERE id = ?`,
+      )
+      .get(messageID) as
+      | { id: string; session_id: string; type: string; data: string }
+      | null;
+
+    if (!row) return;
+
+    let data: any;
+    try {
+      data = JSON.parse(row.data);
+    } catch {
+      return;
+    }
+
+    if (row.type === "user") {
+      // User content is a flat text field (plus optional file attachments).
+      if (typeof data.text === "string" && data.text) {
+        yield {
+          id: `${row.id}#text`,
+          messageID: row.id,
+          sessionID: row.session_id,
+          type: "text",
+          text: data.text,
+        };
+      }
+      return;
+    }
+
+    if (row.type !== "assistant") return;
+
+    const content = Array.isArray(data.content) ? data.content : [];
+    for (let i = 0; i < content.length; i++) {
+      const p = content[i];
+      if (!p || typeof p !== "object") continue;
+
+      if (p.type === "text" && typeof p.text === "string" && p.text) {
+        yield {
+          id: `${row.id}#text${i}`,
+          messageID: row.id,
+          sessionID: row.session_id,
+          type: "text",
+          text: p.text,
+        };
+      } else if (p.type === "tool") {
+        const state = p.state || {};
+        const errorText =
+          state.error && typeof state.error.message === "string"
+            ? state.error.message
+            : state.error
+              ? JSON.stringify(state.error)
+              : "";
+        yield {
+          id: typeof p.id === "string" ? p.id : `${row.id}#tool${i}`,
+          messageID: row.id,
+          sessionID: row.session_id,
+          type: "tool",
+          tool: typeof p.name === "string" ? p.name : undefined,
+          state: {
+            input: state.input,
+            output: toolOutputText(state) + (errorText ? `\n${errorText}` : ""),
+            title: state.title,
+          },
+        };
+      } else if (p.type === "patch" && Array.isArray(p.files)) {
+        yield {
+          id: `${row.id}#patch${i}`,
+          messageID: row.id,
+          sessionID: row.session_id,
+          type: "patch",
+          files: p.files.filter((f: any) => typeof f === "string"),
+        };
+      }
+      // reasoning, step-start, step-finish, compaction, file, subtask, etc.
+      // are not searched (matches V1 behaviour, which skipped reasoning parts).
+    }
+  } finally {
+    if (shouldClose) _db.close();
+  }
+}

package/src/storage.ts

@@ -0,0 +1,134 @@
+import path from "path";
+import fs from "fs";
+import { Glob } from "bun";
+import { getDataDir } from "./paths";
+
+export interface Session {
+  id: string;
+  projectID: string;
+  title: string;
+  directory: string;
+  time: { created: number; updated: number };
+}
+
+export interface Message {
+  id: string;
+  sessionID: string;
+  role: "user" | "assistant";
+  agent: string;
+  time: { created: number };
+}
+
+export interface Part {
+  id: string;
+  messageID: string;
+  sessionID: string;
+  type: "text" | "tool" | "file" | "patch";
+  text?: string;
+  tool?: string;
+  state?: {
+    input?: any;
+    output?: string;
+    title?: string;
+  };
+  files?: string[]; // For patch parts — list of modified file paths
+}
+
+export async function getStorageDir(): Promise<string> {
+  return path.join(getDataDir(), "storage");
+}
+
+export async function* listSessions(
+  projectID: string | null,
+): AsyncGenerator<Session> {
+  const storageDir = await getStorageDir();
+  const sessionDir = path.join(storageDir, "session");
+
+  if (projectID !== null) {
+    const projectDir = path.join(sessionDir, projectID);
+    try {
+      for await (const file of new Glob("*.json").scan({ cwd: projectDir })) {
+        try {
+          const content = await Bun.file(path.join(projectDir, file)).json();
+          yield content as Session;
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+      return;
+    }
+    return;
+  }
+
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(sessionDir);
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    const projectDir = path.join(sessionDir, entry);
+    let stat: fs.Stats;
+    try {
+      stat = fs.statSync(projectDir);
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory()) continue;
+
+    try {
+      for await (const file of new Glob("*.json").scan({ cwd: projectDir })) {
+        try {
+          const content = await Bun.file(path.join(projectDir, file)).json();
+          yield content as Session;
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+}
+
+export async function* listMessages(
+  sessionID: string,
+  role?: "user" | "assistant",
+): AsyncGenerator<Message> {
+  const storageDir = await getStorageDir();
+  const messageDir = path.join(storageDir, "message", sessionID.trim());
+
+  try {
+    for await (const file of new Glob("*.json").scan({ cwd: messageDir })) {
+      try {
+        const content = await Bun.file(path.join(messageDir, file)).json();
+        if (role && content.role !== role) continue;
+        yield content as Message;
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return;
+  }
+}
+
+export async function* listParts(messageID: string): AsyncGenerator<Part> {
+  const storageDir = await getStorageDir();
+  const partDir = path.join(storageDir, "part", messageID.trim());
+
+  try {
+    for await (const file of new Glob("*.json").scan({ cwd: partDir })) {
+      try {
+        const content = await Bun.file(path.join(partDir, file)).json();
+        yield content as Part;
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return;
+  }
+}