opencode-history-search-v2 1.0.0

package/src/search/date-filter.ts

@@ -0,0 +1,132 @@
+/**
+ * Date filtering utilities for search results
+ * Supports natural language dates: "today", "yesterday", "last N days/weeks/months"
+ * Supports ISO dates: "YYYY-MM-DD"
+ * Supports date ranges: "YYYY-MM-DD to YYYY-MM-DD"
+ */
+
+export interface DateRange {
+  start: Date;
+  end: Date;
+}
+
+/**
+ * Parse a date filter string into a DateRange
+ * @param filter Date filter string (e.g., "today", "last 7 days", "2024-01-15", "2024-01-01 to 2024-01-31")
+ * @returns DateRange object with start and end dates (inclusive)
+ * @throws Error if the filter format is invalid
+ */
+export function parseDateFilter(filter: string): DateRange {
+  const normalized = filter.trim().toLowerCase();
+
+  // Today: 00:00:00 to 23:59:59 today
+  if (normalized === "today") {
+    const start = new Date();
+    start.setHours(0, 0, 0, 0);
+    const end = new Date();
+    end.setHours(23, 59, 59, 999);
+    return { start, end };
+  }
+
+  // Yesterday: 00:00:00 to 23:59:59 yesterday
+  if (normalized === "yesterday") {
+    const start = new Date();
+    start.setDate(start.getDate() - 1);
+    start.setHours(0, 0, 0, 0);
+    const end = new Date(start);
+    end.setHours(23, 59, 59, 999);
+    return { start, end };
+  }
+
+  // "last N days/weeks/months" - from N units ago until now
+  const relativeMatch = normalized.match(/^last (\d+) (day|week|month)s?$/);
+  if (relativeMatch && relativeMatch[1] && relativeMatch[2]) {
+    const count = parseInt(relativeMatch[1], 10);
+    const unit = relativeMatch[2];
+    const end = new Date();
+    const start = new Date();
+
+    if (unit === "day") {
+      start.setDate(start.getDate() - count);
+    } else if (unit === "week") {
+      start.setDate(start.getDate() - count * 7);
+    } else if (unit === "month") {
+      start.setMonth(start.getMonth() - count);
+    }
+
+    start.setHours(0, 0, 0, 0);
+    return { start, end };
+  }
+
+  // Date range: "YYYY-MM-DD to YYYY-MM-DD"
+  const rangeMatch = normalized.match(
+    /^(\d{4}-\d{2}-\d{2})\s+to\s+(\d{4}-\d{2}-\d{2})$/,
+  );
+  if (rangeMatch && rangeMatch[1] && rangeMatch[2]) {
+    const start = new Date(rangeMatch[1]);
+    const end = new Date(rangeMatch[2]);
+    end.setHours(23, 59, 59, 999); // Include entire end date
+
+    if (isNaN(start.getTime()) || isNaN(end.getTime())) {
+      throw new Error(`Invalid date range: ${filter}`);
+    }
+
+    if (start > end) {
+      throw new Error(`Start date must be before end date: ${filter}`);
+    }
+
+    return { start, end };
+  }
+
+  // Single date: "YYYY-MM-DD" or "YYYY-MM" (month)
+  const isoMatch = normalized.match(/^(\d{4}-\d{2}(?:-\d{2})?)$/);
+  if (isoMatch && isoMatch[1]) {
+    const dateStr = isoMatch[1];
+
+    // Month only (YYYY-MM)
+    if (dateStr.match(/^\d{4}-\d{2}$/)) {
+      const start = new Date(`${dateStr}-01`);
+      const end = new Date(start);
+      end.setMonth(end.getMonth() + 1);
+      end.setDate(0); // Last day of month
+      end.setHours(23, 59, 59, 999);
+
+      if (isNaN(start.getTime())) {
+        throw new Error(`Invalid date: ${filter}`);
+      }
+
+      return { start, end };
+    }
+
+    // Full date (YYYY-MM-DD)
+    const start = new Date(dateStr);
+    const end = new Date(dateStr);
+    end.setHours(23, 59, 59, 999);
+
+    if (isNaN(start.getTime())) {
+      throw new Error(`Invalid date: ${filter}`);
+    }
+
+    return { start, end };
+  }
+
+  throw new Error(
+    `Unrecognized date filter format: ${filter}. Supported formats: "today", "yesterday", "last N days/weeks/months", "YYYY-MM-DD", "YYYY-MM", "YYYY-MM-DD to YYYY-MM-DD"`,
+  );
+}
+
+/**
+ * Filter search results by date range
+ * @param results Array of search results with timestamp field (milliseconds since epoch)
+ * @param dateRange DateRange to filter by
+ * @returns Filtered array containing only results within the date range
+ */
+export function filterByDate<T extends { timestamp: number }>(
+  results: T[],
+  dateRange: DateRange,
+): T[] {
+  return results.filter((result) => {
+    const timestamp = new Date(result.timestamp);
+    return timestamp >= dateRange.start && timestamp <= dateRange.end;
+  });
+}

