lmgrep 0.1.18 → 0.2.1

package/dist/application/indexing/IndexingProgress.d.ts

@@ -0,0 +1,34 @@
+/** A phase of an index run, for progress reporting. */
+export type IndexingPhase = "scan" | "chunk" | "embed" | "store";
+export interface IndexingProgressEvent {
+    phase: IndexingPhase;
+    current: number;
+    total: number;
+    message?: string;
+}
+export interface IndexBuildOptions {
+    /** Drop every table and rebuild from scratch. */
+    reset?: boolean;
+    /** Only consider files modified within this duration (e.g. "10m", "2h"). */
+    since?: string;
+    /** Report what would be indexed without doing it. */
+    dry?: boolean;
+    verbose?: boolean;
+    /** Only process these paths instead of scanning the tree. */
+    files?: string[];
+    /**
+     * Allow this run to train a vector index if none exists. Off by default:
+     * training reads every vector and peaks at several GB, which must not
+     * happen behind a background watcher.
+     */
+    createIndex?: boolean;
+    onProgress?: (event: IndexingProgressEvent) => void;
+}
+export interface IndexBuildResult {
+    /** Chunks embedded and stored. */
+    succeeded: number;
+    /** Chunks that failed to embed. */
+    failed: number;
+    /** Files dropped because they no longer exist in the working tree. */
+    removed: number;
+}

package/dist/application/indexing/IndexingProgress.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IndexingProgress.js.map

package/dist/application/indexing/IndexingProgress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IndexingProgress.js","sourceRoot":"","sources":["../../../src/application/indexing/IndexingProgress.ts"],"names":[],"mappings":""}

package/dist/application/operations/Deadline.d.ts

@@ -0,0 +1,13 @@
+/** Bounds how long an operation may take. */
+export declare class Deadline {
+    private readonly milliseconds;
+    private constructor();
+    static after(milliseconds: number): Deadline;
+    /**
+     * Reject if `work` has not settled in time.
+     *
+     * The timer is always cleared, including on the happy path — an uncleared
+     * timer keeps the event loop alive and would stop a CLI process exiting.
+     */
+    enforce<T>(work: Promise<T>): Promise<T>;
+}

package/dist/application/operations/Deadline.js

@@ -0,0 +1,29 @@
+/** Bounds how long an operation may take. */
+export class Deadline {
+    milliseconds;
+    constructor(milliseconds) {
+        this.milliseconds = milliseconds;
+    }
+    static after(milliseconds) {
+        return new Deadline(milliseconds);
+    }
+    /**
+     * Reject if `work` has not settled in time.
+     *
+     * The timer is always cleared, including on the happy path — an uncleared
+     * timer keeps the event loop alive and would stop a CLI process exiting.
+     */
+    enforce(work) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error(`timeout after ${this.milliseconds}ms`)), this.milliseconds);
+            work.then((value) => {
+                clearTimeout(timer);
+                resolve(value);
+            }, (error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+    }
+}
+//# sourceMappingURL=Deadline.js.map

package/dist/application/operations/Deadline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Deadline.js","sourceRoot":"","sources":["../../../src/application/operations/Deadline.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,MAAM,OAAO,QAAQ;IACiB;IAArC,YAAqC,YAAoB;QAApB,iBAAY,GAAZ,YAAY,CAAQ;IAAG,CAAC;IAE7D,MAAM,CAAC,KAAK,CAAC,YAAoB;QAChC,OAAO,IAAI,QAAQ,CAAC,YAAY,CAAC,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACH,OAAO,CAAI,IAAgB;QAC1B,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACzC,MAAM,KAAK,GAAG,UAAU,CACvB,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,iBAAiB,IAAI,CAAC,YAAY,IAAI,CAAC,CAAC,EAC/D,IAAI,CAAC,YAAY,CACjB,CAAC;YACF,IAAI,CAAC,IAAI,CACR,CAAC,KAAK,EAAE,EAAE;gBACT,YAAY,CAAC,KAAK,CAAC,CAAC;gBACpB,OAAO,CAAC,KAAK,CAAC,CAAC;YAChB,CAAC,EACD,CAAC,KAAK,EAAE,EAAE;gBACT,YAAY,CAAC,KAAK,CAAC,CAAC;gBACpB,MAAM,CAAC,KAAK,CAAC,CAAC;YACf,CAAC,CACD,CAAC;QACH,CAAC,CAAC,CAAC;IACJ,CAAC;CACD"}

