gitnexus 1.6.9 → 1.6.10-aptos.0

package/dist/core/lbug/node-table-layout.d.ts

@@ -0,0 +1,29 @@
+import type { NodeTableName } from '../../_shared/index.js';
+export type CsvColumnEncoding = 'node-id' | 'string' | 'number' | 'boolean' | 'string-array' | 'content' | 'description';
+export interface NodeTableColumnSpec {
+    name: string;
+    ddlType: string;
+    csvEncoding: CsvColumnEncoding;
+    defaultValue?: string | number | boolean;
+}
+export interface NodeTableLayout {
+    table: NodeTableName;
+    columns: readonly NodeTableColumnSpec[];
+    quoteTableName?: boolean;
+}
+export declare const CODE_ELEMENT_COLUMNS: string[];
+export declare const MULTI_LANG_BASE_COLUMNS: string[];
+export declare const NODE_TABLE_LAYOUTS: {
+    readonly Function: NodeTableLayout;
+    readonly Struct: NodeTableLayout;
+    readonly Enum: NodeTableLayout;
+    readonly EnumVariant: NodeTableLayout;
+    readonly Const: NodeTableLayout;
+    readonly Module: NodeTableLayout;
+};
+export type LayoutTableName = keyof typeof NODE_TABLE_LAYOUTS;
+export declare const hasNodeTableLayout: (table: string) => table is LayoutTableName;
+export declare const getNodeTableLayout: (table: LayoutTableName) => NodeTableLayout;
+export declare const getNodeTableColumnNames: (table: NodeTableName) => readonly string[] | undefined;
+export declare const getNodeTableCsvHeader: (table: LayoutTableName) => string;
+export declare const buildNodeTableSchema: (table: LayoutTableName) => string;

package/dist/core/lbug/node-table-layout.js

