@cruxy/cli 1.0.3 → 1.0.5

package/dist/hooks/types.d.ts

@@ -1,147 +0,0 @@
-import { z } from "zod";
-/**
- * Types for hooks + custom slash commands (C.19). Everything here is **data**:
- * hook and command definitions are validated (fail-loud, malformed excluded) and
- * NEVER eval'd — a hook's `command` string only ever reaches execution through
- * the shared U.3-gated + C.16-sandboxed shell path (see `runner.ts`), exactly
- * like an agent-run command.
- */
-/**
- * The core hook lifecycle events. Deliberately a small, closed set for this
- * build; the enum is the extension point for future events (out of scope).
- * - `before-run` / `after-run` — around a whole user turn (the agent loop).
- * - `before-tool` / `after-tool` — around each tool call.
- * - `on-file-change` — after a file-mutating tool (write/edit/patch) succeeds.
- */
-export declare const HOOK_EVENTS: readonly ["before-run", "after-run", "before-tool", "after-tool", "on-file-change"];
-export type HookEvent = (typeof HOOK_EVENTS)[number];
-/** `before-*` events default to blocking (fail-closed pre-checks); everything
- * that fires *after* an action defaults to advisory. Overridable per hook. */
-export declare function defaultBlocking(event: HookEvent): boolean;
-/** Where a hook / command was discovered. `project` is the supply-chain-risky
- * source (another author); `user` is your own `~/.cruxy`. */
-export type HookSource = "project" | "user";
-/** Precedence: a project definition overrides a user one of the same name. */
-export declare const HOOK_SOURCE_PRECEDENCE: readonly HookSource[];
-/** Strict schema for one hook definition in a `hooks.json`. Unknown keys are a
- * loud error (`.strict()`); `blocking` is optional (resolved from the event). */
-export declare const HookSpecSchema: z.ZodObject<{
-    name: z.ZodString;
-    event: z.ZodEnum<["before-run", "after-run", "before-tool", "after-tool", "on-file-change"]>;
-    command: z.ZodString;
-    blocking: z.ZodOptional<z.ZodBoolean>;
-}, "strict", z.ZodTypeAny, {
-    name: string;
-    command: string;
-    event: "before-run" | "after-run" | "before-tool" | "after-tool" | "on-file-change";
-    blocking?: boolean | undefined;
-}, {
-    name: string;
-    command: string;
-    event: "before-run" | "after-run" | "before-tool" | "after-tool" | "on-file-change";
-    blocking?: boolean | undefined;
-}>;
-export type HookSpec = z.infer<typeof HookSpecSchema>;
-/** The whole `hooks.json` file shape. */
-export declare const HooksFileSchema: z.ZodObject<{
-    hooks: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        event: z.ZodEnum<["before-run", "after-run", "before-tool", "after-tool", "on-file-change"]>;
-        command: z.ZodString;
-        blocking: z.ZodOptional<z.ZodBoolean>;
-    }, "strict", z.ZodTypeAny, {
-        name: string;
-        command: string;
-        event: "before-run" | "after-run" | "before-tool" | "after-tool" | "on-file-change";
-        blocking?: boolean | undefined;
-    }, {
-        name: string;
-        command: string;
-        event: "before-run" | "after-run" | "before-tool" | "after-tool" | "on-file-change";
-        blocking?: boolean | undefined;
-    }>, "many">>;
-}, "strict", z.ZodTypeAny, {
-    hooks: {
-        name: string;
-        command: string;
-        event: "before-run" | "after-run" | "before-tool" | "after-tool" | "on-file-change";
-        blocking?: boolean | undefined;
-    }[];
-}, {
-    hooks?: {
-        name: string;
-        command: string;
-        event: "before-run" | "after-run" | "before-tool" | "after-tool" | "on-file-change";
-        blocking?: boolean | undefined;
-    }[] | undefined;
-}>;
-/** A validated hook, tagged with its source and with `blocking` resolved. */
-export interface HookDefinition {
-    name: string;
-    event: HookEvent;
-    command: string;
-    /** Resolved (event default applied) — the value the runner acts on. */
-    blocking: boolean;
-    source: HookSource;
-}
-/**
- * A custom slash command. `prompt` (the safe default) expands a text template
- * fed to the agent; `shell` binds a command that runs through the SAME gate +
- * sandbox as everything else. Never arbitrary code by default.
- */
-export type SlashKind = "prompt" | "shell";
-/** Strict frontmatter for a `commands/<name>.md`. The command NAME comes from
- * the filename; the markdown BODY is the prompt template (kind `prompt`). */
-export declare const SlashFrontmatterSchema: z.ZodObject<{
-    kind: z.ZodDefault<z.ZodEnum<["prompt", "shell"]>>;
-    description: z.ZodString;
-    /** Required (and only meaningful) when `kind: "shell"`. */
-    command: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    kind: "shell" | "prompt";
-    description: string;
-    command?: string | undefined;
-}, {
-    description: string;
-    kind?: "shell" | "prompt" | undefined;
-    command?: string | undefined;
-}>;
-export type SlashFrontmatter = z.infer<typeof SlashFrontmatterSchema>;
-/** A validated custom slash command, tagged with source. */
-export interface SlashCommandSpec {
-    name: string;
-    kind: SlashKind;
-    description: string;
-    /** Prompt template (kind `prompt`); `{{args}}` is substituted at expansion. */
-    template?: string;
-    /** Shell command (kind `shell`) — gated + sandboxed when run. */
-    command?: string;
-    source: HookSource;
-}
-/** A malformed hook / command, excluded from the catalog and surfaced loudly
- * (never eval'd, never silently dropped). */
-export interface HookConfigError {
-    source: HookSource;
-    /** Absolute path of the offending file. */
-    file: string;
-    /** The would-be name (filename / spec name), for display. */
-    name: string;
-    message: string;
-}
-/** The resolved hook catalog: valid definitions (deduped by precedence) + the
- * malformed ones that were excluded. */
-export interface HookCatalog {
-    hooks: HookDefinition[];
-    commands: SlashCommandSpec[];
-    errors: HookConfigError[];
-}
-/** One repo's recorded trust decision (persisted in `~/.cruxy/trust.json`). The
- * `fingerprint` binds trust to the exact hook commands seen at trust time. */
-export interface HookTrust {
-    /** Absolute project root. */
-    root: string;
-    /** sha256 of the canonicalized project hook specs (see `trust.ts`). */
-    fingerprint: string;
-    /** ISO timestamp the decision was recorded. */
-    at: string;
-}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/indexing/chunker.d.ts

