@cruxy/cli 0.1.1 → 0.3.0

package/dist/indexing/store.d.ts

@@ -0,0 +1,103 @@
+import type DatabaseNs from "better-sqlite3";
+import type { EmbeddedChunk, ScoredRecord } from "./types.js";
+/**
+ * Vector storage for the codebase index. The {@link VectorStore} interface hides
+ * the backend so the brute-force cosine search here can be swapped for an ANN
+ * index later without touching the indexer, retriever, or tool. Two backends
+ * ship: {@link SqliteVectorStore} (persistent, the default) and
+ * {@link InMemoryVectorStore} (ephemeral, for tests).
+ *
+ * Vectors are stored L2-normalized, so cosine similarity reduces to a dot
+ * product (see {@link dot}).
+ */
+/** Embedder identity + dimensionality the index was built with. */
+export interface VectorStoreMeta {
+    embedderId: string;
+    dim: number;
+}
+export interface VectorStore {
+    /** Embedder identity + dim recorded for this index, or null if never set. */
+    getMeta(): VectorStoreMeta | null;
+    /** Record the embedder identity + dim. Called when the index is (re)initialized. */
+    setMeta(meta: VectorStoreMeta): void;
+    /** Map of indexed file path → content hash, for incremental decisions. */
+    getFileHashes(): Map<string, string>;
+    /** Replace every chunk for `path` with `chunks` and record its hash. Atomic. */
+    upsertFile(path: string, hash: string, chunks: EmbeddedChunk[]): void;
+    /** Remove a file and all of its chunks. */
+    deleteByPath(path: string): void;
+    /**
+     * Brute-force cosine top-k over stored vectors, optionally restricted to paths
+     * for which `pathFilter` returns true. Results are sorted by score, descending.
+     */
+    search(query: Float32Array, k: number, pathFilter?: (path: string) => boolean): ScoredRecord[];
+    /** Number of indexed files. */
+    countFiles(): number;
+    /** Number of stored chunks. */
+    countChunks(): number;
+    /** Release any held resources (e.g. the SQLite handle). Idempotent. */
+    close(): void;
+}
+/** Dot product over the overlapping prefix of two vectors. */
+export declare function dot(a: Float32Array, b: Float32Array): number;
+/** Cosine similarity in [-1, 1]. Returns 0 if either vector is all-zero. */
+export declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;
+/** Serialize a vector to a little-endian Float32 BLOB (an owning copy). */
+export declare function vectorToBlob(v: Float32Array): Buffer;
+/** Deserialize a little-endian Float32 BLOB back into a vector. */
+export declare function blobToVector(buf: Buffer): Float32Array;
+/** Indices of the `k` largest scores, sorted descending. */
+export declare function topKIndices(scores: ArrayLike<number>, k: number): number[];
+/**
+ * A non-persistent {@link VectorStore} backed by plain JS maps. Used by the test
+ * suite and as the `auto` fallback when the SQLite native dependency is
+ * unavailable. Holds everything in memory; rebuilt on each process.
+ */
+export declare class InMemoryVectorStore implements VectorStore {
+    private meta;
+    private readonly fileHashes;
+    private readonly chunksByPath;
+    getMeta(): VectorStoreMeta | null;
+    setMeta(meta: VectorStoreMeta): void;
+    getFileHashes(): Map<string, string>;
+    upsertFile(path: string, hash: string, chunks: EmbeddedChunk[]): void;
+    deleteByPath(path: string): void;
+    countFiles(): number;
+    countChunks(): number;
+    search(query: Float32Array, k: number, pathFilter?: (path: string) => boolean): ScoredRecord[];
+    close(): void;
+}
+type DB = DatabaseNs.Database;
+/**
+ * Persistent {@link VectorStore} backed by better-sqlite3 at `.cruxy/index.db`.
+ * Vectors are stored as Float32 BLOBs; search lazily loads them into one
+ * contiguous matrix (cached until the next write) so warm queries are a tight
+ * dot-product scan rather than per-row deserialization.
+ *
+ * Construct via {@link createSqliteVectorStore}, which loads the native module.
+ */
+export declare class SqliteVectorStore implements VectorStore {
+    private readonly db;
+    private cache;
+    private closed;
+    constructor(db: DB);
+    getMeta(): VectorStoreMeta | null;
+    setMeta(meta: VectorStoreMeta): void;
+    getFileHashes(): Map<string, string>;
+    upsertFile(path: string, hash: string, chunks: EmbeddedChunk[]): void;
+    deleteByPath(path: string): void;
+    countFiles(): number;
+    countChunks(): number;
+    search(query: Float32Array, k: number, pathFilter?: (path: string) => boolean): ScoredRecord[];
+    close(): void;
+    private ensureCache;
+    private getMetaValue;
+    private setMetaValue;
+}
+/**
+ * Open (or create) a {@link SqliteVectorStore} at `dbPath`. The native module is
+ * imported lazily here, so nothing loads it until an index is actually used.
+ * The parent directory must already exist.
+ */
+export declare function createSqliteVectorStore(dbPath: string): Promise<SqliteVectorStore>;
+export {};