@@ -0,0 +1,119 @@
+const column = (name, ddlType, csvEncoding = 'string', defaultValue) => ({ name, ddlType, csvEncoding, defaultValue });
+const CODE_ELEMENT_BASE = [
+    column('id', 'STRING', 'node-id'),
+    column('name', 'STRING'),
+    column('filePath', 'STRING'),
+    column('startLine', 'INT64', 'number', -1),
+    column('endLine', 'INT64', 'number', -1),
+    column('isExported', 'BOOLEAN', 'boolean', false),
+    column('content', 'STRING', 'content'),
+    column('description', 'STRING', 'description'),
+];
+// Same base as code elements minus isExported (multi-language tables have none).
+const MULTI_LANGUAGE_BASE = CODE_ELEMENT_BASE.filter(({ name }) => name !== 'isExported');
+export const CODE_ELEMENT_COLUMNS = CODE_ELEMENT_BASE.map(({ name }) => name);
+export const MULTI_LANG_BASE_COLUMNS = MULTI_LANGUAGE_BASE.map(({ name }) => name);
+const FUNCTION_LAYOUT = {
+    table: 'Function',
+    columns: [
+        ...CODE_ELEMENT_BASE,
+        column('language', 'STRING'),
+        column('qualifiedName', 'STRING'),
+        column('moduleQualifiedName', 'STRING'),
+        column('visibility', 'STRING'),
+        column('visibilityModifier', 'STRING'),
+        column('isEntry', 'BOOLEAN', 'boolean', false),
+        column('isView', 'BOOLEAN', 'boolean', false),
+        column('isInline', 'BOOLEAN', 'boolean', false),
+        column('isNative', 'BOOLEAN', 'boolean', false),
+        column('parameterCount', 'INT32', 'number', 0),
+        column('returnType', 'STRING'),
+        column('acquires', 'STRING[]', 'string-array'),
+        column('usedTypes', 'STRING[]', 'string-array'),
+        column('attributes', 'STRING[]', 'string-array'),
+        column('attributesJson', 'STRING'),
+        column('typeParamsJson', 'STRING'),
+        column('locationFidelity', 'STRING'),
+    ],
+};
+const structLikeLayout = (table) => ({
+    table,
+    quoteTableName: true,
+    columns: [
+        ...MULTI_LANGUAGE_BASE,
+        column('language', 'STRING'),
+        column('qualifiedName', 'STRING'),
+        column('moduleQualifiedName', 'STRING'),
+        column('moduleAddress', 'STRING'),
+        column('abilities', 'STRING[]', 'string-array'),
+        column('isResource', 'BOOLEAN', 'boolean', false),
+        column('isEvent', 'BOOLEAN', 'boolean', false),
+        column('fieldList', 'STRING[]', 'string-array'),
+        column('attributes', 'STRING[]', 'string-array'),
+        column('attributesJson', 'STRING'),
+        column('typeParamsJson', 'STRING'),
+        column('moveDeclarationKind', 'STRING'),
+        column('locationFidelity', 'STRING'),
+    ],
+});
+const ENUM_VARIANT_LAYOUT = {
+    table: 'EnumVariant',
+    quoteTableName: true,
+    columns: [
+        ...MULTI_LANGUAGE_BASE,
+        column('language', 'STRING'),
+        column('qualifiedName', 'STRING'),
+        column('parentEnum', 'STRING'),
+        column('moduleQualifiedName', 'STRING'),
+        column('variantKind', 'STRING'),
+        column('fieldsJson', 'STRING'),
+        column('attributes', 'STRING[]', 'string-array'),
+        column('attributesJson', 'STRING'),
+        column('locationFidelity', 'STRING'),
+    ],
+};
+const CONST_LAYOUT = {
+    table: 'Const',
+    quoteTableName: true,
+    columns: [
+        ...MULTI_LANGUAGE_BASE,
+        column('language', 'STRING'),
+        column('qualifiedName', 'STRING'),
+        column('moduleQualifiedName', 'STRING'),
+        column('constType', 'STRING'),
+        column('constValue', 'STRING'),
+        column('isErrorCode', 'BOOLEAN', 'boolean', false),
+        column('locationFidelity', 'STRING'),
+    ],
+};
+const MODULE_LAYOUT = {
+    table: 'Module',
+    quoteTableName: true,
+    columns: [
+        ...MULTI_LANGUAGE_BASE,
+        column('language', 'STRING'),
+        column('qualifiedName', 'STRING'),
+        column('moduleAddress', 'STRING'),
+        column('attributes', 'STRING[]', 'string-array'),
+        column('attributesJson', 'STRING'),
+        column('locationFidelity', 'STRING'),
+    ],
+};
+export const NODE_TABLE_LAYOUTS = {
+    Function: FUNCTION_LAYOUT,
+    Struct: structLikeLayout('Struct'),
+    Enum: structLikeLayout('Enum'),
+    EnumVariant: ENUM_VARIANT_LAYOUT,
+    Const: CONST_LAYOUT,
+    Module: MODULE_LAYOUT,
+};
+export const hasNodeTableLayout = (table) => Object.hasOwn(NODE_TABLE_LAYOUTS, table);
+export const getNodeTableLayout = (table) => NODE_TABLE_LAYOUTS[table];
+export const getNodeTableColumnNames = (table) => hasNodeTableLayout(table) ? getNodeTableLayout(table).columns.map(({ name }) => name) : undefined;
+export const getNodeTableCsvHeader = (table) => NODE_TABLE_LAYOUTS[table].columns.map(({ name }) => name).join(',');
+export const buildNodeTableSchema = (table) => {
+    const layout = NODE_TABLE_LAYOUTS[table];
+    const tableName = layout.quoteTableName ? `\`${layout.table}\`` : layout.table;
+    const columns = layout.columns.map(({ name, ddlType }) => `  ${name} ${ddlType},`).join('\n');
+    return `\nCREATE NODE TABLE ${tableName} (\n${columns}\n  PRIMARY KEY (id)\n)`;
+};

package/dist/core/lbug/pool-adapter.d.ts

@@ -15,6 +15,21 @@
  * from the same Database is the officially supported concurrency pattern.
  */
 import lbug from '@ladybugdb/core';
