local-agent-memory 0.0.0-stage → 1.0.1

package/dist/core/parser.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countTokens = countTokens;
+exports.parseMarkdown = parseMarkdown;
+const remark_parse_1 = __importDefault(require("remark-parse"));
+const unified_1 = __importDefault(require("unified"));
+/**
+ * A very simple token count heuristic (4 chars ~ 1 token)
+ * to avoid depending on tiktoken or similar heavy libraries,
+ * suitable for MiniLM approximation.
+ */
+function countTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Recursively splits a markdown node's text so that each chunk is under maxChars.
+ * Preserves code block delimiters (prefix/suffix) in each fragment.
+ */
+function splitNodeTextRecursively(text, startLine, maxChars, prefix = "", suffix = "", breadcrumb = "") {
+    const fullLength = prefix.length + text.length + suffix.length;
+    // Stop recursion if it fits or if text cannot be reasonably split further
+    if (fullLength <= maxChars || text.length <= 1) {
+        const lines = text.split("\n").length;
+        const fullText = prefix + text + suffix;
+        return [
+            {
+                text: fullText,
+                tokens: countTokens(fullText),
+                startLine,
+                endLine: startLine + lines - 1,
+                breadcrumb,
+            },
+        ];
+    }
+    const half = Math.floor(text.length / 2);
+    let splitIndex = text.lastIndexOf("\n", half);
+    if (splitIndex <= 0) {
+        splitIndex = text.indexOf("\n", half);
+    }
+    if (splitIndex <= 0) {
+        splitIndex = half;
+    }
+    const leftText = text.slice(0, splitIndex);
+    const rightText = text.slice(text[splitIndex] === "\n" ? splitIndex + 1 : splitIndex);
+    const leftLinesCount = leftText.split("\n").length - 1;
+    const rightStartLine = startLine + leftLinesCount + (text[splitIndex] === "\n" ? 1 : 0);
+    return [
+        ...splitNodeTextRecursively(leftText, startLine, maxChars, prefix, suffix, breadcrumb),
+        ...splitNodeTextRecursively(rightText, rightStartLine, maxChars, prefix, suffix, breadcrumb),
+    ];
+}
+/**
+ * Parses markdown content and breaks it down into chunks of text
+ * bounded by maxTokens, aiming to preserve logical code blocks and headings.
+ * Includes simple breadcrumbs based on headings.
+ *
+ * @param content The markdown text content.
+ * @param path The file path (for metadata).
+ * @param maxTokens Maximum number of tokens per chunk.
+ * @param overlapTokens Target token overlap between chunks.
+ * @returns Array of chunk objects.
+ */
+async function parseMarkdown(content, path, maxTokens = 450, overlapTokens = 50) {
+    const processor = (0, unified_1.default)().use(remark_parse_1.default);
+    const ast = processor.parse(content);
+    const chunks = [];
+    let breadcrumbs = [];
+    let currentBlocks = [];
+    function getBreadcrumbString() {
+        return breadcrumbs.map((b) => b.text).join(" > ");
+    }
+    function pushChunk() {
+        if (currentBlocks.length > 0) {
+            const first = currentBlocks[0];
+            const last = currentBlocks[currentBlocks.length - 1];
+            chunks.push({
+                path,
+                text: currentBlocks.map((b) => b.text).join("\n\n"),
+                breadcrumbs: first.breadcrumb,
+                startLine: first.startLine,
+                endLine: last.endLine,
+            });
+        }
+    }
+    if (ast?.children) {
+        for (const node of ast.children) {
+            // Update breadcrumbs based on headings
+            if (node.type === "heading") {
+                const depth = node.depth;
+                // Simple extraction of heading text
+                const text = content
+                    .slice(node.position.start.offset, node.position.end.offset)
+                    .replace(/^#+\s*/, "")
+                    .trim();
+                breadcrumbs = breadcrumbs.filter((b) => b.depth < depth);
+                breadcrumbs.push({ depth, text });
+            }
+            const nodeText = content.slice(node.position.start.offset, node.position.end.offset);
+            const nodeTokens = countTokens(nodeText);
+            let blocksToAdd = [];
+            const MAX_CHARS = 1500;
+            if (nodeText.length > MAX_CHARS || nodeTokens > maxTokens) {
+                let contentToSplit = nodeText;
+                let prefix = "";
+                let suffix = "";
+                if (node.type === "code" && typeof node.value === "string") {
+                    contentToSplit = node.value;
+                    prefix = `\`\`\`${node.lang || ""}\n`;
+                    suffix = "\n```";
+                }
+                blocksToAdd = splitNodeTextRecursively(contentToSplit, node.position.start.line, MAX_CHARS, prefix, suffix, getBreadcrumbString());
+            }
+            else {
+                blocksToAdd.push({
+                    text: nodeText,
+                    tokens: nodeTokens,
+                    startLine: node.position.start.line,
+                    endLine: node.position.end.line,
+                    breadcrumb: getBreadcrumbString(),
+                });
+            }
+            for (const block of blocksToAdd) {
+                const currentTokens = currentBlocks.reduce((acc, b) => acc + b.tokens, 0);
+                if (currentTokens + block.tokens > maxTokens &&
+                    currentBlocks.length > 0) {
+                    pushChunk();
+                    const overlapBlocks = [];
+                    let overlapTokensCount = 0;
+                    for (let i = currentBlocks.length - 1; i >= 0; i--) {
+                        const b = currentBlocks[i];
+                        if (overlapTokensCount + b.tokens <= overlapTokens) {
+                            overlapBlocks.unshift(b);
+                            overlapTokensCount += b.tokens;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    currentBlocks = overlapBlocks;
+                }
+                currentBlocks.push(block);
+            }
+        }
+    }
+    // Push the last chunk if any
+    pushChunk();
+    return chunks;
+}

package/dist/core/search.d.ts

@@ -0,0 +1,19 @@
+import type { Database } from "sqlite3";
+import type { Chunk } from "./parser";
+export interface SearchResult extends Chunk {
+    id: number;
+    score: number;
+}
+/**
+ * Sanitizes a search query for safe use in SQLite FTS5 MATCH clause.
+ * Wrapping each term in double quotes avoids FTS5 syntax errors with reserved keywords
+ * or punctuation (like *, AND, OR, NEAR).
+ */
+export declare function sanitizeFtsQuery(query: string): string;
+/**
+ * Performs a hybrid search combining FTS5 lexical search and sqlite-vec vector search.
+ * Uses Reciprocal Rank Fusion (RRF) to combine results.
+ *
+ * RRF Score = 1 / (k + rank) where k is typically 60.
+ */
+export declare function hybridSearch(query: string, limit: number, db: Database, filter?: string): Promise<SearchResult[]>;

package/dist/core/search.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeFtsQuery = sanitizeFtsQuery;
+exports.hybridSearch = hybridSearch;
+const embeddings_1 = require("./embeddings");
+const sync_1 = require("./sync");
+/**
+ * Sanitizes a search query for safe use in SQLite FTS5 MATCH clause.
+ * Wrapping each term in double quotes avoids FTS5 syntax errors with reserved keywords
+ * or punctuation (like *, AND, OR, NEAR).
+ */
+function sanitizeFtsQuery(query) {
+    if (!query)
+        return "";
+    const terms = query.split(/\s+/).filter((t) => t.trim().length > 0);
+    if (terms.length === 0)
+        return "";
+    return terms.map((t) => `"${t.replace(/"/g, '""')}"`).join(" ");
+}
+/**
+ * Performs a hybrid search combining FTS5 lexical search and sqlite-vec vector search.
+ * Uses Reciprocal Rank Fusion (RRF) to combine results.
+ *
+ * RRF Score = 1 / (k + rank) where k is typically 60.
+ */
+async function hybridSearch(query, limit, db, filter) {
+    const asyncDb = new sync_1.AsyncDatabase(db);
+    const RRF_K = 60;
+    // 1. FTS5 Search
+    const ftsResults = await new Promise((resolve, reject) => {
+        // Sanitize query to prevent FTS5 syntax errors
+        const ftsQuery = sanitizeFtsQuery(query);
+        if (!ftsQuery) {
+            return resolve([]);
+        }
+        // using bm25() for scoring in FTS5
+        db.all(`SELECT rowid as id, rank as score FROM chunks_fts WHERE chunks_fts MATCH ? ORDER BY rank LIMIT 100`, [ftsQuery], (err, rows) => {
+            if (err)
+                reject(err);
+            else
+                resolve(rows);
+        });
+    });
+    // 2. Vector Search
+    const queryEmbedding = await (0, embeddings_1.generateEmbedding)(query);
+    const vectorData = Buffer.from(new Float32Array(queryEmbedding).buffer);
+    const vecResults = await new Promise((resolve, reject) => {
+        // sqlite-vec distance function. distance is lower = better (closer)
+        // we want smallest distance first
+        db.all(`SELECT rowid as id, distance FROM chunks_vec
+       WHERE embedding MATCH ? AND k = 100
+       ORDER BY distance`, [vectorData], (err, rows) => {
+            if (err)
+                reject(err);
+            else
+                resolve(rows);
+        });
+    });
+    // 3. RRF Fusion
+    const rrfScores = new Map();
+    // Add FTS scores
+    ftsResults.forEach((res, index) => {
+        const rank = index + 1;
+        const currentScore = rrfScores.get(res.id) || 0;
+        rrfScores.set(res.id, currentScore + 1 / (RRF_K + rank));
+    });
+    // Add Vector scores
+    vecResults.forEach((res, index) => {
+        const rank = index + 1;
+        const currentScore = rrfScores.get(res.id) || 0;
+        rrfScores.set(res.id, currentScore + 1 / (RRF_K + rank));
+    });
+    // Sort by RRF score descending
+    const sortedIds = Array.from(rrfScores.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, limit);
+    // Fetch actual chunk data
+    const finalResults = [];
+    for (const [id, score] of sortedIds) {
+        let row;
+        if (filter) {
+            row = await asyncDb.get("SELECT * FROM chunks WHERE id = ? AND path LIKE ?", [id, `%${filter}%`]);
+        }
+        else {
+            row = await asyncDb.get("SELECT * FROM chunks WHERE id = ?", [id]);
+        }
+        if (row) {
+            finalResults.push({
+                id: row.id,
+                path: row.path,
+                text: row.text,
+                breadcrumbs: row.breadcrumbs,
+                startLine: row.startLine,
+                endLine: row.endLine,
+                score,
+            });
+        }
+    }
+    return finalResults;
+}

package/dist/core/sync.d.ts

@@ -0,0 +1,22 @@
+import type { Database } from "sqlite3";
+/**
+ * Interface to interact with the DB properly using Promises
+ */
+export declare class AsyncDatabase {
+    db: Database;
+    constructor(db: Database);
+    get(sql: string, params?: any[]): Promise<any>;
+    run(sql: string, params?: any[]): Promise<void>;
+}
+/**
+ * Synchronizes a single markdown file into the database.
+ * Uses incremental sync logic based on SHA256 hashes.
+ * If the file changed, processes chunks, generates embeddings,
+ * and updates DB in a transaction.
+ */
+export declare function syncFile(path: string, content: string, db: Database): Promise<void>;
+/**
+ * Removes a file and all its corresponding chunks, vectors, and FTS entries
+ * from the database atomically. Also removes the file_manifest entry.
+ */
+export declare function removeFile(path: string, db: Database): Promise<void>;

package/dist/core/sync.js

@@ -0,0 +1,159 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncDatabase = void 0;
+exports.syncFile = syncFile;
+exports.removeFile = removeFile;
+const crypto = __importStar(require("node:crypto"));
+const embeddings_1 = require("./embeddings");
+const parser_1 = require("./parser");
+function getHash(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+}
+/**
+ * Interface to interact with the DB properly using Promises
+ */
+class AsyncDatabase {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    get(sql, params = []) {
+        return new Promise((resolve, reject) => {
+            this.db.get(sql, params, (err, row) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(row);
+            });
+        });
+    }
+    run(sql, params = []) {
+        return new Promise((resolve, reject) => {
+            this.db.run(sql, params, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+}
+exports.AsyncDatabase = AsyncDatabase;
+/**
+ * Synchronizes a single markdown file into the database.
+ * Uses incremental sync logic based on SHA256 hashes.
+ * If the file changed, processes chunks, generates embeddings,
+ * and updates DB in a transaction.
+ */
+async function syncFile(path, content, db) {
+    const asyncDb = new AsyncDatabase(db);
+    const hash = getHash(content);
+    try {
+        // We expect the table files_metadata to exist
+        // files_metadata (path TEXT PRIMARY KEY, hash TEXT)
+        // We expect chunks to exist (id INTEGER PRIMARY KEY, path TEXT, text TEXT, breadcrumbs TEXT, startLine INTEGER, endLine INTEGER)
+        // We expect chunks_fts to exist (FTS5)
+        // We expect chunks_vec to exist (sqlite-vec)
+        const existingFile = await asyncDb.get("SELECT hash FROM files_metadata WHERE path = ?", [path]);
+        if (existingFile && existingFile.hash === hash) {
+            // File hasn't changed, skip
+            return;
+        }
+        // Begin transaction
+        await asyncDb.run("BEGIN TRANSACTION");
+        // Remove existing chunks for this path if any
+        await asyncDb.run("DELETE FROM chunks_vec WHERE rowid IN (SELECT id FROM chunks WHERE path = ?)", [path]);
+        await asyncDb.run("DELETE FROM chunks_fts WHERE rowid IN (SELECT id FROM chunks WHERE path = ?)", [path]);
+        await asyncDb.run("DELETE FROM chunks WHERE path = ?", [path]);
+        await asyncDb.run("DELETE FROM files_metadata WHERE path = ?", [path]);
+        // Insert new hash
+        await asyncDb.run("INSERT INTO files_metadata (path, hash) VALUES (?, ?)", [
+            path,
+            hash,
+        ]);
+        const chunks = await (0, parser_1.parseMarkdown)(content, path);
+        const BATCH_SIZE = 8;
+        for (let i = 0; i < chunks.length; i += BATCH_SIZE) {
+            const batch = chunks.slice(i, i + BATCH_SIZE);
+            // Process embeddings in batches of BATCH_SIZE to avoid blocking Event Loop too long
+            const embeddings = await Promise.all(batch.map((chunk) => (0, embeddings_1.generateEmbedding)(chunk.text)));
+            for (let j = 0; j < batch.length; j++) {
+                const chunk = batch[j];
+                const embedding = embeddings[j];
+                // Store in main table
+                await asyncDb.run("INSERT INTO chunks (path, text, breadcrumbs, startLine, endLine) VALUES (?, ?, ?, ?, ?)", [
+                    chunk.path,
+                    chunk.text,
+                    chunk.breadcrumbs,
+                    chunk.startLine,
+                    chunk.endLine,
+                ]);
+                const row = await asyncDb.get("SELECT last_insert_rowid() as id");
+                const chunkId = row.id;
+                // Ensure FTS5 sync
+                await asyncDb.run("INSERT INTO chunks_fts (rowid, path, text, breadcrumbs) VALUES (?, ?, ?, ?)", [chunkId, chunk.path, chunk.text, chunk.breadcrumbs]);
+                // Insert vector
+                const vectorData = Buffer.from(new Float32Array(embedding).buffer);
+                await asyncDb.run("INSERT INTO chunks_vec (rowid, embedding) VALUES (?, ?)", [chunkId, vectorData]);
+            }
+        }
+        await asyncDb.run("COMMIT");
+    }
+    catch (err) {
+        await asyncDb.run("ROLLBACK");
+        throw err;
+    }
+}
+/**
+ * Removes a file and all its corresponding chunks, vectors, and FTS entries
+ * from the database atomically. Also removes the file_manifest entry.
+ */
+async function removeFile(path, db) {
+    const asyncDb = new AsyncDatabase(db);
+    await asyncDb.run("BEGIN TRANSACTION");
+    try {
+        await asyncDb.run("DELETE FROM chunks_vec WHERE rowid IN (SELECT id FROM chunks WHERE path = ?)", [path]);
+        await asyncDb.run("DELETE FROM chunks_fts WHERE rowid IN (SELECT id FROM chunks WHERE path = ?)", [path]);
+        await asyncDb.run("DELETE FROM chunks WHERE path = ?", [path]);
+        await asyncDb.run("DELETE FROM files_metadata WHERE path = ?", [path]);
+        await asyncDb.run("DELETE FROM file_manifest WHERE file_path = ?", [path]);
+        await asyncDb.run("COMMIT");
+    }
+    catch (err) {
+        await asyncDb.run("ROLLBACK");
+        throw err;
+    }
+}

package/dist/db/project.d.ts

@@ -0,0 +1,12 @@
+import sqlite3 from "sqlite3";
+export interface FileManifestRow {
+    file_path: string;
+    mtime: number;
+    sha256: string;
+}
+export declare function getLocalDbPath(projectRoot: string): string;
+export declare function initLocalDb(dbPath: string): sqlite3.Database;
+export declare function upsertFileManifest(dbPath: string, file_path: string, mtime: number, sha256: string): Promise<void>;
+export declare function getFileManifest(dbPath: string, file_path: string): Promise<FileManifestRow | null>;
+export declare function getAllManifests(dbPath: string): Promise<FileManifestRow[]>;
+export declare function removeFileManifest(dbPath: string, file_path: string): Promise<void>;

package/dist/db/project.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalDbPath = getLocalDbPath;
+exports.initLocalDb = initLocalDb;
+exports.upsertFileManifest = upsertFileManifest;
+exports.getFileManifest = getFileManifest;
+exports.getAllManifests = getAllManifests;
+exports.removeFileManifest = removeFileManifest;
+const node_path_1 = __importDefault(require("node:path"));
+const sqlite3_1 = __importDefault(require("sqlite3"));
+function getLocalDbPath(projectRoot) {
+    return node_path_1.default.join(projectRoot, ".memory", "local.sqlite");
+}
+function initLocalDb(dbPath) {
+    const db = new sqlite3_1.default.Database(dbPath);
+    db.configure("busyTimeout", 5000);
+    db.serialize(() => {
+        db.run("PRAGMA journal_mode = WAL;");
+        db.run("PRAGMA busy_timeout = 5000;");
+        db.run(`
+      CREATE TABLE IF NOT EXISTS file_manifest (
+        file_path TEXT PRIMARY KEY,
+        mtime INTEGER NOT NULL,
+        sha256 TEXT NOT NULL,
+        last_synced DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.run(`
+      CREATE TABLE IF NOT EXISTS files_metadata (
+        path TEXT PRIMARY KEY,
+        hash TEXT NOT NULL
+      )
+    `);
+        db.run(`
+      CREATE TABLE IF NOT EXISTS chunks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        path TEXT NOT NULL,
+        text TEXT NOT NULL,
+        breadcrumbs TEXT,
+        startLine INTEGER,
+        endLine INTEGER
+      )
+    `);
+        // Note: for real usage, chunks_fts and chunks_vec need FTS5 and vec0 extensions enabled.
+        // Standard sqlite3 node driver has FTS5, but vec0 must be loaded.
+        // Assuming they are available or using regular tables for E2E.
+        db.run(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+        path, text, breadcrumbs, content='chunks', content_rowid='id'
+      )
+    `);
+        // Create a regular table for chunks_vec to prevent crashes in tests or environments
+        // where the sqlite-vec extension is not loaded yet.
+        db.run(`
+      CREATE TABLE IF NOT EXISTS chunks_vec (
+        rowid INTEGER,
+        embedding BLOB
+      )
+    `);
+    });
+    return db;
+}
+async function upsertFileManifest(dbPath, file_path, mtime, sha256) {
+    return new Promise((resolve, reject) => {
+        const db = initLocalDb(dbPath);
+        db.run("INSERT OR REPLACE INTO file_manifest (file_path, mtime, sha256, last_synced) VALUES (?, ?, ?, CURRENT_TIMESTAMP)", [file_path, mtime, sha256], (err) => {
+            db.close();
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+}
+async function getFileManifest(dbPath, file_path) {
+    return new Promise((resolve, reject) => {
+        const db = initLocalDb(dbPath);
+        db.get("SELECT file_path, mtime, sha256 FROM file_manifest WHERE file_path = ?", [file_path], (err, row) => {
+            db.close();
+            if (err)
+                reject(err);
+            else
+                resolve(row || null);
+        });
+    });
+}
+async function getAllManifests(dbPath) {
+    return new Promise((resolve, reject) => {
+        const db = initLocalDb(dbPath);
+        db.all("SELECT file_path, mtime, sha256 FROM file_manifest", (err, rows) => {
+            db.close();
+            if (err)
+                reject(err);
+            else
+                resolve(rows || []);
+        });
+    });
+}
+async function removeFileManifest(dbPath, file_path) {
+    return new Promise((resolve, reject) => {
+        const db = initLocalDb(dbPath);
+        db.run("DELETE FROM file_manifest WHERE file_path = ?", [file_path], (err) => {
+            db.close();
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+}

package/dist/db/registry.d.ts

@@ -0,0 +1,9 @@
+import sqlite3 from "sqlite3";
+export declare function getRegistryDbPath(): string;
+export declare function initRegistryDb(dbPath?: string): sqlite3.Database;
+export declare function registerProject(projectId: string, projectPath: string, dbPath?: string): Promise<void>;
+export declare function getProjectByPath(projectPath: string, dbPath?: string): Promise<string | null>;
+export declare function getProjectRootFromRegistry(activePath: string, dbPath?: string): Promise<{
+    path: string;
+    fallback: boolean;
+} | null>;

package/dist/db/registry.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRegistryDbPath = getRegistryDbPath;
+exports.initRegistryDb = initRegistryDb;
+exports.registerProject = registerProject;
+exports.getProjectByPath = getProjectByPath;
+exports.getProjectRootFromRegistry = getProjectRootFromRegistry;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const sqlite3_1 = __importDefault(require("sqlite3"));
+const initGlobal_1 = require("../setup/initGlobal");
+function getRegistryDbPath() {
+    const memDir = (0, initGlobal_1.getLocalMemoryDir)();
+    if (!node_fs_1.default.existsSync(memDir)) {
+        node_fs_1.default.mkdirSync(memDir, { recursive: true });
+    }
+    return node_path_1.default.join(memDir, "registry.sqlite");
+}
+function initRegistryDb(dbPath = getRegistryDbPath()) {
+    const db = new sqlite3_1.default.Database(dbPath);
+    db.configure("busyTimeout", 5000);
+    db.serialize(() => {
+        db.run("PRAGMA journal_mode = WAL;");
+        db.run("PRAGMA busy_timeout = 5000;");
+        db.run(`
+      CREATE TABLE IF NOT EXISTS projects (
+        project_id TEXT PRIMARY KEY,
+        file_path TEXT NOT NULL UNIQUE,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    });
+    return db;
+}
+async function registerProject(projectId, projectPath, dbPath = getRegistryDbPath()) {
+    return new Promise((resolve, reject) => {
+        const db = initRegistryDb(dbPath);
+        db.run("INSERT OR REPLACE INTO projects (project_id, file_path) VALUES (?, ?)", [projectId, projectPath], (err) => {
+            db.close();
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+}
+async function getProjectByPath(projectPath, dbPath = getRegistryDbPath()) {
+    return new Promise((resolve, reject) => {
+        const db = initRegistryDb(dbPath);
+        db.get("SELECT project_id FROM projects WHERE file_path = ?", [projectPath], (err, row) => {
+            db.close();
+            if (err)
+                reject(err);
+            else
+                resolve(row ? row.project_id : null);
+        });
+    });
+}
+async function getProjectRootFromRegistry(activePath, dbPath = getRegistryDbPath()) {
+    return new Promise((resolve, reject) => {
+        const db = initRegistryDb(dbPath);
+        db.all("SELECT file_path FROM projects ORDER BY created_at DESC", [], (err, rows) => {
+            db.close();
+            if (err) {
+                return reject(err);
+            }
+            let bestMatch = null;
+            let maxLen = -1;
+            for (const row of rows) {
+                const p = row.file_path;
+                if (activePath.startsWith(p) || activePath === p) {
+                    if (p.length > maxLen) {
+                        maxLen = p.length;
+                        bestMatch = p;
+                    }
+                }
+            }
+            if (bestMatch) {
+                resolve({ path: bestMatch, fallback: false });
+            }
+            else if (rows.length > 0) {
+                resolve({ path: rows[0].file_path, fallback: true });
+            }
+            else {
+                resolve(null);
+            }
+        });
+    });
+}

package/dist/mcp/middleware.d.ts

@@ -0,0 +1 @@
+export declare function syncMiddleware(cwd?: string): Promise<void>;