lmgrep 0.1.18 → 0.2.1

package/dist/infrastructure/fs/Loggers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Loggers.js","sourceRoot":"","sources":["../../../src/infrastructure/fs/Loggers.ts"],"names":[],"mappings":"AAEA,oEAAoE;AACpE,MAAM,OAAO,aAAa;IACzB,IAAI,CAAC,OAAe;QACnB,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,KAAK,OAAO,EAAE,CAAC,CAAC;IACzD,CAAC;IAED,KAAK,CAAC,OAAe;QACpB,OAAO,CAAC,KAAK,CAAC,IAAI,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,KAAK,OAAO,EAAE,CAAC,CAAC;IAC3D,CAAC;CACD;AAED;;;GAGG;AACH,MAAM,OAAO,YAAY;IACxB,IAAI,KAAU,CAAC;IACf,KAAK,KAAU,CAAC;CAChB"}

package/dist/infrastructure/fs/PidFileLock.d.ts

@@ -0,0 +1,40 @@
+/** What a lock records about its owner. */
+export interface LockOwner {
+    pid: number;
+    /** Working tree the owner is responsible for, when it has one. */
+    root?: string;
+    /** Database the owner holds. Lock files no longer sit beside it. */
+    database?: string;
+}
+/**
+ * A lock file recording its owning process.
+ *
+ * The pid is what makes the lock recoverable: a process that dies without
+ * cleaning up leaves the file behind, and the next contender takes it over
+ * once it sees the owner is gone. Without that, one crash would wedge a
+ * database until someone deleted the file by hand.
+ */
+export declare class PidFileLock {
+    readonly path: string;
+    constructor(path: string);
+    /** True when acquired; false when a live process already holds it. */
+    tryAcquire(owner?: Omit<LockOwner, "pid">): boolean;
+    /** Release unconditionally — used by the long-lived maintainer lock. */
+    release(): void;
+    /**
+     * Release only if this process still owns it, so a lock already lost to a
+     * takeover is not deleted out from under its new owner.
+     */
+    releaseIfOwned(): void;
+    isHeldByLiveProcess(): boolean;
+    /**
+     * Parse the lock body.
+     *
+     * Locks written before this carried a bare pid, and a stale one of those
+     * must still be recognised — otherwise an upgrade would treat a live
+     * watcher's lock as free and start a second one.
+     */
+    read(): LockOwner | undefined;
+    /** Signal 0 tests for existence without delivering anything. */
+    static isAlive(pid: number): boolean;
+}

package/dist/infrastructure/fs/PidFileLock.js

