devsmind-mcp 2.3.0 → 3.0.0

package/dist/db/grep.js

@@ -0,0 +1,475 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefaultIgnoredFile = isDefaultIgnoredFile;
+exports.escapeRegExp = escapeRegExp;
+exports.grepRepos = grepRepos;
+exports.rankGrepHits = rankGrepHits;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * A fast, dependency-free filesystem grep — the "last resort" file layer of `search_nodes`,
+ * and the thing that lets it finally cover files the graph never indexes (CSS, JSON, config,
+ * markup, un-indexed code). Deliberately self-contained: no DB, no MCP, so it can be unit-tested
+ * in isolation and reasoned about purely as "given roots + a pattern, return where it appears".
+ *
+ * The pattern is a REAL regex — not escaped, not split on a delimiter. An agent can pass exactly
+ * what it would give `grep`: alternation (`a|b`), escaped literals (`item\.liked`), character
+ * classes, anything. Earlier versions took a list of literal `keywords`, escaped each one, and
+ * OR-joined them — which meant an agent passing its OWN already-correct regex (e.g.
+ * `item\.liked`) got it re-escaped into a search for a literal backslash, silently matching
+ * nothing. That mismatch between what the caller wrote and what the tool actually searched for
+ * is the whole reason for this rewrite.
+ *
+ * Performance is the whole point: the tool is only worth using if it's as fast as grep, or the
+ * AI just reaches for grep instead. So this does ONE walk over each repo, tests the pattern in a
+ * single compiled regex per line, skips junk dirs / binary / oversized files before ever reading
+ * them, and hard-stops at a deadline with a partial result rather than ever blowing the budget.
+ *
+ * Walking and reading are both SYNCHRONOUS (`fs.readdirSync`/`fs.statSync`/`fs.readFileSync`), not
+ * `fs.promises` + bounded concurrency as an earlier version did. That sounds like it should be
+ * slower — it isn't. Every `fs.promises` call queues onto Node's libuv threadpool, which defaults
+ * to just 4 threads; "bounded concurrency" in JS-land doesn't mean bounded OS-level parallelism,
+ * it means potentially thousands of promises competing for 4 real workers, and on Windows especially
+ * (antivirus adds latency to every filesystem call) that queuing dominated wall-clock time. Measured
+ * against a real 8-repo production checkout: the async version took multiple MINUTES per search on
+ * some queries; sync took low hundreds of milliseconds for the identical walk. Sync fs calls bypass
+ * the threadpool entirely — a brief main-thread block for a fast operation beats a "concurrent" one
+ * queued behind a 4-worker bottleneck.
+ */
+/** Directories never worth searching — build output, deps, VCS internals. Mirrors scanner.ts. */
+const ALWAYS_IGNORED = [
+    'node_modules', '.git', 'dist', 'build', 'out', '.next',
+    '__pycache__', '.venv', 'venv', 'coverage', '.turbo',
+    '.cache', '.idea', '.vscode', '.devmind',
+    // Mobile/native build & dependency caches — not JS/Python-shaped, so the list above misses
+    // them entirely. Left out originally, these are exactly the giant, non-source directories
+    // (hundreds of thousands of files in Pods/DerivedData on a real iOS checkout) that a
+    // path-blind grep walk would otherwise crawl on every single search.
+    '.dart_tool', '.gradle', '.symlinks', 'Pods', 'DerivedData', '.expo', 'Carthage'
+];
+/**
+ * Individual FILES never worth grepping, matched on basename. Every entry here is machine-written:
+ * a dependency resolution dump or a build artifact. They are the single biggest source of false
+ * positives in a real search — a lockfile mentions every package name in the tree, so a pattern
+ * like `alipay|Alipay` matches `yarn.lock` and `package-lock.json` purely because a dependency is
+ * named that, ranking them alongside the actual source the agent was looking for.
+ *
+ * Note what is deliberately NOT here: `.env`. The file-level doc comment above, the `search_nodes`
+ * tool description, and the generated agent memory all advertise the files bucket as how you find
+ * "CSS, JSON, .env, markup" — "which env var drives this" is a documented, intended use. Excluding
+ * it by default would silently reverse a shipped contract. A user who wants it gone can still put
+ * it in `ignored_paths`, which IS honored per-file now (see `shouldIgnorePath`).
+ *
+ * Exact basenames, not globs, on purpose: `ignored_paths` has no glob engine (init.ts filters glob
+ * lines out of .gitignore import and tells the user so), and a built-in list that spoke a language
+ * the user's own config couldn't would be its own trap. `DENIED_SUFFIXES` covers the few cases
+ * that genuinely need a wildcard, via plain `endsWith`.
+ */
+const DENIED_BASENAMES = new Set([
+    'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'npm-shrinkwrap.json', 'bun.lockb',
+    'composer.lock', 'Gemfile.lock', 'poetry.lock', 'Cargo.lock', 'Podfile.lock', 'pubspec.lock',
+    'go.sum'
+]);
+/** Generated/derived files, matched on suffix — minified bundles and source maps. */
+const DENIED_SUFFIXES = ['.min.js', '.min.css', '.map'];
+/**
+ * True if a path is a lockfile or build artifact excluded from search by default. Exported so
+ * `searchNodes` can tell an agent that explicitly scoped `path` AT such a file WHY it got nothing
+ * back, rather than leaving it to read as "the pattern isn't in there".
+ */
+function isDefaultIgnoredFile(filePath) {
+    const base = path.basename(filePath);
+    return DENIED_BASENAMES.has(base) || DENIED_SUFFIXES.some(sfx => base.endsWith(sfx));
+}
+/** Files above this are almost never hand-written source worth grepping (minified bundles, data dumps). */
+const MAX_FILE_BYTES = 1_000_000;
+/** Bytes sniffed from the head of a file to decide "is this binary" (a NUL byte ⇒ binary). */
+const BINARY_SNIFF_BYTES = 4096;
+/** Caps matches recorded per line — a pathological line (a minified bundle that slipped past the
+ * size/binary filters, or a pattern like `.` against a long line) shouldn't blow up memory. */
+const MAX_MATCHES_PER_LINE = 20;
+/**
+ * Path-segment-aware, mirroring scanner.ts's `shouldIgnore` exactly (kept as a separate copy,
+ * not a shared import — grep.ts is deliberately dependency-free, see the file-level doc comment).
+ *
+ * This used to be a bare `ALWAYS_IGNORED.includes(name) || extraIgnored.includes(name)` — an
+ * EXACT match against just the current directory's basename. That silently failed to honor any
+ * multi-segment `ignored_paths` entry (e.g. "ios/Pods", or a path picked via the `devsmind init`
+ * folder browser, which stores a path like "ios/Pods" rather than the bare name "Pods"): walking
+ * into a directory literally named "Pods" tested `"ios/Pods".includes("Pods")` against the wrong
+ * variable — `extraIgnored.includes(name)` checks array membership of "Pods" against the literal
+ * string "ios/Pods", which is never true. The directory was walked (and every file in it read)
+ * on every single search regardless of the exclusion the user explicitly configured. Same root
+ * cause the file-level doc comment already documents for enumeration cost in general: this was
+ * the biggest reason a single un-ignored deep native-deps folder could dominate `search_nodes`
+ * latency even after the user had "already excluded it."
+ *
+ * Named `shouldIgnorePath`, not `shouldIgnoreDir`, because it is applied to FILE entries too now.
+ * It always could be — the matching is on the full path, so `".../package-lock.json"` correctly
+ * satisfies `endsWith("/package-lock.json")`. It simply was never called on the file branch of
+ * the walk, which meant every FILE entry a user had put in `ignored_paths` was silently inert for
+ * search. That was not a rare configuration: `devsmind init`'s own preset list is entirely file
+ * names (package-lock.json, yarn.lock, tsconfig.json…), and .gitignore import passes literal file
+ * names straight through. Users had excluded these, seen them keep showing up in every result,
+ * and had no way to tell the exclusion was being dropped on the floor. `scanner.ts` applies the
+ * equivalent check to files correctly; grep.ts was the outlier.
+ *
+ * The leading-slash strip matters for the same class of reason: `.gitignore` conventionally writes
+ * a repo-root anchor as `/dist`, and `isLiteralIgnorePattern` accepts it (there is no glob
+ * metacharacter in it), so it lands in `ignored_paths` verbatim. Stripping only the TRAILING slash
+ * left the test as `normalized.includes('//dist/')` — a doubled slash that can never occur in a
+ * real path, so the entry matched nothing, forever, in silence.
+ */
+function shouldIgnorePath(fullPath, extraIgnored) {
+    const normalized = fullPath.replace(/\\/g, '/');
+    const allIgnored = [...ALWAYS_IGNORED, ...extraIgnored];
+    return allIgnored.some(pattern => {
+        const p = pattern.replace(/\\/g, '/').replace(/^\//, '').replace(/\/$/, '');
+        return normalized.includes(`/${p}/`) || normalized.endsWith(`/${p}`);
+    });
+}
+/** Escapes a literal string so it matches as text, not as a regex pattern. Exported so callers
+ * building a regex out of LITERAL terms (e.g. `searchNodes` deriving one from query tokens when
+ * no explicit `pattern` was given) can reuse the exact same escaping grep.ts uses internally. */
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Recursively lists every candidate file under a root, skipping junk dirs. Enumeration only — no
+ * file contents are read here.
+ *
+ * `root` may be a single FILE, not just a directory — this is what makes `path` scoping to one
+ * file work: `readdirSync` throws on a file, so that case is checked up front and short-circuits
+ * to a one-element result instead of falling into the directory walk.
+ *
+ * SYNCHRONOUS on purpose, not `fsp.readdir` fanned out via `Promise.all`. Every `fs.promises` call
+ * queues onto Node's libuv threadpool, which defaults to just 4 threads — an unbounded
+ * `Promise.all(subdirs.map(walk))` doesn't give the OS real parallelism, it just piles hundreds or
+ * thousands of directory-listing promises onto that tiny pool. On Windows in particular (real-time
+ * antivirus scanning adds latency to every single filesystem call), that queuing turned a walk of
+ * real 8-repo, ~3500-file trees — 32ms with plain synchronous `readdirSync` — into multi-MINUTE
+ * enumeration times, measured against a real production checkout. `readdirSync` bypasses the
+ * threadpool entirely (it's one direct syscall per directory), which is why it doesn't have this
+ * problem. A brief synchronous block for a fast operation beats a "concurrent" one queued behind a
+ * 4-worker bottleneck.
+ *
+ * Deadline-checked between every directory (not just, as before, only in the file-read phase) —
+ * `listFiles` alone used to have NO way to bail out early, so a single pathological repo could
+ * blow the entire search budget before the read phase's own deadline check ever ran. Returns
+ * whatever was found so far plus `truncated: true` if the deadline hit mid-walk.
+ */
+function listFiles(root, extraIgnored, deadline) {
+    let rootStat;
+    try {
+        rootStat = fs.statSync(root);
+    }
+    catch {
+        return { files: [], truncated: false }; // doesn't exist / unreadable — nothing to search
+    }
+    if (rootStat.isFile())
+        return { files: [root], truncated: false };
+    const out = [];
+    let truncated = false;
+    function walk(dir) {
+        if (truncated)
+            return;
+        if (timeMonotonic() > deadline) {
+            truncated = true;
+            return;
+        }
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // unreadable dir — skip, don't fail the whole search
+        }
+        for (const entry of entries) {
+            if (truncated)
+                return;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!shouldIgnorePath(fullPath, extraIgnored))
+                    walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                // Files are filtered here, at enumeration, not later in `grepFile` — a lockfile is
+                // typically a few hundred KB of non-binary text, so it clears every check `grepFile`
+                // makes (size, NUL sniff) and gets read and scanned in full on every single search.
+                if (!isDefaultIgnoredFile(fullPath) && !shouldIgnorePath(fullPath, extraIgnored)) {
+                    out.push(fullPath);
+                }
+            }
+        }
+    }
+    walk(root);
+    return { files: out, truncated };
+}
+/** True if the head of the buffer contains a NUL byte — the standard cheap "is binary" heuristic. */
+function looksBinary(buf) {
+    const n = Math.min(buf.length, BINARY_SNIFF_BYTES);
+    for (let i = 0; i < n; i++)
+        if (buf[i] === 0)
+            return true;
+    return false;
+}
+/**
+ * Reads one file and collects every line matching the regex. Returns [] on any read error, binary
+ * content, or oversize — a single bad file never breaks the search.
+ *
+ * `matcher` MUST carry the `g` flag (the caller builds it once and reuses it across every file) —
+ * without it there is no way to find every match on a line, only the first. `lastIndex` is reset
+ * per line since a stateful global regex otherwise silently skips matches or scans stale offsets
+ * from the PREVIOUS line.
+ *
+ * Zero-length matches are a real hazard with an arbitrary caller-supplied pattern (e.g. `x*`
+ * against a line with no "x" still "matches" at every position with length 0): `exec` never
+ * advances `lastIndex` on its own for those, so a naive loop spins forever at the same index.
+ * Guarded by force-advancing whenever `lastIndex` didn't move — the standard fix for this exact
+ * MDN-documented `RegExp.exec` footgun.
+ *
+ * SYNCHRONOUS on purpose (`fs.statSync`/`fs.readFileSync`), same reasoning as `listFiles`: this
+ * used to be `fsp.stat`/`fsp.readFile` run through a 24-way `mapPool`, which sounds like real
+ * parallelism but every one of those calls queues onto Node's 4-thread libuv threadpool — on a
+ * real repo tree (thousands of files, many of them non-source assets a `public/`-style directory
+ * pulls in) that queuing, not the actual I/O, was the dominant cost, especially on Windows where
+ * antivirus adds latency per filesystem call. Measured on a real production checkout: converting
+ * this phase from bounded-async to plain sync took what could run into MINUTES down to comfortably
+ * under the search budget. "Bounded concurrency" isn't a meaningful concept for sync calls anyway
+ * — they're inherently one-at-a-time — so the caller now just loops with a deadline check between
+ * files instead of pooling workers.
+ */
+function grepFile(filePath, matcher) {
+    let stat;
+    try {
+        stat = fs.statSync(filePath);
+    }
+    catch {
+        return [];
+    }
+    if (!stat.isFile() || stat.size === 0 || stat.size > MAX_FILE_BYTES)
+        return [];
+    let buf;
+    try {
+        buf = fs.readFileSync(filePath);
+    }
+    catch {
+        return [];
+    }
+    if (looksBinary(buf))
+        return [];
+    const text = buf.toString('utf-8');
+    const lines = text.split('\n');
+    const hits = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        matcher.lastIndex = 0;
+        let m;
+        let countOnLine = 0;
+        while (countOnLine < MAX_MATCHES_PER_LINE && (m = matcher.exec(line)) !== null) {
+            if (m[0].length > 0) {
+                hits.push({ file_path: filePath, line_number: i + 1, line_content: line.slice(0, 400), matched_text: m[0].toLowerCase() });
+                countOnLine++;
+            }
+            // Zero-length match guard (see doc comment) — applies whether or not this iteration
+            // recorded a hit, since `lastIndex` can stall on an empty match either way.
+            if (matcher.lastIndex === m.index)
+                matcher.lastIndex++;
+        }
+    }
+    return hits;
+}
+/**
+ * Greps every configured repo root (or, when `opts.scopePath` is given, just that one folder or
+ * file) for `pattern` — a real regex, used as-is. Returns raw hits plus whether the deadline
+ * forced an early, partial stop. Ranking is a separate pure step (`rankGrepHits`).
+ *
+ * Invalid regex throws `Invalid regex pattern: <message>` immediately (same shape as the
+ * precedent already established by `DevMindDatabase.searchCode`) rather than surfacing as an
+ * opaque failure deeper in the walk.
+ */
+async function grepRepos(repoRoots, pattern, opts = {}) {
+    const trimmedPattern = pattern.trim();
+    const hasRoots = opts.scopePath ? true : repoRoots.filter(Boolean).length > 0;
+    if (!trimmedPattern || !hasRoots) {
+        return { hits: [], truncated: false, files_scanned: 0 };
+    }
+    const extraIgnored = opts.ignoredPaths ?? [];
+    // No default cap — a 3s deadline was silently truncating results on repos that legitimately
+    // take longer than that to walk, which read as "grep just didn't find it" with no signal that
+    // anything was cut short. Callers that DO want a bound (e.g. a latency-sensitive UI) should
+    // pass an explicit timeoutMs; `search_nodes` (the only current caller) intentionally doesn't —
+    // deliberate even now that `pattern` is a real regex: an unbounded walk against `node_modules`
+    // et al is already impossible (ALWAYS_IGNORED / shouldIgnoreDir below run BEFORE any matching,
+    // independent of the pattern), so a slow catastrophic-backtrack pattern still only ever runs
+    // against real project source, not the whole disk.
+    const timeoutMs = opts.timeoutMs ?? Infinity;
+    const deadline = timeMonotonic() + timeoutMs;
+    const caseInsensitive = opts.caseInsensitive !== false;
+    let matcher;
+    try {
+        matcher = new RegExp(pattern, caseInsensitive ? 'gi' : 'g');
+    }
+    catch (err) {
+        throw new Error(`Invalid regex pattern: ${err.message}`);
+    }
+    // Scoped to one folder/file → that's the only walk root. The scope itself is checked against
+    // the ignore rules here (walk() below only checks CHILDREN it descends into, never the root it
+    // starts from) — otherwise a scope path pointing straight AT an ignored dir (or a file inside
+    // one) would bypass the ignore list entirely instead of correctly finding nothing.
+    //
+    // The default file denylist is enforced here too, deliberately: "explicit scoping wins" sounds
+    // right but would be inconsistent, since a scope pointing at an ignored DIRECTORY has always
+    // correctly found nothing. Making files the exception would mean one function enforced two
+    // opposite rules. The confusing part of an empty result is not the emptiness, it's the silence
+    // — so `searchNodes` pairs this with a hint saying the path was excluded by default, rather
+    // than letting it read as "the pattern isn't in there".
+    const walkRoots = opts.scopePath ? [opts.scopePath] : repoRoots.filter(Boolean);
+    const allFiles = [];
+    let truncated = false;
+    for (const root of walkRoots) {
+        if (truncated)
+            break;
+        if (opts.scopePath && (shouldIgnorePath(root, extraIgnored) || isDefaultIgnoredFile(root)))
+            continue;
+        const result = listFiles(root, extraIgnored, deadline);
+        allFiles.push(...result.files);
+        if (result.truncated)
+            truncated = true;
+    }
+    const hits = [];
+    let scanned = 0;
+    // Read+scan — synchronous (see grepFile's doc comment for why), deadline-checked between every
+    // file so a pathological repo yields a partial result instead of hanging, same as enumeration
+    // above. This is the whole point of the "as fast as grep" goal.
+    for (const file of allFiles) {
+        if (timeMonotonic() > deadline) {
+            truncated = true;
+            break;
+        }
+        const fileHits = grepFile(file, matcher);
+        scanned++;
+        if (fileHits.length)
+            hits.push(...fileHits);
+    }
+    return { hits, truncated, files_scanned: scanned };
+}
+/**
+ * Ranks raw hits into a capped, ordered PAGE of files — the anti-firehose gate — plus the TRUE
+ * total file count before that cap, so a caller can tell "that's everything" from "more exists,
+ * ask for the next page" instead of guessing from a bare capped list. Unranked hits across 8
+ * repos can be hundreds; dumping them recreates the exact "15-20 low-confidence results I have to
+ * eyeball-filter" complaint that made the AI distrust the tool. So: group by file, score by match
+ * count weighted toward RARER matched strings (IDF-shaped, same instinct as BM25), reward files
+ * matching MULTIPLE distinct strings, sort with a stable tiebreaker, and page.
+ */
+function rankGrepHits(hits, opts = {}) {
+    const maxFiles = opts.maxFiles ?? 25;
+    const maxSampleLines = opts.maxSampleLines ?? 5;
+    const offset = opts.offset ?? 0;
+    if (hits.length === 0)
+        return { files: [], total: 0 };
+    // Document frequency per matched string: in how many distinct files does each one appear? A
+    // string in few files is a stronger signal than one that's everywhere — the rarity weight below.
+    const filesPerText = new Map();
+    for (const h of hits) {
+        let set = filesPerText.get(h.matched_text);
+        if (!set) {
+            set = new Set();
+            filesPerText.set(h.matched_text, set);
+        }
+        set.add(h.file_path);
+    }
+    const totalFiles = new Set(hits.map(h => h.file_path)).size;
+    const rarity = (text) => {
+        const df = filesPerText.get(text)?.size ?? 1;
+        // log-shaped IDF: rarer ⇒ higher, but never below a small floor so a common string still counts.
+        return Math.max(Math.log(1 + totalFiles / df), 0.3);
+    };
+    const byFile = new Map();
+    for (const h of hits) {
+        let acc = byFile.get(h.file_path);
+        if (!acc) {
+            acc = { total: 0, counts: {}, lines: [] };
+            byFile.set(h.file_path, acc);
+        }
+        acc.total++;
+        acc.counts[h.matched_text] = (acc.counts[h.matched_text] || 0) + 1;
+        if (acc.lines.length < maxSampleLines)
+            acc.lines.push({ line_number: h.line_number, line_content: h.line_content });
+    }
+    const ranked = Array.from(byFile.entries()).map(([file_path, acc]) => {
+        const distinct = Object.keys(acc.counts).length;
+        // Base: sum over matched strings of (saturating count × that string's rarity). The
+        // saturating `1 + log(count)` stops 50 hits of one string from running away, and rarer
+        // strings weigh more. Then multiply by `distinct` — the number of DISTINCT matched strings
+        // this file contains — because coverage beats frequency: a file matching two different parts
+        // of the pattern is almost always more relevant than one matching a single part many times.
+        // Rarity still differentiates within a coverage level, so a single hit of an ultra-rare
+        // string can still outrank two hits of two common ones.
+        let base = 0;
+        for (const [text, count] of Object.entries(acc.counts)) {
+            const tf = 1 + Math.log(count);
+            base += tf * rarity(text);
+        }
+        const score = base * distinct;
+        return {
+            file_path,
+            total_matches: acc.total,
+            match_counts: acc.counts,
+            distinct_matches: distinct,
+            score,
+            sample_lines: acc.lines
+        };
+    });
+    // Stable final tiebreaker (file_path) — without one, equal-scoring files have no guaranteed
+    // order, so paginating with offset/limit could repeat or skip rows across calls whenever the
+    // sort happens to land them differently.
+    ranked.sort((a, b) => b.score - a.score ||
+        b.distinct_matches - a.distinct_matches ||
+        b.total_matches - a.total_matches ||
+        a.file_path.localeCompare(b.file_path));
+    return { files: ranked.slice(offset, offset + maxFiles), total: ranked.length };
+}
+/**
+ * A monotonic millisecond clock. `Date.now()` is banned in some execution contexts here and can
+ * jump backwards on a clock adjustment; `process.hrtime` is monotonic and always available in Node.
+ */
+function timeMonotonic() {
+    const [s, ns] = process.hrtime();
+    return s * 1000 + ns / 1e6;
+}
+//# sourceMappingURL=grep.js.map