@@ -1,28 +0,0 @@
-import type { Chunk } from "./types.js";
-/** Knobs for {@link chunkFile}. */
-export interface ChunkOptions {
-    /** Target window size, in lines. */
-    windowLines: number;
-    /** Lines shared between consecutive windows (clamped to < windowLines). */
-    overlapLines: number;
-    /**
-     * How far (in lines) the window end may slide to land on a blank-line
-     * boundary. Keeps chunks aligned to natural gaps without drifting too far
-     * from the target size.
-     */
-    snapSlack?: number;
-}
-/**
- * Split a file's text into overlapping line windows.
- *
- * Windows are `windowLines` long and advance by `windowLines - overlapLines`, so
- * consecutive chunks share `overlapLines` lines (context that would otherwise be
- * severed at a hard cut). Where possible the window end is nudged — within
- * `snapSlack` lines — to fall right after a blank line, so chunks break at
- * natural boundaries (between functions, paragraphs, etc.).
- *
- * Line numbers are 1-based and inclusive. A whitespace-only (or empty) file
- * yields no chunks. A file shorter than one window yields exactly one chunk.
- * Coverage is gap-free: every source line belongs to at least one chunk.
- */
-export declare function chunkFile(path: string, text: string, opts: ChunkOptions): Chunk[];

package/dist/indexing/embedder.d.ts

