lmgrep 0.1.18 → 0.2.0

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

@@ -0,0 +1,52 @@
+import type { LockPort } from "../../domain/ports/LockPort.js";
+/**
+ * The two locks a database has, which exist for different reasons and are
+ * therefore scoped differently.
+ *
+ * The **write mutex** (`.writelock`) is per *database*, because that is what
+ * concurrent writers actually contend for: two indexers writing the same
+ * tables race into duplicate rows. It is held only around a build.
+ *
+ * The **maintainer** lock is per *worktree*. Watching is inherently per
+ * working tree — a watcher scans its own root and maintains its own branch's
+ * manifest — but worktrees of one repository share a single database. Keying
+ * this lock by database, as it once was, meant the first worktree to start
+ * silently prevented every sibling from ever watching, leaving their branches
+ * to go stale with no indication. It also doubles as the liveness registry
+ * `lmgrep status` reads, which is why the owning worktree is recorded in it.
+ *
+ * Both live in the state directory rather than beside the database. Locks
+ * coordinate processes on *this machine*; a database now lives inside a
+ * repository, which may be on a network filesystem, may be read-only, and is
+ * the wrong place to record which local pid is busy with it. Keeping them
+ * together in one directory is also what lets `status` find every running
+ * lmgrep by reading a single directory.
+ */
+export declare class DatabaseLocks implements LockPort {
+    private readonly databasePath;
+    /** Working tree this process would be responsible for. */
+    private readonly workspaceRoot;
+    private static readonly DEFAULT_WAIT_MS;
+    private static readonly DEFAULT_POLL_MS;
+    /** Enough to separate worktrees without making the filename unreadable. */
+    private static readonly ROOT_DIGEST_LENGTH;
+    private readonly maintainer;
+    private readonly writer;
+    constructor(locksDirectory: string, databasePath: string, 
+    /** Working tree this process would be responsible for. */
+    workspaceRoot: string);
+    acquireMaintainer(): boolean;
+    releaseMaintainer(): void;
+    isMaintained(): boolean;
+    /**
+     * Run `fn` holding the write mutex. Waits for a busy lock, taking over one
+     * whose owner has died. Throws if it cannot be acquired in time — better to
+     * fail than to write concurrently and duplicate rows.
+     */
+    withWriteLock<T>(fn: () => Promise<T>, options?: {
+        waitMs?: number;
+        pollMs?: number;
+    }): Promise<T>;
+    /** Short stable name for a path, used to key lock files. */
+    private static digestOf;
+}

package/dist/infrastructure/fs/DatabaseLocks.js