+/** Filesystem identity used to detect an index rebuilt/mutated under a live
+ *  read pool. `ino` catches a full-rebuild unlink+recreate or an atomic-rename
+ *  swap; `mtimeMs`+`size` catch an in-place incremental writeback. */
+interface DbIdentity {
+    ino: number;
+    mtimeMs: number;
+    size: number;
+}
+export declare function statDbIdentity(dbPath: string): Promise<DbIdentity | null>;
+/** True only when both identities are known AND differ. A stat failure
+ *  (ENOENT during the brief unlink window of a full rebuild) yields false, so
+ *  the reader keeps serving its still-valid open inode until the NEW file
+ *  appears with a different identity — avoiding a churn into a failed reopen
+ *  mid-rebuild. */
+export declare function dbIdentityChanged(prev: DbIdentity | null, next: DbIdentity | null): boolean;
 /**
  * Listeners notified when a pool entry is torn down (LRU eviction, idle
  * timeout, explicit close). Used by upper layers (e.g. the BM25 search
@@ -87,7 +102,14 @@ export declare function restoreStdout(): void;
  * 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 declare const initLbug: (repoId: string, dbPath: string) => Promise<void>;
+/**
+ * Returns `true` when this call (re)opened a fresh handle onto the current
+ * on-disk file, `false` when it reused/served the existing handle (unchanged,
+ * or changed-but-a-query-is-in-flight). Callers that gate their own freshness
+ * bookkeeping on "did the pool actually roll over" (LocalBackend) use the
+ * return value; callers that only need the pool ready can ignore it.
+ */
+export declare const initLbug: (repoId: string, dbPath: string) => Promise<boolean>;
 /**
  * Initialize a pool entry from a pre-existing Database object.
  *

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

@@ -16,10 +16,29 @@
  */
 import fs from 'fs/promises';
 import lbug from '@ladybugdb/core';
-import { isReadOnlyDbError, loadFTSExtension } from './lbug-adapter.js';
+import { isReadOnlyDbError, loadFTSExtension, loadVectorExtension } from './lbug-adapter.js';
 import { closeQueryResults } from './query-result-utils.js';
 import { createLbugDatabase, isWalCorruptionError, toNativeSafePath, WAL_RECOVERY_SUGGESTION, } from './lbug-config.js';
-import { isMissingFsError, isMissingShadowSidecarError, isReadOnlyShadowReplayError, preflightLbugSidecars, quarantineWalForMissingShadow, renameFailureMessage, statIfExists, } from './sidecar-recovery.js';
+import { guardWalQuarantine, isMissingFsError, isMissingShadowSidecarError, isReadOnlyShadowReplayError, preflightLbugSidecars, quarantineWalForMissingShadow, renameFailureMessage, statIfExists, } from './sidecar-recovery.js';
+export async function statDbIdentity(dbPath) {
+    try {
+        const s = await fs.stat(dbPath);
+        return { ino: s.ino, mtimeMs: s.mtimeMs, size: s.size };
+    }
+    catch {
+        return null;
+    }
+}
+/** True only when both identities are known AND differ. A stat failure
+ *  (ENOENT during the brief unlink window of a full rebuild) yields false, so
+ *  the reader keeps serving its still-valid open inode until the NEW file
+ *  appears with a different identity — avoiding a churn into a failed reopen
+ *  mid-rebuild. */
+export function dbIdentityChanged(prev, next) {
+    if (!prev || !next)
+        return false;
+    return prev.ino !== next.ino || prev.mtimeMs !== next.mtimeMs || prev.size !== next.size;
+}
 const pool = new Map();
 const poolCloseListeners = new Set();
 /**
@@ -244,6 +263,7 @@ function closeOne(repoId) {
                 // for the same dbPath reuse it instead of hitting a file lock.
                 shared.refCount = 0;
                 shared.ftsLoaded = false;
+                shared.vectorLoaded = false;
             }
             else {
                 shared.db.close().catch(() => { });
@@ -306,7 +326,16 @@ setInterval(() => {
 function createConnection(db) {
     silenceStdout();
     try {
-        return new lbug.Connection(db);
+        const conn = new lbug.Connection(db);
+        // Bound a single query at the engine level so a pathological query cannot
+        // hang a pooled connection past the JS-side Promise.race guard (which frees
+        // the waiter but not the native call). Matches QUERY_TIMEOUT_MS. Guarded so
+        // test doubles that don't model the engine method don't break connection
+        // creation.
+        if (typeof conn.setQueryTimeout === 'function') {
+            conn.setQueryTimeout(QUERY_TIMEOUT_MS);
+        }
+        return conn;
     }
     finally {
         restoreStdout();
@@ -316,6 +345,8 @@ function createConnection(db) {
 const QUERY_TIMEOUT_MS = 30_000;
 /** Waiter queue timeout in milliseconds */
 const WAITER_TIMEOUT_MS = 15_000;
