memonaut 0.0.0 → 0.2.0

package/dist/regex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.d.ts","sourceRoot":"","sources":["../src/regex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,SAAS,CAAC;AAChC,OAAO,KAAK,EAAC,SAAS,EAAE,SAAS,EAAC,MAAM,YAAY,CAAC;AAKrD;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,MAAM,WAAW,UAAU;IAC1B,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,gDAAgD;IAChD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,4CAA4C;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,qEAAqE;IACrE,aAAa,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,cAAc,EAAE,MAAM,CAAC;IACvB,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,SAAS,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,eAAO,MAAM,mBAAmB,OAAO,CAAC;AA8GxC;;;GAGG;AACH,wBAAsB,WAAW,CAChC,EAAE,EAAE,EAAE,EACN,KAAK,EAAE,UAAU,GACf,OAAO,CAAC,YAAY,CAAC,CAyLvB"}

package/dist/regex.js

@@ -0,0 +1,242 @@
+import { extractEntry } from './pi-source.js';
+import { ripgrep } from './ripgrep.js';
+import { collectThreads, loadFiles, visibleSets } from './search.js';
+export const DEFAULT_MAX_PER_FILE = 200;
+export const DEFAULT_MAX_MATCHES = 2000;
+/** Context kept either side of the match in a snippet, in characters. */
+const SNIPPET_RADIUS = 70;
+/** Everything the extractor can see, so the snippet is not limited by the tier. */
+const FULL_EXTRACT = {
+    tier: 'full',
+    toolResultHeadBytes: Number.MAX_SAFE_INTEGER,
+    toolArgsHeadBytes: Number.MAX_SAFE_INTEGER,
+};
+function windowAround(text, start, length, radius = SNIPPET_RADIUS) {
+    const from = Math.max(0, start - radius);
+    const to = Math.min(text.length, start + length + radius);
+    // \u0001/\u0002 are the same markers FTS5 `snippet()` emits, so the renderer
+    // paints a regex hit exactly like a normal one.
+    return ((from > 0 ? '…' : '') +
+        text.slice(from, start) +
+        '\u0001' +
+        text.slice(start, start + length) +
+        '\u0002' +
+        text.slice(start + length, to) +
+        (to < text.length ? '…' : ''));
+}
+function indexOfNeedle(haystack, needle, ignoreCase) {
+    if (!needle)
+        return -1;
+    if (!ignoreCase)
+        return haystack.indexOf(needle);
+    return haystack.toLowerCase().indexOf(needle.toLowerCase());
+}
+/**
+ * Turn a matched raw line into something a human can read, and say where the
+ * matched bytes actually live.
+ *
+ * The needle is rg's own `submatches[0]`, which is a LITERAL whatever the
+ * pattern was, so nothing here has to re-implement Rust regex semantics in
+ * JavaScript.
+ *
+ * Three outcomes, and keeping them apart is the honesty of the whole feature:
+ * the needle is in extracted text that is also indexed (`index`); it is in
+ * extracted text that is NOT indexed, because of the tier or because the chunk
+ * was truncated before it (`transcript`); or it is in none of the extracted
+ * text at all, so it matched a JSON key, an id or an escape sequence
+ * (`structure`). Only the middle one means "the index could never have found
+ * this". Labelling a match on `"timestamp":` that way would be a lie about an
+ * entry whose text is indexed perfectly well.
+ */
+function describeMatch(raw, match, ignoreCase, indexedTexts) {
+    const extracted = extractEntry(raw, 0, 0, FULL_EXTRACT)?.chunks ?? [];
+    for (const chunk of extracted) {
+        const at = indexOfNeedle(chunk.text, match.needle, ignoreCase);
+        if (at < 0)
+            continue;
+        const indexed = indexedTexts.some((text) => indexOfNeedle(text, match.needle, ignoreCase) >= 0);
+        return {
+            kind: chunk.kind,
+            snippet: windowAround(chunk.text, at, match.needle.length),
+            matchedIn: indexed ? 'index' : 'transcript',
+        };
+    }
+    // Nothing anyone wrote: no kind fits, so none is invented.
+    const at = indexOfNeedle(match.line, match.needle, ignoreCase);
+    return {
+        snippet: at >= 0
+            ? windowAround(match.line.trimEnd(), at, match.needle.length)
+            : match.line.slice(0, SNIPPET_RADIUS * 2),
+        matchedIn: 'structure',
+    };
+}
+/**
+ * Search the transcripts themselves, and report the result exactly as the
+ * index-backed search would.
+ */
+export async function regexSearch(db, query) {
+    const limit = query.limit ?? 20;
+    const threadLimit = query.threadLimit ?? 3;
+    // A cap that is NaN or zero would mean "collect every match in the corpus",
+    // which is exactly the unbounded read this is here to prevent.
+    const maxMatches = query.maxMatches !== undefined &&
+        Number.isFinite(query.maxMatches) &&
+        query.maxMatches > 0
+        ? query.maxMatches
+        : DEFAULT_MAX_MATCHES;
+    const files = loadFiles(db);
+    const visible = visibleSets(files, query);
+    // The earliest moment a lineage could hold: a fork's own `started` is later
+    // than the entries it inherited, so an `until` bound must be judged against
+    // the whole family or a fork whose parent is gone from disk would be skipped.
+    const lineageStart = new Map();
+    for (const file of files.values()) {
+        if (file.lineage_id === null || !file.started)
+            continue;
+        const id = Number(file.lineage_id);
+        const known = lineageStart.get(id);
+        if (!known || file.started < known)
+            lineageStart.set(id, file.started);
+    }
+    // Path to lineage: the lineage is all a matched line needs, because entry
+    // identity is (lineage_id, entry_key) and a fork copy resolves to the entry
+    // its ancestor owns.
+    const byPath = new Map();
+    const paths = [];
+    for (const file of files.values()) {
+        const fileId = Number(file.id);
+        if (!visible.files.has(fileId))
+            continue;
+        if (file.lineage_id === null)
+            continue;
+        const lineageId = Number(file.lineage_id);
+        // Time prefilters, kept conservative: `last_activity` is the newest entry
+        // in this file INCLUDING inherited ones, so it is a sound `since` bound.
+        if (query.since && file.last_activity && file.last_activity < query.since)
+            continue;
+        const start = lineageStart.get(lineageId);
+        if (query.until && start && start > query.until)
+            continue;
+        byPath.set(file.path, lineageId);
+        paths.push(file.path);
+    }
+    const outcome = {
+        hits: [],
+        filesSearched: paths.length,
+        rawMatches: 0,
+        entriesMatched: 0,
+        scanned: 0,
+        truncated: false,
+        unresolved: 0,
+    };
+    if (paths.length === 0)
+        return outcome;
+    const entryStmt = db.prepare(`SELECT id, entry_key, lineage_id, role, tool, ts
+       FROM entry WHERE lineage_id = ? AND entry_key = ?`);
+    const chunkStmt = db.prepare('SELECT text FROM chunk WHERE entry_id = ?');
+    const roleFilter = query.role?.length ? new Set(query.role) : null;
+    const toolFilter = query.tool?.length ? new Set(query.tool) : null;
+    const kindFilter = query.kind?.length ? new Set(query.kind) : null;
+    const seen = new Set();
+    const candidates = [];
+    await ripgrep(paths, {
+        pattern: query.pattern,
+        ignoreCase: query.ignoreCase,
+        fixed: query.fixed,
+        maxPerFile: query.maxPerFile ?? DEFAULT_MAX_PER_FILE,
+        binary: query.binary,
+    }, (match) => {
+        outcome.rawMatches++;
+        const lineage = byPath.get(match.path);
+        if (lineage === undefined)
+            return;
+        let raw;
+        try {
+            raw = JSON.parse(match.line);
+        }
+        catch {
+            outcome.unresolved++;
+            return;
+        }
+        const entryKey = typeof raw.id === 'string' ? raw.id : null;
+        if (!entryKey)
+            return; // the session header line carries no identity
+        const entry = entryStmt.get(lineage, entryKey);
+        if (!entry) {
+            outcome.unresolved++;
+            return;
+        }
+        // THE fork rule: a shared entry is reported by rg once per fork file
+        // that copied it, and must collapse to one hit here. `(lineage, key)`
+        // resolved to one entry row, so its id is the deduplication key.
+        const entryId = Number(entry.id);
+        if (seen.has(entryId))
+            return;
+        seen.add(entryId);
+        if (roleFilter && !roleFilter.has(entry.role))
+            return;
+        if (toolFilter && !(entry.tool && toolFilter.has(entry.tool)))
+            return;
+        if (query.since && (!entry.ts || entry.ts < query.since))
+            return;
+        if (query.until && (!entry.ts || entry.ts > query.until))
+            return;
+        const indexedTexts = chunkStmt.all(entryId).map((r) => r.text);
+        const described = describeMatch(raw, match, Boolean(query.ignoreCase), indexedTexts);
+        // A structural match has no kind, so a --kind filter excludes it: it is
+        // not text of that kind, and pretending otherwise would be a guess.
+        if (kindFilter && !(described.kind && kindFilter.has(described.kind)))
+            return;
+        candidates.push({ entry, ...described });
+        if (candidates.length >= maxMatches) {
+            outcome.truncated = true;
+            return false;
+        }
+    });
+    outcome.entriesMatched = candidates.length;
+    // No bm25 here, and inventing a score would be a lie. Recency of the matched
+    // entry is the ordering, newest first.
+    candidates.sort((a, b) => (b.entry.ts ?? '').localeCompare(a.entry.ts ?? ''));
+    const memberStmt = db.prepare('SELECT file_id, seq FROM membership WHERE entry_id = ?');
+    const groups = new Map();
+    const order = [];
+    for (const candidate of candidates) {
+        const lineageId = Number(candidate.entry.lineage_id);
+        const existing = groups.get(lineageId);
+        if (existing) {
+            // Same grouping as the FTS path: one chatty lineage cannot own the page,
+            // and the matches it displaced are counted rather than dropped silently.
+            existing.otherHits++;
+            continue;
+        }
+        const threads = collectThreads(Number(candidate.entry.id), memberStmt, files, visible.files);
+        if (threads.length === 0)
+            continue;
+        const hit = {
+            entryId: Number(candidate.entry.id),
+            entryKey: candidate.entry.entry_key,
+            lineageId,
+            role: candidate.entry.role,
+            tool: candidate.entry.tool,
+            ts: candidate.entry.ts,
+            kind: candidate.kind,
+            snippet: candidate.snippet,
+            // No bm25 to rank with, so no score is claimed; the array order is the
+            // answer, newest match first.
+            score: 0,
+            threads: threadLimit < 0 ? threads : threads.slice(0, Math.max(threadLimit, 1)),
+            threadTotal: threads.length,
+            otherHits: 0,
+            matchedIn: candidate.matchedIn,
+        };
+        groups.set(lineageId, hit);
+        order.push(lineageId);
+    }
+    outcome.scanned = order.length;
+    outcome.hits = order
+        .map((id) => groups.get(id))
+        .filter((h) => Boolean(h))
+        .slice(0, limit);
+    return outcome;
+}
+//# sourceMappingURL=regex.js.map