@@ -0,0 +1,92 @@
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { PidFileLock } from "./PidFileLock.js";
+/**
+ * The two locks a database has, which exist for different reasons and are
+ * therefore scoped differently.
+ *
+ * The **write mutex** (`.writelock`) is per *database*, because that is what
+ * concurrent writers actually contend for: two indexers writing the same
+ * tables race into duplicate rows. It is held only around a build.
+ *
+ * The **maintainer** lock is per *worktree*. Watching is inherently per
+ * working tree — a watcher scans its own root and maintains its own branch's
+ * manifest — but worktrees of one repository share a single database. Keying
+ * this lock by database, as it once was, meant the first worktree to start
+ * silently prevented every sibling from ever watching, leaving their branches
+ * to go stale with no indication. It also doubles as the liveness registry
+ * `lmgrep status` reads, which is why the owning worktree is recorded in it.
+ *
+ * Both live in the state directory rather than beside the database. Locks
+ * coordinate processes on *this machine*; a database now lives inside a
+ * repository, which may be on a network filesystem, may be read-only, and is
+ * the wrong place to record which local pid is busy with it. Keeping them
+ * together in one directory is also what lets `status` find every running
+ * lmgrep by reading a single directory.
+ */
+export class DatabaseLocks {
+    databasePath;
+    workspaceRoot;
+    static DEFAULT_WAIT_MS = 120_000;
+    static DEFAULT_POLL_MS = 200;
+    /** Enough to separate worktrees without making the filename unreadable. */
+    static ROOT_DIGEST_LENGTH = 12;
+    maintainer;
+    writer;
+    constructor(locksDirectory, databasePath, 
+    /** Working tree this process would be responsible for. */
+    workspaceRoot) {
+        this.databasePath = databasePath;
+        this.workspaceRoot = workspaceRoot;
+        const database = DatabaseLocks.digestOf(databasePath);
+        this.maintainer = new PidFileLock(join(locksDirectory, `${database}@${DatabaseLocks.digestOf(workspaceRoot)}.lock`));
+        this.writer = new PidFileLock(join(locksDirectory, `${database}.writelock`));
+    }
+    acquireMaintainer() {
+        // The database path goes in the payload because it is no longer in the
+        // filename: a digest cannot be reversed, and `status` needs to name the
+        // index a process is holding.
+        return this.maintainer.tryAcquire({
+            root: this.workspaceRoot,
+            database: this.databasePath,
+        });
+    }
+    releaseMaintainer() {
+        this.maintainer.release();
+    }
+    isMaintained() {
+        return this.maintainer.isHeldByLiveProcess();
+    }
+    /**
+     * Run `fn` holding the write mutex. Waits for a busy lock, taking over one
+     * whose owner has died. Throws if it cannot be acquired in time — better to
+     * fail than to write concurrently and duplicate rows.
+     */
+    async withWriteLock(fn, options = {}) {
+        const waitMs = options.waitMs ?? DatabaseLocks.DEFAULT_WAIT_MS;
+        const pollMs = options.pollMs ?? DatabaseLocks.DEFAULT_POLL_MS;
+        let waited = 0;
+        while (!this.writer.tryAcquire()) {
+            if (waited >= waitMs) {
+                throw new Error("Could not acquire the index write lock — another indexer is busy. " +
+                    "Try again once it finishes.");
+            }
+            await new Promise((r) => setTimeout(r, pollMs));
+            waited += pollMs;
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            this.writer.releaseIfOwned();
+        }
+    }
+    /** Short stable name for a path, used to key lock files. */
+    static digestOf(path) {
+        return createHash("sha256")
+            .update(path)
+            .digest("hex")
+            .slice(0, DatabaseLocks.ROOT_DIGEST_LENGTH);
+    }
+}
+//# sourceMappingURL=DatabaseLocks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DatabaseLocks.js","sourceRoot":"","sources":["../../../src/infrastructure/fs/DatabaseLocks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,OAAO,aAAa;IAWP;IAEA;IAZV,MAAM,CAAU,eAAe,GAAG,OAAO,CAAC;IAC1C,MAAM,CAAU,eAAe,GAAG,GAAG,CAAC;IAC9C,2EAA2E;IACnE,MAAM,CAAU,kBAAkB,GAAG,EAAE,CAAC;IAE/B,UAAU,CAAc;IACxB,MAAM,CAAc;IAErC,YACC,cAAsB,EACL,YAAoB;IACrC,0DAA0D;IACzC,aAAqB;QAFrB,iBAAY,GAAZ,YAAY,CAAQ;QAEpB,kBAAa,GAAb,aAAa,CAAQ;QAEtC,MAAM,QAAQ,GAAG,aAAa,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;QACtD,IAAI,CAAC,UAAU,GAAG,IAAI,WAAW,CAChC,IAAI,CACH,cAAc,EACd,GAAG,QAAQ,IAAI,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,CAC3D,CACD,CAAC;QACF,IAAI,CAAC,MAAM,GAAG,IAAI,WAAW,CAC5B,IAAI,CAAC,cAAc,EAAE,GAAG,QAAQ,YAAY,CAAC,CAC7C,CAAC;IACH,CAAC;IAED,iBAAiB;QAChB,uEAAuE;QACvE,wEAAwE;QACxE,8BAA8B;QAC9B,OAAO,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;YACjC,IAAI,EAAE,IAAI,CAAC,aAAa;YACxB,QAAQ,EAAE,IAAI,CAAC,YAAY;SAC3B,CAAC,CAAC;IACJ,CAAC;IAED,iBAAiB;QAChB,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED,YAAY;QACX,OAAO,IAAI,CAAC,UAAU,CAAC,mBAAmB,EAAE,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,aAAa,CAClB,EAAoB,EACpB,UAAgD,EAAE;QAElD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,aAAa,CAAC,eAAe,CAAC;QAC/D,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,aAAa,CAAC,eAAe,CAAC;QAE/D,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,EAAE,CAAC;YAClC,IAAI,MAAM,IAAI,MAAM,EAAE,CAAC;gBACtB,MAAM,IAAI,KAAK,CACd,oEAAoE;oBACnE,6BAA6B,CAC9B,CAAC;YACH,CAAC;YACD,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;YAChD,MAAM,IAAI,MAAM,CAAC;QAClB,CAAC;QAED,IAAI,CAAC;YACJ,OAAO,MAAM,EAAE,EAAE,CAAC;QACnB,CAAC;gBAAS,CAAC;YACV,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;QAC9B,CAAC;IACF,CAAC;IAED,4DAA4D;IACpD,MAAM,CAAC,QAAQ,CAAC,IAAY;QACnC,OAAO,UAAU,CAAC,QAAQ,CAAC;aACzB,MAAM,CAAC,IAAI,CAAC;aACZ,MAAM,CAAC,KAAK,CAAC;aACb,KAAK,CAAC,CAAC,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAC;IAC9C,CAAC"}

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