package/dist/indexing/store.js

@@ -0,0 +1,279 @@
+// ── Pure vector helpers (exported for direct testing) ─────────────────────────
+/** Dot product over the overlapping prefix of two vectors. */
+export function dot(a, b) {
+    const n = Math.min(a.length, b.length);
+    let s = 0;
+    for (let i = 0; i < n; i++)
+        s += a[i] * b[i];
+    return s;
+}
+/** Cosine similarity in [-1, 1]. Returns 0 if either vector is all-zero. */
+export function cosineSimilarity(a, b) {
+    const n = Math.min(a.length, b.length);
+    let d = 0;
+    let na = 0;
+    let nb = 0;
+    for (let i = 0; i < n; i++) {
+        d += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
+    }
+    const denom = Math.sqrt(na) * Math.sqrt(nb);
+    return denom === 0 ? 0 : d / denom;
+}
+/** Serialize a vector to a little-endian Float32 BLOB (an owning copy). */
+export function vectorToBlob(v) {
+    const buf = Buffer.allocUnsafe(v.length * 4);
+    for (let i = 0; i < v.length; i++)
+        buf.writeFloatLE(v[i], i * 4);
+    return buf;
+}
+/** Deserialize a little-endian Float32 BLOB back into a vector. */
+export function blobToVector(buf) {
+    const out = new Float32Array(buf.byteLength >> 2);
+    for (let i = 0; i < out.length; i++)
+        out[i] = buf.readFloatLE(i << 2);
+    return out;
+}
+/** Indices of the `k` largest scores, sorted descending. */
+export function topKIndices(scores, k) {
+    const n = scores.length;
+    const idx = new Array(n);
+    for (let i = 0; i < n; i++)
+        idx[i] = i;
+    idx.sort((a, b) => scores[b] - scores[a]);
+    idx.length = Math.min(Math.max(0, k), n);
+    return idx;
+}
+// ── In-memory backend ─────────────────────────────────────────────────────────
+/**
+ * A non-persistent {@link VectorStore} backed by plain JS maps. Used by the test
+ * suite and as the `auto` fallback when the SQLite native dependency is
+ * unavailable. Holds everything in memory; rebuilt on each process.
+ */
+export class InMemoryVectorStore {
+    meta = null;
+    fileHashes = new Map();
+    chunksByPath = new Map();
+    getMeta() {
+        return this.meta;
+    }
+    setMeta(meta) {
+        this.meta = { ...meta };
+    }
+    getFileHashes() {
+        return new Map(this.fileHashes);
+    }
+    upsertFile(path, hash, chunks) {
+        this.fileHashes.set(path, hash);
+        this.chunksByPath.set(path, chunks);
+    }
+    deleteByPath(path) {
+        this.fileHashes.delete(path);
+        this.chunksByPath.delete(path);
+    }
+    countFiles() {
+        return this.fileHashes.size;
+    }
+    countChunks() {
+        let total = 0;
+        for (const chunks of this.chunksByPath.values())
+            total += chunks.length;
+        return total;
+    }
+    search(query, k, pathFilter) {
+        const records = [];
+        const scores = [];
+        for (const [path, chunks] of this.chunksByPath) {
+            if (pathFilter && !pathFilter(path))
+                continue;
+            for (const ec of chunks) {
+                records.push({
+                    path: ec.chunk.path,
+                    startLine: ec.chunk.startLine,
+                    endLine: ec.chunk.endLine,
+                    text: ec.chunk.text,
+                    score: dot(query, ec.vector),
+                });
+                scores.push(records[records.length - 1].score);
+            }
+        }
+        return topKIndices(scores, k).map((i) => records[i]);
+    }
+    close() {
+        /* nothing to release */
+    }
+}
+const SCHEMA_VERSION = "1";
+/**
+ * Persistent {@link VectorStore} backed by better-sqlite3 at `.cruxy/index.db`.
+ * Vectors are stored as Float32 BLOBs; search lazily loads them into one
+ * contiguous matrix (cached until the next write) so warm queries are a tight
+ * dot-product scan rather than per-row deserialization.
+ *
+ * Construct via {@link createSqliteVectorStore}, which loads the native module.
+ */
+export class SqliteVectorStore {
+    db;
+    cache = null;
+    closed = false;
+    constructor(db) {
+        this.db = db;
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("synchronous = NORMAL");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS meta (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS files (
+        path TEXT PRIMARY KEY,
+        hash TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS chunks (
+        id         INTEGER PRIMARY KEY AUTOINCREMENT,
+        path       TEXT    NOT NULL,
+        start_line INTEGER NOT NULL,
+        end_line   INTEGER NOT NULL,
+        text       TEXT    NOT NULL,
+        vector     BLOB    NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_chunks_path ON chunks(path);
+    `);
+        this.setMetaValue("schema_version", SCHEMA_VERSION);
+    }
+    getMeta() {
+        const embedderId = this.getMetaValue("embedder_id");
+        const dimStr = this.getMetaValue("dim");
+        if (embedderId === null || dimStr === null)
+            return null;
+        return { embedderId, dim: Number(dimStr) };
+    }
+    setMeta(meta) {
+        this.setMetaValue("embedder_id", meta.embedderId);
+        this.setMetaValue("dim", String(meta.dim));
+    }
+    getFileHashes() {
+        const rows = this.db
+            .prepare("SELECT path, hash FROM files")
+            .all();
+        const map = new Map();
+        for (const r of rows)
+            map.set(r.path, r.hash);
+        return map;
+    }
+    upsertFile(path, hash, chunks) {
+        const tx = this.db.transaction(() => {
+            this.db.prepare("DELETE FROM chunks WHERE path = ?").run(path);
+            this.db
+                .prepare("INSERT INTO files (path, hash) VALUES (?, ?) " +
+                "ON CONFLICT(path) DO UPDATE SET hash = excluded.hash")
+                .run(path, hash);
+            const insert = this.db.prepare("INSERT INTO chunks (path, start_line, end_line, text, vector) VALUES (?, ?, ?, ?, ?)");
+            for (const { chunk, vector } of chunks) {
+                insert.run(path, chunk.startLine, chunk.endLine, chunk.text, vectorToBlob(vector));
+            }
+        });
+        tx();
+        this.cache = null;
+    }
+    deleteByPath(path) {
+        const tx = this.db.transaction(() => {
+            this.db.prepare("DELETE FROM chunks WHERE path = ?").run(path);
+            this.db.prepare("DELETE FROM files WHERE path = ?").run(path);
+        });
+        tx();
+        this.cache = null;
+    }
+    countFiles() {
+        return this.db.prepare("SELECT COUNT(*) AS n FROM files").get().n;
+    }
+    countChunks() {
+        return this.db.prepare("SELECT COUNT(*) AS n FROM chunks").get().n;
+    }
+    search(query, k, pathFilter) {
+        const cache = this.ensureCache();
+        if (cache.n === 0)
+            return [];
+        const { dim, matrix } = cache;
+        const candidates = [];
+        const scores = [];
+        for (let i = 0; i < cache.n; i++) {
+            if (pathFilter && !pathFilter(cache.paths[i]))
+                continue;
+            let s = 0;
+            const off = i * dim;
+            for (let d = 0; d < dim; d++)
+                s += query[d] * matrix[off + d];
+            candidates.push(i);
+            scores.push(s);
+        }
+        const getText = this.db.prepare("SELECT text FROM chunks WHERE id = ?");
+        return topKIndices(scores, k).map((j) => {
+            const row = candidates[j];
+            const text = getText.get(cache.ids[row])?.text ??
+                "";
+            return {
+                path: cache.paths[row],
+                startLine: cache.starts[row],
+                endLine: cache.ends[row],
+                text,
+                score: scores[j],
+            };
+        });
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.db.close();
+        this.closed = true;
+    }
+    // ── internals ──────────────────────────────────────────────────────────────
+    ensureCache() {
+        if (this.cache)
+            return this.cache;
+        const rows = this.db
+            .prepare("SELECT id, path, start_line, end_line, vector FROM chunks ORDER BY id")
+            .all();
+        const n = rows.length;
+        const dim = n > 0 ? rows[0].vector.byteLength >> 2 : (this.getMeta()?.dim ?? 0);
+        const matrix = new Float32Array(n * dim);
+        const ids = new Array(n);
+        const paths = new Array(n);
+        const starts = new Array(n);
+        const ends = new Array(n);
+        for (let i = 0; i < n; i++) {
+            const r = rows[i];
+            ids[i] = r.id;
+            paths[i] = r.path;
+            starts[i] = r.start_line;
+            ends[i] = r.end_line;
+            const off = i * dim;
+            for (let d = 0; d < dim; d++)
+                matrix[off + d] = r.vector.readFloatLE(d << 2);
+        }
+        this.cache = { n, dim, matrix, ids, paths, starts, ends };
+        return this.cache;
+    }
+    getMetaValue(key) {
+        const row = this.db
+            .prepare("SELECT value FROM meta WHERE key = ?")
+            .get(key);
+        return row ? row.value : null;
+    }
+    setMetaValue(key, value) {
+        this.db
+            .prepare("INSERT INTO meta (key, value) VALUES (?, ?) " +
+            "ON CONFLICT(key) DO UPDATE SET value = excluded.value")
+            .run(key, value);
+    }
+}
+/**
+ * Open (or create) a {@link SqliteVectorStore} at `dbPath`. The native module is
+ * imported lazily here, so nothing loads it until an index is actually used.
+ * The parent directory must already exist.
+ */
+export async function createSqliteVectorStore(dbPath) {
+    const { default: Database } = await import("better-sqlite3");
+    return new SqliteVectorStore(new Database(dbPath));
+}

package/dist/indexing/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Shared types for the codebase index (C.17). Kept in one place so the walker,
+ * chunker, embedder, store, indexer, and retriever can depend on the same
+ * vocabulary without import cycles — mirroring `src/tools/types.ts`.
+ */
+/** A contiguous slice of a source file: the unit that gets embedded and stored. */
+export interface Chunk {
+    /** Project-relative POSIX path of the source file. */
+    path: string;
+    /** 1-based line where the chunk begins (inclusive). */
+    startLine: number;
+    /** 1-based line where the chunk ends (inclusive). */
+    endLine: number;
+    /** The chunk's raw text (the joined source lines). */
+    text: string;
+}
+/** A chunk paired with its embedding, ready to persist. */
+export interface EmbeddedChunk {
+    chunk: Chunk;
+    /** L2-normalized embedding; length equals the embedder's `dim`. */
+    vector: Float32Array;
+}
+/** A stored chunk scored against a query, as returned by `VectorStore.search`. */
+export interface ScoredRecord {
+    path: string;
+    startLine: number;
+    endLine: number;
+    text: string;
+    /** Cosine similarity in [-1, 1]; higher is more relevant. */
+    score: number;
+}
+/** One ranked search result handed back to the agent. */
+export interface SearchHit {
+    path: string;
+    startLine: number;
+    endLine: number;
+    /** Cosine similarity in [-1, 1], rounded for display. */
+    score: number;
+    /** The (possibly trimmed) source snippet for the chunk. */
+    snippet: string;
+}
+/** Outcome of an indexing run, surfaced by `cruxy index`. */
+export interface IndexStats {
+    /** Candidate text files remaining after the walk's ignore/size/binary filters. */
+    filesSeen: number;
+    /** Files added or re-embedded this run (content changed, new, or forced). */
+    filesIndexed: number;
+    /** Files skipped because their content hash was unchanged. */
+    filesSkipped: number;
+    /** Files removed from the index (deleted on disk or newly ignored). */
+    filesPurged: number;
+    /** Chunks embedded this run. */
+    chunksIndexed: number;
+    /** Wall-clock duration in milliseconds. */
+    durationMs: number;
+}
+/** Snapshot of the on-disk index for `cruxy index --status`. */
+export interface IndexStatus {
+    /** Whether a populated index already exists. */
+    exists: boolean;
+    /** Embedder identity the index was built with (e.g. `fastembed:bge-small-en-v1.5`). */
+    embedderId: string | null;
+    /** Embedding dimensionality recorded in the index. */
+    dim: number | null;
+    /** Number of indexed files. */
+    files: number;
+    /** Number of stored chunks. */
+    chunks: number;
+    /** Absolute path of the index store, or null for an in-memory store. */
+    storePath: string | null;
+}

package/dist/indexing/types.js

@@ -0,0 +1,6 @@
+/**
+ * Shared types for the codebase index (C.17). Kept in one place so the walker,
+ * chunker, embedder, store, indexer, and retriever can depend on the same
+ * vocabulary without import cycles — mirroring `src/tools/types.ts`.
+ */
+export {};

package/dist/indexing/util.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Small shared helpers for the index pipeline: content hashing, vector
+ * normalization, a bounded-concurrency map, a token estimate, and glob→RegExp
+ * compilation (reused by both the `pathGlob` search filter and the gitignore
+ * matcher in `walker.ts`).
+ */
+/** Stable content hash of a file's bytes — sha256, hex. Drives incremental indexing. */
+export declare function contentHash(data: Buffer | string): string;
+/**
+ * L2-normalize `v` in place and return it. A zero vector is left untouched (its
+ * norm is 0). Normalizing at embed time lets the store treat cosine similarity
+ * as a plain dot product.
+ */
+export declare function l2normalize(v: Float32Array): Float32Array;
+/**
+ * Approximate token count via the chars/4 heuristic used elsewhere in the CLI
+ * (see `agent/session.ts`). Good enough to budget snippet sizes.
+ */
+export declare function estimateTokens(text: string): number;
+/**
+ * Run `fn` over `items` with at most `limit` calls in flight, preserving input
+ * order in the result. Used to bound filesystem/CPU concurrency during indexing.
+ */
+export declare function mapLimit<T, R>(items: readonly T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
+/**
+ * Convert a glob into the *body* of a RegExp (no anchors), supporting `*`
+ * (within a path segment), `**` (across segments, including zero), and `?`
+ * (a single non-separator char). Backslashes are normalized to `/` first.
+ */
+export declare function globToRegexBody(glob: string): string;
+/** Compile a glob into a RegExp anchored to a full POSIX path. */
+export declare function globToRegExp(glob: string): RegExp;
+/** Sniff the head of a buffer for a NUL byte — the cheap "is this binary?" test. */
+export declare function isBinary(buf: Buffer, sniffBytes?: number): boolean;

package/dist/indexing/util.js

@@ -0,0 +1,97 @@
+import { createHash } from "node:crypto";
+/**
+ * Small shared helpers for the index pipeline: content hashing, vector
+ * normalization, a bounded-concurrency map, a token estimate, and glob→RegExp
+ * compilation (reused by both the `pathGlob` search filter and the gitignore
+ * matcher in `walker.ts`).
+ */
+/** Stable content hash of a file's bytes — sha256, hex. Drives incremental indexing. */
+export function contentHash(data) {
+    return createHash("sha256").update(data).digest("hex");
+}
+/**
+ * L2-normalize `v` in place and return it. A zero vector is left untouched (its
+ * norm is 0). Normalizing at embed time lets the store treat cosine similarity
+ * as a plain dot product.
+ */
+export function l2normalize(v) {
+    let sum = 0;
+    for (let i = 0; i < v.length; i++)
+        sum += v[i] * v[i];
+    const norm = Math.sqrt(sum);
+    if (norm > 0) {
+        for (let i = 0; i < v.length; i++)
+            v[i] /= norm;
+    }
+    return v;
+}
+/**
+ * Approximate token count via the chars/4 heuristic used elsewhere in the CLI
+ * (see `agent/session.ts`). Good enough to budget snippet sizes.
+ */
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Run `fn` over `items` with at most `limit` calls in flight, preserving input
+ * order in the result. Used to bound filesystem/CPU concurrency during indexing.
+ */
+export async function mapLimit(items, limit, fn) {
+    const results = new Array(items.length);
+    if (items.length === 0)
+        return results;
+    let next = 0;
+    const workers = Math.max(1, Math.min(limit, items.length));
+    async function run() {
+        for (;;) {
+            const i = next++;
+            if (i >= items.length)
+                return;
+            results[i] = await fn(items[i], i);
+        }
+    }
+    await Promise.all(Array.from({ length: workers }, () => run()));
+    return results;
+}
+/**
+ * Convert a glob into the *body* of a RegExp (no anchors), supporting `*`
+ * (within a path segment), `**` (across segments, including zero), and `?`
+ * (a single non-separator char). Backslashes are normalized to `/` first.
+ */
+export function globToRegexBody(glob) {
+    const g = glob.replace(/\\/g, "/");
+    let re = "";
+    for (let i = 0; i < g.length; i++) {
+        const c = g[i];
+        if (c === "*") {
+            if (g[i + 1] === "*") {
+                // `**/` matches zero or more leading directories; a trailing/standalone
+                // `**` matches anything (including separators).
+                const slash = g[i + 2] === "/";
+                i += slash ? 2 : 1;
+                re += slash ? "(?:.*/)?" : ".*";
+            }
+            else {
+                re += "[^/]*";
+            }
+        }
+        else if (c === "?") {
+            re += "[^/]";
+        }
+        else if (/[.+^${}()|[\]\\]/.test(c)) {
+            re += `\\${c}`;
+        }
+        else {
+            re += c;
+        }
+    }
+    return re;
+}
+/** Compile a glob into a RegExp anchored to a full POSIX path. */
+export function globToRegExp(glob) {
+    return new RegExp(`^${globToRegexBody(glob)}$`);
+}
+/** Sniff the head of a buffer for a NUL byte — the cheap "is this binary?" test. */
+export function isBinary(buf, sniffBytes = 4096) {
+    return buf.subarray(0, sniffBytes).includes(0);
+}

package/dist/indexing/walker.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Repository walker for the index. Enumerates indexable text files under a root,
+ * honoring `.gitignore` and `.cruxyignore` (nested files included), an
+ * always-ignore set, a hard secrets denylist, a per-file size cap, and a binary
+ * sniff. Yielded paths are project-relative and POSIX-separated.
+ */
+/** A file the walker considers indexable. */
+export interface WalkEntry {
+    /** Project-relative POSIX path. */
+    relPath: string;
+    /** Absolute path on disk. */
+    absPath: string;
+    /** File size in bytes. */
+    size: number;
+}
+export interface WalkOptions {
+    /** Hard per-file size cap, in bytes. Larger files are skipped. */
+    maxFileBytes: number;
+    /** Ignore-file names to honor, relative to each directory (gitignore syntax). */
+    ignoreFileNames?: string[];
+}
+/**
+ * A compiled set of gitignore-style patterns, matched against paths relative to
+ * the file's own directory. Supports comments, blank lines, `!` negation,
+ * leading-`/` anchoring, trailing-`/` directory-only rules, and `*`/`**`/`?`.
+ */
+export declare class IgnoreMatcher {
+    private readonly rules;
+    constructor(patterns: string[]);
+    private add;
+    /**
+     * Decide whether `relPath` is ignored: `true`/`false` when a rule matches
+     * (last match wins), or `undefined` when no rule applies.
+     */
+    decide(relPath: string, isDir: boolean): boolean | undefined;
+}
+/**
+ * Walk `root` and yield every indexable text file. Directories in the
+ * always-ignore set are skipped wholesale; ignore files accumulate down the
+ * tree; secret-bearing, oversized, and binary files are filtered out.
+ */
+export declare function walkRepo(root: string, opts: WalkOptions): AsyncGenerator<WalkEntry>;