package/dist/regex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.js","sourceRoot":"","sources":["../src/regex.ts"],"names":[],"mappings":"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"}

package/dist/ripgrep.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Thin wrapper around `rg --json`.
+ *
+ * Regex over the raw transcripts is a genuinely different capability from the
+ * FTS index (see `docs/DESIGN.md`): FTS5 tokenises, so it can never do
+ * substring-inside-identifier or true regex, and the raw files hold text the
+ * index deliberately does not (tool output is 42% of the bytes). Rather than
+ * reimplement a scanner over 2 GB of JSONL in JavaScript, this shells out to
+ * the tool that already does it well, and refuses to pretend when it is absent.
+ */
+export declare const DEFAULT_RG = "rg";
+export declare function ripgrepBinary(env?: NodeJS.ProcessEnv): string;
+export declare class RipgrepMissingError extends Error {
+    readonly binary: string;
+    constructor(binary: string);
+}
+export declare class RipgrepError extends Error {
+    constructor(message: string);
+}
+/** One matching line, as rg reported it. */
+export interface RipgrepMatch {
+    /** Path exactly as it was handed to rg, so it can be looked up in the index. */
+    path: string;
+    /** The whole matching line, which for a transcript is one complete JSON entry. */
+    line: string;
+    /** Byte offset of the line within the file. */
+    offset: number;
+    /** The literal text the pattern matched. A literal, whatever the pattern was. */
+    needle: string;
+}
+export interface RipgrepOptions {
+    pattern: string;
+    ignoreCase?: boolean;
+    /** `-F`: the pattern is a literal string, not a regex. */
+    fixed?: boolean;
+    /** `-m`: per-file cap. 0 disables it. */
+    maxPerFile?: number;
+    binary?: string;
+}
+/**
+ * Run rg over `paths`, calling `onMatch` for each matching line.
+ *
+ * Output is consumed as it arrives, so at most ONE record is ever held: a
+ * single transcript line can be megabytes (a base64 image), and `--json` echoes
+ * the whole line back, so accumulating rg's output is not an option. What
+ * `onMatch` then does with that one line is its own business, and runs inline
+ * on this handler. Returning `false` stops the scan and kills rg.
+ */
+export declare function ripgrep(paths: string[], opts: RipgrepOptions, onMatch: (match: RipgrepMatch) => boolean | void): Promise<void>;
+/** True when a usable ripgrep is on PATH. For tests and for `--help` honesty. */
+export declare function ripgrepAvailable(binary?: string): Promise<boolean>;
+//# sourceMappingURL=ripgrep.d.ts.map