@@ -0,0 +1,6 @@
+/** Recursive on-disk size, for reporting what an index actually costs. */
+export declare class DiskUsage {
+    /** Bytes used by `path` and everything under it; 0 when unreadable. */
+    static of(path: string): number;
+    static format(bytes: number): string;
+}

package/dist/infrastructure/fs/DiskUsage.js

@@ -0,0 +1,41 @@
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+/** Recursive on-disk size, for reporting what an index actually costs. */
+export class DiskUsage {
+    /** Bytes used by `path` and everything under it; 0 when unreadable. */
+    static of(path) {
+        let total = 0;
+        let entries;
+        try {
+            entries = readdirSync(path, { withFileTypes: true });
+        }
+        catch {
+            return 0;
+        }
+        for (const entry of entries) {
+            const child = join(path, entry.name);
+            if (entry.isDirectory()) {
+                total += DiskUsage.of(child);
+                continue;
+            }
+            try {
+                total += statSync(child).size;
+            }
+            catch {
+                // Vanished mid-walk; the number is a report, not an invariant.
+            }
+        }
+        return total;
+    }
+    static format(bytes) {
+        const units = ["B", "KB", "MB", "GB", "TB"];
+        let value = bytes;
+        let unit = 0;
+        while (value >= 1024 && unit < units.length - 1) {
+            value /= 1024;
+            unit++;
+        }
+        return `${value < 10 && unit > 0 ? value.toFixed(1) : Math.round(value)}${units[unit]}`;
+    }
+}
+//# sourceMappingURL=DiskUsage.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DiskUsage.js","sourceRoot":"","sources":["../../../src/infrastructure/fs/DiskUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,0EAA0E;AAC1E,MAAM,OAAO,SAAS;IACrB,uEAAuE;IACvE,MAAM,CAAC,EAAE,CAAC,IAAY;QACrB,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,OAAmC,CAAC;QACxC,IAAI,CAAC;YACJ,OAAO,GAAG,WAAW,CAAC,IAAI,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;QACtD,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,CAAC,CAAC;QACV,CAAC;QACD,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC7B,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;YACrC,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;gBACzB,KAAK,IAAI,SAAS,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;gBAC7B,SAAS;YACV,CAAC;YACD,IAAI,CAAC;gBACJ,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC;YAC/B,CAAC;YAAC,MAAM,CAAC;gBACR,+DAA+D;YAChE,CAAC;QACF,CAAC;QACD,OAAO,KAAK,CAAC;IACd,CAAC;IAED,MAAM,CAAC,MAAM,CAAC,KAAa;QAC1B,MAAM,KAAK,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QAC5C,IAAI,KAAK,GAAG,KAAK,CAAC;QAClB,IAAI,IAAI,GAAG,CAAC,CAAC;QACb,OAAO,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACjD,KAAK,IAAI,IAAI,CAAC;YACd,IAAI,EAAE,CAAC;QACR,CAAC;QACD,OAAO,GAAG,KAAK,GAAG,EAAE,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;IACzF,CAAC;CACD"}

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