@@ -1,98 +0,0 @@
-/**
- * Output dimensionality of bge-small-en-v1.5, and the default size of the
- * hashing embedder's feature space, so the two backends are interchangeable in
- * the store schema.
- */
-export declare const DEFAULT_DIM = 384;
-/**
- * Turns text into vectors. Two implementations ship: {@link FastEmbedEmbedder}
- * (local ONNX, semantic) and {@link HashingEmbedder} (dependency-free,
- * deterministic, lexical). The store records `id`; if it changes, the index is
- * re-embedded from scratch (see `indexer.ts`).
- */
-export interface Embedder {
-    /** Stable identity of this embedder + model. Persisted with the index. */
-    readonly id: string;
-    /** Embedding dimensionality. */
-    readonly dim: number;
-    /**
-     * Embed document/passage texts. Returns one L2-normalized vector per input,
-     * in the same order. An empty input yields an empty array.
-     */
-    embed(texts: string[]): Promise<Float32Array[]>;
-    /**
-     * Embed a search query. May use a different representation than {@link embed}
-     * (e.g. bge prepends a retrieval instruction to queries).
-     */
-    embedQuery(text: string): Promise<Float32Array>;
-}
-/**
- * Split text into lowercase lexical tokens, breaking identifiers on camelCase
- * and snake/kebab boundaries so `getUserById` contributes `get`/`user`/`by`/`id`.
- */
-export declare function tokenize(text: string): string[];
-export interface HashingEmbedderOptions {
-    dim?: number;
-}
-/**
- * A deterministic, dependency-free embedder: signed feature hashing
- * (bag-of-words) over code-aware tokens, L2-normalized. It captures lexical
- * overlap rather than true semantics, but it is offline, instant, and stable —
- * which makes it the right default for tests and a sane fallback when the native
- * embedding model is unavailable.
- */
-export declare class HashingEmbedder implements Embedder {
-    readonly id: string;
-    readonly dim: number;
-    constructor(opts?: HashingEmbedderOptions);
-    embed(texts: string[]): Promise<Float32Array[]>;
-    embedQuery(text: string): Promise<Float32Array>;
-    private embedOne;
-}
-export interface FastEmbedEmbedderOptions {
-    /** Where the ONNX model is downloaded/cached. Defaults to fastembed's own dir. */
-    cacheDir?: string;
-    /** Max model input length, in tokens. */
-    maxLength?: number;
-    /** Texts per inference batch. */
-    batchSize?: number;
-    /** Print the model download progress on first run. */
-    showDownloadProgress?: boolean;
-}
-/**
- * Local semantic embeddings via fastembed (ONNX), model bge-small-en-v1.5
- * (384-dim). The native dependency is imported lazily on first use, so merely
- * registering the `search_codebase` tool stays cheap and the heavy ONNX runtime
- * only loads when an index is actually built or queried.
- *
- * Embedding is CPU-bound and single-threaded inside ONNX, so throughput is
- * bounded by `batchSize` (fed sequentially through fastembed's batching
- * generator) rather than by JS-level concurrency.
- */
-export declare class FastEmbedEmbedder implements Embedder {
-    readonly id = "fastembed:bge-small-en-v1.5";
-    readonly dim = 384;
-    private readonly opts;
-    private model;
-    constructor(opts?: FastEmbedEmbedderOptions);
-    private getModel;
-    embed(texts: string[]): Promise<Float32Array[]>;
-    embedQuery(text: string): Promise<Float32Array>;
-}
-export interface CreateEmbedderOptions {
-    /** Cache dir for the fastembed model. */
-    cacheDir?: string;
-}
-/**
- * Build the **production** embedder: fastembed / bge-small-en-v1.5.
- *
- * The native dependency is loaded eagerly here so a missing or broken install
- * fails *now*, loudly, with an actionable message — rather than silently
- * degrading search quality at query time. There is deliberately **no** fallback
- * to {@link HashingEmbedder}: that backend is reachable only by explicit
- * injection in tests (see `getIndexService`'s `deps.embedder`), never selected
- * automatically by this factory or by config.
- *
- * @throws if the fastembed native module cannot be loaded.
- */
-export declare function createEmbedder(opts?: CreateEmbedderOptions): Promise<Embedder>;

