@kyleparrott/where-was-i 0.1.0

package/dist/src/core/indexer.js

@@ -0,0 +1,60 @@
+import fs from "node:fs";
+import path from "node:path";
+import { discoverCodexSessionFiles, parseCodexSessionFile } from "./codex.js";
+import { SessionSearchDb } from "./database.js";
+export function indexCodexSessions(options) {
+    const db = new SessionSearchDb(options.dbPath);
+    try {
+        const cutoffMs = options.days ? Date.now() - options.days * 24 * 60 * 60 * 1000 : null;
+        const files = filterSessionFiles(discoverCodexSessionFiles(options.codexHome, options.includeArchived), options.sessionIds);
+        const summary = { discovered: files.length, indexed: 0, skipped: 0, failed: [] };
+        let candidates = files.map((file) => ({ file, stat: fs.statSync(file) }));
+        if (cutoffMs) {
+            const before = candidates.length;
+            candidates = candidates.filter(({ stat }) => stat.mtimeMs >= cutoffMs);
+            summary.skipped += before - candidates.length;
+        }
+        if (options.recent) {
+            const before = candidates.length;
+            candidates = candidates
+                .sort((left, right) => right.stat.mtimeMs - left.stat.mtimeMs || left.file.localeCompare(right.file))
+                .slice(0, options.recent);
+            summary.skipped += before - candidates.length;
+        }
+        for (const { file, stat } of candidates) {
+            const source = {
+                path: file,
+                source: "codex",
+                size: stat.size,
+                mtimeMs: Math.round(stat.mtimeMs)
+            };
+            const existing = db.getSource(file);
+            if (!options.force &&
+                existing &&
+                existing.size === source.size &&
+                existing.mtimeMs === source.mtimeMs &&
+                db.sourceHasMessages(file)) {
+                summary.skipped += 1;
+                continue;
+            }
+            try {
+                const parsed = parseCodexSessionFile(file, { includeTools: options.includeTools });
+                db.upsertParsedSession(parsed, source);
+                summary.indexed += 1;
+            }
+            catch (error) {
+                summary.failed.push({ path: file, error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        return summary;
+    }
+    finally {
+        db.close();
+    }
+}
+function filterSessionFiles(files, sessionIds) {
+    if (!sessionIds || sessionIds.length === 0) {
+        return files;
+    }
+    return files.filter((file) => sessionIds.some((sessionId) => path.basename(file).includes(sessionId)));
+}

package/dist/src/core/paths.js

@@ -0,0 +1,20 @@
+import os from "node:os";
+import path from "node:path";
+export function expandHome(input) {
+    if (input === "~") {
+        return os.homedir();
+    }
+    if (input.startsWith("~/")) {
+        return path.join(os.homedir(), input.slice(2));
+    }
+    return input;
+}
+export function defaultCodexHome() {
+    return process.env.CODEX_HOME ? expandHome(process.env.CODEX_HOME) : path.join(os.homedir(), ".codex");
+}
+export function defaultIndexPath() {
+    if (process.env.WHERE_WAS_I_INDEX_PATH) {
+        return expandHome(process.env.WHERE_WAS_I_INDEX_PATH);
+    }
+    return path.join(os.homedir(), ".where-was-i", "index.sqlite");
+}

package/dist/src/core/reset.js

@@ -0,0 +1,18 @@
+import fs from "node:fs";
+export function resetIndexFiles(dbPath) {
+    const paths = [dbPath, `${dbPath}-wal`, `${dbPath}-shm`, `${dbPath}-journal`];
+    const summary = { deleted: [], missing: [] };
+    for (const target of paths) {
+        if (!fs.existsSync(target)) {
+            summary.missing.push(target);
+            continue;
+        }
+        const stat = fs.lstatSync(target);
+        if (stat.isDirectory()) {
+            throw new Error(`Refusing to delete directory while resetting index: ${target}`);
+        }
+        fs.unlinkSync(target);
+        summary.deleted.push(target);
+    }
+    return summary;
+}

package/dist/src/core/search-mode.js

@@ -0,0 +1,17 @@
+import { OpenAICompatibleEmbeddingProvider, isEmbeddingProviderConfigured } from "./embeddings.js";
+import { semanticFreshness } from "./semantic.js";
+export async function resolveConfiguredSearchMode(options) {
+    if (options.requestedMode !== "auto") {
+        return options.requestedMode;
+    }
+    const provider = new OpenAICompatibleEmbeddingProvider(options.embedding);
+    if (!isEmbeddingProviderConfigured(provider.config)) {
+        return "fts";
+    }
+    const freshness = await semanticFreshness({
+        dbPath: options.dbPath,
+        embedding: options.embedding,
+        probeProvider: false
+    });
+    return freshness.indexedChunks > 0 && freshness.incompatibleStoredVectors === 0 ? "hybrid" : "fts";
+}

package/dist/src/core/search.js

@@ -0,0 +1,562 @@
+import fs from "node:fs";
+import { SessionSearchDb } from "./database.js";
+import { OpenAICompatibleEmbeddingProvider } from "./embeddings.js";
+import { searchVectorChunks } from "./vector.js";
+export async function searchSessions(options) {
+    const mode = options.mode ?? "fts";
+    if (mode === "semantic") {
+        return searchSemanticSessions(options);
+    }
+    if (mode === "hybrid") {
+        return searchHybridSessions(options);
+    }
+    return searchFtsSessions(options);
+}
+export function groupSearchResultsBySession(results, maxHitsPerSession = 3) {
+    const grouped = new Map();
+    for (const result of results) {
+        const existing = grouped.get(result.sessionId);
+        if (existing) {
+            if (existing.hits.length < maxHitsPerSession && !hasDuplicatePreview(existing.hits, result)) {
+                existing.hits.push(result);
+            }
+            existing.score = Math.max(existing.score, result.scores.final);
+            if (isBetterHit(result, existing.bestHit)) {
+                existing.bestHit = result;
+                existing.bestMessage = resolvedLocatorFromSearchResult(result);
+                existing.match = result.match;
+                existing.session.displayTitle = displayTitleForResult(result);
+            }
+            continue;
+        }
+        const bestMessage = resolvedLocatorFromSearchResult(result);
+        grouped.set(result.sessionId, {
+            session: {
+                id: result.sessionId,
+                conversationId: result.conversationId,
+                title: isBootstrapText(result.title ?? "") ? null : result.title,
+                displayTitle: displayTitleForResult(result),
+                cwd: result.cwd,
+                sourcePath: result.sessionSourcePath,
+                startedAt: result.sessionStartedAt,
+                updatedAt: result.sessionUpdatedAt ?? result.timestamp
+            },
+            bestMessage,
+            match: result.match,
+            bestHit: result,
+            hits: [result],
+            score: result.scores.final
+        });
+    }
+    return Array.from(grouped.values()).sort((left, right) => right.score - left.score);
+}
+export function searchFtsSessions(options) {
+    const db = new SessionSearchDb(options.dbPath);
+    try {
+        const matchedTerms = contentQueryTerms(options.query);
+        const ftsQuery = toFtsQuery(matchedTerms);
+        const limit = Math.min(Math.max(options.limit ?? 10, 1), 50);
+        const rows = db.db
+            .prepare(`SELECT
+          c.id AS chunkId,
+          c.message_id AS messageId,
+          c.session_id AS sessionId,
+          c.conversation_id AS conversationId,
+          c.turn_id AS turnId,
+          c.source AS source,
+          c.source_path AS sourcePath,
+          c.ordinal AS ordinal,
+          c.chunk_index AS chunkIndex,
+          c.role AS role,
+          c.kind AS kind,
+          c.timestamp AS timestamp,
+          s.title AS title,
+          s.cwd AS cwd,
+          s.started_at AS sessionStartedAt,
+          s.updated_at AS sessionUpdatedAt,
+          s.source_path AS sessionSourcePath,
+          c.line_start AS lineStart,
+          c.line_end AS lineEnd,
+          bm25(chunks_fts) AS score,
+          snippet(chunks_fts, 3, '[', ']', '...', 14) AS snippet,
+          c.text AS text
+        FROM chunks_fts
+        JOIN chunks c ON c.id = chunks_fts.chunk_id
+        LEFT JOIN sessions s ON s.id = c.session_id
+        WHERE chunks_fts MATCH ?
+        ORDER BY score ASC
+        LIMIT ?`)
+            .all(ftsQuery, limit);
+        return rows.map((row, index) => {
+            const locator = locatorFromSearchRow(row);
+            const finalScore = 1 / (index + 1);
+            const result = {
+                ...row,
+                score: finalScore,
+                preview: previewFromText(row.text),
+                locator,
+                links: linksForLocator(locator),
+                matchMode: "fts",
+                match: {
+                    mode: "fts",
+                    sources: ["fts"],
+                    score: finalScore,
+                    rank: index + 1,
+                    ftsRank: index + 1,
+                    ftsScore: row.score,
+                    matchedTerms,
+                    matchedRoles: [row.role]
+                },
+                scores: {
+                    final: finalScore,
+                    ftsRank: index + 1,
+                    ftsScore: row.score
+                }
+            };
+            return options.includeText ? result : withoutText(result);
+        });
+    }
+    finally {
+        db.close();
+    }
+}
+async function searchSemanticSessions(options) {
+    const provider = new OpenAICompatibleEmbeddingProvider(options.embedding);
+    const embedding = await provider.embedQuery(options.query);
+    const limit = Math.min(Math.max(options.limit ?? 10, 1), 50);
+    const db = new SessionSearchDb(options.dbPath);
+    try {
+        const vectorRows = searchVectorChunks(db.db, provider.config, embedding, limit);
+        return hydrateVectorResults(db, vectorRows, "semantic", options.includeText);
+    }
+    finally {
+        db.close();
+    }
+}
+async function searchHybridSessions(options) {
+    const limit = Math.min(Math.max(options.limit ?? 10, 1), 50);
+    const ftsResults = searchFtsSessions({ ...options, limit: Math.max(limit, 25), includeText: true });
+    const semanticResults = await searchSemanticSessions({ ...options, limit: Math.max(limit, 25), includeText: true });
+    const merged = new Map();
+    for (const [index, result] of ftsResults.entries()) {
+        const finalScore = 1 / (index + 1);
+        merged.set(result.chunkId, {
+            ...result,
+            matchMode: "hybrid",
+            score: finalScore,
+            match: {
+                ...result.match,
+                mode: "hybrid",
+                sources: ["fts"],
+                score: finalScore,
+                rank: index + 1,
+                ftsRank: index + 1,
+                ftsScore: result.scores.ftsScore,
+                semanticRank: undefined,
+                vectorDistance: undefined
+            },
+            scores: {
+                final: finalScore,
+                ftsRank: index + 1,
+                ftsScore: result.scores.ftsScore
+            }
+        });
+    }
+    for (const [index, result] of semanticResults.entries()) {
+        const vectorScore = 1 / (index + 1);
+        const existing = merged.get(result.chunkId);
+        if (existing) {
+            existing.scores.vectorRank = index + 1;
+            existing.scores.vectorDistance = result.scores.vectorDistance;
+            existing.scores.final += vectorScore;
+            existing.score = existing.scores.final;
+            existing.match = {
+                ...existing.match,
+                sources: mergeSources(existing.match.sources, ["semantic"]),
+                score: existing.scores.final,
+                semanticRank: index + 1,
+                vectorDistance: result.scores.vectorDistance,
+                matchedRoles: mergeRoles(existing.match.matchedRoles, [result.role])
+            };
+        }
+        else {
+            merged.set(result.chunkId, {
+                ...result,
+                matchMode: "hybrid",
+                score: vectorScore,
+                match: {
+                    ...result.match,
+                    mode: "hybrid",
+                    sources: ["semantic"],
+                    score: vectorScore,
+                    rank: index + 1,
+                    semanticRank: index + 1
+                },
+                scores: {
+                    final: vectorScore,
+                    vectorRank: index + 1,
+                    vectorDistance: result.scores.vectorDistance
+                }
+            });
+        }
+    }
+    return Array.from(merged.values())
+        .sort((left, right) => right.scores.final - left.scores.final)
+        .slice(0, limit)
+        .map((result) => (options.includeText ? result : withoutText(result)));
+}
+function hydrateVectorResults(db, vectorRows, mode, includeText = false) {
+    if (vectorRows.length === 0) {
+        return [];
+    }
+    const byChunkId = new Map(vectorRows.map((row, index) => [row.chunkId, { ...row, rank: index + 1 }]));
+    const placeholders = vectorRows.map(() => "?").join(", ");
+    const rows = db.db
+        .prepare(`SELECT
+        c.id AS chunkId,
+        c.message_id AS messageId,
+        c.session_id AS sessionId,
+        c.conversation_id AS conversationId,
+        c.turn_id AS turnId,
+        c.source AS source,
+        c.source_path AS sourcePath,
+        c.ordinal AS ordinal,
+        c.chunk_index AS chunkIndex,
+        c.role AS role,
+        c.kind AS kind,
+        c.timestamp AS timestamp,
+        s.title AS title,
+        s.cwd AS cwd,
+        s.started_at AS sessionStartedAt,
+        s.updated_at AS sessionUpdatedAt,
+        s.source_path AS sessionSourcePath,
+        c.line_start AS lineStart,
+        c.line_end AS lineEnd,
+        c.text AS text
+       FROM chunks c
+       LEFT JOIN sessions s ON s.id = c.session_id
+       WHERE c.id IN (${placeholders})`)
+        .all(...vectorRows.map((row) => row.chunkId));
+    return rows
+        .map((row) => {
+        const vector = byChunkId.get(row.chunkId);
+        if (!vector) {
+            throw new Error(`Missing vector row for chunk ${row.chunkId}.`);
+        }
+        const vectorRankScore = 1 / vector.rank;
+        const locator = locatorFromSearchRow(row);
+        const result = {
+            ...row,
+            score: vectorRankScore,
+            snippet: snippetFromText(row.text),
+            preview: previewFromText(row.text),
+            locator,
+            links: linksForLocator(locator),
+            matchMode: mode,
+            match: {
+                mode,
+                sources: ["semantic"],
+                score: vectorRankScore,
+                rank: vector.rank,
+                semanticRank: vector.rank,
+                vectorDistance: vector.distance,
+                matchedTerms: [],
+                matchedRoles: [row.role]
+            },
+            scores: {
+                final: vectorRankScore,
+                vectorRank: vector.rank,
+                vectorDistance: vector.distance
+            }
+        };
+        return includeText ? result : withoutText(result);
+    })
+        .sort((left, right) => (left.scores.vectorRank ?? 0) - (right.scores.vectorRank ?? 0));
+}
+export function readSession(dbPath, sessionId, limit, offset) {
+    const db = new SessionSearchDb(dbPath);
+    try {
+        return db.listSessionMessages(sessionId, limit, offset);
+    }
+    finally {
+        db.close();
+    }
+}
+export function listRecentSessions(dbPath, limit, offset) {
+    const db = new SessionSearchDb(dbPath);
+    try {
+        return db.listRecentSessions(limit, offset).map((session) => ({
+            id: session.id,
+            conversationId: session.conversationId,
+            title: isBootstrapText(session.title ?? "") ? null : session.title,
+            displayTitle: displayTitleForSession(session.title, session.firstUserText),
+            cwd: session.cwd,
+            sourcePath: session.sourcePath,
+            startedAt: session.startedAt,
+            updatedAt: session.updatedAt,
+            messageCount: session.messageCount,
+            turnCount: session.turnCount,
+            links: linksForConversationId(session.conversationId, session.sourcePath)
+        }));
+    }
+    finally {
+        db.close();
+    }
+}
+export function readMessageContext(dbPath, messageId, before, after) {
+    const db = new SessionSearchDb(dbPath);
+    try {
+        return db.listMessagesAround(messageId, before, after);
+    }
+    finally {
+        db.close();
+    }
+}
+export function resolveMessageLocator(dbPath, messageId) {
+    const db = new SessionSearchDb(dbPath);
+    try {
+        const message = db.getMessage(messageId);
+        return message ? resolvedLocatorFromMessage(message) : null;
+    }
+    finally {
+        db.close();
+    }
+}
+export function readTurn(dbPath, turnId, limit) {
+    const db = new SessionSearchDb(dbPath);
+    try {
+        return db.listTurnMessages(turnId, limit);
+    }
+    finally {
+        db.close();
+    }
+}
+export function indexStats(dbPath) {
+    if (!fs.existsSync(dbPath)) {
+        return emptyIndexStats();
+    }
+    const db = new SessionSearchDb(dbPath);
+    try {
+        return db.stats();
+    }
+    finally {
+        db.close();
+    }
+}
+function emptyIndexStats() {
+    return {
+        sourceFiles: 0,
+        sessions: 0,
+        turns: 0,
+        messages: 0,
+        chunks: 0,
+        vectors: 0,
+        embeddingProviders: 0,
+        schemaVersion: 0,
+        lastIndexedAt: null
+    };
+}
+const QUERY_STOPWORDS = new Set([
+    "a",
+    "about",
+    "again",
+    "an",
+    "and",
+    "any",
+    "can",
+    "could",
+    "find",
+    "for",
+    "from",
+    "had",
+    "i",
+    "in",
+    "last",
+    "look",
+    "looking",
+    "me",
+    "of",
+    "on",
+    "or",
+    "session",
+    "sessions",
+    "some",
+    "that",
+    "the",
+    "this",
+    "to",
+    "talk",
+    "talked",
+    "talking",
+    "we",
+    "week",
+    "where",
+    "with",
+    "you"
+]);
+function contentQueryTerms(query) {
+    const tokens = uniqueTokens(Array.from(query.matchAll(/[\p{L}\p{N}_]+/gu), (match) => match[0].toLowerCase()));
+    if (tokens.length === 0) {
+        throw new Error("Search query must contain at least one word or number.");
+    }
+    const contentTerms = tokens.filter((token) => !QUERY_STOPWORDS.has(token));
+    return contentTerms.length > 0 ? contentTerms : tokens;
+}
+function toFtsQuery(tokens) {
+    return tokens.map((token) => ftsTerm(token)).join(" AND ");
+}
+function ftsTerm(token) {
+    const variants = new Set([token]);
+    if (token.endsWith("s") && token.length > 3) {
+        variants.add(token.slice(0, -1));
+    }
+    if (variants.size === 1) {
+        return `${token}*`;
+    }
+    return `(${Array.from(variants, (variant) => `${variant}*`).join(" OR ")})`;
+}
+function uniqueTokens(tokens) {
+    return Array.from(new Set(tokens));
+}
+function withoutText(row) {
+    const { text: _text, ...rest } = row;
+    return rest;
+}
+function snippetFromText(text) {
+    return text.replace(/\s+/g, " ").trim().slice(0, 240);
+}
+function previewFromText(text) {
+    return snippetFromText(text);
+}
+function locatorFromSearchRow(row) {
+    return {
+        source: row.source,
+        sourcePath: row.sourcePath,
+        lineStart: row.lineStart,
+        lineEnd: row.lineEnd,
+        sessionId: row.sessionId,
+        conversationId: row.conversationId,
+        turnId: row.turnId,
+        messageId: row.messageId,
+        role: row.role,
+        timestamp: row.timestamp
+    };
+}
+function locatorFromMessage(message) {
+    return {
+        source: message.source,
+        sourcePath: message.sourcePath,
+        lineStart: message.lineStart,
+        lineEnd: message.lineEnd,
+        sessionId: message.sessionId,
+        conversationId: message.conversationId,
+        turnId: message.turnId,
+        messageId: message.id,
+        role: message.role,
+        timestamp: message.timestamp
+    };
+}
+function linksForLocator(locator) {
+    return linksForConversationId(locator.source === "codex" ? locator.conversationId : null, `${locator.sourcePath}:${locator.lineStart}`);
+}
+export function linksForConversationId(conversationId, source) {
+    const codex = conversationId ? codexThreadLink(conversationId) : null;
+    return {
+        codex,
+        openCommand: codex ? openCommandForUri(codex) : null,
+        source
+    };
+}
+export function codexThreadLink(conversationId) {
+    return `codex://threads/${encodeURIComponent(conversationId)}`;
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+export function openCommandForUri(uri) {
+    if (process.platform === "win32") {
+        return `start "" ${windowsQuote(uri)}`;
+    }
+    if (process.platform === "darwin") {
+        return `open ${shellQuote(uri)}`;
+    }
+    return `xdg-open ${shellQuote(uri)}`;
+}
+function windowsQuote(value) {
+    return `"${value.replaceAll('"', '\\"')}"`;
+}
+function resolvedLocatorFromSearchResult(result) {
+    return {
+        messageId: result.messageId,
+        sessionId: result.sessionId,
+        conversationId: result.conversationId,
+        turnId: result.turnId,
+        role: result.role,
+        timestamp: result.timestamp,
+        preview: result.preview,
+        locator: result.locator,
+        links: result.links
+    };
+}
+function resolvedLocatorFromMessage(message) {
+    const locator = locatorFromMessage(message);
+    return {
+        messageId: message.id,
+        sessionId: message.sessionId,
+        conversationId: message.conversationId,
+        turnId: message.turnId,
+        role: message.role,
+        timestamp: message.timestamp,
+        preview: previewFromText(message.text),
+        locator,
+        links: linksForLocator(locator)
+    };
+}
+function displayTitleForResult(result) {
+    if (!isBootstrapText(result.preview)) {
+        return result.preview;
+    }
+    if (result.title && !isBootstrapText(result.title)) {
+        return result.title;
+    }
+    return "(untitled session)";
+}
+function displayTitleForSession(title, firstUserText) {
+    if (title && !isBootstrapText(title)) {
+        return previewFromText(title);
+    }
+    if (firstUserText && !isBootstrapText(firstUserText)) {
+        return previewFromText(firstUserText);
+    }
+    return "(untitled session)";
+}
+function hasDuplicatePreview(results, candidate) {
+    const normalized = normalizePreview(candidate.preview);
+    return results.some((result) => normalizePreview(result.preview) === normalized);
+}
+function normalizePreview(value) {
+    return value.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function isBetterHit(candidate, current) {
+    const scoreDelta = candidate.scores.final - current.scores.final;
+    if (Math.abs(scoreDelta) > Number.EPSILON) {
+        return scoreDelta > 0;
+    }
+    if (isBootstrapText(current.preview) !== isBootstrapText(candidate.preview)) {
+        return !isBootstrapText(candidate.preview);
+    }
+    if (current.role !== "user" && candidate.role === "user") {
+        return true;
+    }
+    return candidate.timestamp !== null && current.timestamp !== null && candidate.timestamp < current.timestamp;
+}
+function isBootstrapText(text) {
+    const normalized = text.trim();
+    return normalized.startsWith("# AGENTS.md instructions") || normalized.startsWith("<INSTRUCTIONS>");
+}
+function mergeSources(existing, next) {
+    return Array.from(new Set([...existing, ...next]));
+}
+function mergeRoles(existing, next) {
+    return Array.from(new Set([...existing, ...next]));
+}