@@ -0,0 +1,33 @@
+import type { ExtensionRules } from "../../domain/ports/WorkspacePort.js";
+/**
+ * Decides which files are worth indexing.
+ *
+ * Two independent filters: an extension allow-list (is this even source?) and
+ * ignore patterns (should this source be skipped?). Ignore rules come from the
+ * built-in list, the user's config, `.gitignore` and `.lmgrepignore`, plus
+ * nested `.gitignore` files further down the tree.
+ */
+export declare class IndexableFileRules {
+    private readonly cwd;
+    static readonly DEFAULT_IGNORE: string[];
+    static readonly CODE_EXTENSIONS: Set<string>;
+    private readonly root;
+    private readonly extensions;
+    private readonly nested;
+    constructor(cwd: string, extraIgnore?: string[], extensionRules?: ExtensionRules);
+    /** Whether the path's extension is one we index at all. */
+    hasIndexableExtension(filePath: string): boolean;
+    /** Whether the root-level ignore rules exclude this path. */
+    isIgnored(filePath: string): boolean;
+    /**
+     * Load `.gitignore` files sitting in subdirectories, so a nested ignore
+     * applies to its own subtree the way git applies it.
+     */
+    loadNestedIgnores(relativePaths: readonly string[]): void;
+    /** Whether any nested `.gitignore` excludes this path. */
+    isIgnoredByNested(filePath: string): boolean;
+    /** Full decision for a scanned path. */
+    admits(filePath: string): boolean;
+    private static buildIgnore;
+    private static buildExtensions;
+}

package/dist/infrastructure/fs/IndexableFileRules.js