package/dist/indexing/index.d.ts

@@ -1,9 +0,0 @@
-export * from "./types.js";
-export * from "./util.js";
-export * from "./chunker.js";
-export * from "./embedder.js";
-export * from "./store.js";
-export * from "./walker.js";
-export * from "./indexer.js";
-export * from "./retriever.js";
-export * from "./service.js";

package/dist/indexing/indexer.d.ts

@@ -1,45 +0,0 @@
-import { type ChunkOptions } from "./chunker.js";
-import type { Embedder } from "./embedder.js";
-import type { VectorStore } from "./store.js";
-import type { IndexStats } from "./types.js";
-/** Minimal logger surface the indexer reports progress to. */
-interface IndexerLogger {
-    debug(message: string): void;
-    info(message: string): void;
-}
-export interface IndexerOptions {
-    /** Absolute project root to index. */
-    root: string;
-    /** Where embeddings are stored. */
-    store: VectorStore;
-    /** How text is turned into vectors. */
-    embedder: Embedder;
-    /** Hard per-file size cap, in bytes. */
-    maxFileBytes: number;
-    /** Chunking parameters. */
-    chunk: ChunkOptions;
-    /** Concurrency for reading/hashing files. */
-    readConcurrency?: number;
-    /** Files chunked + embedded + upserted per batch (bounds peak memory). */
-    fileBatchSize?: number;
-    /** Optional progress logger. */
-    logger?: IndexerLogger;
-}
-/**
- * Orchestrates the index: walk → hash → (skip unchanged | chunk → embed →
- * upsert) → purge removed.
- *
- * Incrementality is content-hash based: a file is re-embedded only when its
- * bytes change; unchanged files are skipped; files that disappeared (deleted or
- * newly ignored) are purged. Changing the embedder (a new model or dimension)
- * invalidates the whole index — its signature is stored, and a mismatch forces a
- * full re-embed so vectors never mix across models.
- */
-export declare class Indexer {
-    private readonly opts;
-    constructor(opts: IndexerOptions);
-    index(runOpts?: {
-        force?: boolean;
-    }): Promise<IndexStats>;
-}
-export {};

package/dist/indexing/retriever.d.ts

@@ -1,61 +0,0 @@
-import type { Embedder } from "./embedder.js";
-import type { VectorStore } from "./store.js";
-import type { SearchHit } from "./types.js";
-/** Inputs to {@link searchCodebase}. */
-export interface SearchOptions {
-    query: string;
-    /** Number of hits to return; falls back to `defaultK`. Clamped to [1, 50]. */
-    k?: number;
-    /** Optional glob restricting results by path, e.g. `src/**\/*.ts`. */
-    pathGlob?: string;
-    /**
-     * The declared name of the root being searched (C.26). Stamped onto every
-     * returned hit so a fanned multi-root search can attribute each hit to its
-     * source root. Required: this retriever runs against exactly one root's store,
-     * so the caller that selected that store names it here — no hit is unattributed.
-     */
-    root: string;
-    /**
-     * Per-call override of the snippet token budget (C.26). A fanned multi-root
-     * search passes `Infinity` so each root returns its top-k by score *unbudgeted*,
-     * then applies the real budget ONCE over the merged set ({@link mergeRankedHits},
-     * ⚖︎JC-I) — a true global budget, not the budget applied N× (once per root).
-     * Omitted by single-root callers, who keep the config budget (byte-identical).
-     */
-    tokenBudget?: number;
-}
-/** Collaborators + budget knobs for the retriever. */
-export interface RetrieverDeps {
-    store: VectorStore;
-    embedder: Embedder;
-    /** `k` used when the caller omits it. */
-    defaultK: number;
-    /** Approximate combined-snippet token budget (chars/4 heuristic). */
-    tokenBudget: number;
-    /** Maximum lines kept in any single snippet. */
-    maxSnippetLines: number;
-}
-/**
- * Embed the query, run a cosine top-k over the index, and return ranked hits.
- *
- * Results are token-budgeted: snippets are trimmed to `maxSnippetLines`, then
- * hits are appended only while the combined snippet estimate stays under
- * `tokenBudget` — except the top hit, which is always included so a single large
- * match is never dropped. This keeps tool output from flooding the agent's
- * context window.
- */
-export declare function searchCodebase(deps: RetrieverDeps, opts: SearchOptions): Promise<SearchHit[]>;
-/**
- * Merge per-root hit lists into one globally-ranked, budgeted, k-capped list —
- * the cross-root half of a fanned {@link searchCodebase}. The cap and the token
- * budget are applied **after** the merge (⚖︎JC-I), so `k` is a global top-k across
- * all roots (a strong hit in root B is never crowded out by weaker hits in root A
- * that a per-root cap happened to keep), and the combined snippet budget is
- * honored once for the whole result — not N× as it would be if each root budgeted
- * independently. Hits already carry their `root`, so the merge never loses
- * attribution. Mirrors the single-root budget rule: always keep the top hit.
- */
-export declare function mergeRankedHits(perRoot: readonly (readonly SearchHit[])[], opts: {
-    k: number;
-    tokenBudget: number;
-}): SearchHit[];

