arceus-s 1.6.4

package/dist/core/lbug/pool-adapter.js

@@ -0,0 +1,592 @@
+/**
+ * LadybugDB connection pool (core). Used by MCP, sync, search, wiki, etc.
+ *
+ * LadybugDB Adapter (Connection Pool)
+ *
+ * Manages a pool of LadybugDB databases keyed by repoId, each with
+ * multiple Connection objects for safe concurrent query execution.
+ *
+ * LadybugDB Connections are NOT thread-safe — a single Connection
+ * segfaults if concurrent .query() calls hit it simultaneously.
+ * This adapter provides a checkout/return connection pool so each
+ * concurrent query gets its own Connection from the same Database.
+ *
+ * @see https://docs.ladybugdb.com/concurrency — multiple Connections
+ * from the same Database is the officially supported concurrency pattern.
+ */
+import fs from 'fs/promises';
+import lbug from '@ladybugdb/core';
+import { loadFTSExtension } from './lbug-adapter.js';
+import { createLbugDatabase, isWalCorruptionError } from './lbug-config.js';
+const pool = new Map();
+const poolCloseListeners = new Set();
+/**
+ * Subscribe to pool-close events. Returns a disposer that removes the
+ * listener (handy for tests).
+ */
+export function addPoolCloseListener(listener) {
+    poolCloseListeners.add(listener);
+    return () => {
+        poolCloseListeners.delete(listener);
+    };
+}
+const dbCache = new Map();
+/** Max repos in the pool (LRU eviction) */
+const MAX_POOL_SIZE = 5;
+/** Idle timeout before closing a repo's connections */
+const IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+/** Max connections per repo (caps concurrent queries per repo) */
+const MAX_CONNS_PER_REPO = 8;
+let idleTimer = null;
+// Stdout-capture state lives in `arc/src/mcp/stdio-capture.ts` — a leaf
+// module with zero non-`node:` imports. We re-export the same symbols here
+// so the existing test mock seam (`arc/src/mcp/core/lbug-adapter.ts`
+// re-exports * from this file, and 8+ test files use that path with
+// `vi.mock(...)`) continues to work without churn. The source of truth is
+// the leaf module; this re-export is a compatibility shim.
+//
+// Why the leaf module exists: Codex's adversarial review on PR #1383 found
+// that putting this state in pool-adapter.ts pulled `@ladybugdb/core` into
+// `cli/mcp.ts`'s static-import closure (via stdio-context → pool-adapter →
+// @ladybugdb/core), corrupting stdout in the pre-sentinel window. Routing
+// through the leaf breaks that chain.
+export { realStdoutWrite, realStderrWrite, setActiveStdoutWrite } from '../../mcp/stdio-capture.js';
+import { getActiveStdoutWrite, realStderrWrite } from '../../mcp/stdio-capture.js';
+let stdoutSilenceCount = 0;
+/** True while pre-warming connections — prevents watchdog from prematurely restoring stdout */
+let preWarmActive = false;
+/**
+ * Start the idle cleanup timer (runs every 60s)
+ */
+function ensureIdleTimer() {
+    if (idleTimer)
+        return;
+    idleTimer = setInterval(() => {
+        const now = Date.now();
+        for (const [repoId, entry] of pool) {
+            if (now - entry.lastUsed > IDLE_TIMEOUT_MS && entry.checkedOut === 0) {
+                closeOne(repoId);
+            }
+        }
+    }, 60_000);
+    if (idleTimer && typeof idleTimer === 'object' && 'unref' in idleTimer) {
+        idleTimer.unref();
+    }
+}
+/**
+ * Touch a repo to reset its idle timeout.
+ * Call this during long-running operations to prevent the connection from being closed.
+ */
+export const touchRepo = (repoId) => {
+    const entry = pool.get(repoId);
+    if (entry) {
+        entry.lastUsed = Date.now();
+    }
+};
+/**
+ * Evict the least-recently-used repo if pool is at capacity
+ */
+function evictLRU() {
+    if (pool.size < MAX_POOL_SIZE)
+        return;
+    let oldestId = null;
+    let oldestTime = Infinity;
+    for (const [id, entry] of pool) {
+        if (entry.checkedOut === 0 && entry.lastUsed < oldestTime) {
+            oldestTime = entry.lastUsed;
+            oldestId = id;
+        }
+    }
+    if (oldestId) {
+        closeOne(oldestId);
+    }
+}
+/**
+ * Remove a repo from the pool, close its connections, and release its
+ * shared Database ref.  Only closes the Database when no other repoIds
+ * reference it (refCount === 0).
+ */
+function closeOne(repoId) {
+    const entry = pool.get(repoId);
+    if (!entry)
+        return;
+    entry.closed = true;
+    // Close available connections — fire-and-forget with .catch() to prevent
+    // unhandled rejections.  Native close() returns Promise<void> but can crash
+    // the N-API destructor on macOS/Windows; deferring to process exit lets
+    // dangerouslyIgnoreUnhandledErrors absorb the crash.
+    for (const conn of entry.available) {
+        conn.close().catch(() => { });
+    }
+    entry.available.length = 0;
+    // Checked-out connections can't be closed here — they're in-flight.
+    // The checkin() function detects entry.closed and closes them on return.
+    // Only close the Database when no other repoIds reference it.
+    // External databases (injected via initLbugWithDb) are never closed here —
+    // the core adapter owns them and handles their lifecycle.
+    const shared = dbCache.get(entry.dbPath);
+    if (shared) {
+        shared.refCount--;
+        if (shared.refCount === 0) {
+            if (shared.external) {
+                // External databases are owned by the core adapter — don't close
+                // or remove from cache.  Keep the entry so future initLbug() calls
+                // for the same dbPath reuse it instead of hitting a file lock.
+                shared.refCount = 0;
+                shared.ftsLoaded = false;
+            }
+            else {
+                shared.db.close().catch(() => { });
+                dbCache.delete(entry.dbPath);
+            }
+        }
+    }
+    pool.delete(repoId);
+    // Notify listeners AFTER the pool entry is gone so any cache-invalidation
+    // they perform is consistent with `isLbugReady(repoId) === false`.
+    for (const listener of poolCloseListeners) {
+        try {
+            listener(repoId);
+        }
+        catch {
+            // Isolate listener failures — teardown must complete.
+        }
+    }
+}
+/**
+ * Create a new Connection from a repo's Database.
+ * Silences stdout to prevent native module output from corrupting MCP stdio.
+ */
+let activeQueryCount = 0;
+/**
+ * Silence stdout by replacing process.stdout.write with a no-op.
+ * Uses a reference counter so nested silence/restore pairs are safe.
+ * Exported so other modules (e.g. embedder) use the same mechanism instead
+ * of independently patching stdout, which causes restore-order conflicts.
+ */
+export function silenceStdout() {
+    if (stdoutSilenceCount++ === 0) {
+        // eslint-disable-next-line no-restricted-syntax -- silencing infrastructure; replacement is a no-op
+        process.stdout.write = (() => true);
+    }
+}
+export function restoreStdout() {
+    if (--stdoutSilenceCount <= 0) {
+        stdoutSilenceCount = 0;
+        // eslint-disable-next-line no-restricted-syntax -- restoring the active stdout-write handler is the silencing API contract
+        process.stdout.write = getActiveStdoutWrite();
+    }
+}
+// Safety watchdog: restore stdout if it gets stuck silenced (e.g. native crash
+// inside createConnection before restoreStdout runs).
+// Exempts active queries and pre-warm — these legitimately hold silence for
+// longer than 1 second (queries can take up to QUERY_TIMEOUT_MS = 30s).
+setInterval(() => {
+    if (stdoutSilenceCount > 0 && !preWarmActive && activeQueryCount === 0) {
+        stdoutSilenceCount = 0;
+        // eslint-disable-next-line no-restricted-syntax -- watchdog recovery for stuck silencing
+        process.stdout.write = getActiveStdoutWrite();
+    }
+}, 1000).unref();
+function createConnection(db) {
+    silenceStdout();
+    try {
+        return new lbug.Connection(db);
+    }
+    finally {
+        restoreStdout();
+    }
+}
+/** Query timeout in milliseconds */
+const QUERY_TIMEOUT_MS = 30_000;
+/** Waiter queue timeout in milliseconds */
+const WAITER_TIMEOUT_MS = 15_000;
+const LOCK_RETRY_ATTEMPTS = 3;
+const LOCK_RETRY_DELAY_MS = 2000;
+async function openReadOnlyDatabase(dbPath) {
+    let db;
+    silenceStdout();
+    try {
+        db = createLbugDatabase(lbug, dbPath, {
+            readOnly: true,
+            throwOnWalReplayFailure: false,
+        });
+        await db.init();
+        return db;
+    }
+    catch (err) {
+        if (db)
+            await db.close().catch(() => { });
+        throw err;
+    }
+    finally {
+        restoreStdout();
+    }
+}
+/**
+ * Quarantine the .wal file and retry opening the database.
+ * Used when the initial open fails with a WAL corruption error.
+ */
+async function tryQuarantineAndReopen(dbPath, repoId) {
+    const walPath = dbPath + '.wal';
+    const quarantineName = `${walPath}.corrupt.${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    try {
+        await fs.rename(walPath, quarantineName);
+    }
+    catch {
+        throw new Error(`LadybugDB WAL corruption detected for ${repoId}. ` +
+            `Run \`arc analyze\` to rebuild the index. (quarantine failed)`);
+    }
+    realStderrWrite(`Arceus: LadybugDB WAL quarantined for ${repoId}; graph may be stale. ` +
+        `Run \`arc analyze\` to rebuild the index.\n`);
+    return await openReadOnlyDatabase(dbPath);
+}
+/** Deduplicates concurrent initLbug calls for the same repoId */
+const initPromises = new Map();
+/**
+ * Initialize (or reuse) a Database + connection pool for a specific repo.
+ * Retries on lock errors (e.g., when `arc analyze` is running).
+ *
+ * Concurrent calls for the same repoId are deduplicated — the second caller
+ * awaits the first's in-progress init rather than starting a redundant one.
+ */
+export const initLbug = async (repoId, dbPath) => {
+    const existing = pool.get(repoId);
+    if (existing) {
+        existing.lastUsed = Date.now();
+        return;
+    }
+    // Deduplicate concurrent init calls for the same repoId —
+    // prevents double-init race when multiple parallel tool calls
+    // trigger initialization for the same repo simultaneously.
+    const pending = initPromises.get(repoId);
+    if (pending)
+        return pending;
+    const promise = doInitLbug(repoId, dbPath);
+    initPromises.set(repoId, promise);
+    try {
+        await promise;
+    }
+    finally {
+        initPromises.delete(repoId);
+    }
+};
+/**
+ * Internal init — creates DB, pre-warms connections, loads FTS, then registers pool.
+ * Pool entry is registered LAST so concurrent executeQuery calls see either
+ * "not initialized" (and throw) or a fully ready pool — never a half-built one.
+ */
+async function doInitLbug(repoId, dbPath) {
+    // Check if database exists
+    try {
+        await fs.stat(dbPath);
+    }
+    catch {
+        throw new Error(`LadybugDB not found at ${dbPath}. Run: arc analyze`);
+    }
+    evictLRU();
+    // Reuse an existing native Database if another repoId already opened this path.
+    // This prevents buffer manager exhaustion from multiple mmap regions on the same file.
+    let shared = dbCache.get(dbPath);
+    if (!shared) {
+        // Open in read-only mode — MCP server never writes to the database.
+        // This allows multiple MCP server instances to read concurrently, and
+        // avoids lock conflicts when `arc analyze` is writing.
+        let lastError = null;
+        for (let attempt = 1; attempt <= LOCK_RETRY_ATTEMPTS; attempt++) {
+            try {
+                const db = await openReadOnlyDatabase(dbPath);
+                shared = { db, refCount: 0, ftsLoaded: false };
+                dbCache.set(dbPath, shared);
+                break;
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                if (isWalCorruptionError(lastError)) {
+                    try {
+                        const db = await tryQuarantineAndReopen(dbPath, repoId);
+                        shared = { db, refCount: 0, ftsLoaded: false };
+                        dbCache.set(dbPath, shared);
+                        break;
+                    }
+                    catch (retryErr) {
+                        throw new Error(`LadybugDB WAL corruption detected for ${repoId}. ` +
+                            `Run \`arc analyze\` to rebuild the index. ` +
+                            `(${retryErr instanceof Error ? retryErr.message : String(retryErr)})`);
+                    }
+                }
+                const isLockError = lastError.message.includes('Could not set lock') || lastError.message.includes('lock');
+                if (!isLockError || attempt === LOCK_RETRY_ATTEMPTS)
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_DELAY_MS * attempt));
+            }
+        }
+        if (!shared) {
+            throw new Error(`LadybugDB unavailable for ${repoId}. Another process may be rebuilding the index. ` +
+                `Retry later. (${lastError?.message || 'unknown error'})`);
+        }
+    }
+    shared.refCount++;
+    const db = shared.db;
+    // Pre-create the full pool upfront so createConnection() (which silences
+    // stdout) is never called lazily during active query execution.
+    // Mark preWarmActive so the watchdog timer doesn't interfere.
+    preWarmActive = true;
+    const available = [];
+    try {
+        for (let i = 0; i < MAX_CONNS_PER_REPO; i++) {
+            available.push(createConnection(db));
+        }
+    }
+    finally {
+        preWarmActive = false;
+    }
+    // Load FTS extension once per shared Database.
+    // Done BEFORE pool registration so no concurrent checkout can grab
+    // the connection while the async FTS load is in progress.
+    // policy: 'load-only' — the read pool must never trigger a network
+    // install; analyze owns extension installation. If LOAD fails, search
+    // features degrade gracefully and the user-facing query path proceeds.
+    if (!shared.ftsLoaded) {
+        // Windows guard: LOAD EXTENSION fts crashes with SIGSEGV on Windows when
+        // the FTS extension binary is not installed locally (@ladybugdb/core native
+        // bug — the extension loader hits an unhandled error path that signals SIGSEGV
+        // rather than throwing a JS exception, so try/catch cannot protect here).
+        // Skip the load on Windows; bm25-index.js catches the resulting Kuzu catalog
+        // errors and returns empty BM25 results gracefully. Graph queries are unaffected.
+        if (process.platform === 'win32') {
+            shared.ftsLoaded = true;
+        }
+        else {
+            shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
+        }
+    }
+    // Register pool entry only after all connections are pre-warmed and FTS is
+    // loaded.  Concurrent executeQuery calls see either "not initialized"
+    // (and throw cleanly) or a fully ready pool — never a half-built one.
+    pool.set(repoId, {
+        db,
+        available,
+        checkedOut: 0,
+        waiters: [],
+        lastUsed: Date.now(),
+        dbPath,
+        closed: false,
+    });
+    ensureIdleTimer();
+}
+/**
+ * Initialize a pool entry from a pre-existing Database object.
+ *
+ * Used in tests to avoid the writable→close→read-only cycle that crashes
+ * on macOS due to N-API destructor segfaults.  The pool adapter reuses
+ * the core adapter's writable Database instead of opening a new read-only one.
+ *
+ * The Database is registered in the shared dbCache so closeOne() decrements
+ * the refCount correctly.  If the Database is already cached (e.g. another
+ * repoId already injected it), the existing entry is reused.
+ */
+export async function initLbugWithDb(repoId, existingDb, dbPath) {
+    const existing = pool.get(repoId);
+    if (existing) {
+        existing.lastUsed = Date.now();
+        return;
+    }
+    // Register in dbCache with external: true so other initLbug() calls
+    // for the same dbPath reuse this Database instead of trying to open
+    // a new one (which would fail with a file lock error).
+    // closeOne() respects the external flag and skips db.close().
+    let shared = dbCache.get(dbPath);
+    if (!shared) {
+        shared = { db: existingDb, refCount: 0, ftsLoaded: false, external: true };
+        dbCache.set(dbPath, shared);
+    }
+    shared.refCount++;
+    const available = [];
+    preWarmActive = true;
+    try {
+        for (let i = 0; i < MAX_CONNS_PER_REPO; i++) {
+            available.push(createConnection(existingDb));
+        }
+    }
+    finally {
+        preWarmActive = false;
+    }
+    // Load FTS extension if not already loaded on this Database.
+    // policy: 'load-only' — same contract as initLbug above; the read pool
+    // must not block on a network install during query execution.
+    // Windows guard: same SIGSEGV risk as doInitLbug above — skip on Windows.
+    if (!shared.ftsLoaded) {
+        if (process.platform === 'win32') {
+            shared.ftsLoaded = true;
+        }
+        else {
+            shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
+        }
+    }
+    pool.set(repoId, {
+        db: existingDb,
+        available,
+        checkedOut: 0,
+        waiters: [],
+        lastUsed: Date.now(),
+        dbPath,
+        closed: false,
+    });
+    ensureIdleTimer();
+}
+/**
+ * Checkout a connection from the pool.
+ * Returns an available connection, or creates a new one if under the cap.
+ * If all connections are busy and at cap, queues the caller until one is returned.
+ */
+function checkout(entry) {
+    // Fast path: grab an available connection
+    if (entry.available.length > 0) {
+        entry.checkedOut++;
+        return Promise.resolve(entry.available.pop());
+    }
+    // Pool was pre-warmed to MAX_CONNS_PER_REPO during init.  If we're here
+    // with fewer total connections, something leaked — surface the bug rather
+    // than silently creating a connection (which would silence stdout mid-query).
+    const totalConns = entry.available.length + entry.checkedOut;
+    if (totalConns < MAX_CONNS_PER_REPO) {
+        throw new Error(`Connection pool integrity error: expected ${MAX_CONNS_PER_REPO} ` +
+            `connections but found ${totalConns} (${entry.available.length} available, ` +
+            `${entry.checkedOut} checked out)`);
+    }
+    // At capacity — queue the caller with a timeout.
+    return new Promise((resolve, reject) => {
+        const waiter = (conn) => {
+            clearTimeout(timer);
+            resolve(conn);
+        };
+        const timer = setTimeout(() => {
+            const idx = entry.waiters.indexOf(waiter);
+            if (idx !== -1)
+                entry.waiters.splice(idx, 1);
+            reject(new Error(`Connection pool exhausted: timed out after ${WAITER_TIMEOUT_MS}ms waiting for a free connection`));
+        }, WAITER_TIMEOUT_MS);
+        entry.waiters.push(waiter);
+    });
+}
+/**
+ * Return a connection to the pool after use.
+ * If the pool entry was closed while the connection was checked out (e.g.
+ * LRU eviction), close the orphaned connection instead of returning it.
+ * If there are queued waiters, hand the connection directly to the next one
+ * instead of putting it back in the available array (avoids race conditions).
+ */
+function checkin(entry, conn) {
+    if (entry.closed) {
+        // Pool entry was deleted during checkout — close the orphaned connection
+        conn.close().catch(() => { });
+        return;
+    }
+    if (entry.waiters.length > 0) {
+        // Hand directly to the next waiter — no intermediate available state
+        const waiter = entry.waiters.shift();
+        waiter(conn);
+    }
+    else {
+        entry.checkedOut--;
+        entry.available.push(conn);
+    }
+}
+/**
+ * Execute a query on a specific repo's connection pool.
+ * Automatically checks out a connection, runs the query, and returns it.
+ */
+/** Race a promise against a timeout */
+function withTimeout(promise, ms, label) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    });
+    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+export const executeQuery = async (repoId, cypher) => {
+    const entry = pool.get(repoId);
+    if (!entry) {
+        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initLbug first.`);
+    }
+    if (isWriteQuery(cypher)) {
+        throw new Error('Write operations are not allowed. The pool adapter is read-only.');
+    }
+    entry.lastUsed = Date.now();
+    const conn = await checkout(entry);
+    silenceStdout();
+    activeQueryCount++;
+    try {
+        const queryResult = await withTimeout(conn.query(cypher), QUERY_TIMEOUT_MS, 'Query');
+        const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
+        const rows = await result.getAll();
+        return rows;
+    }
+    finally {
+        activeQueryCount--;
+        restoreStdout();
+        checkin(entry, conn);
+    }
+};
+/**
+ * Execute a parameterized query on a specific repo's connection pool.
+ * Uses prepare/execute pattern to prevent Cypher injection.
+ */
+export const executeParameterized = async (repoId, cypher, params) => {
+    const entry = pool.get(repoId);
+    if (!entry) {
+        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initLbug first.`);
+    }
+    entry.lastUsed = Date.now();
+    const conn = await checkout(entry);
+    silenceStdout();
+    activeQueryCount++;
+    try {
+        const stmt = await withTimeout(conn.prepare(cypher), QUERY_TIMEOUT_MS, 'Prepare');
+        if (!stmt.isSuccess()) {
+            const errMsg = await stmt.getErrorMessage();
+            throw new Error(`Prepare failed: ${errMsg}`);
+        }
+        const queryResult = await withTimeout(conn.execute(stmt, params), QUERY_TIMEOUT_MS, 'Execute');
+        const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
+        const rows = await result.getAll();
+        return rows;
+    }
+    finally {
+        activeQueryCount--;
+        restoreStdout();
+        checkin(entry, conn);
+    }
+};
+/**
+ * Close one or all repo pools.
+ * If repoId is provided, close only that repo's connections.
+ * If omitted, close all repos.
+ */
+export const closeLbug = async (repoId) => {
+    if (repoId) {
+        closeOne(repoId);
+        return;
+    }
+    for (const id of [...pool.keys()]) {
+        closeOne(id);
+    }
+    if (idleTimer) {
+        clearInterval(idleTimer);
+        idleTimer = null;
+    }
+};
+/**
+ * Check if a specific repo's pool is active
+ */
+export const isLbugReady = (repoId) => pool.has(repoId);
+/** Regex to detect write operations in user-supplied Cypher queries.
+ * Note: CALL is NOT blocked — it's used for read-only FTS (CALL QUERY_FTS_INDEX)
+ * and vector search (CALL QUERY_VECTOR_INDEX). The database is opened in
+ * read-only mode as defense-in-depth against write procedures. */
+export const CYPHER_WRITE_RE = /(?<!:)\b(CREATE|DELETE|SET|MERGE|REMOVE|DROP|ALTER|COPY|DETACH|FOREACH|INSTALL|LOAD)\b/i;
+/** Check if a Cypher query contains write operations */
+export function isWriteQuery(query) {
+    return CYPHER_WRITE_RE.test(query);
+}