package/dist/db/grep.js.map

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

package/dist/db/message-revert.d.ts

@@ -0,0 +1,63 @@
+export interface RevertOutcome {
+    ok: boolean;
+    /** Messages actually flipped to 'reverted' this call, oldest-affected-first. */
+    reverted: string[];
+    /** Set when the cascade stopped before finishing everything requested. */
+    blocked_at?: {
+        message_id: string;
+        reason: string;
+    };
+}
+export interface UnrevertOutcome {
+    ok: boolean;
+    error?: string;
+    message_id?: string;
+}
+/** Outcome of reverting/un-reverting one file's edits within one message. */
+export interface FileRevertOutcome {
+    ok: boolean;
+    error?: string;
+    /** Ids of the edits actually flipped this call. */
+    edit_ids?: string[];
+}
+/** Outcome of reverting/un-reverting exactly one edit. */
+export interface EditRevertOutcome {
+    ok: boolean;
+    error?: string;
+}
+/**
+ * Reverts `messageId` and every message after it that isn't already fully reverted — the stack
+ * model: later messages were built on top of earlier ones, so undoing one partway through the
+ * stack undoes everything above it too, newest first. Stops at the first message that can't be
+ * fully reverted (a drifted edit) and reports which; everything reverted before that point in
+ * this call stays reverted. A `partial` message (touched by an earlier file/edit-level revert)
+ * counts as "not yet fully reverted" and is swept up here too, finishing the job on it.
+ */
+export declare function revertMessage(devmindPath: string, messageId: string): RevertOutcome;
+/**
+ * Re-applies exactly one message: the OLDEST currently-**fully**-reverted one. Un-revert restores
+ * up the stack in the order things came off it — out-of-order restoration would recreate the same
+ * "later edit built on code that isn't there yet" hazard the revert direction guards against, so
+ * it's refused rather than attempted. A `partial` message wasn't produced by that cascade — it was
+ * touched by a surgical file/edit-level revert — so it can be un-reverted independently of the
+ * fully-reverted stack's ordering.
+ */
+export declare function unrevertMessage(devmindPath: string, messageId: string): UnrevertOutcome;
+/**
+ * Reverts just the edits ONE file picked up within ONE message, leaving the message's other
+ * files untouched. Newest-edit-first within that file, atomic (rolls back this operation's own
+ * partial progress on failure, same as the whole-message path) — never leaves this one file
+ * half-reverted, though the message as a whole is expected to end up `partial`.
+ */
+export declare function revertMessageFile(devmindPath: string, messageId: string, filePath: string): FileRevertOutcome;
+/** Symmetric to revertMessageFile: oldest-edit-first, same atomic rollback. */
+export declare function unrevertMessageFile(devmindPath: string, messageId: string, filePath: string): FileRevertOutcome;
+/**
+ * Reverts exactly ONE edit, identified by its stable `id`, regardless of what else in the message
+ * or file is applied. Safe by construction: if a later edit (to the same node, in this message or
+ * a later one) already changed this text further, this edit's `after` string won't be found on
+ * disk anymore and the exact-match guard in applyEdit refuses rather than guessing.
+ */
+export declare function revertMessageEdit(devmindPath: string, messageId: string, editId: string): EditRevertOutcome;
+/** Symmetric to revertMessageEdit. */
+export declare function unrevertMessageEdit(devmindPath: string, messageId: string, editId: string): EditRevertOutcome;