package/dist/application/operations/HealthMonitor.d.ts

@@ -0,0 +1,58 @@
+import type { LmgrepConfig } from "../../domain/config/LmgrepConfig.js";
+export type HealthReason = "ok" | "not_indexed" | "embedding_failed" | "search_empty";
+export interface HealthState {
+    healthy: boolean;
+    reason: HealthReason;
+}
+/** What the monitor needs to probe, without knowing how any of it works. */
+export interface HealthProbe {
+    isIndexed(): boolean;
+    /** Full status check; throws when the embedder is unreachable. */
+    inspect(): Promise<{
+        fileCount: number;
+        embeddingOk: boolean;
+        searchOk: boolean;
+    }>;
+    /** Ensure the file watcher is running, if this process can hold the lock. */
+    ensureWatching(): void;
+}
+/**
+ * Tracks whether search is usable, and tells listeners when that changes.
+ *
+ * The polling policy matters more than it looks. While healthy the monitor
+ * never pings the embedder at all: a local model should be free to unload and
+ * sleep, and a billed remote provider should not be charged for liveness
+ * checks. Polling arms only when a real search has failed, and disarms the
+ * moment one succeeds — so the cost is paid exactly when something is wrong.
+ */
+export declare class HealthMonitor {
+    private readonly probe;
+    private state;
+    private readonly listeners;
+    private timer;
+    private polling;
+    private delayMs;
+    private disposed;
+    private readonly baseDelayMs;
+    private readonly maxDelayMs;
+    constructor(probe: HealthProbe, config: LmgrepConfig);
+    get current(): HealthState;
+    onChange(listener: (state: HealthState) => void): () => void;
+    /**
+     * Boot: start watching, but do not poll. The initial optimistic state
+     * already drives an accurate tool description, and the embedder stays
+     * asleep until something actually needs it.
+     */
+    start(): void;
+    /** A completed search proves the embedder and index are both live. */
+    markHealthy(): void;
+    /** A failed search may mean the embedder is down; watch for recovery. */
+    markFailed(): void;
+    dispose(): void;
+    private check;
+    private refresh;
+    private transition;
+    private startPolling;
+    private poll;
+    private stopPolling;
+}

package/dist/application/operations/HealthMonitor.js