@@ -0,0 +1,177 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, extname, join } from "node:path";
+import ignore from "ignore";
+/**
+ * Decides which files are worth indexing.
+ *
+ * Two independent filters: an extension allow-list (is this even source?) and
+ * ignore patterns (should this source be skipped?). Ignore rules come from the
+ * built-in list, the user's config, `.gitignore` and `.lmgrepignore`, plus
+ * nested `.gitignore` files further down the tree.
+ */
+export class IndexableFileRules {
+    cwd;
+    static DEFAULT_IGNORE = [
+        "node_modules",
+        ".git",
+        "dist",
+        "build",
+        ".next",
+        "__pycache__",
+        ".venv",
+        "vendor",
+        "target",
+        ".lmgrep",
+        "*.min.js",
+        "*.min.css",
+        "*.map",
+        "*.lock",
+        "pnpm-lock.yaml",
+        "package-lock.json",
+        "yarn.lock",
+        "*.png",
+        "*.jpg",
+        "*.jpeg",
+        "*.gif",
+        "*.ico",
+        "*.woff",
+        "*.woff2",
+        "*.ttf",
+        "*.eot",
+        "*.svg",
+        "*.zip",
+        "*.tar",
+        "*.gz",
+        "*.bin",
+        "*.exe",
+        "*.dll",
+        "*.so",
+        "*.dylib",
+        "*.wasm",
+    ];
+    static CODE_EXTENSIONS = new Set([
+        ".js",
+        ".ts",
+        ".jsx",
+        ".tsx",
+        ".py",
+        ".rs",
+        ".go",
+        ".rb",
+        ".c",
+        ".h",
+        ".cpp",
+        ".hpp",
+        ".cc",
+        ".swift",
+        ".json",
+        ".yaml",
+        ".yml",
+        ".toml",
+        ".lua",
+        ".scala",
+        ".zig",
+        ".md",
+        ".markdown",
+        ".mdx",
+        ".sh",
+        ".bash",
+        ".sql",
+        ".graphql",
+        ".gql",
+        ".proto",
+        ".html",
+        ".css",
+        ".scss",
+        ".vue",
+        ".svelte",
+        ".nix",
+        ".tf",
+        ".hcl",
+        ".kt",
+        ".java",
+        ".php",
+        ".cs",
+        ".rst",
+        ".adoc",
+    ]);
+    root;
+    extensions;
+    nested = new Map();
+    constructor(cwd, extraIgnore, extensionRules) {
+        this.cwd = cwd;
+        this.root = IndexableFileRules.buildIgnore(cwd, extraIgnore);
+        this.extensions = IndexableFileRules.buildExtensions(extensionRules);
+    }
+    /** Whether the path's extension is one we index at all. */
+    hasIndexableExtension(filePath) {
+        return this.extensions.has(extname(filePath));
+    }
+    /** Whether the root-level ignore rules exclude this path. */
+    isIgnored(filePath) {
+        try {
+            return this.root.ignores(filePath);
+        }
+        catch {
+            // `ignore` rejects paths it considers malformed; treat those as
+            // ignorable rather than letting one bad name abort a whole scan.
+            return true;
+        }
+    }
+    /**
+     * Load `.gitignore` files sitting in subdirectories, so a nested ignore
+     * applies to its own subtree the way git applies it.
+     */
+    loadNestedIgnores(relativePaths) {
+        for (const f of relativePaths) {
+            if (f.endsWith("/.gitignore") || f === ".gitignore")
+                continue;
+            const dir = dirname(f);
+            if (dir === "." || this.nested.has(dir))
+                continue;
+            const nestedPath = join(this.cwd, dir, ".gitignore");
+            if (!existsSync(nestedPath))
+                continue;
+            const rules = ignore();
+            rules.add(readFileSync(nestedPath, "utf-8"));
+            this.nested.set(dir, rules);
+        }
+    }
+    /** Whether any nested `.gitignore` excludes this path. */
+    isIgnoredByNested(filePath) {
+        for (const [dir, rules] of this.nested) {
+            if (!filePath.startsWith(`${dir}/`))
+                continue;
+            if (rules.ignores(filePath.slice(dir.length + 1)))
+                return true;
+        }
+        return false;
+    }
+    /** Full decision for a scanned path. */
+    admits(filePath) {
+        return (this.hasIndexableExtension(filePath) &&
+            !this.isIgnored(filePath) &&
+            !this.isIgnoredByNested(filePath));
+    }
+    static buildIgnore(cwd, extra) {
+        const rules = ignore();
+        rules.add([...IndexableFileRules.DEFAULT_IGNORE]);
+        if (extra)
+            rules.add(extra);
+        for (const name of [".gitignore", ".lmgrepignore"]) {
+            const path = join(cwd, name);
+            if (existsSync(path))
+                rules.add(readFileSync(path, "utf-8"));
+        }
+        return rules;
+    }
+    static buildExtensions(rules) {
+        const exts = new Set(IndexableFileRules.CODE_EXTENSIONS);
+        for (const e of rules?.include ?? [])
+            exts.add(e);
+        for (const e of rules?.exclude ?? [])
+            exts.delete(e);
+        return exts;
+    }
+}
+//# sourceMappingURL=IndexableFileRules.js.map

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

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

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

@@ -0,0 +1,14 @@
+import type { LoggerPort } from "../../domain/ports/LoggerPort.js";
+/** Timestamped output on stdout/stderr, for foreground commands. */
+export declare class ConsoleLogger implements LoggerPort {
+    info(message: string): void;
+    error(message: string): void;
+}
+/**
+ * Discards everything. Used by the MCP server, whose stdout is a protocol
+ * stream — a stray log line there corrupts the transport.
+ */
+export declare class SilentLogger implements LoggerPort {
+    info(): void;
+    error(): void;
+}

package/dist/infrastructure/fs/Loggers.js

@@ -0,0 +1,18 @@
+/** Timestamped output on stdout/stderr, for foreground commands. */
+export class ConsoleLogger {
+    info(message) {
+        console.log(`[${new Date().toISOString()}] ${message}`);
+    }
+    error(message) {
+        console.error(`[${new Date().toISOString()}] ${message}`);
+    }
+}
+/**
+ * Discards everything. Used by the MCP server, whose stdout is a protocol
+ * stream — a stray log line there corrupts the transport.
+ */
+export class SilentLogger {
+    info() { }
+    error() { }
+}
+//# sourceMappingURL=Loggers.js.map

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"}