@@ -0,0 +1,97 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname } from "node:path";
+/**
+ * A lock file recording its owning process.
+ *
+ * The pid is what makes the lock recoverable: a process that dies without
+ * cleaning up leaves the file behind, and the next contender takes it over
+ * once it sees the owner is gone. Without that, one crash would wedge a
+ * database until someone deleted the file by hand.
+ */
+export class PidFileLock {
+    path;
+    constructor(path) {
+        this.path = path;
+    }
+    /** True when acquired; false when a live process already holds it. */
+    tryAcquire(owner = {}) {
+        if (this.isHeldByLiveProcess())
+            return false;
+        mkdirSync(dirname(this.path), { recursive: true });
+        writeFileSync(this.path, `${JSON.stringify({ pid: process.pid, ...owner })}\n`);
+        return true;
+    }
+    /** Release unconditionally — used by the long-lived maintainer lock. */
+    release() {
+        try {
+            unlinkSync(this.path);
+        }
+        catch { }
+    }
+    /**
+     * Release only if this process still owns it, so a lock already lost to a
+     * takeover is not deleted out from under its new owner.
+     */
+    releaseIfOwned() {
+        try {
+            if (this.read()?.pid === process.pid)
+                unlinkSync(this.path);
+        }
+        catch { }
+    }
+    isHeldByLiveProcess() {
+        if (!existsSync(this.path))
+            return false;
+        const owner = this.read();
+        // An unreadable or corrupt lock is stale, and safe to take over.
+        if (owner === undefined)
+            return false;
+        return PidFileLock.isAlive(owner.pid);
+    }
+    /**
+     * Parse the lock body.
+     *
+     * Locks written before this carried a bare pid, and a stale one of those
+     * must still be recognised — otherwise an upgrade would treat a live
+     * watcher's lock as free and start a second one.
+     */
+    read() {
+        let raw;
+        try {
+            raw = readFileSync(this.path, "utf-8").trim();
+        }
+        catch {
+            return undefined;
+        }
+        if (raw.length === 0)
+            return undefined;
+        if (raw.startsWith("{")) {
+            try {
+                const parsed = JSON.parse(raw);
+                return typeof parsed.pid === "number"
+                    ? {
+                        pid: parsed.pid,
+                        root: parsed.root,
+                        database: parsed.database,
+                    }
+                    : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const pid = Number.parseInt(raw, 10);
+        return Number.isNaN(pid) ? undefined : { pid };
+    }
+    /** Signal 0 tests for existence without delivering anything. */
+    static isAlive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=PidFileLock.js.map

package/dist/infrastructure/fs/PidFileLock.js.map

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

package/dist/infrastructure/fs/ProjectIndexes.d.ts

@@ -0,0 +1,8 @@
+import type { IndexMetadataPort } from "../../domain/ports/IndexMetadataPort.js";
+import type { ProjectIndex, ProjectIndexesPort } from "../../domain/ports/ProjectIndexesPort.js";
+/** ProjectIndexesPort over the index home directory. */
+export declare class ProjectIndexes implements ProjectIndexesPort {
+    private readonly metadata;
+    constructor(metadata: IndexMetadataPort);
+    list(indexHome: string): ProjectIndex[];
+}

package/dist/infrastructure/fs/ProjectIndexes.js

@@ -0,0 +1,35 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+import { DiskUsage } from "./DiskUsage.js";
+/** ProjectIndexesPort over the index home directory. */
+export class ProjectIndexes {
+    metadata;
+    constructor(metadata) {
+        this.metadata = metadata;
+    }
+    list(indexHome) {
+        let entries;
+        try {
+            entries = readdirSync(indexHome, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        const out = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const databasePath = join(indexHome, entry.name);
+            const meta = this.metadata.read(databasePath);
+            out.push({
+                databasePath,
+                model: meta?.model,
+                dimensions: meta?.dimensions,
+                indexedAt: meta?.indexedAt,
+                bytes: DiskUsage.of(databasePath),
+            });
+        }
+        return out.sort((a, b) => b.bytes - a.bytes);
+    }
+}
+//# sourceMappingURL=ProjectIndexes.js.map

package/dist/infrastructure/fs/ProjectIndexes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectIndexes.js","sourceRoot":"","sources":["../../../src/infrastructure/fs/ProjectIndexes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAMjC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,wDAAwD;AACxD,MAAM,OAAO,cAAc;IACG;IAA7B,YAA6B,QAA2B;QAA3B,aAAQ,GAAR,QAAQ,CAAmB;IAAG,CAAC;IAE5D,IAAI,CAAC,SAAiB;QACrB,IAAI,OAAmC,CAAC;QACxC,IAAI,CAAC;YACJ,OAAO,GAAG,WAAW,CAAC,SAAS,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;QAC3D,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,EAAE,CAAC;QACX,CAAC;QAED,MAAM,GAAG,GAAmB,EAAE,CAAC;QAC/B,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC7B,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE;gBAAE,SAAS;YACnC,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;YACjD,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAC9C,GAAG,CAAC,IAAI,CAAC;gBACR,YAAY;gBACZ,KAAK,EAAE,IAAI,EAAE,KAAK;gBAClB,UAAU,EAAE,IAAI,EAAE,UAAU;gBAC5B,SAAS,EAAE,IAAI,EAAE,SAAS;gBAC1B,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC,YAAY,CAAC;aACjC,CAAC,CAAC;QACJ,CAAC;QACD,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;CACD"}

package/dist/infrastructure/fs/ProjectMetadataStore.d.ts

@@ -0,0 +1,42 @@
+import type { IndexMetadataPort } from "../../domain/ports/IndexMetadataPort.js";
+import type { IndexMetadata } from "../../domain/project/IndexMetadata.js";
+/**
+ * The `lmgrep.json` sidecar written beside each database.
+ *
+ * It records the model and dimensions the index was built with, which is what
+ * lets a later search refuse to run against incompatible embeddings instead of
+ * silently returning nonsense.
+ */
+export declare class ProjectMetadataStore implements IndexMetadataPort {
+    private static readonly FILE;
+    /** What an lmgrep database looks like from the outside. */
+    private static readonly MARKERS;
+    read(databasePath: string): IndexMetadata | undefined;
+    /**
+     * Write the sidecar, preserving the model and dimensions already recorded.
+     *
+     * The first index establishes the baseline; later writes must not overwrite
+     * it, or a search with a different model would stop being detectable as a
+     * mismatch.
+     */
+    write(databasePath: string, metadata: Omit<IndexMetadata, "indexedAt">): void;
+    /**
+     * Whether a directory holds an lmgrep database, or is an empty directory
+     * safe to treat as one.
+     *
+     * `--database <path>` lets a caller aim any directory at any command, so a
+     * destructive operation must confirm the target is ours before touching it
+     * — without this, `lmgrep prune --database .` would delete a working tree.
+     * An empty directory passes because that is what an interrupted index
+     * leaves behind, and removing it cannot lose data.
+     */
+    isDatabaseDirectory(databasePath: string): boolean;
+    /**
+     * Whether a directory actually holds an index.
+     *
+     * Same markers as {@link isDatabaseDirectory}, without its allowance for
+     * an empty directory — the two are kept on one marker set so that what
+     * counts as a database is defined in exactly one place.
+     */
+    holdsIndex(databasePath: string): boolean;
+}

package/dist/infrastructure/fs/ProjectMetadataStore.js

@@ -0,0 +1,86 @@
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { TableName } from "../lancedb/LanceTables.js";
+/**
+ * The `lmgrep.json` sidecar written beside each database.
+ *
+ * It records the model and dimensions the index was built with, which is what
+ * lets a later search refuse to run against incompatible embeddings instead of
+ * silently returning nonsense.
+ */
+export class ProjectMetadataStore {
+    static FILE = "lmgrep.json";
+    /** What an lmgrep database looks like from the outside. */
+    static MARKERS = new Set([
+        ProjectMetadataStore.FILE,
+        `${TableName.Chunks}.lance`,
+        `${TableName.Files}.lance`,
+        `${TableName.LegacyVocab}.lance`,
+    ]);
+    read(databasePath) {
+        try {
+            return JSON.parse(readFileSync(join(databasePath, ProjectMetadataStore.FILE), "utf-8"));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Write the sidecar, preserving the model and dimensions already recorded.
+     *
+     * The first index establishes the baseline; later writes must not overwrite
+     * it, or a search with a different model would stop being detectable as a
+     * mismatch.
+     */
+    write(databasePath, metadata) {
+        mkdirSync(databasePath, { recursive: true });
+        const existing = this.read(databasePath);
+        const merged = {
+            root: metadata.root,
+            remote: metadata.remote,
+            branch: metadata.branch,
+            indexedAt: new Date().toISOString(),
+            model: existing?.model ?? metadata.model,
+            dimensions: existing?.dimensions ?? metadata.dimensions,
+        };
+        writeFileSync(join(databasePath, ProjectMetadataStore.FILE), JSON.stringify(merged, null, 2));
+    }
+    /**
+     * Whether a directory holds an lmgrep database, or is an empty directory
+     * safe to treat as one.
+     *
+     * `--database <path>` lets a caller aim any directory at any command, so a
+     * destructive operation must confirm the target is ours before touching it
+     * — without this, `lmgrep prune --database .` would delete a working tree.
+     * An empty directory passes because that is what an interrupted index
+     * leaves behind, and removing it cannot lose data.
+     */
+    isDatabaseDirectory(databasePath) {
+        let entries;
+        try {
+            entries = readdirSync(databasePath);
+        }
+        catch {
+            return false;
+        }
+        if (entries.length === 0)
+            return true;
+        return entries.some((e) => ProjectMetadataStore.MARKERS.has(e));
+    }
+    /**
+     * Whether a directory actually holds an index.
+     *
+     * Same markers as {@link isDatabaseDirectory}, without its allowance for
+     * an empty directory — the two are kept on one marker set so that what
+     * counts as a database is defined in exactly one place.
+     */
+    holdsIndex(databasePath) {
+        try {
+            return readdirSync(databasePath).some((e) => ProjectMetadataStore.MARKERS.has(e));
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=ProjectMetadataStore.js.map

package/dist/infrastructure/fs/ProjectMetadataStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectMetadataStore.js","sourceRoot":"","sources":["../../../src/infrastructure/fs/ProjectMetadataStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC9E,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAEtD;;;;;;GAMG;AACH,MAAM,OAAO,oBAAoB;IACxB,MAAM,CAAU,IAAI,GAAG,aAAa,CAAC;IAC7C,2DAA2D;IACnD,MAAM,CAAU,OAAO,GAAG,IAAI,GAAG,CAAS;QACjD,oBAAoB,CAAC,IAAI;QACzB,GAAG,SAAS,CAAC,MAAM,QAAQ;QAC3B,GAAG,SAAS,CAAC,KAAK,QAAQ;QAC1B,GAAG,SAAS,CAAC,WAAW,QAAQ;KAChC,CAAC,CAAC;IAEH,IAAI,CAAC,YAAoB;QACxB,IAAI,CAAC;YACJ,OAAO,IAAI,CAAC,KAAK,CAChB,YAAY,CAAC,IAAI,CAAC,YAAY,EAAE,oBAAoB,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CACnD,CAAC;QACpB,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,SAAS,CAAC;QAClB,CAAC;IACF,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CACJ,YAAoB,EACpB,QAA0C;QAE1C,SAAS,CAAC,YAAY,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACzC,MAAM,MAAM,GAAkB;YAC7B,IAAI,EAAE,QAAQ,CAAC,IAAI;YACnB,MAAM,EAAE,QAAQ,CAAC,MAAM;YACvB,MAAM,EAAE,QAAQ,CAAC,MAAM;YACvB,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACnC,KAAK,EAAE,QAAQ,EAAE,KAAK,IAAI,QAAQ,CAAC,KAAK;YACxC,UAAU,EAAE,QAAQ,EAAE,UAAU,IAAI,QAAQ,CAAC,UAAU;SACvD,CAAC;QACF,aAAa,CACZ,IAAI,CAAC,YAAY,EAAE,oBAAoB,CAAC,IAAI,CAAC,EAC7C,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAC/B,CAAC;IACH,CAAC;IAED;;;;;;;;;OASG;IACH,mBAAmB,CAAC,YAAoB;QACvC,IAAI,OAAiB,CAAC;QACtB,IAAI,CAAC;YACJ,OAAO,GAAG,WAAW,CAAC,YAAY,CAAC,CAAC;QACrC,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,KAAK,CAAC;QACd,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QACtC,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACjE,CAAC;IAED;;;;;;OAMG;IACH,UAAU,CAAC,YAAoB;QAC9B,IAAI,CAAC;YACJ,OAAO,WAAW,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAC3C,oBAAoB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CACnC,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,KAAK,CAAC;QACd,CAAC;IACF,CAAC"}

package/dist/infrastructure/fs/ProjectRegistry.d.ts

@@ -0,0 +1,25 @@
+import type { ProjectRegistryPort, RegisteredIndex } from "../../domain/ports/ProjectRegistryPort.js";
+import type { StateDirectoryPort } from "../../domain/ports/StateDirectoryPort.js";
+/**
+ * ProjectRegistryPort as one small JSON file per database.
+ *
+ * One file per entry rather than one file listing all of them, because several
+ * lmgrep processes index different projects at the same time — a shared list
+ * would need a lock and would still lose writes if one crashed mid-rewrite.
+ * Separate files make every write independent and every partial write
+ * survivable: a corrupt entry is skipped, not fatal to the listing.
+ */
+export declare class ProjectRegistry implements ProjectRegistryPort {
+    private readonly state;
+    private static readonly SUFFIX;
+    private static readonly KEY_LENGTH;
+    constructor(state: StateDirectoryPort);
+    record(entry: Omit<RegisteredIndex, "indexedAt">): void;
+    list(): RegisteredIndex[];
+    dangling(): RegisteredIndex[];
+    forget(databasePath: string): void;
+    private all;
+    private exists;
+    /** Keyed by database path, so re-indexing refreshes rather than duplicates. */
+    private pathFor;
+}

package/dist/infrastructure/fs/ProjectRegistry.js

@@ -0,0 +1,83 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+/**
+ * ProjectRegistryPort as one small JSON file per database.
+ *
+ * One file per entry rather than one file listing all of them, because several
+ * lmgrep processes index different projects at the same time — a shared list
+ * would need a lock and would still lose writes if one crashed mid-rewrite.
+ * Separate files make every write independent and every partial write
+ * survivable: a corrupt entry is skipped, not fatal to the listing.
+ */
+export class ProjectRegistry {
+    state;
+    static SUFFIX = ".json";
+    static KEY_LENGTH = 16;
+    constructor(state) {
+        this.state = state;
+    }
+    record(entry) {
+        const directory = this.state.registryDirectory();
+        mkdirSync(directory, { recursive: true });
+        const full = {
+            ...entry,
+            indexedAt: new Date().toISOString(),
+        };
+        writeFileSync(this.pathFor(entry.databasePath), JSON.stringify(full, null, 2));
+    }
+    list() {
+        return this.all().filter((e) => this.exists(e.databasePath));
+    }
+    dangling() {
+        return this.all().filter((e) => !this.exists(e.databasePath));
+    }
+    forget(databasePath) {
+        try {
+            unlinkSync(this.pathFor(databasePath));
+        }
+        catch { }
+    }
+    all() {
+        let names;
+        try {
+            names = readdirSync(this.state.registryDirectory());
+        }
+        catch {
+            return [];
+        }
+        const out = [];
+        for (const name of names) {
+            if (!name.endsWith(ProjectRegistry.SUFFIX))
+                continue;
+            try {
+                const parsed = JSON.parse(readFileSync(join(this.state.registryDirectory(), name), "utf-8"));
+                if (typeof parsed.databasePath === "string" && parsed.databasePath) {
+                    out.push(parsed);
+                }
+            }
+            catch {
+                // A truncated or hand-edited entry is a lost pointer, never a
+                // reason to fail the listing that would have shown the rest.
+            }
+        }
+        return out;
+    }
+    exists(databasePath) {
+        try {
+            return statSync(databasePath).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Keyed by database path, so re-indexing refreshes rather than duplicates. */
+    pathFor(databasePath) {
+        const key = createHash("sha256")
+            .update(databasePath)
+            .digest("hex")
+            .slice(0, ProjectRegistry.KEY_LENGTH);
+        return join(this.state.registryDirectory(), `${key}${ProjectRegistry.SUFFIX}`);
+    }
+}
+//# sourceMappingURL=ProjectRegistry.js.map

package/dist/infrastructure/fs/ProjectRegistry.js.map

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

package/dist/infrastructure/fs/StateDirectory.d.ts

@@ -0,0 +1,28 @@
+import type { StateDirectoryPort } from "../../domain/ports/StateDirectoryPort.js";
+/**
+ * StateDirectoryPort over the real filesystem, rooted at the XDG state
+ * location.
+ *
+ * The subdirectories are new; earlier versions wrote databases and their lock
+ * files as immediate children of the root, interleaved. {@link RESERVED} is
+ * what keeps the two schemes apart, so a legacy scan never mistakes the
+ * registry for a database.
+ *
+ * Existence probes swallow their errors: an unreadable or missing path is
+ * simply "not a database", never a failure.
+ */
+export declare class StateDirectory implements StateDirectoryPort {
+    private static readonly LOCKS;
+    private static readonly REGISTRY;
+    private static readonly DATABASES;
+    /** Subdirectories of the state root that are not legacy databases. */
+    private static readonly RESERVED;
+    private readonly base;
+    constructor(base?: string);
+    root(): string;
+    isDirectory(path: string): boolean;
+    locksDirectory(): string;
+    registryDirectory(): string;
+    databasesDirectory(): string;
+    legacyDatabaseDirectories(): string[];
+}

package/dist/infrastructure/fs/StateDirectory.js

@@ -0,0 +1,71 @@
+import { readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * StateDirectoryPort over the real filesystem, rooted at the XDG state
+ * location.
+ *
+ * The subdirectories are new; earlier versions wrote databases and their lock
+ * files as immediate children of the root, interleaved. {@link RESERVED} is
+ * what keeps the two schemes apart, so a legacy scan never mistakes the
+ * registry for a database.
+ *
+ * Existence probes swallow their errors: an unreadable or missing path is
+ * simply "not a database", never a failure.
+ */
+export class StateDirectory {
+    static LOCKS = "locks";
+    static REGISTRY = "registry";
+    static DATABASES = "db";
+    /** Subdirectories of the state root that are not legacy databases. */
+    static RESERVED = new Set([
+        StateDirectory.LOCKS,
+        StateDirectory.REGISTRY,
+        StateDirectory.DATABASES,
+    ]);
+    base;
+    constructor(base) {
+        // LMGREP_STATE_DIR relocates everything machine-global in one step,
+        // which is what makes an isolated run possible without also moving
+        // HOME — moving HOME breaks provider resolution, since AI SDK packages
+        // are found through the user's global node_modules.
+        this.base =
+            base ??
+                process.env.LMGREP_STATE_DIR ??
+                join(homedir(), ".local", "state", "lmgrep");
+    }
+    root() {
+        return this.base;
+    }
+    isDirectory(path) {
+        try {
+            return statSync(path).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    locksDirectory() {
+        return join(this.base, StateDirectory.LOCKS);
+    }
+    registryDirectory() {
+        return join(this.base, StateDirectory.REGISTRY);
+    }
+    databasesDirectory() {
+        return join(this.base, StateDirectory.DATABASES);
+    }
+    legacyDatabaseDirectories() {
+        let entries;
+        try {
+            entries = readdirSync(this.base);
+        }
+        catch {
+            return [];
+        }
+        return entries
+            .filter((name) => !StateDirectory.RESERVED.has(name))
+            .map((name) => join(this.base, name))
+            .filter((p) => this.isDirectory(p));
+    }
+}
+//# sourceMappingURL=StateDirectory.js.map

package/dist/infrastructure/fs/StateDirectory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateDirectory.js","sourceRoot":"","sources":["../../../src/infrastructure/fs/StateDirectory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,cAAc;IAClB,MAAM,CAAU,KAAK,GAAG,OAAO,CAAC;IAChC,MAAM,CAAU,QAAQ,GAAG,UAAU,CAAC;IACtC,MAAM,CAAU,SAAS,GAAG,IAAI,CAAC;IACzC,sEAAsE;IAC9D,MAAM,CAAU,QAAQ,GAAG,IAAI,GAAG,CAAS;QAClD,cAAc,CAAC,KAAK;QACpB,cAAc,CAAC,QAAQ;QACvB,cAAc,CAAC,SAAS;KACxB,CAAC,CAAC;IAEc,IAAI,CAAS;IAE9B,YAAY,IAAa;QACxB,oEAAoE;QACpE,mEAAmE;QACnE,uEAAuE;QACvE,oDAAoD;QACpD,IAAI,CAAC,IAAI;YACR,IAAI;gBACJ,OAAO,CAAC,GAAG,CAAC,gBAAgB;gBAC5B,IAAI,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC/C,CAAC;IAED,IAAI;QACH,OAAO,IAAI,CAAC,IAAI,CAAC;IAClB,CAAC;IAED,WAAW,CAAC,IAAY;QACvB,IAAI,CAAC;YACJ,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;QACrC,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,KAAK,CAAC;QACd,CAAC;IACF,CAAC;IAED,cAAc;QACb,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IAED,iBAAiB;QAChB,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;IACjD,CAAC;IAED,kBAAkB;QACjB,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC;IAClD,CAAC;IAED,yBAAyB;QACxB,IAAI,OAAiB,CAAC;QACtB,IAAI,CAAC;YACJ,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAClC,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,EAAE,CAAC;QACX,CAAC;QACD,OAAO,OAAO;aACZ,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;aACpD,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;aACpC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IACtC,CAAC"}

package/dist/infrastructure/fs/Workspace.d.ts

@@ -0,0 +1,25 @@
+import { ContentHash } from "../../domain/corpus/ContentHash.js";
+import type { ChangeSet, ExtensionRules, WatchHandle, WorkspacePort } from "../../domain/ports/WorkspacePort.js";
+/** The working tree on the real filesystem. */
+export declare class Workspace implements WorkspacePort {
+    listFiles(cwd: string, extraIgnore?: string[], extensions?: ExtensionRules): string[];
+    hashOf(cwd: string, filePath: string): ContentHash | undefined;
+    modifiedSince(files: string[], cwd: string, cutoffMs: number): string[];
+    /**
+     * Compare on-disk hashes against what the manifest recorded.
+     *
+     * Unreadable files are skipped rather than reported as changed — a
+     * transient read error should not evict a file from the index.
+     */
+    detectChanges(files: string[], manifest: {
+        versionOf(path: string): ContentHash | undefined;
+    }, cwd: string, force?: boolean): ChangeSet;
+    /**
+     * Watch for changes, coalescing a burst into one callback.
+     *
+     * fs.watch's recursive mode misses events on Linux (new subdirectories,
+     * editor atomic saves); callers pair this with a periodic reconcile rather
+     * than trusting it alone.
+     */
+    watch(cwd: string, extraIgnore: string[] | undefined, onChanges: (changedFiles: string[]) => void, debounceMs: number, extensions?: ExtensionRules): WatchHandle;
+}