@@ -0,0 +1,128 @@
+/**
+ * Tracks whether search is usable, and tells listeners when that changes.
+ *
+ * The polling policy matters more than it looks. While healthy the monitor
+ * never pings the embedder at all: a local model should be free to unload and
+ * sleep, and a billed remote provider should not be charged for liveness
+ * checks. Polling arms only when a real search has failed, and disarms the
+ * moment one succeeds — so the cost is paid exactly when something is wrong.
+ */
+export class HealthMonitor {
+    probe;
+    state;
+    listeners = new Set();
+    timer;
+    polling = false;
+    delayMs = 0;
+    disposed = false;
+    baseDelayMs;
+    maxDelayMs;
+    constructor(probe, config) {
+        this.probe = probe;
+        // A local embedder is free to poll often; a billed one is not.
+        this.baseDelayMs = config.local ? 10_000 : 60_000;
+        // Cap the backoff so a long-down provider is not pinged every base
+        // period for hours: ~2min local, ~5min remote.
+        this.maxDelayMs = config.local ? 120_000 : 300_000;
+        this.state = probe.isIndexed()
+            ? { healthy: true, reason: "ok" }
+            : { healthy: false, reason: "not_indexed" };
+    }
+    get current() {
+        return this.state;
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    /**
+     * Boot: start watching, but do not poll. The initial optimistic state
+     * already drives an accurate tool description, and the embedder stays
+     * asleep until something actually needs it.
+     */
+    start() {
+        this.probe.ensureWatching();
+    }
+    /** A completed search proves the embedder and index are both live. */
+    markHealthy() {
+        this.transition({ healthy: true, reason: "ok" });
+        this.probe.ensureWatching();
+        this.stopPolling();
+    }
+    /** A failed search may mean the embedder is down; watch for recovery. */
+    markFailed() {
+        this.startPolling();
+    }
+    dispose() {
+        this.disposed = true;
+        this.stopPolling();
+        this.listeners.clear();
+    }
+    async check() {
+        if (!this.probe.isIndexed()) {
+            return { healthy: false, reason: "not_indexed" };
+        }
+        try {
+            const info = await this.probe.inspect();
+            if (info.fileCount === 0) {
+                return { healthy: false, reason: "not_indexed" };
+            }
+            if (!info.embeddingOk) {
+                return { healthy: false, reason: "embedding_failed" };
+            }
+            if (!info.searchOk) {
+                return { healthy: false, reason: "search_empty" };
+            }
+            return { healthy: true, reason: "ok" };
+        }
+        catch {
+            return { healthy: false, reason: "embedding_failed" };
+        }
+    }
+    async refresh() {
+        if (this.disposed)
+            return;
+        this.transition(await this.check());
+        if (this.state.healthy) {
+            // Recovered — stop pinging so the embedder can sleep again. The
+            // loop re-arms on the next failed search.
+            this.probe.ensureWatching();
+            this.stopPolling();
+        }
+    }
+    transition(next) {
+        if (next.healthy === this.state.healthy &&
+            next.reason === this.state.reason) {
+            return;
+        }
+        this.state = next;
+        for (const listener of this.listeners)
+            listener(next);
+    }
+    startPolling() {
+        if (this.polling || this.disposed)
+            return;
+        this.polling = true;
+        this.delayMs = this.baseDelayMs;
+        this.probe.ensureWatching();
+        void this.poll();
+    }
+    async poll() {
+        if (!this.polling || this.disposed)
+            return;
+        await this.refresh();
+        // refresh() disarms polling if the embedder recovered.
+        if (!this.polling || this.disposed)
+            return;
+        this.timer = setTimeout(() => void this.poll(), this.delayMs);
+        this.timer.unref?.();
+        this.delayMs = Math.min(this.delayMs * 2, this.maxDelayMs);
+    }
+    stopPolling() {
+        this.polling = false;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+    }
+}
+//# sourceMappingURL=HealthMonitor.js.map

package/dist/application/operations/HealthMonitor.js.map

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

package/dist/application/operations/IndexAlternatives.d.ts

@@ -0,0 +1,35 @@
+import type { LmgrepConfig } from "../../domain/config/LmgrepConfig.js";
+import type { ProjectIndex, ProjectIndexesPort } from "../../domain/ports/ProjectIndexesPort.js";
+import type { DatabaseLocation } from "../../domain/project/DatabaseLocation.js";
+import type { ProjectLocator } from "../../domain/project/ProjectLocator.js";
+/** What to say when the configured model has no index but another one does. */
+export interface AbsenceExplanation {
+    reason: string;
+    fix: string;
+    /** The indexes that do exist, largest first. */
+    others: readonly ProjectIndex[];
+}
+/**
+ * Explains an index that is absent because the model changed.
+ *
+ * Storing one database per model makes switching models safe and reversible,
+ * but it also means a switch turns a working project into an empty one — and
+ * "not indexed" is then a true statement that badly misdescribes the
+ * situation. The old index is intact, one directory away, and reachable by
+ * putting the old model back. Without saying so, the obvious next step is
+ * `lmgrep index`, which re-embeds the entire repository to reach a state the
+ * user may not have meant to ask for.
+ */
+export declare class IndexAlternatives {
+    private readonly indexes;
+    private readonly locator;
+    private readonly location;
+    private readonly config;
+    private readonly cwd;
+    constructor(indexes: ProjectIndexesPort, locator: ProjectLocator, location: DatabaseLocation, config: LmgrepConfig, cwd: string);
+    /** Indexes for this project built with some other model. */
+    others(): ProjectIndex[];
+    /** The explanation, or nothing when this is simply an unindexed project. */
+    explainAbsence(): AbsenceExplanation | undefined;
+    private describe;
+}

package/dist/application/operations/IndexAlternatives.js

@@ -0,0 +1,61 @@
+import { ModelIdentity } from "../../domain/project/ModelIdentity.js";
+/**
+ * Explains an index that is absent because the model changed.
+ *
+ * Storing one database per model makes switching models safe and reversible,
+ * but it also means a switch turns a working project into an empty one — and
+ * "not indexed" is then a true statement that badly misdescribes the
+ * situation. The old index is intact, one directory away, and reachable by
+ * putting the old model back. Without saying so, the obvious next step is
+ * `lmgrep index`, which re-embeds the entire repository to reach a state the
+ * user may not have meant to ask for.
+ */
+export class IndexAlternatives {
+    indexes;
+    locator;
+    location;
+    config;
+    cwd;
+    constructor(indexes, locator, location, config, cwd) {
+        this.indexes = indexes;
+        this.locator = locator;
+        this.location = location;
+        this.config = config;
+        this.cwd = cwd;
+    }
+    /** Indexes for this project built with some other model. */
+    others() {
+        // A database chosen by name or path is not one of a project's model
+        // variants, so it has no siblings to speak of.
+        if (this.location.manual)
+            return [];
+        return this.indexes
+            .list(this.locator.indexHomeFor(this.cwd))
+            .filter((index) => index.databasePath !== this.location.path)
+            .filter((index) => index.bytes > 0);
+    }
+    /** The explanation, or nothing when this is simply an unindexed project. */
+    explainAbsence() {
+        const others = this.others();
+        if (others.length === 0)
+            return undefined;
+        const named = others.filter((index) => index.model);
+        const previous = named[0] ?? others[0];
+        const configured = ModelIdentity.of(this.config.model).family;
+        return {
+            reason: `This project has no index for "${configured}" — but it is indexed ` +
+                `with ${this.describe(named)}.`,
+            fix: `Set \`model\` back to ${previous.model ?? "the previous model"} to use that index immediately, ` +
+                "or run `lmgrep index` to embed this project with the new model (the other index is kept).",
+            others,
+        };
+    }
+    describe(indexes) {
+        if (indexes.length === 0)
+            return "another model";
+        return indexes
+            .map((index) => `"${ModelIdentity.of(index.model ?? "").family}"`)
+            .join(", ");
+    }
+}
+//# sourceMappingURL=IndexAlternatives.js.map

package/dist/application/operations/IndexAlternatives.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IndexAlternatives.js","sourceRoot":"","sources":["../../../src/application/operations/IndexAlternatives.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAWtE;;;;;;;;;;GAUG;AACH,MAAM,OAAO,iBAAiB;IAEX;IACA;IACA;IACA;IACA;IALlB,YACkB,OAA2B,EAC3B,OAAuB,EACvB,QAA0B,EAC1B,MAAoB,EACpB,GAAW;QAJX,YAAO,GAAP,OAAO,CAAoB;QAC3B,YAAO,GAAP,OAAO,CAAgB;QACvB,aAAQ,GAAR,QAAQ,CAAkB;QAC1B,WAAM,GAAN,MAAM,CAAc;QACpB,QAAG,GAAH,GAAG,CAAQ;IAC1B,CAAC;IAEJ,4DAA4D;IAC5D,MAAM;QACL,oEAAoE;QACpE,+CAA+C;QAC/C,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM;YAAE,OAAO,EAAE,CAAC;QACpC,OAAO,IAAI,CAAC,OAAO;aACjB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aACzC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,YAAY,KAAK,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;aAC5D,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;IACtC,CAAC;IAED,4EAA4E;IAC5E,cAAc;QACb,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC7B,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAE1C,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACpD,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC;QACvC,MAAM,UAAU,GAAG,aAAa,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;QAE9D,OAAO;YACN,MAAM,EACL,kCAAkC,UAAU,wBAAwB;gBACpE,QAAQ,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG;YAChC,GAAG,EACF,yBAAyB,QAAQ,CAAC,KAAK,IAAI,oBAAoB,kCAAkC;gBACjG,2FAA2F;YAC5F,MAAM;SACN,CAAC;IACH,CAAC;IAEO,QAAQ,CAAC,OAAgC;QAChD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,eAAe,CAAC;QACjD,OAAO,OAAO;aACZ,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC;aACjE,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,CAAC;CACD"}

package/dist/application/operations/IndexInventory.d.ts

@@ -0,0 +1,69 @@
+import type { IndexMetadataPort } from "../../domain/ports/IndexMetadataPort.js";
+import type { ProjectRegistryPort } from "../../domain/ports/ProjectRegistryPort.js";
+import type { StateDirectoryPort } from "../../domain/ports/StateDirectoryPort.js";
+/** One index on this machine, and what is known about it. */
+export interface InventoryEntry {
+    databasePath: string;
+    /** Working tree it describes, when that is recorded. */
+    root?: string;
+    /** Name of a standalone index, which is its identity instead of a root. */
+    name?: string;
+    remote?: string;
+    model?: string;
+    dimensions?: number;
+    indexedAt?: string;
+    bytes: number;
+    /**
+     * `live`           — its working tree is there.
+     * `orphaned`       — it names a working tree that is gone.
+     * `unattributable` — it records no working tree at all, so nothing can be
+     *                    concluded about whether its project still exists.
+     */
+    state: "live" | "orphaned" | "unattributable";
+    /**
+     * `repository` — inside the repo it indexes, the current scheme.
+     * `standalone` — in the state directory, for corpora with no repo.
+     * `legacy`     — written by a version that kept every index in the state
+     *                directory; readable, adoptable, removable.
+     */
+    kind: "repository" | "standalone" | "legacy";
+}
+export interface Inventory {
+    entries: InventoryEntry[];
+    /** Registry entries whose database is gone: pointers to nothing. */
+    dangling: number;
+    totalBytes: number;
+}
+/**
+ * The list of every index this machine holds.
+ *
+ * This exists because indexes stopped being enumerable by listing a directory.
+ * That was the point — an index inside its repository cannot be orphaned by
+ * deleting the repository — but it removed the only way anyone could see what
+ * lmgrep had accumulated. Before this, an install could hold a hundred
+ * databases and many gigabytes with no command that would say so, and the only
+ * thing that could enumerate them was an MCP tool the user could not call.
+ */
+export declare class IndexInventory {
+    private readonly registry;
+    private readonly metadata;
+    private readonly state;
+    private readonly sizeOf;
+    constructor(registry: ProjectRegistryPort, metadata: IndexMetadataPort, state: StateDirectoryPort, sizeOf: (path: string) => number);
+    collect(): Inventory;
+    /**
+     * Whether an index still has a project.
+     *
+     * "No recorded root" is kept distinct from "recorded root is gone". They
+     * look the same in a listing and are not the same thing at all: the second
+     * is safe to delete, while the first is an index whose provenance was
+     * simply never written down — an interrupted first run, most often, but
+     * possibly a working index for a project that is right there.
+     */
+    private stateOf;
+    /**
+     * Where an index lives. Decided by path rather than by a stored flag, so an
+     * entry written by any version reports the truth about where it is now.
+     */
+    private kindOf;
+}

package/dist/application/operations/IndexInventory.js

@@ -0,0 +1,99 @@
+import { existsSync } from "node:fs";
+/**
+ * The list of every index this machine holds.
+ *
+ * This exists because indexes stopped being enumerable by listing a directory.
+ * That was the point — an index inside its repository cannot be orphaned by
+ * deleting the repository — but it removed the only way anyone could see what
+ * lmgrep had accumulated. Before this, an install could hold a hundred
+ * databases and many gigabytes with no command that would say so, and the only
+ * thing that could enumerate them was an MCP tool the user could not call.
+ */
+export class IndexInventory {
+    registry;
+    metadata;
+    state;
+    sizeOf;
+    constructor(registry, metadata, state, sizeOf) {
+        this.registry = registry;
+        this.metadata = metadata;
+        this.state = state;
+        this.sizeOf = sizeOf;
+    }
+    collect() {
+        const entries = [];
+        const seen = new Set();
+        for (const registered of this.registry.list()) {
+            seen.add(registered.databasePath);
+            entries.push({
+                databasePath: registered.databasePath,
+                root: registered.root,
+                name: registered.name,
+                remote: registered.remote,
+                model: registered.model,
+                dimensions: registered.dimensions,
+                indexedAt: registered.indexedAt,
+                bytes: this.sizeOf(registered.databasePath),
+                // A standalone index outlives the directory it was built from,
+                // so its project cannot be "gone" — collecting it on that
+                // basis would delete a corpus that is working fine.
+                state: registered.name || existsSync(registered.root) ? "live" : "orphaned",
+                kind: this.kindOf(registered.databasePath),
+            });
+        }
+        for (const path of this.state.legacyDatabaseDirectories()) {
+            if (seen.has(path))
+                continue;
+            // A directory with no sidecar and no tables is not an index, and
+            // saying otherwise sends the user to adopt something that is not
+            // there. This is not hypothetical: a server left running across an
+            // upgrade still writes the previous layout, recreating its
+            // database directory under the state root every time it starts a
+            // scan.
+            if (!this.metadata.holdsIndex(path))
+                continue;
+            const meta = this.metadata.read(path);
+            entries.push({
+                databasePath: path,
+                root: meta?.root,
+                remote: meta?.remote,
+                model: meta?.model,
+                dimensions: meta?.dimensions,
+                indexedAt: meta?.indexedAt,
+                bytes: this.sizeOf(path),
+                state: this.stateOf(meta?.root),
+                kind: "legacy",
+            });
+        }
+        entries.sort((a, b) => b.bytes - a.bytes);
+        return {
+            entries,
+            dangling: this.registry.dangling().length,
+            totalBytes: entries.reduce((sum, e) => sum + e.bytes, 0),
+        };
+    }
+    /**
+     * Whether an index still has a project.
+     *
+     * "No recorded root" is kept distinct from "recorded root is gone". They
+     * look the same in a listing and are not the same thing at all: the second
+     * is safe to delete, while the first is an index whose provenance was
+     * simply never written down — an interrupted first run, most often, but
+     * possibly a working index for a project that is right there.
+     */
+    stateOf(root) {
+        if (!root)
+            return "unattributable";
+        return existsSync(root) ? "live" : "orphaned";
+    }
+    /**
+     * Where an index lives. Decided by path rather than by a stored flag, so an
+     * entry written by any version reports the truth about where it is now.
+     */
+    kindOf(databasePath) {
+        return databasePath.startsWith(this.state.databasesDirectory())
+            ? "standalone"
+            : "repository";
+    }
+}
+//# sourceMappingURL=IndexInventory.js.map

package/dist/application/operations/IndexInventory.js.map

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

package/dist/application/operations/StatusService.d.ts

@@ -0,0 +1,90 @@
+import type { ConfigSource } from "../../domain/config/ConfigSource.js";
+import type { LmgrepConfig } from "../../domain/config/LmgrepConfig.js";
+import type { ChunkRepositoryPort } from "../../domain/ports/ChunkRepositoryPort.js";
+import type { EmbedderPort } from "../../domain/ports/EmbedderPort.js";
+import type { IndexMaintenancePort, VectorIndexState } from "../../domain/ports/IndexMaintenancePort.js";
+import type { IndexMetadataPort } from "../../domain/ports/IndexMetadataPort.js";
+import type { DatabaseLocation } from "../../domain/project/DatabaseLocation.js";
+import type { ProjectLocator } from "../../domain/project/ProjectLocator.js";
+import type { IndexAlternatives } from "./IndexAlternatives.js";
+/**
+ * Whether search works right now, and if not, the one thing to do about it.
+ *
+ * A single verdict rather than a wall of statistics: the question someone runs
+ * `status` to answer is "is it working", and burying that under file counts
+ * and latency figures made every reader derive it themselves.
+ */
+export type StatusVerdict = {
+    searchable: true;
+    note?: string;
+} | {
+    searchable: false;
+    reason: string;
+    fix: string;
+};
+export interface StatusInfo {
+    verdict: StatusVerdict;
+    projectRoot: string;
+    prefix: string;
+    databasePath: string;
+    config: LmgrepConfig;
+    /** Which files supplied the configuration, in increasing precedence. */
+    configSources: readonly ConfigSource[];
+    fileCount: number;
+    chunkCount: number;
+    uniqueHashes: number;
+    embeddingOk: boolean;
+    embeddingLatencyMs?: number;
+    embeddingError?: string;
+    /** Did a generic smoke query return at least one result on this branch? */
+    searchOk: boolean;
+    searchResultCount?: number;
+    searchLatencyMs?: number;
+    /**
+     * Whether the database holds anything at all, ignoring branch scope. The
+     * gap between this and {@link searchOk} is what distinguishes "this branch
+     * has not been indexed" from "the index is broken".
+     */
+    anyBranchOk?: boolean;
+    indexModel?: string;
+    indexDimensions?: number;
+    /** How searches are answered: by vector index, or by scanning every row. */
+    vectorIndex: VectorIndexState;
+}
+/**
+ * Reports what the index holds and whether it actually works.
+ *
+ * The two liveness checks are deliberately shallow and time-boxed: `status`
+ * must stay responsive even when the embedder is wedged, since diagnosing that
+ * is exactly why someone runs it.
+ */
+export declare class StatusService {
+    private readonly chunks;
+    private readonly maintenance;
+    private readonly embedder;
+    private readonly locator;
+    private readonly metadata;
+    private readonly location;
+    private readonly config;
+    private readonly cwd;
+    private readonly configSources;
+    private readonly alternatives;
+    private static readonly PROBE_TIMEOUT_MS;
+    /** A word generic enough to match something in any codebase. */
+    private static readonly SMOKE_QUERY;
+    constructor(chunks: ChunkRepositoryPort, maintenance: IndexMaintenancePort, embedder: EmbedderPort, locator: ProjectLocator, metadata: IndexMetadataPort, location: DatabaseLocation, config: LmgrepConfig, cwd: string, configSources: readonly ConfigSource[], alternatives: IndexAlternatives);
+    status(): Promise<StatusInfo>;
+    /**
+     * Reduce the probes to one answer, in the order a user would care.
+     *
+     * A missing vector index is a note rather than a failure: search works, it
+     * is just answering by reading every embedding, which nothing else would
+     * tell you.
+     */
+    private judge;
+    /**
+     * Embed once and reuse the vector for the search check — one roundtrip
+     * covers both, which keeps `status` cheap against a billed provider.
+     */
+    private probe;
+}