package/dist/indexing/service.d.ts

@@ -1,49 +0,0 @@
-import type { CruxyConfig } from "../config/index.js";
-import { type Embedder } from "./embedder.js";
-import { type SearchOptions } from "./retriever.js";
-import type { IndexStats, IndexStatus, SearchHit } from "./types.js";
-/** Logger surface the service reports through. */
-interface ServiceLogger {
-    debug(message: string): void;
-    info(message: string): void;
-    warn(message: string): void;
-}
-/**
- * A ready-to-use index for one project root: it owns the store, embedder, and
- * indexer, exposes `search`/`index`/`status`, and refreshes itself lazily on the
- * first search. Build one with {@link getIndexService}, which caches per cwd so
- * the heavy backends are constructed at most once per process.
- */
-export interface IndexService {
-    /** Search the index, refreshing it first if it hasn't been this process. */
-    search(opts: SearchOptions): Promise<SearchHit[]>;
-    /** Build/refresh the index (incremental unless `force`). */
-    index(runOpts?: {
-        force?: boolean;
-    }): Promise<IndexStats>;
-    /** Read-only snapshot for `cruxy index --status` (does not modify the index). */
-    status(): IndexStatus;
-    /** Release backend resources. */
-    close(): void;
-}
-/** Absolute path of the SQLite index for a project root. */
-export declare function indexDbPath(cwd: string): string;
-/**
- * Explicit dependency overrides. The sole supported override is `embedder`: it
- * is the *only* way to substitute a non-production embedder (e.g.
- * `HashingEmbedder`) and exists for tests. Production callers (the
- * `search_codebase` tool, `cruxy index`) never pass it, so they always go
- * through {@link createEmbedder} — fastembed or a loud failure.
- */
-export interface IndexServiceDeps {
-    embedder?: Embedder;
-}
-/**
- * Get (or build) the {@link IndexService} for a project root, cached per
- * resolved cwd so the embedder + store are created at most once per process.
- * `deps` is for explicit test injection only (see {@link IndexServiceDeps}).
- */
-export declare function getIndexService(cwd: string, config: CruxyConfig, logger: ServiceLogger, deps?: IndexServiceDeps): Promise<IndexService>;
-/** Drop all cached services (closing them). For tests and process teardown. */
-export declare function resetIndexServices(): Promise<void>;
-export {};

package/dist/indexing/store.d.ts

@@ -1,103 +0,0 @@
-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/types.d.ts

@@ -1,78 +0,0 @@
-/**
- * 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 {
-    /**
-     * The declared name of the root this hit was indexed from (C.26). Required —
-     * so a hit can never be un-attributed — and stamped at construction from the
-     * same root whose store produced it, which is what lets a fanned multi-root
-     * search label each hit with its true source (the honesty pin).
-     */
-    root: string;
-    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/util.d.ts

@@ -1,34 +0,0 @@
-/**
- * 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;