package/src/search/file-trace.ts

@@ -0,0 +1,189 @@
+import { getDbPath, projectFilterParts, type ProjectFilter } from "../storage-sqlite";
+
+export interface FileTraceResult {
+  sessionID: string;
+  sessionTitle: string;
+  timestamp: number;
+  firstTouch: boolean;
+  userPrompt: string | null;
+  toolName: string | null;
+  filePath: string;
+}
+
+export interface TraceFileOptions {
+  limit?: number;
+}
+
+interface Candidate {
+  sessionID: string;
+  sessionTitle: string;
+  messageID: string;
+  timestamp: number;
+  toolName: string | null;
+  filePath: string;
+}
+
+/**
+ * Trace which sessions created or modified a file.
+ *
+ * V2 schema: parts are embedded in `session_message.data`. Assistant tool
+ * parts live in `data.content[]` as { type:"tool", name, state:{input} }.
+ * New V2 write/edit inputs use `input.path`; migrated legacy parts may keep
+ * `input.filePath`. Patch parts carry `files: string[]`.
+ */
+export async function traceFile(
+  projectID: ProjectFilter,
+  filePath: string,
+  options?: TraceFileOptions,
+): Promise<FileTraceResult[]> {
+  const { Database } = await import("bun:sqlite");
+  const dbPath = getDbPath();
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    const normalizedQuery = filePath.replace(/\\/g, "/");
+    const isExactPath = normalizedQuery.includes("/");
+    const likePattern = `%${normalizedQuery}%`;
+
+    const { clause, binds } = projectFilterParts(projectID);
+
+    // Broad SQL pre-filter: assistant messages whose JSON payload mentions the
+    // path, then exact/basename matching is refined in TypeScript.
+    const sql = `
+      SELECT
+        s.id AS session_id,
+        s.title AS session_title,
+        m.id AS message_id,
+        m.time_created AS message_time,
+        m.data AS message_data
+      FROM session_v2 s
+      JOIN session_message m ON m.session_id = s.id
+      WHERE m.type = 'assistant'
+        AND m.data LIKE ? ESCAPE '\\'
+        ${clause}
+      ORDER BY m.time_created DESC
+    `;
+
+    const rows = db.query(sql).all(...[likePattern, ...binds]) as Array<{
+      session_id: string;
+      session_title: string | null;
+      message_id: string;
+      message_time: number;
+      message_data: string;
+    }>;
+
+    const candidates: Candidate[] = [];
+
+    for (const row of rows) {
+      let data: any;
+      try {
+        data = JSON.parse(row.message_data);
+      } catch {
+        continue;
+      }
+
+      const content = Array.isArray(data.content) ? data.content : [];
+      for (const p of content) {
+        if (!p || typeof p !== "object") continue;
+
+        if (p.type === "tool" && (p.name === "write" || p.name === "edit")) {
+          const input = p.state?.input || {};
+          const touched =
+            typeof input.path === "string"
+              ? input.path
+              : typeof input.filePath === "string"
+                ? input.filePath
+                : null;
+          if (touched && isMatch(touched, normalizedQuery, isExactPath)) {
+            candidates.push({
+              sessionID: row.session_id,
+              sessionTitle: row.session_title || "",
+              messageID: row.message_id,
+              timestamp: row.message_time,
+              toolName: typeof p.name === "string" ? p.name : null,
+              filePath: touched,
+            });
+          }
+        } else if (p.type === "patch" && Array.isArray(p.files)) {
+          for (const f of p.files) {
+            if (typeof f === "string" && isMatch(f, normalizedQuery, isExactPath)) {
+              candidates.push({
+                sessionID: row.session_id,
+                sessionTitle: row.session_title || "",
+                messageID: row.message_id,
+                timestamp: row.message_time,
+                toolName: null,
+                filePath: f,
+              });
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    // Deduplicate by sessionID + messageID + filePath. SQL is ordered by
+    // message_time DESC, so the first occurrence per key wins.
+    const seen = new Set<string>();
+    const deduped: Candidate[] = [];
+    for (const c of candidates) {
+      const key = `${c.sessionID}|${c.messageID}|${c.filePath}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        deduped.push(c);
+      }
+    }
+
+    // firstTouch = the earliest touch overall.
+    let earliestTime = Infinity;
+    let earliestIndex = -1;
+    for (let i = 0; i < deduped.length; i++) {
+      const candidate = deduped[i];
+      if (candidate.timestamp < earliestTime) {
+        earliestTime = candidate.timestamp;
+        earliestIndex = i;
+      }
+    }
+
+    const findUserPrompt = db.query(
+      `SELECT data FROM session_message
+       WHERE session_id = ? AND type = 'user' AND time_created < ?
+       ORDER BY seq DESC
+       LIMIT 1`,
+    );
+
+    const limit = options?.limit ?? 50;
+
+    return deduped.slice(0, limit).map((c, idx) => {
+      const promptRow = findUserPrompt.get(
+        c.sessionID,
+        c.timestamp,
+      ) as { data: string } | undefined;
+      let userPrompt: string | null = null;
+      if (promptRow) {
+        try {
+          userPrompt = JSON.parse(promptRow.data).text || null;
+        } catch {
+          userPrompt = null;
+        }
+      }
+      return {
+        sessionID: c.sessionID,
+        sessionTitle: c.sessionTitle,
+        timestamp: c.timestamp,
+        firstTouch: idx === earliestIndex,
+        userPrompt,
+        toolName: c.toolName,
+        filePath: c.filePath,
+      };
+    });
+  } finally {
+    db.close();
+  }
+}
+
+function isMatch(path: string, query: string, isExact: boolean): boolean {
+  if (isExact) {
+    return path === query;
+  }
+  return path === query || path.endsWith(`/${query}`);
+}

package/src/search/fuzzy.ts

@@ -0,0 +1,158 @@
+import Fuse from "fuse.js";
+import type { Session, Message, Part, ProjectFilter } from "../storage-provider";
+import { listSessions, listMessages, listParts } from "../storage-provider";
+import type { SearchMatch } from "./keyword";
+
+interface SearchableItem {
+  session: Session;
+  content: string;
+  type: "title" | "message" | "tool" | "filepath";
+  messageID?: string;
+  partID?: string;
+  timestamp: number;
+}
+
+export async function searchFuzzy(
+  projectID: ProjectFilter,
+  query: string,
+  options: {
+    threshold?: number; // 0.0 = exact, 1.0 = anything (default: 0.4)
+    limit?: number;
+    role?: "user" | "assistant";
+  } = {},
+): Promise<SearchMatch[]> {
+  const threshold = options.threshold ?? 0.4;
+  const limit = options.limit ?? 50;
+
+  // Build searchable index
+  const items: SearchableItem[] = [];
+
+  try {
+    for await (const session of listSessions(projectID)) {
+      // Index session title
+      items.push({
+        session,
+        content: session.title,
+        type: "title",
+        timestamp: session.time.updated,
+      });
+
+      // Index messages
+      try {
+        for await (const message of listMessages(session.id, options.role)) {
+          try {
+            for await (const part of listParts(message.id)) {
+              if (part.type === "text" && part.text) {
+                items.push({
+                  session,
+                  content: part.text,
+                  type: "message",
+                  messageID: message.id,
+                  partID: part.id,
+                  timestamp: message.time.created,
+                });
+              }
+
+              if (part.type === "tool" && part.tool) {
+                items.push({
+                  session,
+                  content: part.tool + " " + (part.state?.title || ""),
+                  type: "tool",
+                  messageID: message.id,
+                  partID: part.id,
+                  timestamp: message.time.created,
+                });
+              }
+
+              // Index file paths from tool inputs/outputs
+              if (part.type === "tool" && part.state) {
+                const inputStr = JSON.stringify(part.state.input || {});
+                const outputStr = part.state.output || "";
+                const combined = inputStr + " " + outputStr;
+
+                // Extract file path patterns
+                const pathMatches = combined.match(/(?:\/[^/\s]+)+/g);
+                if (pathMatches) {
+                  for (const path of pathMatches) {
+                    items.push({
+                      session,
+                      content: path,
+                      type: "filepath",
+                      messageID: message.id,
+                      partID: part.id,
+                      timestamp: message.time.created,
+                    });
+                  }
+                }
+              }
+
+              // Index file paths from patch parts
+              if (part.type === "patch" && part.files) {
+                for (const filePath of part.files) {
+                  items.push({
+                    session,
+                    content: filePath,
+                    type: "filepath",
+                    messageID: message.id,
+                    partID: part.id,
+                    timestamp: message.time.created,
+                  });
+                }
+              }
+            }
+          } catch {
+            // Skip corrupt part files
+            continue;
+          }
+        }
+      } catch {
+        // Skip sessions with missing message directory
+        continue;
+      }
+    }
+  } catch {
+    // Handle missing sessions directory
+    return [];
+  }
+
+  // Perform fuzzy search
+  const fuse = new Fuse(items, {
+    keys: ["content"],
+    threshold,
+    includeScore: true,
+    includeMatches: true,
+    ignoreLocation: true, // Don't bias toward beginning of string
+    minMatchCharLength: 2,
+  });
+
+  const results = fuse.search(query, { limit });
+
+  return results
+    .map((result) => {
+      const matchedText = result.matches?.[0]?.value || result.item.content;
+      const matchIndex = result.matches?.[0]?.indices?.[0]?.[0] || 0;
+
+      // Extract context around the match
+      const contextStart = Math.max(0, matchIndex - 100);
+      const contextEnd = Math.min(matchedText.length, matchIndex + 200);
+      const context = matchedText.slice(contextStart, contextEnd);
+
+      // Extract excerpt (the matched portion)
+      const excerptStart = Math.max(0, matchIndex - 20);
+      const excerptEnd = Math.min(matchedText.length, matchIndex + 80);
+      const excerpt = matchedText.slice(excerptStart, excerptEnd);
+
+      return {
+        sessionID: result.item.session.id,
+        sessionTitle: result.item.session.title,
+        timestamp: result.item.timestamp,
+        matchType: result.item.type,
+        excerpt: excerpt || query,
+        context: context || excerpt,
+        messageID: result.item.messageID,
+        partID: result.item.partID,
+        projectDirectory: result.item.session.directory,
+      };
+    })
+    .sort((a, b) => b.timestamp - a.timestamp);
+}

package/src/search/keyword.ts

@@ -0,0 +1,146 @@
+import type { Session, Message, Part, ProjectFilter } from "../storage-provider";
+import { listSessions, listMessages, listParts } from "../storage-provider";
+
+export interface SearchMatch {
+  sessionID: string;
+  sessionTitle: string;
+  timestamp: number;
+  matchType: "title" | "message" | "tool" | "filepath";
+  excerpt: string;
+  context: string;
+  messageID?: string;
+  partID?: string;
+  projectDirectory: string;
+}
+
+export async function searchKeyword(
+  projectID: ProjectFilter,
+  query: string,
+  options: {
+    regex?: boolean;
+    caseSensitive?: boolean;
+    limit?: number;
+    role?: "user" | "assistant";
+  } = {},
+): Promise<SearchMatch[]> {
+  const results: SearchMatch[] = [];
+  const pattern = options.regex
+    ? new RegExp(query, options.caseSensitive ? "" : "i")
+    : new RegExp(
+        query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
+        options.caseSensitive ? "" : "i",
+      );
+
+  const limit = options.limit || 50;
+
+  for await (const session of listSessions(projectID)) {
+    if (results.length >= limit) break;
+
+    if (pattern.test(session.title)) {
+      results.push({
+        sessionID: session.id,
+        sessionTitle: session.title,
+        timestamp: session.time.updated,
+        matchType: "title",
+        excerpt: session.title,
+        context: session.title,
+        projectDirectory: session.directory,
+      });
+      if (results.length >= limit) break;
+    }
+
+    for await (const message of listMessages(session.id, options.role)) {
+      if (results.length >= limit) break;
+
+      for await (const part of listParts(message.id)) {
+        if (results.length >= limit) break;
+
+        if (part.type === "text" && part.text && pattern.test(part.text)) {
+          const match = part.text.match(pattern);
+          const matchIndex = match ? part.text.indexOf(match[0]) : 0;
+          const contextStart = Math.max(0, matchIndex - 100);
+          const contextEnd = Math.min(
+            part.text.length,
+            matchIndex + match![0].length + 100,
+          );
+          const context = part.text.slice(contextStart, contextEnd);
+
+          results.push({
+            sessionID: session.id,
+            sessionTitle: session.title,
+            timestamp: message.time.created,
+            matchType: "message",
+            excerpt: match ? match[0] : query,
+            context: context,
+            messageID: message.id,
+            partID: part.id,
+            projectDirectory: session.directory,
+          });
+          if (results.length >= limit) break;
+        }
+
+        if (results.length >= limit) break;
+        if (part.type === "tool" && part.tool && pattern.test(part.tool)) {
+          results.push({
+            sessionID: session.id,
+            sessionTitle: session.title,
+            timestamp: message.time.created,
+            matchType: "tool",
+            excerpt: part.tool,
+            context: part.state?.title || part.tool,
+            messageID: message.id,
+            partID: part.id,
+            projectDirectory: session.directory,
+          });
+          if (results.length >= limit) break;
+        }
+
+        if (results.length >= limit) break;
+        if (part.type === "tool" && part.state) {
+          const inputStr = JSON.stringify(part.state.input || {});
+          const outputStr = part.state.output || "";
+
+          if (pattern.test(inputStr) || pattern.test(outputStr)) {
+            const matched = pattern.exec(inputStr) || pattern.exec(outputStr);
+            if (matched) {
+              results.push({
+                sessionID: session.id,
+                sessionTitle: session.title,
+                timestamp: message.time.created,
+                matchType: "filepath",
+                excerpt: matched[0],
+                context: part.state.title || part.tool || "",
+                messageID: message.id,
+                partID: part.id,
+                projectDirectory: session.directory,
+              });
+              if (results.length >= limit) break;
+            }
+          }
+        }
+
+        // Search patch parts for file paths
+        if (results.length < limit && part.type === "patch" && part.files) {
+          for (const filePath of part.files) {
+            if (results.length >= limit) break;
+            if (pattern.test(filePath)) {
+              results.push({
+                sessionID: session.id,
+                sessionTitle: session.title,
+                timestamp: message.time.created,
+                matchType: "filepath",
+                excerpt: filePath,
+                context: `Modified file: ${filePath}`,
+                messageID: message.id,
+                partID: part.id,
+                projectDirectory: session.directory,
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return results.sort((a, b) => b.timestamp - a.timestamp);
+}