@spool-lab/core 0.3.3

package/dist/db/queries.js

@@ -0,0 +1,828 @@
+import { randomUUID } from 'node:crypto';
+import { DB_PATH, getDBSize } from './db.js';
+import { buildSearchPlan, canUseSessionSearchFts, getNaturalSearchPhrase, getNaturalSearchTerms, selectFtsTableKind } from './search-query.js';
+export function getOrCreateProject(db, sourceId, slug, displayPath, displayName) {
+    const existing = db
+        .prepare('SELECT id FROM projects WHERE source_id = ? AND slug = ?')
+        .get(sourceId, slug);
+    if (existing)
+        return existing.id;
+    const result = db
+        .prepare('INSERT INTO projects (source_id, slug, display_path, display_name) VALUES (?, ?, ?, ?)')
+        .run(sourceId, slug, displayPath, displayName);
+    return Number(result.lastInsertRowid);
+}
+export function getSourceId(db, name) {
+    const row = db.prepare('SELECT id FROM sources WHERE name = ?').get(name);
+    if (!row)
+        throw new Error(`Source '${name}' not found in DB`);
+    return row.id;
+}
+export function getSessionMtime(db, filePath) {
+    const row = db
+        .prepare('SELECT raw_file_mtime FROM sessions WHERE file_path = ?')
+        .get(filePath);
+    return row?.raw_file_mtime ?? null;
+}
+export function deleteSessionByFilePath(db, filePath) {
+    const result = db.prepare('DELETE FROM sessions WHERE file_path = ?').run(filePath);
+    return result.changes > 0;
+}
+export function getAllSessionMtimes(db) {
+    const rows = db
+        .prepare('SELECT file_path, raw_file_mtime FROM sessions')
+        .all();
+    return new Map(rows.map(r => [r.file_path, r.raw_file_mtime]));
+}
+export function upsertSession(db, opts) {
+    const existing = db
+        .prepare('SELECT id FROM sessions WHERE session_uuid = ?')
+        .get(opts.sessionUuid);
+    if (existing) {
+        db.prepare('DELETE FROM messages WHERE session_id = ?').run(existing.id);
+        db.prepare(`
+      UPDATE sessions SET
+        title = ?, started_at = ?, ended_at = ?, message_count = ?,
+        has_tool_use = ?, cwd = ?, model = ?, raw_file_mtime = ?
+      WHERE id = ?
+    `).run(opts.title, opts.startedAt, opts.endedAt, opts.messageCount, opts.hasToolUse ? 1 : 0, opts.cwd, opts.model, opts.rawFileMtime, existing.id);
+        return existing.id;
+    }
+    const result = db.prepare(`
+    INSERT INTO sessions
+      (project_id, source_id, session_uuid, file_path, title,
+       started_at, ended_at, message_count, has_tool_use, cwd, model, raw_file_mtime)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(opts.projectId, opts.sourceId, opts.sessionUuid, opts.filePath, opts.title, opts.startedAt, opts.endedAt, opts.messageCount, opts.hasToolUse ? 1 : 0, opts.cwd, opts.model, opts.rawFileMtime);
+    return Number(result.lastInsertRowid);
+}
+export function upsertSessionSearch(db, opts) {
+    db.prepare(`
+    INSERT INTO session_search (session_id, title, user_text, assistant_text, updated_at)
+    VALUES (?, ?, ?, ?, datetime('now'))
+    ON CONFLICT(session_id) DO UPDATE SET
+      title = excluded.title,
+      user_text = excluded.user_text,
+      assistant_text = excluded.assistant_text,
+      updated_at = datetime('now')
+  `).run(opts.sessionId, opts.title, opts.userText, opts.assistantText);
+}
+export function insertMessages(db, sessionId, sourceId, messages) {
+    const stmt = db.prepare(`
+    INSERT INTO messages
+      (session_id, source_id, msg_uuid, parent_uuid, role,
+       content_text, timestamp, is_sidechain, tool_names, seq)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    for (const m of messages) {
+        stmt.run(sessionId, sourceId, m.uuid, m.parentUuid, m.role, m.contentText, m.timestamp, m.isSidechain ? 1 : 0, JSON.stringify(m.toolNames), m.seq);
+    }
+}
+export function listRecentSessions(db, limit = 50) {
+    return db.prepare(`
+    SELECT
+      s.id, s.project_id AS projectId, s.source_id AS sourceId,
+      s.session_uuid AS sessionUuid, s.file_path AS filePath,
+      s.title, s.started_at AS startedAt, s.ended_at AS endedAt,
+      s.message_count AS messageCount, s.has_tool_use AS hasToolUse,
+      s.cwd, s.model,
+      src.name AS source,
+      p.display_path AS projectDisplayPath,
+      p.display_name AS projectDisplayName
+    FROM sessions s
+    JOIN sources src ON src.id = s.source_id
+    JOIN projects p ON p.id = s.project_id
+    ORDER BY s.started_at DESC
+    LIMIT ?
+  `).all(limit).map(rowToSession);
+}
+export function getSessionWithMessages(db, sessionUuid) {
+    const sessionRow = db.prepare(`
+    SELECT
+      s.id, s.project_id AS projectId, s.source_id AS sourceId,
+      s.session_uuid AS sessionUuid, s.file_path AS filePath,
+      s.title, s.started_at AS startedAt, s.ended_at AS endedAt,
+      s.message_count AS messageCount, s.has_tool_use AS hasToolUse,
+      s.cwd, s.model,
+      src.name AS source,
+      p.display_path AS projectDisplayPath,
+      p.display_name AS projectDisplayName
+    FROM sessions s
+    JOIN sources src ON src.id = s.source_id
+    JOIN projects p ON p.id = s.project_id
+    WHERE s.session_uuid = ?
+  `).get(sessionUuid);
+    if (!sessionRow)
+        return null;
+    const session = rowToSession(sessionRow);
+    const msgRows = db.prepare(`
+    SELECT id, session_id AS sessionId, msg_uuid AS msgUuid,
+           parent_uuid AS parentUuid, role, content_text AS contentText,
+           timestamp, is_sidechain AS isSidechain, tool_names AS toolNames, seq
+    FROM messages
+    WHERE session_id = ? AND is_sidechain = 0
+    ORDER BY seq
+  `).all(session.id);
+    const messages = msgRows.map(r => ({
+        id: r['id'],
+        sessionId: r['sessionId'],
+        msgUuid: r['msgUuid'],
+        parentUuid: r['parentUuid'],
+        role: r['role'],
+        contentText: r['contentText'],
+        timestamp: r['timestamp'],
+        isSidechain: Boolean(r['isSidechain']),
+        toolNames: JSON.parse(r['toolNames']),
+        seq: r['seq'],
+    }));
+    return { session, messages };
+}
+export function searchFragments(db, query, opts = {}) {
+    const { limit = 10, source, since } = opts;
+    const rowLimit = Math.max(limit * 10, 50);
+    const naturalTerms = getNaturalSearchTerms(query);
+    const naturalPhrase = getNaturalSearchPhrase(query);
+    const canUseSessionFts = canUseSessionSearchFts(query);
+    if (naturalTerms.length === 1) {
+        return searchFragmentSessionFallback(db, naturalTerms, naturalPhrase, rowLimit, 'fts', {
+            ...(source ? { source } : {}),
+            ...(since ? { since } : {}),
+        }).slice(0, limit);
+    }
+    const groups = buildSearchPlan(query).map(step => {
+        if (naturalTerms.length > 1 && (step.matchType === 'phrase' || step.matchType === 'all_terms')) {
+            return searchFragmentSessionFallback(db, naturalTerms, naturalPhrase, rowLimit, step.matchType, {
+                ...(source ? { source } : {}),
+                ...(since ? { since } : {}),
+            });
+        }
+        const ftsTable = selectFtsTableKind(query) === 'trigram' ? 'messages_fts_trigram' : 'messages_fts';
+        const rows = searchFragmentRows(db, ftsTable, step.query, rowLimit, {
+            ...(source ? { source } : {}),
+            ...(since ? { since } : {}),
+        });
+        return collapseFragmentRows(rows, step.matchType);
+    });
+    return mergeFragmentGroups(groups, limit);
+}
+export function searchSessionPreview(db, query, opts = {}) {
+    const { limit = 5, source, since } = opts;
+    const normalizedQuery = query.trim();
+    if (!normalizedQuery)
+        return [];
+    const terms = getNaturalSearchTerms(query);
+    const previewTerms = terms.length > 0 ? terms : [normalizedQuery];
+    const rows = searchPreviewRows(db, previewTerms, limit, {
+        ...(source ? { source } : {}),
+        ...(since ? { since } : {}),
+    });
+    const snippetRows = selectBestSessionSnippets(db, rows.map(row => row['sessionId']), previewTerms);
+    return rows.map((row, index) => {
+        const sessionId = row['sessionId'];
+        const snippetRow = snippetRows.get(sessionId);
+        const snippetSource = snippetRow?.contentText ?? String(row['sessionTitle'] ?? '');
+        const profileLabel = getProfileLabelFromFilePath(row['filePath']);
+        return {
+            rank: index + 1,
+            sessionId,
+            sessionUuid: row['sessionUuid'],
+            sessionTitle: row['sessionTitle'] ?? '(no title)',
+            matchCount: snippetRow?.matchingMessageCount ?? 1,
+            matchType: 'all_terms',
+            source: row['source'],
+            ...(profileLabel ? { profileLabel } : {}),
+            ...(row['cwd'] ? { cwd: row['cwd'] } : {}),
+            project: row['project'],
+            startedAt: row['startedAt'],
+            snippet: buildLikeSnippet(snippetSource, previewTerms),
+            messageId: snippetRow?.messageId ?? 0,
+            messageRole: snippetRow?.messageRole ?? 'system',
+            messageTimestamp: snippetRow?.messageTimestamp ?? row['startedAt'],
+        };
+    });
+}
+function searchFragmentRows(db, ftsTable, ftsQuery, limit, opts = {}) {
+    const { source, since } = opts;
+    const conditions = [`${ftsTable} MATCH ?`, 'm.is_sidechain = 0'];
+    const params = [ftsQuery];
+    if (source) {
+        conditions.push('src2.name = ?');
+        params.push(source);
+    }
+    if (since) {
+        conditions.push('m.timestamp >= ?');
+        params.push(since);
+    }
+    params.push(limit);
+    const sql = `
+    SELECT
+      rank,
+      m.id          AS messageId,
+      m.role        AS messageRole,
+      m.timestamp   AS messageTimestamp,
+      sess.id       AS sessionId,
+      sess.session_uuid AS sessionUuid,
+      sess.file_path AS filePath,
+      sess.title    AS sessionTitle,
+      sess.started_at AS startedAt,
+      sess.cwd      AS cwd,
+      p.display_path AS project,
+      src2.name     AS source,
+      snippet(${ftsTable}, -1, '<mark>', '</mark>', '…', 20) AS snippet
+    FROM ${ftsTable}
+    JOIN messages m ON m.id = ${ftsTable}.rowid
+    JOIN sessions sess ON sess.id = m.session_id
+    JOIN projects p ON p.id = sess.project_id
+    JOIN sources src2 ON src2.id = sess.source_id
+    WHERE ${conditions.join(' AND ')}
+    ORDER BY rank
+    LIMIT ?
+  `;
+    return db.prepare(sql).all(...params);
+}
+function searchPreviewRows(db, terms, limit, opts = {}) {
+    const { source, since } = opts;
+    const scoreParts = [];
+    const scoreParams = [];
+    const whereClauses = [];
+    const whereParams = [];
+    for (const term of terms) {
+        const containsPattern = toLikePattern(term);
+        const prefixPattern = `${escapeLike(term)}%`;
+        scoreParts.push(`CASE WHEN ss.title LIKE ? ESCAPE '\\' THEN 20 ELSE 0 END`);
+        scoreParams.push(prefixPattern);
+        scoreParts.push(`CASE WHEN ss.title LIKE ? ESCAPE '\\' THEN 8 ELSE 0 END`);
+        scoreParams.push(containsPattern);
+        scoreParts.push(`CASE WHEN ss.user_text LIKE ? ESCAPE '\\' THEN 4 ELSE 0 END`);
+        scoreParams.push(containsPattern);
+        scoreParts.push(`CASE WHEN ss.assistant_text LIKE ? ESCAPE '\\' THEN 1 ELSE 0 END`);
+        scoreParams.push(containsPattern);
+        whereClauses.push(`(
+      ss.title LIKE ? ESCAPE '\\'
+      OR ss.user_text LIKE ? ESCAPE '\\'
+      OR ss.assistant_text LIKE ? ESCAPE '\\'
+    )`);
+        whereParams.push(containsPattern, containsPattern, containsPattern);
+    }
+    const conditions = [...whereClauses];
+    const params = [...scoreParams, ...whereParams];
+    if (source) {
+        conditions.push('src2.name = ?');
+        params.push(source);
+    }
+    if (since) {
+        conditions.push('sess.started_at >= ?');
+        params.push(since);
+    }
+    params.push(limit);
+    const previewScoreExpr = scoreParts.join(' + ');
+    const sql = `
+    SELECT
+      sess.id AS sessionId,
+      sess.session_uuid AS sessionUuid,
+      sess.file_path AS filePath,
+      sess.title AS sessionTitle,
+      sess.started_at AS startedAt,
+      sess.cwd AS cwd,
+      p.display_path AS project,
+      src2.name AS source,
+      ${previewScoreExpr} AS previewScore
+    FROM sessions sess
+    JOIN session_search ss ON ss.session_id = sess.id
+    JOIN projects p ON p.id = sess.project_id
+    JOIN sources src2 ON src2.id = sess.source_id
+    WHERE ${conditions.join(' AND ')}
+    ORDER BY previewScore DESC, sess.started_at DESC
+    LIMIT ?
+  `;
+    return db.prepare(sql).all(...params);
+}
+function collapseFragmentRows(rows, matchType) {
+    const seen = new Map();
+    const ordered = [];
+    for (const row of rows) {
+        const sessionUuid = row['sessionUuid'];
+        const existing = seen.get(sessionUuid);
+        if (existing) {
+            existing.matchCount += 1;
+            continue;
+        }
+        const profileLabel = getProfileLabelFromFilePath(row['filePath']);
+        const fragment = {
+            rank: ordered.length + 1,
+            sessionId: row['sessionId'],
+            sessionUuid,
+            sessionTitle: row['sessionTitle'] ?? '(no title)',
+            matchCount: 1,
+            matchType,
+            source: row['source'],
+            ...(profileLabel ? { profileLabel } : {}),
+            ...(row['cwd'] ? { cwd: row['cwd'] } : {}),
+            project: row['project'],
+            startedAt: row['startedAt'],
+            snippet: row['snippet'],
+            messageId: row['messageId'],
+            messageRole: row['messageRole'],
+            messageTimestamp: row['messageTimestamp'],
+        };
+        seen.set(sessionUuid, fragment);
+        ordered.push(fragment);
+    }
+    return ordered;
+}
+function mergeFragmentGroups(groups, limit) {
+    const merged = [];
+    const seen = new Map();
+    for (const group of groups) {
+        for (const fragment of group) {
+            const existing = seen.get(fragment.sessionUuid);
+            if (existing) {
+                existing.matchCount = Math.max(existing.matchCount, fragment.matchCount);
+                continue;
+            }
+            if (merged.length >= limit)
+                continue;
+            const next = {
+                ...fragment,
+                rank: merged.length + 1,
+            };
+            merged.push(next);
+            seen.set(next.sessionUuid, next);
+        }
+    }
+    return merged;
+}
+function searchFragmentSessionFallback(db, terms, phrase, limit, matchType, opts = {}) {
+    if (terms.length < 1)
+        return [];
+    const rows = searchSessionRowsByTerms(db, terms, phrase, limit, matchType, opts);
+    const snippetRows = selectBestSessionSnippets(db, rows.map(row => row['sessionId']), terms);
+    const ranked = rows.map((row) => {
+        const snippetRow = snippetRows.get(row['sessionId']);
+        const snippetSource = snippetRow?.contentText ?? String(row['sessionTitle'] ?? '');
+        const profileLabel = getProfileLabelFromFilePath(row['filePath']);
+        return {
+            sessionId: row['sessionId'],
+            sessionUuid: row['sessionUuid'],
+            sessionTitle: row['sessionTitle'] ?? '(no title)',
+            matchCount: snippetRow?.matchingMessageCount ?? 1,
+            matchType,
+            source: row['source'],
+            ...(profileLabel ? { profileLabel } : {}),
+            ...(row['cwd'] ? { cwd: row['cwd'] } : {}),
+            project: row['project'],
+            startedAt: row['startedAt'],
+            snippet: buildLikeSnippet(snippetSource, terms),
+            messageId: snippetRow?.messageId ?? 0,
+            messageRole: snippetRow?.messageRole ?? 'system',
+            messageTimestamp: snippetRow?.messageTimestamp ?? row['startedAt'],
+            _titleMatchScore: row['titleMatchScore'],
+            _userMatchScore: row['userMatchScore'],
+            _assistantMatchScore: row['assistantMatchScore'],
+            _sameMessageCoverage: snippetRow?.termCoverage ?? 0,
+        };
+    });
+    ranked.sort((a, b) => {
+        if (b._sameMessageCoverage !== a._sameMessageCoverage) {
+            return b._sameMessageCoverage - a._sameMessageCoverage;
+        }
+        if (b._titleMatchScore !== a._titleMatchScore) {
+            return b._titleMatchScore - a._titleMatchScore;
+        }
+        if (b._userMatchScore !== a._userMatchScore) {
+            return b._userMatchScore - a._userMatchScore;
+        }
+        if (b._assistantMatchScore !== a._assistantMatchScore) {
+            return b._assistantMatchScore - a._assistantMatchScore;
+        }
+        return String(b.startedAt).localeCompare(String(a.startedAt));
+    });
+    return ranked.map((row, index) => ({
+        rank: index + 1,
+        sessionId: row.sessionId,
+        sessionUuid: row.sessionUuid,
+        sessionTitle: row.sessionTitle,
+        matchCount: row.matchCount,
+        matchType: row.matchType,
+        source: row.source,
+        ...(row.profileLabel ? { profileLabel: row.profileLabel } : {}),
+        ...(row.cwd ? { cwd: row.cwd } : {}),
+        project: row.project,
+        startedAt: row.startedAt,
+        snippet: row.snippet,
+        messageId: row.messageId,
+        messageRole: row.messageRole,
+        messageTimestamp: row.messageTimestamp,
+    }));
+}
+function searchSessionRowsByTerms(db, terms, phrase, limit, matchType, opts = {}) {
+    if (canUseSessionSearchFts(phrase)) {
+        return searchSessionRowsByFts(db, terms, phrase, limit, matchType, opts);
+    }
+    return searchSessionRowsByLike(db, terms, limit, opts);
+}
+function searchSessionRowsByLike(db, terms, limit, opts = {}) {
+    const { source, since } = opts;
+    const titleScoreParts = [];
+    const whereClauses = [];
+    const scoreParams = [];
+    const whereParams = [];
+    for (const term of terms) {
+        const pattern = toLikePattern(term);
+        titleScoreParts.push(`CASE WHEN ss.title LIKE ? ESCAPE '\\' THEN 1 ELSE 0 END`);
+        scoreParams.push(pattern);
+        titleScoreParts.push(`CASE WHEN ss.user_text LIKE ? ESCAPE '\\' THEN 1 ELSE 0 END`);
+        scoreParams.push(pattern);
+        titleScoreParts.push(`CASE WHEN ss.assistant_text LIKE ? ESCAPE '\\' THEN 1 ELSE 0 END`);
+        scoreParams.push(pattern);
+        whereClauses.push(`(
+      ss.title LIKE ? ESCAPE '\\'
+      OR ss.user_text LIKE ? ESCAPE '\\'
+      OR ss.assistant_text LIKE ? ESCAPE '\\'
+    )`);
+        whereParams.push(pattern, pattern, pattern);
+    }
+    const conditions = [...whereClauses];
+    const params = [...scoreParams, ...whereParams];
+    if (source) {
+        conditions.push('src2.name = ?');
+        params.push(source);
+    }
+    if (since) {
+        conditions.push('sess.started_at >= ?');
+        params.push(since);
+    }
+    params.push(limit);
+    const titleScoreExpr = titleScoreParts.filter((_, index) => index % 3 === 0).join(' + ');
+    const userScoreExpr = titleScoreParts.filter((_, index) => index % 3 === 1).join(' + ');
+    const assistantScoreExpr = titleScoreParts.filter((_, index) => index % 3 === 2).join(' + ');
+    const sql = `
+    SELECT
+      sess.id AS sessionId,
+      sess.session_uuid AS sessionUuid,
+      sess.file_path AS filePath,
+      sess.title AS sessionTitle,
+      sess.started_at AS startedAt,
+      sess.cwd AS cwd,
+      p.display_path AS project,
+      src2.name AS source,
+      ${titleScoreExpr} AS titleMatchScore,
+      ${userScoreExpr} AS userMatchScore,
+      ${assistantScoreExpr} AS assistantMatchScore
+    FROM sessions sess
+    JOIN session_search ss ON ss.session_id = sess.id
+    JOIN projects p ON p.id = sess.project_id
+    JOIN sources src2 ON src2.id = sess.source_id
+    WHERE ${conditions.join(' AND ')}
+    ORDER BY titleMatchScore DESC, userMatchScore DESC, assistantMatchScore DESC, sess.started_at DESC
+    LIMIT ?
+  `;
+    return db.prepare(sql).all(...params);
+}
+function searchSessionRowsByFts(db, terms, phrase, limit, matchType, opts = {}) {
+    const { source, since } = opts;
+    const ftsTable = selectFtsTableKind(phrase) === 'trigram' ? 'session_search_fts_trigram' : 'session_search_fts';
+    const ftsQuery = matchType === 'phrase'
+        ? `"${phrase.replace(/"/g, '""')}"`
+        : terms.map(term => `"${term.replace(/"/g, '""')}"`).join(' AND ');
+    const titleScoreParts = [];
+    const scoreParams = [];
+    const likeParams = [];
+    for (const term of terms) {
+        const pattern = toLikePattern(term);
+        titleScoreParts.push(`CASE WHEN ss.title LIKE ? ESCAPE '\\' THEN 1 ELSE 0 END`);
+        scoreParams.push(pattern);
+        titleScoreParts.push(`CASE WHEN ss.user_text LIKE ? ESCAPE '\\' THEN 1 ELSE 0 END`);
+        scoreParams.push(pattern);
+        titleScoreParts.push(`CASE WHEN ss.assistant_text LIKE ? ESCAPE '\\' THEN 1 ELSE 0 END`);
+        scoreParams.push(pattern);
+    }
+    const conditions = [`${ftsTable} MATCH ?`];
+    const params = [...scoreParams, ftsQuery];
+    if (source) {
+        conditions.push('src2.name = ?');
+        params.push(source);
+    }
+    if (since) {
+        conditions.push('sess.started_at >= ?');
+        params.push(since);
+    }
+    params.push(limit);
+    const titleScoreExpr = titleScoreParts.filter((_, index) => index % 3 === 0).join(' + ');
+    const userScoreExpr = titleScoreParts.filter((_, index) => index % 3 === 1).join(' + ');
+    const assistantScoreExpr = titleScoreParts.filter((_, index) => index % 3 === 2).join(' + ');
+    const sql = `
+    SELECT
+      sess.id AS sessionId,
+      sess.session_uuid AS sessionUuid,
+      sess.file_path AS filePath,
+      sess.title AS sessionTitle,
+      sess.started_at AS startedAt,
+      sess.cwd AS cwd,
+      p.display_path AS project,
+      src2.name AS source,
+      bm25(${ftsTable}, 5.0, 1.5, 0.8) AS ftsScore,
+      ${titleScoreExpr} AS titleMatchScore,
+      ${userScoreExpr} AS userMatchScore,
+      ${assistantScoreExpr} AS assistantMatchScore
+    FROM ${ftsTable}
+    JOIN session_search ss ON ss.session_id = ${ftsTable}.rowid
+    JOIN sessions sess ON sess.id = ss.session_id
+    JOIN projects p ON p.id = sess.project_id
+    JOIN sources src2 ON src2.id = sess.source_id
+    WHERE ${conditions.join(' AND ')}
+    ORDER BY titleMatchScore DESC, userMatchScore DESC, assistantMatchScore DESC, ftsScore ASC, sess.started_at DESC
+    LIMIT ?
+  `;
+    return db.prepare(sql).all(...params);
+}
+function selectBestSessionSnippets(db, sessionIds, terms) {
+    if (sessionIds.length === 0)
+        return new Map();
+    const coverageExpr = terms.map(() => `CASE WHEN content_text LIKE ? ESCAPE '\\' THEN 1 ELSE 0 END`).join(' + ');
+    const anyClauses = terms.map(() => 'content_text LIKE ? ESCAPE \'\\\'').join(' OR ');
+    const allPatterns = terms.map(toLikePattern);
+    const anyPatterns = terms.map(toLikePattern);
+    const sessionPlaceholders = sessionIds.map(() => '?').join(', ');
+    const matchSql = `
+    WITH raw AS (
+      SELECT
+        id AS messageId,
+        session_id AS sessionId,
+        role AS messageRole,
+        timestamp AS messageTimestamp,
+        content_text AS contentText,
+        seq,
+        ${coverageExpr} AS termCoverage
+      FROM messages
+      WHERE session_id IN (${sessionPlaceholders})
+        AND is_sidechain = 0
+        AND (${anyClauses})
+    ),
+    ranked AS (
+      SELECT
+        sessionId,
+        messageId,
+        messageRole,
+        messageTimestamp,
+        contentText,
+        termCoverage,
+        COUNT(*) OVER (PARTITION BY sessionId) AS matchingMessageCount,
+        ROW_NUMBER() OVER (
+          PARTITION BY sessionId
+          ORDER BY termCoverage DESC, CASE WHEN messageRole = 'user' THEN 0 ELSE 1 END, seq
+        ) AS rn
+      FROM raw
+    )
+    SELECT
+      sessionId,
+      messageId,
+      messageRole,
+      messageTimestamp,
+      contentText,
+      termCoverage,
+      matchingMessageCount
+    FROM ranked
+    WHERE rn = 1
+  `;
+    const rows = db.prepare(matchSql).all(...allPatterns, ...sessionIds, ...anyPatterns);
+    return new Map(rows.map(row => [row.sessionId, row]));
+}
+export function buildLikeSnippet(text, terms) {
+    const normalizedText = text.trim();
+    if (!normalizedText)
+        return '';
+    // Case-insensitive hit search: the upstream SQL uses LIKE which is ASCII
+    // case-insensitive, so the matched content may differ in case from the
+    // query terms (e.g. user typed "dark fantasy", text has "Dark Fantasy").
+    const lowerText = normalizedText.toLowerCase();
+    const firstHit = terms
+        .map(term => lowerText.indexOf(term.toLowerCase()))
+        .filter(index => index >= 0)
+        .sort((a, b) => a - b)[0] ?? 0;
+    const start = Math.max(0, firstHit - 60);
+    const end = Math.min(normalizedText.length, firstHit + 140);
+    let snippet = normalizedText.slice(start, end);
+    if (start > 0)
+        snippet = `…${snippet}`;
+    if (end < normalizedText.length)
+        snippet = `${snippet}…`;
+    // Highlight preserving original casing via case-insensitive regex.
+    const uniqueTerms = Array.from(new Set(terms)).sort((a, b) => b.length - a.length);
+    for (const term of uniqueTerms) {
+        if (!term)
+            continue;
+        const pattern = new RegExp(escapeRegex(term), 'gi');
+        snippet = snippet.replace(pattern, m => `<mark>${m}</mark>`);
+    }
+    return snippet;
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function toLikePattern(term) {
+    return `%${escapeLike(term)}%`;
+}
+function escapeLike(value) {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/%/g, '\\%')
+        .replace(/_/g, '\\_');
+}
+export function getStatus(db) {
+    const counts = db.prepare(`
+    SELECT src.name, COUNT(*) AS cnt
+    FROM sessions s JOIN sources src ON src.id = s.source_id
+    GROUP BY src.name
+  `).all();
+    const lastSync = db.prepare(`
+    SELECT MAX(synced_at) AS last FROM sync_log WHERE status = 'ok'
+  `).get();
+    const totalSessions = counts.reduce((sum, r) => sum + r.cnt, 0);
+    const claudeRow = counts.find(r => r.name === 'claude');
+    const codexRow = counts.find(r => r.name === 'codex');
+    const geminiRow = counts.find(r => r.name === 'gemini');
+    return {
+        dbPath: DB_PATH,
+        totalSessions,
+        claudeSessions: claudeRow?.cnt ?? 0,
+        codexSessions: codexRow?.cnt ?? 0,
+        geminiSessions: geminiRow?.cnt ?? 0,
+        lastSyncedAt: lastSync?.last ?? null,
+        dbSizeBytes: getDBSize(),
+    };
+}
+function rowToSession(r) {
+    return {
+        id: r['id'],
+        projectId: r['projectId'],
+        sourceId: r['sourceId'],
+        sessionUuid: r['sessionUuid'],
+        filePath: r['filePath'],
+        title: r['title'],
+        startedAt: r['startedAt'],
+        endedAt: r['endedAt'],
+        messageCount: r['messageCount'],
+        hasToolUse: Boolean(r['hasToolUse']),
+        cwd: r['cwd'],
+        model: r['model'],
+        source: r['source'],
+        projectDisplayPath: r['projectDisplayPath'],
+        projectDisplayName: r['projectDisplayName'],
+    };
+}
+function getProfileLabelFromFilePath(filePath) {
+    const match = filePath.match(/\/\.(?:claude|codex)-profiles\/([^/]+)\//);
+    return match?.[1];
+}
+// ── Captures ────────────────────────────────────────────────────────────────
+export function insertCapture(db, sourceId, item) {
+    const captureUuid = randomUUID();
+    // Dedup by platform_id if provided
+    if (item.platformId) {
+        const existing = db
+            .prepare('SELECT id FROM captures WHERE platform = ? AND platform_id = ?')
+            .get(item.platform, item.platformId);
+        if (existing) {
+            db.prepare(`
+        UPDATE captures SET
+          title = ?, content_text = ?, author = ?, metadata = ?,
+          captured_at = ?, raw_json = ?, thumbnail_url = ?
+        WHERE id = ?
+      `).run(item.title, item.contentText, item.author, JSON.stringify(item.metadata), item.capturedAt, item.rawJson, item.thumbnailUrl, existing.id);
+            return existing.id;
+        }
+    }
+    const result = db.prepare(`
+    INSERT INTO captures
+      (source_id, capture_uuid, url, title, content_text,
+       author, platform, platform_id, content_type, thumbnail_url,
+       metadata, captured_at, raw_json)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(sourceId, captureUuid, item.url, item.title, item.contentText, item.author, item.platform, item.platformId, item.contentType, item.thumbnailUrl, JSON.stringify(item.metadata), item.capturedAt, item.rawJson);
+    return Number(result.lastInsertRowid);
+}
+export function searchCaptures(db, query, opts = {}) {
+    const { limit = 10, platform, since } = opts;
+    const ftsTable = selectFtsTableKind(query) === 'trigram' ? 'captures_fts_trigram' : 'captures_fts';
+    const rowLimit = Math.max(limit * 10, 50);
+    const groups = buildSearchPlan(query).map(step => {
+        const rows = searchCaptureRows(db, ftsTable, step.query, rowLimit, {
+            ...(platform ? { platform } : {}),
+            ...(since ? { since } : {}),
+        });
+        return mapCaptureRows(rows, step.matchType);
+    });
+    return mergeCaptureGroups(groups, limit);
+}
+function searchCaptureRows(db, ftsTable, ftsQuery, limit, opts = {}) {
+    const { platform, since } = opts;
+    const conditions = [`${ftsTable} MATCH ?`];
+    const params = [ftsQuery];
+    if (platform) {
+        conditions.push('c.platform = ?');
+        params.push(platform);
+    }
+    if (since) {
+        conditions.push('c.captured_at >= ?');
+        params.push(since);
+    }
+    params.push(limit);
+    const sql = `
+    SELECT
+      rank,
+      c.id            AS captureId,
+      c.capture_uuid  AS captureUuid,
+      c.url,
+      c.title,
+      c.author,
+      c.platform,
+      c.content_type  AS contentType,
+      c.captured_at   AS capturedAt,
+      snippet(${ftsTable}, -1, '<mark>', '</mark>', '…', 20) AS snippet
+    FROM ${ftsTable}
+    JOIN captures c ON c.id = ${ftsTable}.rowid
+    WHERE ${conditions.join(' AND ')}
+    ORDER BY rank
+    LIMIT ?
+  `;
+    return db.prepare(sql).all(...params);
+}
+function mapCaptureRows(rows, matchType) {
+    return rows.map((row, i) => ({
+        rank: i + 1,
+        captureId: row['captureId'],
+        captureUuid: row['captureUuid'],
+        matchType,
+        url: row['url'],
+        title: row['title'] || '(no title)',
+        snippet: row['snippet'],
+        platform: row['platform'],
+        contentType: row['contentType'],
+        author: row['author'] ?? null,
+        capturedAt: row['capturedAt'],
+    }));
+}
+function mergeCaptureGroups(groups, limit) {
+    const merged = [];
+    const seen = new Set();
+    for (const group of groups) {
+        for (const capture of group) {
+            if (seen.has(capture.captureUuid))
+                continue;
+            if (merged.length >= limit)
+                continue;
+            const next = {
+                ...capture,
+                rank: merged.length + 1,
+            };
+            merged.push(next);
+            seen.add(next.captureUuid);
+        }
+    }
+    return merged;
+}
+export function searchAll(db, query, opts = {}) {
+    const { limit = 20, source, since } = opts;
+    const fragOpts = { limit };
+    if (source === 'claude' || source === 'codex' || source === 'gemini')
+        fragOpts.source = source;
+    if (since)
+        fragOpts.since = since;
+    const fragments = searchFragments(db, query, fragOpts)
+        .map(f => ({ ...f, kind: 'fragment' }));
+    const capOpts = { limit };
+    if (since)
+        capOpts.since = since;
+    const captures = searchCaptures(db, query, capOpts)
+        .map(c => ({ ...c, kind: 'capture' }));
+    return [...fragments, ...captures]
+        .sort(compareSearchResultRelevance)
+        .slice(0, limit)
+        .map((result, index) => ({ ...result, rank: index + 1 }));
+}
+function compareSearchResultRelevance(a, b) {
+    const typeDiff = getMatchTypePriority(a.matchType) - getMatchTypePriority(b.matchType);
+    if (typeDiff !== 0)
+        return typeDiff;
+    return a.rank - b.rank;
+}
+function getMatchTypePriority(matchType) {
+    switch (matchType) {
+        case 'phrase':
+            return 0;
+        case 'all_terms':
+            return 1;
+        default:
+            return 2;
+    }
+}
+export function getCaptureCount(db, platform) {
+    if (platform) {
+        const row = db.prepare('SELECT COUNT(*) AS cnt FROM captures WHERE platform = ?').get(platform);
+        return row.cnt;
+    }
+    const row = db.prepare('SELECT COUNT(*) AS cnt FROM captures').get();
+    return row.cnt;
+}
+//# sourceMappingURL=queries.js.map