package/dist/ripgrep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ripgrep.d.ts","sourceRoot":"","sources":["../src/ripgrep.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAEH,eAAO,MAAM,UAAU,OAAO,CAAC;AAE/B,wBAAgB,aAAa,CAAC,GAAG,oBAAc,GAAG,MAAM,CAEvD;AAED,qBAAa,mBAAoB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBACZ,MAAM,EAAE,MAAM;CAW1B;AAED,qBAAa,YAAa,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM;CAI3B;AAED,4CAA4C;AAC5C,MAAM,WAAW,YAAY;IAC5B,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;IACb,kFAAkF;IAClF,IAAI,EAAE,MAAM,CAAC;IACb,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,MAAM,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,yCAAyC;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAiED;;;;;;;;GAQG;AACH,wBAAsB,OAAO,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,GAAG,IAAI,GAC9C,OAAO,CAAC,IAAI,CAAC,CAgBf;AA2FD,iFAAiF;AACjF,wBAAsB,gBAAgB,CACrC,MAAM,SAAkB,GACtB,OAAO,CAAC,OAAO,CAAC,CAalB"}

package/dist/ripgrep.js

@@ -0,0 +1,217 @@
+import { spawn } from 'node:child_process';
+/**
+ * Thin wrapper around `rg --json`.
+ *
+ * Regex over the raw transcripts is a genuinely different capability from the
+ * FTS index (see `docs/DESIGN.md`): FTS5 tokenises, so it can never do
+ * substring-inside-identifier or true regex, and the raw files hold text the
+ * index deliberately does not (tool output is 42% of the bytes). Rather than
+ * reimplement a scanner over 2 GB of JSONL in JavaScript, this shells out to
+ * the tool that already does it well, and refuses to pretend when it is absent.
+ */
+export const DEFAULT_RG = 'rg';
+export function ripgrepBinary(env = process.env) {
+    return env.MEMONAUT_RG?.trim() || DEFAULT_RG;
+}
+export class RipgrepMissingError extends Error {
+    binary;
+    constructor(binary) {
+        super([
+            `regex search needs ripgrep, and \`${binary}\` was not found.`,
+            '  install it:  apt install ripgrep · brew install ripgrep · cargo install ripgrep',
+            '  or point MEMONAUT_RG at the binary.',
+        ].join('\n'));
+        this.name = 'RipgrepMissingError';
+        this.binary = binary;
+    }
+}
+export class RipgrepError extends Error {
+    constructor(message) {
+        super(`ripgrep: ${message}`);
+        this.name = 'RipgrepError';
+    }
+}
+/**
+ * argv budget per invocation.
+ *
+ * `ARG_MAX` is ~2 MB on Linux and 256 KB on macOS, and a transcript path is
+ * ~110 bytes, so batching by both count and byte length keeps every platform
+ * far away from E2BIG.
+ */
+const BATCH_FILES = 400;
+const BATCH_BYTES = 96_000;
+function decode(field) {
+    if (!field)
+        return '';
+    if (typeof field.text === 'string')
+        return field.text;
+    if (typeof field.bytes === 'string')
+        return Buffer.from(field.bytes, 'base64').toString('utf8');
+    return '';
+}
+function batches(paths) {
+    const out = [];
+    let current = [];
+    let bytes = 0;
+    for (const p of paths) {
+        if (current.length > 0 &&
+            (current.length >= BATCH_FILES || bytes + p.length + 1 > BATCH_BYTES)) {
+            out.push(current);
+            current = [];
+            bytes = 0;
+        }
+        current.push(p);
+        bytes += p.length + 1;
+    }
+    if (current.length)
+        out.push(current);
+    return out;
+}
+function baseArgs(opts) {
+    const args = [
+        '--json',
+        // Errors about files that vanished between the index scan and now are not
+        // the user's problem; a real pattern error still reaches stderr.
+        '--no-messages',
+        // The user's ripgrep config must not change what a search means here.
+        '--no-config',
+        // Explicit paths already come from the index, which is the only ignore
+        // list that matters. --text stops a transcript being silently skipped as
+        // binary; they are JSON, so there is nothing to blow up on.
+        '--no-ignore',
+        '--text',
+    ];
+    if (opts.ignoreCase)
+        args.push('-i');
+    if (opts.fixed)
+        args.push('-F');
+    // Explicitly finite: a NaN cap must not take the same branch as the
+    // documented "0 means all", or a mistyped flag silently removes the bound.
+    if (Number.isFinite(opts.maxPerFile) && opts.maxPerFile > 0)
+        args.push('-m', String(opts.maxPerFile));
+    // -e, so a pattern starting with `-` is a pattern and not a flag.
+    args.push('-e', opts.pattern);
+    return args;
+}
+/**
+ * Run rg over `paths`, calling `onMatch` for each matching line.
+ *
+ * Output is consumed as it arrives, so at most ONE record is ever held: a
+ * single transcript line can be megabytes (a base64 image), and `--json` echoes
+ * the whole line back, so accumulating rg's output is not an option. What
+ * `onMatch` then does with that one line is its own business, and runs inline
+ * on this handler. Returning `false` stops the scan and kills rg.
+ */
+export async function ripgrep(paths, opts, onMatch) {
+    if (paths.length === 0)
+        return;
+    const binary = opts.binary ?? ripgrepBinary();
+    const args = baseArgs(opts);
+    let stop = false;
+    for (const batch of batches(paths)) {
+        if (stop)
+            return;
+        await runOne(binary, [...args, '--', ...batch], (match) => {
+            const keepGoing = onMatch(match);
+            if (keepGoing === false) {
+                stop = true;
+                return false;
+            }
+            return true;
+        });
+    }
+}
+function runOne(binary, args, onMatch) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(binary, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stderr = '';
+        let buffer = '';
+        let killed = false;
+        let settled = false;
+        const finish = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            if (err)
+                reject(err);
+            else
+                resolve();
+        };
+        child.on('error', (err) => {
+            const code = err.code;
+            if (code === 'ENOENT')
+                finish(new RipgrepMissingError(binary));
+            else
+                finish(err);
+        });
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (chunk) => {
+            if (stderr.length < 4096)
+                stderr += chunk;
+        });
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('error', () => {
+            /* EPIPE after an early kill */
+        });
+        child.stdout.on('data', (chunk) => {
+            if (killed)
+                return;
+            buffer += chunk;
+            let nl;
+            while ((nl = buffer.indexOf('\n')) >= 0) {
+                const line = buffer.slice(0, nl);
+                buffer = buffer.slice(nl + 1);
+                if (!line)
+                    continue;
+                let record;
+                try {
+                    record = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (record.type !== 'match')
+                    continue;
+                const data = record.data;
+                const sub = data.submatches?.[0];
+                const match = {
+                    path: decode(data.path),
+                    line: decode(data.lines),
+                    offset: Number(data.absolute_offset ?? 0),
+                    needle: decode(sub?.match),
+                };
+                if (!onMatch(match)) {
+                    killed = true;
+                    buffer = '';
+                    child.kill();
+                    return;
+                }
+            }
+        });
+        child.on('close', (code) => {
+            if (killed)
+                return finish();
+            // 0 = matches, 1 = no matches. 2 is "something went wrong", which with
+            // --no-messages is usually just a transcript that was deleted since the
+            // index last saw it; a real complaint (a bad pattern) reaches stderr.
+            if (code !== null && code >= 2 && stderr.trim())
+                return finish(new RipgrepError(stderr.trim()));
+            finish();
+        });
+    });
+}
+/** True when a usable ripgrep is on PATH. For tests and for `--help` honesty. */
+export async function ripgrepAvailable(binary = ripgrepBinary()) {
+    try {
+        await new Promise((resolve, reject) => {
+            const child = spawn(binary, ['--version'], { stdio: 'ignore' });
+            child.on('error', reject);
+            child.on('close', (code) => code === 0 ? resolve() : reject(new Error(String(code))));
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=ripgrep.js.map

package/dist/ripgrep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ripgrep.js","sourceRoot":"","sources":["../src/ripgrep.ts"],"names":[],"mappings":"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"}

package/dist/search.d.ts

@@ -0,0 +1,114 @@
+import type { DB } from './db.js';
+import type { ChunkKind, SearchHit, ThreadRef } from './model.js';
+export interface FileRecord {
+    id: number;
+    path: string;
+    source: string;
+    session_uuid: string | null;
+    cwd: string | null;
+    project: string | null;
+    name: string | null;
+    parent_id: number | null;
+    lineage_id: number | null;
+    lineage_depth: number;
+    orphaned: number;
+    private: number;
+    started: string | null;
+    last_activity: string | null;
+    entry_count: number;
+}
+export interface SearchQuery {
+    /** FTS5 MATCH expression (see `docs/QUERIES.md`). */
+    text: string;
+    cwd?: string[];
+    project?: string[];
+    role?: string[];
+    tool?: string[];
+    kind?: ChunkKind[];
+    since?: string;
+    until?: string;
+    includePrivate?: boolean;
+    limit?: number;
+    /** Threads listed per group; the total is always reported. */
+    threadLimit?: number;
+    /** Disable the recency nudge and rank purely on bm25 x kind weight. */
+    noRecency?: boolean;
+    /** Pass the query to FTS5 verbatim, never fall back to quoting. */
+    raw?: boolean;
+}
+export interface SearchOutcome {
+    hits: SearchHit[];
+    /** The MATCH expression actually used, after any quoting fallback. */
+    usedQuery: string;
+    /** Total groups found before `limit` was applied. */
+    scanned: number;
+    quotedFallback: boolean;
+}
+export declare function loadFiles(db: DB): Map<number, FileRecord>;
+/** Quote every token, turning a hostile string into a valid FTS5 AND query. */
+export declare function quoteQuery(text: string): string;
+/**
+ * Which transcripts a query is allowed to see.
+ *
+ * Visibility is decided per THREAD, because a lineage can in principle span
+ * working directories; the lineage set is only a prefilter. Both the FTS and
+ * the regex path go through here, so `private` and the cwd/project filters
+ * cannot drift apart between them.
+ */
+export declare function visibleSets(files: Map<number, FileRecord>, query: Pick<SearchQuery, 'cwd' | 'project' | 'includePrivate'>): {
+    files: Set<number>;
+    lineages: Set<number>;
+    totalLineages: Set<number>;
+};
+export declare function search(db: DB, query: SearchQuery, now?: number): SearchOutcome;
+/**
+ * Fan one entry back out to every visible thread that carries it.
+ *
+ * Shared by the FTS and the regex path, because they must produce identical
+ * thread lists: an entry is stored once and `membership` is what turns it back
+ * into "the twelve threads that inherited this".
+ */
+export declare function collectThreads(entryId: number, memberStmt: ReturnType<DB['prepare']>, files: Map<number, FileRecord>, visibleFiles: Set<number>): ThreadRef[];
+/** Resolve a user-supplied reference to a thread: file id, uuid prefix, or path. */
+export declare function resolveThread(db: DB, ref: string): FileRecord | null;
+export interface ThreadEntry {
+    seq: number;
+    entryId: number;
+    entryKey: string;
+    role: string;
+    tool: string | null;
+    ts: string | null;
+    /** True when this entry was inherited from an ancestor rather than written here. */
+    shared: boolean;
+    /** Transcript that first recorded this entry, and where it lives verbatim. */
+    ownerPath: string | null;
+    byteOffset: number;
+    byteLength: number;
+    texts: Array<{
+        kind: ChunkKind;
+        text: string;
+    }>;
+}
+/**
+ * Read one thread back in order.
+ *
+ * `ownerPath` + byte range is the pointer back to the source transcript. The
+ * index deliberately stores tool output truncated (or not at all), so anything
+ * that needs full fidelity re-reads those bytes instead of trusting the cache.
+ */
+export declare function readThread(db: DB, fileId: number, from?: number, limit?: number): ThreadEntry[];
+export interface IndexStatsRow {
+    files: number;
+    lineages: number;
+    forks: number;
+    entries: number;
+    memberships: number;
+    chunks: number;
+    privateFiles: number;
+    orphans: number;
+    projects: number;
+    oldest: string | null;
+    newest: string | null;
+}
+export declare function indexStats(db: DB): IndexStatsRow;
+//# sourceMappingURL=search.d.ts.map