+// Read-only open retry while `gitnexus analyze` writes. Catalogued as entry 4
+// of the lbug-config retry-budget registry.
 const LOCK_RETRY_ATTEMPTS = 3;
 const LOCK_RETRY_DELAY_MS = 2000;
 const SHADOW_REPLAY_PROBE_QUERY = 'MATCH (n) RETURN n LIMIT 1';
@@ -349,6 +380,12 @@ const poolSidecarLogger = {
  * See plan: docs/plans/2026-05-21-001-fix-pr-1747-quarantine-enoent-and-large-wal-plan.md (U2)
  */
 async function tryQuarantineForMissingShadow(dbPath, opts) {
+    // Refuse (throw) before renaming a live WAL when the shadow is present on
+    // disk or the orphan WAL is too large — parity with the serve path's
+    // refuseLargeWalQuarantine (issue #2382 review, Finding B). Kept OUTSIDE the
+    // try so the actionable recovery message propagates to the MCP caller rather
+    // than being re-wrapped as a rename failure.
+    await guardWalQuarantine(dbPath, opts.reason, opts.err, poolSidecarLogger);
     try {
         const quarantinePath = await quarantineWalForMissingShadow(dbPath, {
             logger: poolSidecarLogger,
@@ -396,6 +433,7 @@ async function replayShadowPagesWithWritableOpen(dbPath) {
         if (isMissingShadowSidecarError(err)) {
             await tryQuarantineForMissingShadow(dbPath, {
                 reason: 'pool writable replay recovery',
+                err,
             });
             return;
         }
@@ -429,6 +467,7 @@ async function openReadOnlyDatabase(dbPath) {
                 db = undefined;
                 await tryQuarantineForMissingShadow(dbPath, {
                     reason: 'pool read-only recovery',
+                    err,
                 });
                 await preflightLbugSidecars(dbPath, {
                     mode: 'read-only',
@@ -494,18 +533,46 @@ const initPromises = new Map();
  * Concurrent calls for the same repoId are deduplicated — the second caller
  * awaits the first's in-progress init rather than starting a redundant one.
  */
+/**
+ * Returns `true` when this call (re)opened a fresh handle onto the current
+ * on-disk file, `false` when it reused/served the existing handle (unchanged,
+ * or changed-but-a-query-is-in-flight). Callers that gate their own freshness
+ * bookkeeping on "did the pool actually roll over" (LocalBackend) use the
+ * return value; callers that only need the pool ready can ignore it.
+ */
 export const initLbug = async (repoId, dbPath) => {
     const existing = pool.get(repoId);
     if (existing) {
         existing.lastUsed = Date.now();
-        return;
+        // Detect an index that `analyze` rebuilt or mutated under this live read
+        // pool. Without this, the pool keeps serving the old (POSIX:
+        // unlinked-but-open) inode until LRU/idle eviction — a stale-read window
+        // of up to IDLE_TIMEOUT_MS after analyze finishes.
+        const current = await statDbIdentity(dbPath);
+        if (!dbIdentityChanged(existing.dbIdentity, current))
+            return false; // unchanged → reuse
+        // A query is in flight on this entry; closing its connection (and the
+        // shared Database at refCount 0) mid-use is a native use-after-free. Serve
+        // the current handle for this dispatch — the next initLbug that finds the
+        // entry idle (checkedOut === 0) reopens, since the identity stays divergent
+        // until then. Under sustained overlapping queries `checkedOut` may never
+        // reach 0 and `lastUsed` keeps the idle timer from evicting, so this window
+        // is bounded by the load, not IDLE_TIMEOUT_MS — the data stays consistent
+        // (a complete older snapshot), just not the newest. Callers that route
+        // freshness THROUGH initLbug (rather than calling closeLbug directly) get
+        // this guard for free; that is why LocalBackend delegates here (#2614).
+        if (existing.checkedOut > 0)
+            return false;
+        closeOne(repoId); // idle & changed → evict, then fall through to reopen the new file
     }
     // 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;
+    if (pending) {
+        await pending;
+        return true;
+    }
     const promise = doInitLbug(repoId, dbPath);
     initPromises.set(repoId, promise);
     try {
@@ -514,6 +581,7 @@ export const initLbug = async (repoId, dbPath) => {
     finally {
         initPromises.delete(repoId);
     }
+    return true;
 };
 /**
  * Internal init — creates DB, pre-warms connections, loads FTS, then registers pool.
@@ -532,6 +600,21 @@ async function doInitLbug(repoId, dbPath) {
     // 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 && !shared.external && shared.dbIdentity) {
+        // #2614 F2: a cached read-only Database is keyed by dbPath and shared across
+        // pool consumers. If the on-disk index was rebuilt/swapped (new inode) while
+        // ANOTHER consumer still holds this handle (refCount kept it alive), reusing
+        // it serves a superseded index. Unreachable via the MCP backend (one
+        // consumer per lbugPath ⇒ refCount hits 0 ⇒ closeOne reopens fresh); a
+        // complete fix needs per-inode handles rather than a dbPath-keyed cache.
+        // Surface it so the corner is observable instead of silently stale.
+        const current = await statDbIdentity(dbPath);
+        if (dbIdentityChanged(shared.dbIdentity, current)) {
+            realStderrWrite(`GitNexus: reusing a shared read-only handle for ${dbPath} whose on-disk ` +
+                `index was rebuilt while another consumer holds it — results may be stale ` +
+                `until that consumer releases it.\n`);
+        }
+    }
     if (!shared) {
         // Open in read-only mode — MCP server never writes to the database.
         // This allows multiple MCP server instances to read concurrently, and
@@ -540,7 +623,7 @@ async function doInitLbug(repoId, dbPath) {
         for (let attempt = 1; attempt <= LOCK_RETRY_ATTEMPTS; attempt++) {
             try {
                 const db = await openReadOnlyDatabase(dbPath);
-                shared = { db, refCount: 0, ftsLoaded: false };
+                shared = { db, refCount: 0, ftsLoaded: false, dbIdentity: await statDbIdentity(dbPath) };
                 dbCache.set(dbPath, shared);
                 break;
             }
@@ -549,7 +632,12 @@ async function doInitLbug(repoId, dbPath) {
                 if (isWalCorruptionError(lastError)) {
                     try {
                         const db = await tryQuarantineAndReopen(dbPath, repoId);
-                        shared = { db, refCount: 0, ftsLoaded: false };
+                        shared = {
+                            db,
+                            refCount: 0,
+                            ftsLoaded: false,
+                            dbIdentity: await statDbIdentity(dbPath),
+                        };
                         dbCache.set(dbPath, shared);
                         break;
                     }
@@ -559,6 +647,7 @@ async function doInitLbug(repoId, dbPath) {
                     }
                 }
                 if (lastError.message.startsWith('LadybugDB checkpoint sidecar is missing') ||
+                    lastError.message.startsWith('LadybugDB checkpoint sidecar is present but unreachable') ||
                     lastError.message.startsWith('GitNexus could not move the LadybugDB WAL sidecar') ||
                     isMissingShadowSidecarError(lastError)) {
                     throw lastError;
@@ -599,9 +688,19 @@ async function doInitLbug(repoId, dbPath) {
     if (!shared.ftsLoaded) {
         shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
     }
+    // VECTOR too — extension load scope is per-Database, so this one load
+    // makes QUERY_VECTOR_INDEX legal on every pooled connection. Same
+    // load-only contract as FTS above; on failure the semantic-query lane
+    // falls back to the exact scan with its own diagnostic (#2623 follow-up).
+    if (!shared.vectorLoaded) {
+        shared.vectorLoaded = await loadVectorExtension(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.
+    // Record the on-disk identity so a later initLbug can detect an analyze
+    // rebuild/mutation and re-open onto the new file (pool staleness invalidation).
+    const dbIdentity = await statDbIdentity(dbPath);
     pool.set(repoId, {
         db,
         available,
@@ -609,6 +708,7 @@ async function doInitLbug(repoId, dbPath) {
         waiters: [],
         lastUsed: Date.now(),
         dbPath,
+        dbIdentity,
         closed: false,
     });
     ensureIdleTimer();
@@ -657,6 +757,11 @@ export async function initLbugWithDb(repoId, existingDb, dbPath) {
     if (!shared.ftsLoaded) {
         shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
     }
+    // VECTOR too — same per-Database scope and load-only contract as the
+    // doInitLbug site above (#2623 follow-up).
+    if (!shared.vectorLoaded) {
+        shared.vectorLoaded = await loadVectorExtension(available[0], { policy: 'load-only' });
+    }
     pool.set(repoId, {
         db: existingDb,
         available,
@@ -664,6 +769,8 @@ export async function initLbugWithDb(repoId, existingDb, dbPath) {
         waiters: [],
         lastUsed: Date.now(),
         dbPath,
+        // Injected/external DB (tests) — not tracked for rebuild invalidation.
+        dbIdentity: null,
         closed: false,
     });
     ensureIdleTimer();

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

@@ -13,8 +13,8 @@ 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 FUNCTION_SCHEMA: string;
+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  frameworkAnnotations 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)";
@@ -22,6 +22,7 @@ export declare const COMMUNITY_SCHEMA = "\nCREATE NODE TABLE Community (\n  id S
 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 ENUM_VARIANT_SCHEMA: string;
 export declare const MACRO_SCHEMA: string;
 export declare const TYPEDEF_SCHEMA: string;
 export declare const UNION_SCHEMA: string;
@@ -43,7 +44,7 @@ export declare const ROUTE_SCHEMA = "\nCREATE NODE TABLE Route (\n  id STRING,\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 BASICBLOCK_SCHEMA = "\nCREATE NODE TABLE BasicBlock (\n  id STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  text STRING,\n  callees STRING,\n  calleeIds 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  FROM BasicBlock TO BasicBlock,\n  type STRING,\n  confidence DOUBLE,\n  reason STRING,\n  step INT32\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  // Move/Aptos: module defines structs/enums/consts; enums contain variants.\n  FROM `Module` TO `Struct`,\n  FROM `Module` TO `Enum`,\n  FROM `Module` TO `Const`,\n  FROM `Enum` TO `EnumVariant`,\n  FROM `Module` TO `EnumVariant`,\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 `Property` TO `Property`,\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  FROM BasicBlock TO BasicBlock,\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";

package/dist/core/lbug/schema.js

@@ -10,6 +10,7 @@
  */
 // Import from shared package (single source of truth) — used in DDL templates below
 import { NODE_TABLES, REL_TABLE_NAME, REL_TYPES, EMBEDDING_TABLE_NAME } from '../../_shared/index.js';
+import { buildNodeTableSchema } from './node-table-layout.js';
 // Re-export so downstream consumers keep the same import path
 export { NODE_TABLES, REL_TABLE_NAME, REL_TYPES, EMBEDDING_TABLE_NAME };
 // ============================================================================
@@ -30,18 +31,7 @@ CREATE NODE TABLE Folder (
   filePath STRING,
   PRIMARY KEY (id)
 )`;
-export const FUNCTION_SCHEMA = `
-CREATE NODE TABLE Function (
-  id STRING,
-  name STRING,
-  filePath STRING,
-  startLine INT64,
-  endLine INT64,
-  isExported BOOLEAN,
-  content STRING,
-  description STRING,
-  PRIMARY KEY (id)
-)`;
+export const FUNCTION_SCHEMA = buildNodeTableSchema('Function');
 export const CLASS_SCHEMA = `
 CREATE NODE TABLE Class (
   id STRING,
@@ -52,6 +42,7 @@ CREATE NODE TABLE Class (
   isExported BOOLEAN,
   content STRING,
   description STRING,
+  frameworkAnnotations STRING[],
   PRIMARY KEY (id)
 )`;
 export const INTERFACE_SCHEMA = `
@@ -138,8 +129,9 @@ CREATE NODE TABLE \`${name}\` (
   description STRING,
   PRIMARY KEY (id)
 )`;
-export const STRUCT_SCHEMA = CODE_ELEMENT_BASE('Struct');
-export const ENUM_SCHEMA = CODE_ELEMENT_BASE('Enum');
+export const STRUCT_SCHEMA = buildNodeTableSchema('Struct');
+export const ENUM_SCHEMA = buildNodeTableSchema('Enum');
+export const ENUM_VARIANT_SCHEMA = buildNodeTableSchema('EnumVariant');
 export const MACRO_SCHEMA = CODE_ELEMENT_BASE('Macro');
 export const TYPEDEF_SCHEMA = CODE_ELEMENT_BASE('Typedef');
 export const UNION_SCHEMA = CODE_ELEMENT_BASE('Union');
@@ -147,7 +139,7 @@ export const NAMESPACE_SCHEMA = CODE_ELEMENT_BASE('Namespace');
 export const TRAIT_SCHEMA = CODE_ELEMENT_BASE('Trait');
 export const IMPL_SCHEMA = CODE_ELEMENT_BASE('Impl');
 export const TYPE_ALIAS_SCHEMA = CODE_ELEMENT_BASE('TypeAlias');
-export const CONST_SCHEMA = CODE_ELEMENT_BASE('Const');
+export const CONST_SCHEMA = buildNodeTableSchema('Const');
 export const STATIC_SCHEMA = CODE_ELEMENT_BASE('Static');
 export const VARIABLE_SCHEMA = CODE_ELEMENT_BASE('Variable');
 export const PROPERTY_SCHEMA = `
@@ -167,7 +159,7 @@ export const DELEGATE_SCHEMA = CODE_ELEMENT_BASE('Delegate');
 export const ANNOTATION_SCHEMA = CODE_ELEMENT_BASE('Annotation');
 export const CONSTRUCTOR_SCHEMA = CODE_ELEMENT_BASE('Constructor');
 export const TEMPLATE_SCHEMA = CODE_ELEMENT_BASE('Template');
-export const MODULE_SCHEMA = CODE_ELEMENT_BASE('Module');
+export const MODULE_SCHEMA = buildNodeTableSchema('Module');
 // API route endpoints (Next.js, Express, etc.)
 export const ROUTE_SCHEMA = `
 CREATE NODE TABLE Route (
@@ -357,6 +349,12 @@ CREATE REL TABLE ${REL_TABLE_NAME} (
   FROM \`Macro\` TO Method,
   FROM \`Module\` TO Function,
   FROM \`Module\` TO Method,
+  // Move/Aptos: module defines structs/enums/consts; enums contain variants.
+  FROM \`Module\` TO \`Struct\`,
+  FROM \`Module\` TO \`Enum\`,
+  FROM \`Module\` TO \`Const\`,
+  FROM \`Enum\` TO \`EnumVariant\`,
+  FROM \`Module\` TO \`EnumVariant\`,
   FROM \`Typedef\` TO Community,
   FROM \`Union\` TO Community,
   FROM \`Namespace\` TO Community,
@@ -379,6 +377,7 @@ CREATE REL TABLE ${REL_TABLE_NAME} (
   FROM \`Static\` TO Community,
   FROM \`Variable\` TO Community,
   FROM \`Property\` TO Community,
+  FROM \`Property\` TO \`Property\`,
   FROM \`Record\` TO Method,
   FROM \`Record\` TO \`Constructor\`,
   FROM \`Record\` TO \`Property\`,
@@ -488,6 +487,7 @@ export const NODE_SCHEMA_QUERIES = [
     // Multi-language support
     STRUCT_SCHEMA,
     ENUM_SCHEMA,
+    ENUM_VARIANT_SCHEMA,
     MACRO_SCHEMA,
     TYPEDEF_SCHEMA,
     UNION_SCHEMA,