package/dist/core/lbug/schema.d.ts

@@ -0,0 +1,62 @@
+/**
+ * LadybugDB Schema Definitions
+ *
+ * Hybrid Schema:
+ * - Separate node tables for each code element type (File, Function, Class, etc.)
+ * - Single CodeRelation table with 'type' property for all relationships
+ *
+ * This allows LLMs to write natural Cypher queries like:
+ *   MATCH (f:Function)-[r:CodeRelation {type: 'CALLS'}]->(g:Function) RETURN f, g
+ */
+import { NODE_TABLES, REL_TABLE_NAME, REL_TYPES, EMBEDDING_TABLE_NAME } from '../../_shared/index.js';
+export { NODE_TABLES, REL_TABLE_NAME, REL_TYPES, EMBEDDING_TABLE_NAME };
+export type { NodeTableName, RelType } from '../../_shared/index.js';
+export declare const FILE_SCHEMA = "\nCREATE NODE TABLE File (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  content STRING,\n  PRIMARY KEY (id)\n)";
+export declare const FOLDER_SCHEMA = "\nCREATE NODE TABLE Folder (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  PRIMARY KEY (id)\n)";
+export declare const FUNCTION_SCHEMA = "\nCREATE NODE TABLE Function (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  description STRING,\n  PRIMARY KEY (id)\n)";
+export declare const CLASS_SCHEMA = "\nCREATE NODE TABLE Class (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  description STRING,\n  PRIMARY KEY (id)\n)";
+export declare const INTERFACE_SCHEMA = "\nCREATE NODE TABLE Interface (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  description STRING,\n  PRIMARY KEY (id)\n)";
+export declare const METHOD_SCHEMA = "\nCREATE NODE TABLE Method (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  description STRING,\n  parameterCount INT32,\n  returnType STRING,\n  PRIMARY KEY (id)\n)";
+export declare const CODE_ELEMENT_SCHEMA = "\nCREATE NODE TABLE CodeElement (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  description STRING,\n  PRIMARY KEY (id)\n)";
+export declare const COMMUNITY_SCHEMA = "\nCREATE NODE TABLE Community (\n  id STRING,\n  label STRING,\n  heuristicLabel STRING,\n  keywords STRING[],\n  description STRING,\n  enrichedBy STRING,\n  cohesion DOUBLE,\n  symbolCount INT32,\n  PRIMARY KEY (id)\n)";
+export declare const PROCESS_SCHEMA = "\nCREATE NODE TABLE Process (\n  id STRING,\n  label STRING,\n  heuristicLabel STRING,\n  processType STRING,\n  stepCount INT32,\n  communities STRING[],\n  entryPointId STRING,\n  terminalId STRING,\n  PRIMARY KEY (id)\n)";
+export declare const STRUCT_SCHEMA: string;
+export declare const ENUM_SCHEMA: string;
+export declare const MACRO_SCHEMA: string;
+export declare const TYPEDEF_SCHEMA: string;
+export declare const UNION_SCHEMA: string;
+export declare const NAMESPACE_SCHEMA: string;
+export declare const TRAIT_SCHEMA: string;
+export declare const IMPL_SCHEMA: string;
+export declare const TYPE_ALIAS_SCHEMA: string;
+export declare const CONST_SCHEMA: string;
+export declare const STATIC_SCHEMA: string;
+export declare const VARIABLE_SCHEMA: string;
+export declare const PROPERTY_SCHEMA = "\nCREATE NODE TABLE `Property` (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  content STRING,\n  description STRING,\n  declaredType STRING,\n  PRIMARY KEY (id)\n)";
+export declare const RECORD_SCHEMA: string;
+export declare const DELEGATE_SCHEMA: string;
+export declare const ANNOTATION_SCHEMA: string;
+export declare const CONSTRUCTOR_SCHEMA: string;
+export declare const TEMPLATE_SCHEMA: string;
+export declare const MODULE_SCHEMA: string;
+export declare const ROUTE_SCHEMA = "\nCREATE NODE TABLE Route (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  responseKeys STRING[],\n  errorKeys STRING[],\n  middleware STRING[],\n  PRIMARY KEY (id)\n)";
+export declare const TOOL_SCHEMA = "\nCREATE NODE TABLE Tool (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  description STRING,\n  PRIMARY KEY (id)\n)";
+export declare const SECTION_SCHEMA = "\nCREATE NODE TABLE Section (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  level INT64,\n  content STRING,\n  description STRING,\n  PRIMARY KEY (id)\n)";
+export declare const RELATION_SCHEMA = "\nCREATE REL TABLE CodeRelation (\n  FROM File TO File,\n  FROM File TO Folder,\n  FROM File TO Function,\n  FROM File TO Class,\n  FROM File TO Interface,\n  FROM File TO Method,\n  FROM File TO CodeElement,\n  FROM File TO `Struct`,\n  FROM File TO `Enum`,\n  FROM File TO `Macro`,\n  FROM File TO `Typedef`,\n  FROM File TO `Union`,\n  FROM File TO `Namespace`,\n  FROM File TO `Trait`,\n  FROM File TO `Impl`,\n  FROM File TO `TypeAlias`,\n  FROM File TO `Const`,\n  FROM File TO `Static`,\n  FROM File TO `Variable`,\n  FROM File TO `Property`,\n  FROM File TO `Record`,\n  FROM File TO `Delegate`,\n  FROM File TO `Annotation`,\n  FROM File TO `Constructor`,\n  FROM File TO `Template`,\n  FROM File TO `Module`,\n  FROM File TO Section,\n  FROM Folder TO Folder,\n  FROM Folder TO File,\n  FROM Function TO Function,\n  FROM Function TO Method,\n  FROM Function TO Class,\n  FROM Function TO Community,\n  FROM Function TO `Macro`,\n  FROM Function TO `Struct`,\n  FROM Function TO `Template`,\n  FROM Function TO `Enum`,\n  FROM Function TO `Namespace`,\n  FROM Function TO `TypeAlias`,\n  FROM Function TO `Module`,\n  FROM Function TO `Impl`,\n  FROM Function TO Interface,\n  FROM Function TO `Constructor`,\n  FROM Function TO `Const`,\n  FROM Function TO `Typedef`,\n  FROM Function TO `Union`,\n  FROM Function TO `Property`,\n  FROM Function TO CodeElement,\n  FROM Class TO Method,\n  FROM Class TO Function,\n  FROM Class TO Class,\n  FROM Class TO Interface,\n  FROM Class TO Community,\n  FROM Class TO `Template`,\n  FROM Class TO `TypeAlias`,\n  FROM Class TO `Struct`,\n  FROM Class TO `Enum`,\n  FROM Class TO `Annotation`,\n  FROM Class TO `Constructor`,\n  FROM Class TO `Trait`,\n  FROM Class TO `Macro`,\n  FROM Class TO `Impl`,\n  FROM Class TO `Union`,\n  FROM Class TO `Namespace`,\n  FROM Class TO `Typedef`,\n  FROM Class TO `Property`,\n  FROM Method TO Function,\n  FROM Method TO Method,\n  FROM Method TO Class,\n  FROM Method TO Community,\n  FROM Method TO `Template`,\n  FROM Method TO `Struct`,\n  FROM Method TO `TypeAlias`,\n  FROM Method TO `Enum`,\n  FROM Method TO `Macro`,\n  FROM Method TO `Namespace`,\n  FROM Method TO `Module`,\n  FROM Method TO `Impl`,\n  FROM Method TO Interface,\n  FROM Method TO `Constructor`,\n  FROM Method TO `Property`,\n  FROM Method TO CodeElement,\n  FROM `Template` TO `Template`,\n  FROM `Template` TO Function,\n  FROM `Template` TO Method,\n  FROM `Template` TO Class,\n  FROM `Template` TO `Struct`,\n  FROM `Template` TO `TypeAlias`,\n  FROM `Template` TO `Enum`,\n  FROM `Template` TO `Macro`,\n  FROM `Template` TO Interface,\n  FROM `Template` TO `Constructor`,\n  FROM `Module` TO `Module`,\n  FROM Section TO Section,\n  FROM Section TO File,\n  FROM File TO Route,\n  FROM Function TO Route,\n  FROM Method TO Route,\n  FROM File TO Tool,\n  FROM Function TO Tool,\n  FROM Method TO Tool,\n  FROM CodeElement TO Community,\n  FROM Interface TO Community,\n  FROM Interface TO Function,\n  FROM Interface TO Method,\n  FROM Interface TO Class,\n  FROM Interface TO Interface,\n  FROM Interface TO `TypeAlias`,\n  FROM Interface TO `Struct`,\n  FROM Interface TO `Constructor`,\n  FROM Interface TO `Property`,\n  FROM `Struct` TO Community,\n  FROM `Struct` TO `Trait`,\n  FROM `Struct` TO `Struct`,\n  FROM `Struct` TO Class,\n  FROM `Struct` TO `Enum`,\n  FROM `Struct` TO Function,\n  FROM `Struct` TO Method,\n  FROM `Struct` TO Interface,\n  FROM `Struct` TO `Constructor`,\n  FROM `Struct` TO `Property`,\n  FROM `Enum` TO `Enum`,\n  FROM `Enum` TO Community,\n  FROM `Enum` TO Class,\n  FROM `Enum` TO Interface,\n  FROM `Macro` TO Community,\n  FROM `Macro` TO Function,\n  FROM `Macro` TO Method,\n  FROM `Module` TO Function,\n  FROM `Module` TO Method,\n  FROM `Typedef` TO Community,\n  FROM `Union` TO Community,\n  FROM `Namespace` TO Community,\n  FROM `Namespace` TO `Struct`,\n  FROM `Trait` TO Method,\n  FROM `Trait` TO `Constructor`,\n  FROM `Trait` TO `Property`,\n  FROM `Trait` TO Community,\n  FROM `Impl` TO Method,\n  FROM `Impl` TO `Constructor`,\n  FROM `Impl` TO `Property`,\n  FROM `Impl` TO Community,\n  FROM `Impl` TO `Trait`,\n  FROM `Impl` TO `Struct`,\n  FROM `Impl` TO `Impl`,\n  FROM `TypeAlias` TO Community,\n  FROM `TypeAlias` TO `Trait`,\n  FROM `TypeAlias` TO Class,\n  FROM `Const` TO Community,\n  FROM `Static` TO Community,\n  FROM `Variable` TO Community,\n  FROM `Property` TO Community,\n  FROM `Record` TO Method,\n  FROM `Record` TO `Constructor`,\n  FROM `Record` TO `Property`,\n  FROM `Record` TO Community,\n  FROM `Delegate` TO Community,\n  FROM `Annotation` TO Community,\n  FROM `Constructor` TO Community,\n  FROM `Constructor` TO Interface,\n  FROM `Constructor` TO Class,\n  FROM `Constructor` TO Method,\n  FROM `Constructor` TO Function,\n  FROM `Constructor` TO `Constructor`,\n  FROM `Constructor` TO `Struct`,\n  FROM `Constructor` TO `Macro`,\n  FROM `Constructor` TO `Template`,\n  FROM `Constructor` TO `TypeAlias`,\n  FROM `Constructor` TO `Enum`,\n  FROM `Constructor` TO `Annotation`,\n  FROM `Constructor` TO `Impl`,\n  FROM `Constructor` TO `Namespace`,\n  FROM `Constructor` TO `Module`,\n  FROM `Constructor` TO `Property`,\n  FROM `Constructor` TO `Typedef`,\n  FROM `Template` TO Community,\n  FROM `Module` TO Community,\n  FROM Function TO Process,\n  FROM Method TO Process,\n  FROM Class TO Process,\n  FROM Interface TO Process,\n  FROM `Struct` TO Process,\n  FROM `Constructor` TO Process,\n  FROM `Module` TO Process,\n  FROM `Macro` TO Process,\n  FROM `Impl` TO Process,\n  FROM `Typedef` TO Process,\n  FROM `TypeAlias` TO Process,\n  FROM `Enum` TO Process,\n  FROM `Union` TO Process,\n  FROM `Namespace` TO Process,\n  FROM `Trait` TO Process,\n  FROM `Const` TO Process,\n  FROM `Static` TO Process,\n  FROM `Variable` TO Process,\n  FROM `Property` TO Process,\n  FROM `Record` TO Process,\n  FROM `Delegate` TO Process,\n  FROM `Annotation` TO Process,\n  FROM `Template` TO Process,\n  FROM CodeElement TO Process,\n  FROM Route TO Process,\n  FROM Tool TO Process,\n  type STRING,\n  confidence DOUBLE,\n  reason STRING,\n  step INT32\n)";
+export declare const EMBEDDING_DIMS: number;
+/** HNSW vector index name for the CodeEmbedding table. */
+export declare const EMBEDDING_INDEX_NAME = "code_embedding_idx";
+/**
+ * Sentinel value for "no content hash available" — used in legacy DBs and null rows.
+ * Nodes with this hash are always treated as stale and re-embedded.
+ */
+export declare const STALE_HASH_SENTINEL = "";
+export declare const EMBEDDING_SCHEMA: string;
+/**
+ * Create vector index for semantic search
+ * Uses HNSW (Hierarchical Navigable Small World) algorithm with cosine similarity
+ */
+export declare const CREATE_VECTOR_INDEX_QUERY = "\nCALL CREATE_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 'embedding', metric := 'cosine')\n";
+export declare const NODE_SCHEMA_QUERIES: string[];
+export declare const REL_SCHEMA_QUERIES: string[];
+export declare const SCHEMA_QUERIES: string[];