gitnexus 1.4.6 → 1.4.7

package/dist/core/ingestion/utils.js

@@ -254,7 +254,7 @@ export const CLASS_CONTAINER_TYPES = new Set([
     'class_declaration', 'abstract_class_declaration',
     'interface_declaration', 'struct_declaration', 'record_declaration',
     'class_specifier', 'struct_specifier',
-    'impl_item', 'trait_item',
+    'impl_item', 'trait_item', 'struct_item', 'enum_item',
     'class_definition',
     'trait_declaration',
     'protocol_declaration',
@@ -275,6 +275,8 @@ export const CONTAINER_TYPE_TO_LABEL = {
     class_definition: 'Class',
     impl_item: 'Impl',
     trait_item: 'Trait',
+    struct_item: 'Struct',
+    enum_item: 'Enum',
     trait_declaration: 'Trait',
     record_declaration: 'Record',
     protocol_declaration: 'Interface',
@@ -306,6 +308,21 @@ export const findEnclosingClassId = (node, filePath) => {
                 }
             }
         }
+        // Go: type_declaration wrapping a struct_type (type User struct { ... })
+        // field_declaration → field_declaration_list → struct_type → type_spec → type_declaration
+        if (current.type === 'type_declaration') {
+            const typeSpec = current.children?.find((c) => c.type === 'type_spec');
+            if (typeSpec) {
+                const typeBody = typeSpec.childForFieldName?.('type');
+                if (typeBody?.type === 'struct_type' || typeBody?.type === 'interface_type') {
+                    const nameNode = typeSpec.childForFieldName?.('name');
+                    if (nameNode) {
+                        const label = typeBody.type === 'struct_type' ? 'Struct' : 'Interface';
+                        return generateId(label, `${filePath}:${nameNode.text}`);
+                    }
+                }
+            }
+        }
         if (CLASS_CONTAINER_TYPES.has(current.type)) {
             // Rust impl_item: for `impl Trait for Struct {}`, pick the type after `for`
             if (current.type === 'impl_item') {
@@ -1129,3 +1146,145 @@ export function extractCallChain(receiverCallNode) {
     }
     return chain.length > 0 ? { chain, baseReceiverName: undefined } : undefined;
 }
+/** Node types representing member/field access across languages. */
+const FIELD_ACCESS_NODE_TYPES = new Set([
+    'member_expression', // TS/JS
+    'member_access_expression', // C#
+    'selector_expression', // Go
+    'field_expression', // Rust/C++
+    'field_access', // Java
+    'attribute', // Python
+    'navigation_expression', // Kotlin/Swift
+    'member_binding_expression', // C# null-conditional (user?.Address)
+]);
+/**
+ * Walk a receiver AST node that may interleave field accesses and method calls,
+ * building a unified chain of steps up to MAX_CHAIN_DEPTH.
+ *
+ * For `svc.getUser().address.save()`, called with the receiver of `save`
+ * (`svc.getUser().address`, a field access node):
+ *   returns { chain: [{ kind:'call', name:'getUser' }, { kind:'field', name:'address' }],
+ *             baseReceiverName: 'svc' }
+ *
+ * For `user.getAddress().city.getName()`, called with receiver of `getName`
+ * (`user.getAddress().city`):
+ *   returns { chain: [{ kind:'call', name:'getAddress' }, { kind:'field', name:'city' }],
+ *             baseReceiverName: 'user' }
+ *
+ * Pure field chains and pure call chains are special cases (all steps same kind).
+ */
+export function extractMixedChain(receiverNode) {
+    const chain = [];
+    let current = receiverNode;
+    while (chain.length < MAX_CHAIN_DEPTH) {
+        if (CALL_EXPRESSION_TYPES.has(current.type)) {
+            // ── Call expression: extract method name + inner receiver ────────────
+            const funcNode = current.childForFieldName?.('function')
+                ?? current.childForFieldName?.('name')
+                ?? current.childForFieldName?.('method');
+            let methodName;
+            let innerReceiver = null;
+            if (funcNode) {
+                methodName = funcNode.lastNamedChild?.text ?? funcNode.text;
+            }
+            // Kotlin/Swift: call_expression → navigation_expression
+            if (!funcNode && current.type === 'call_expression') {
+                const callee = current.firstNamedChild;
+                if (callee?.type === 'navigation_expression') {
+                    const suffix = callee.lastNamedChild;
+                    if (suffix?.type === 'navigation_suffix') {
+                        methodName = suffix.lastNamedChild?.text;
+                        for (let i = 0; i < callee.namedChildCount; i++) {
+                            const child = callee.namedChild(i);
+                            if (child && child.type !== 'navigation_suffix') {
+                                innerReceiver = child;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            if (!methodName)
+                break;
+            chain.unshift({ kind: 'call', name: methodName });
+            if (!innerReceiver && funcNode) {
+                innerReceiver = funcNode.childForFieldName?.('object')
+                    ?? funcNode.childForFieldName?.('value')
+                    ?? funcNode.childForFieldName?.('operand')
+                    ?? funcNode.childForFieldName?.('argument') // C/C++ field_expression
+                    ?? funcNode.childForFieldName?.('expression')
+                    ?? null;
+            }
+            if (!innerReceiver && current.type === 'method_invocation') {
+                innerReceiver = current.childForFieldName?.('object') ?? null;
+            }
+            if (!innerReceiver && (current.type === 'member_call_expression' || current.type === 'nullsafe_member_call_expression')) {
+                innerReceiver = current.childForFieldName?.('object') ?? null;
+            }
+            if (!innerReceiver && current.type === 'call') {
+                innerReceiver = current.childForFieldName?.('receiver') ?? null;
+            }
+            if (!innerReceiver)
+                break;
+            if (CALL_EXPRESSION_TYPES.has(innerReceiver.type) || FIELD_ACCESS_NODE_TYPES.has(innerReceiver.type)) {
+                current = innerReceiver;
+            }
+            else {
+                return { chain, baseReceiverName: innerReceiver.text || undefined };
+            }
+        }
+        else if (FIELD_ACCESS_NODE_TYPES.has(current.type)) {
+            // ── Field/member access: extract property name + inner object ─────────
+            let propertyName;
+            let innerObject = null;
+            if (current.type === 'navigation_expression') {
+                for (const child of current.children ?? []) {
+                    if (child.type === 'navigation_suffix') {
+                        for (const sc of child.children ?? []) {
+                            if (sc.isNamed && sc.type !== '.') {
+                                propertyName = sc.text;
+                                break;
+                            }
+                        }
+                    }
+                    else if (child.isNamed && !innerObject) {
+                        innerObject = child;
+                    }
+                }
+            }
+            else if (current.type === 'attribute') {
+                innerObject = current.childForFieldName?.('object') ?? null;
+                propertyName = current.childForFieldName?.('attribute')?.text;
+            }
+            else {
+                innerObject = current.childForFieldName?.('object')
+                    ?? current.childForFieldName?.('value')
+                    ?? current.childForFieldName?.('operand')
+                    ?? current.childForFieldName?.('argument') // C/C++ field_expression
+                    ?? current.childForFieldName?.('expression')
+                    ?? null;
+                propertyName = (current.childForFieldName?.('property')
+                    ?? current.childForFieldName?.('field')
+                    ?? current.childForFieldName?.('name'))?.text;
+            }
+            if (!propertyName)
+                break;
+            chain.unshift({ kind: 'field', name: propertyName });
+            if (!innerObject)
+                break;
+            if (CALL_EXPRESSION_TYPES.has(innerObject.type) || FIELD_ACCESS_NODE_TYPES.has(innerObject.type)) {
+                current = innerObject;
+            }
+            else {
+                return { chain, baseReceiverName: innerObject.text || undefined };
+            }
+        }
+        else {
+            // Simple identifier — this is the base receiver
+            return chain.length > 0
+                ? { chain, baseReceiverName: current.text || undefined }
+                : undefined;
+        }
+    }
+    return chain.length > 0 ? { chain, baseReceiverName: undefined } : undefined;
+}

package/dist/core/ingestion/workers/parse-worker.d.ts

@@ -1,5 +1,7 @@
 import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { type MixedChainStep } from '../utils.js';
 import type { ConstructorBinding } from '../type-env.js';
+import type { NodeLabel } from '../../graph/types.js';
 interface ParsedNode {
     id: string;
     label: string;
@@ -21,7 +23,7 @@ interface ParsedRelationship {
     id: string;
     sourceId: string;
     targetId: string;
-    type: 'DEFINES' | 'HAS_METHOD';
+    type: 'DEFINES' | 'HAS_METHOD' | 'HAS_PROPERTY';
     confidence: number;
     reason: string;
 }
@@ -29,9 +31,10 @@ interface ParsedSymbol {
     filePath: string;
     name: string;
     nodeId: string;
-    type: string;
+    type: NodeLabel;
     parameterCount?: number;
     returnType?: string;
+    declaredType?: string;
     ownerId?: string;
 }
 export interface ExtractedImport {
@@ -57,13 +60,25 @@ export interface ExtractedCall {
     /** Resolved type name of the receiver (e.g., 'User' for user.save() when user: User) */
     receiverTypeName?: string;
     /**
-     * Chained call names when the receiver is itself a call expression.
-     * For `svc.getUser().save()`, the `save` ExtractedCall gets receiverCallChain = ['getUser']
-     * with receiverName = 'svc'.  The chain is ordered outermost-last, e.g.:
-     *   `a.b().c().d()` → calledName='d', receiverCallChain=['b','c'], receiverName='a'
+     * Unified mixed chain when the receiver is a chain of field accesses and/or method calls.
+     * Steps are ordered base-first (innermost to outermost). Examples:
+     *   `svc.getUser().save()`        → chain=[{kind:'call',name:'getUser'}], receiverName='svc'
+     *   `user.address.save()`         → chain=[{kind:'field',name:'address'}], receiverName='user'
+     *   `svc.getUser().address.save()` → chain=[{kind:'call',name:'getUser'},{kind:'field',name:'address'}]
      * Length is capped at MAX_CHAIN_DEPTH (3).
      */
-    receiverCallChain?: string[];
+    receiverMixedChain?: MixedChainStep[];
+}
+export interface ExtractedAssignment {
+    filePath: string;
+    /** generateId of enclosing function, or generateId('File', filePath) for top-level */
+    sourceId: string;
+    /** Receiver text (e.g., 'user' from user.address = value) */
+    receiverText: string;
+    /** Property name being written (e.g., 'address') */
+    propertyName: string;
+    /** Resolved type name of the receiver if available from TypeEnv */
+    receiverTypeName?: string;
 }
 export interface ExtractedHeritage {
     filePath: string;
@@ -93,6 +108,7 @@ export interface ParseWorkerResult {
     symbols: ParsedSymbol[];
     imports: ExtractedImport[];
     calls: ExtractedCall[];
+    assignments: ExtractedAssignment[];
     heritage: ExtractedHeritage[];
     routes: ExtractedRoute[];
     constructorBindings: FileConstructorBindings[];

package/dist/core/ingestion/workers/parse-worker.js

@@ -28,7 +28,7 @@ try {
     Kotlin = _require('tree-sitter-kotlin');
 }
 catch { }
-import { getLanguageFromFilename, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, CALL_EXPRESSION_TYPES, extractCallChain, } from '../utils.js';
+import { getLanguageFromFilename, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, } from '../utils.js';
 import { buildTypeEnv } from '../type-env.js';
 import { isNodeExported } from '../export-detection.js';
 import { detectFrameworkFromAST } from '../framework-detection.js';
@@ -37,6 +37,7 @@ import { generateId } from '../../../lib/utils.js';
 import { extractNamedBindings } from '../named-binding-extraction.js';
 import { appendKotlinWildcard } from '../resolvers/index.js';
 import { callRouters } from '../call-routing.js';
+import { extractPropertyDeclaredType } from '../type-extractors/shared.js';
 // ============================================================================
 // Worker-local parser + language map
 // ============================================================================
@@ -162,6 +163,7 @@ const processBatch = (files, onProgress) => {
         symbols: [],
         imports: [],
         calls: [],
+        assignments: [],
         heritage: [],
         routes: [],
         constructorBindings: [],
@@ -759,6 +761,28 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 });
                 continue;
             }
+            // Extract assignment sites (field write access)
+            if (captureMap['assignment'] && captureMap['assignment.receiver'] && captureMap['assignment.property']) {
+                const receiverText = captureMap['assignment.receiver'].text;
+                const propertyName = captureMap['assignment.property'].text;
+                if (receiverText && propertyName) {
+                    const srcId = findEnclosingFunctionId(captureMap['assignment'], file.path)
+                        || generateId('File', file.path);
+                    let receiverTypeName;
+                    if (typeEnv) {
+                        receiverTypeName = typeEnv.lookup(receiverText, captureMap['assignment']) ?? undefined;
+                    }
+                    result.assignments.push({
+                        filePath: file.path,
+                        sourceId: srcId,
+                        receiverText,
+                        propertyName,
+                        ...(receiverTypeName ? { receiverTypeName } : {}),
+                    });
+                }
+                if (!captureMap['call'])
+                    continue;
+            }
             // Extract call sites
             if (captureMap['call']) {
                 const callNameNode = captureMap['call.name'];
@@ -811,6 +835,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                                     nodeId,
                                     type: 'Property',
                                     ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}),
+                                    ...(item.declaredType ? { declaredType: item.declaredType } : {}),
                                 });
                                 const fileId = generateId('File', file.path);
                                 const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
@@ -824,10 +849,10 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                                 });
                                 if (propEnclosingClassId) {
                                     result.relationships.push({
-                                        id: generateId('HAS_METHOD', `${propEnclosingClassId}->${nodeId}`),
+                                        id: generateId('HAS_PROPERTY', `${propEnclosingClassId}->${nodeId}`),
                                         sourceId: propEnclosingClassId,
                                         targetId: nodeId,
-                                        type: 'HAS_METHOD',
+                                        type: 'HAS_PROPERTY',
                                         confidence: 1.0,
                                         reason: '',
                                     });
@@ -844,26 +869,19 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                         const callForm = inferCallForm(callNode, callNameNode);
                         let receiverName = callForm === 'member' ? extractReceiverName(callNameNode) : undefined;
                         let receiverTypeName = receiverName ? typeEnv.lookup(receiverName, callNode) : undefined;
-                        let receiverCallChain;
-                        // When the receiver is a call_expression (e.g. svc.getUser().save()),
-                        // extractReceiverName returns undefined because it refuses complex expressions.
-                        // Instead, walk the receiver node to build a call chain for deferred resolution.
-                        // We capture the base receiver name so processCallsFromExtracted can look it up
-                        // from constructor bindings. receiverTypeName is intentionally left unset here —
-                        // the chain resolver in processCallsFromExtracted needs the base type as input and
-                        // produces the final receiver type as output.
+                        let receiverMixedChain;
+                        // When the receiver is a complex expression (call chain, field chain, or mixed),
+                        // extractReceiverName returns undefined. Walk the receiver node to build a unified
+                        // mixed chain for deferred resolution in processCallsFromExtracted.
                         if (callForm === 'member' && receiverName === undefined && !receiverTypeName) {
                             const receiverNode = extractReceiverNode(callNameNode);
-                            if (receiverNode && CALL_EXPRESSION_TYPES.has(receiverNode.type)) {
-                                const extracted = extractCallChain(receiverNode);
-                                if (extracted) {
-                                    receiverCallChain = extracted.chain;
-                                    // Set receiverName to the base object so Step 1 in processCallsFromExtracted
-                                    // can resolve it via constructor bindings to a base type for the chain.
+                            if (receiverNode) {
+                                const extracted = extractMixedChain(receiverNode);
+                                if (extracted && extracted.chain.length > 0) {
+                                    receiverMixedChain = extracted.chain;
                                     receiverName = extracted.baseReceiverName;
-                                    // Also try the type environment immediately (covers explicitly-typed locals
-                                    // and annotated parameters like `fn process(svc: &UserService)`).
-                                    // This sets a base type that chain resolution (Step 2) will use as input.
+                                    // Try the type environment immediately for the base receiver
+                                    // (covers explicitly-typed locals and annotated parameters).
                                     if (receiverName) {
                                         receiverTypeName = typeEnv.lookup(receiverName, callNode);
                                     }
@@ -878,7 +896,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                             ...(callForm !== undefined ? { callForm } : {}),
                             ...(receiverName !== undefined ? { receiverName } : {}),
                             ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
-                            ...(receiverCallChain !== undefined ? { receiverCallChain } : {}),
+                            ...(receiverMixedChain !== undefined ? { receiverMixedChain } : {}),
                         });
                     }
                 }
@@ -926,6 +944,21 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             const nodeLabel = getLabelFromCaptures(captureMap);
             if (!nodeLabel)
                 continue;
+            // C/C++: @definition.function is broad and also matches inline class methods (inside
+            // a class/struct body). Those are already captured by @definition.method, so skip
+            // the duplicate Function entry to prevent double-indexing in globalIndex.
+            if ((language === SupportedLanguages.CPlusPlus || language === SupportedLanguages.C) &&
+                nodeLabel === 'Function') {
+                let ancestor = captureMap['definition.function']?.parent;
+                while (ancestor) {
+                    if (ancestor.type === 'class_specifier' || ancestor.type === 'struct_specifier') {
+                        break; // inside a class body — duplicate of @definition.method
+                    }
+                    ancestor = ancestor.parent;
+                }
+                if (ancestor)
+                    continue; // found a class/struct ancestor → skip
+            }
             const nameNode = captureMap['name'];
             // Synthesize name for constructors without explicit @name capture (e.g. Swift init)
             if (!nameNode && nodeLabel !== 'Constructor')
@@ -948,6 +981,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 : null;
             let parameterCount;
             let returnType;
+            let declaredType;
             if (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor') {
                 const sig = extractMethodSignature(definitionNode);
                 parameterCount = sig.parameterCount;
@@ -963,6 +997,11 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     }
                 }
             }
+            else if (nodeLabel === 'Property' && definitionNode) {
+                // Extract the declared type for property/field nodes.
+                // Walk the definition node for type annotation children.
+                declaredType = extractPropertyDeclaredType(definitionNode);
+            }
             result.nodes.push({
                 id: nodeId,
                 label: nodeLabel,
@@ -993,6 +1032,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 type: nodeLabel,
                 ...(parameterCount !== undefined ? { parameterCount } : {}),
                 ...(returnType !== undefined ? { returnType } : {}),
+                ...(declaredType !== undefined ? { declaredType } : {}),
                 ...(enclosingClassId ? { ownerId: enclosingClassId } : {}),
             });
             const fileId = generateId('File', file.path);
@@ -1005,13 +1045,14 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 confidence: 1.0,
                 reason: '',
             });
-            // ── HAS_METHOD: link method/constructor/property to enclosing class ──
+            // ── HAS_METHOD / HAS_PROPERTY: link member to enclosing class ──
             if (enclosingClassId) {
+                const memberEdgeType = nodeLabel === 'Property' ? 'HAS_PROPERTY' : 'HAS_METHOD';
                 result.relationships.push({
-                    id: generateId('HAS_METHOD', `${enclosingClassId}->${nodeId}`),
+                    id: generateId(memberEdgeType, `${enclosingClassId}->${nodeId}`),
                     sourceId: enclosingClassId,
                     targetId: nodeId,
-                    type: 'HAS_METHOD',
+                    type: memberEdgeType,
                     confidence: 1.0,
                     reason: '',
                 });
@@ -1030,7 +1071,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
 /** Accumulated result across sub-batches */
 let accumulated = {
     nodes: [], relationships: [], symbols: [],
-    imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0,
+    imports: [], calls: [], assignments: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0,
 };
 let cumulativeProcessed = 0;
 const mergeResult = (target, src) => {
@@ -1039,6 +1080,7 @@ const mergeResult = (target, src) => {
     target.symbols.push(...src.symbols);
     target.imports.push(...src.imports);
     target.calls.push(...src.calls);
+    target.assignments.push(...src.assignments);
     target.heritage.push(...src.heritage);
     target.routes.push(...src.routes);
     target.constructorBindings.push(...src.constructorBindings);
@@ -1064,7 +1106,7 @@ parentPort.on('message', (msg) => {
         if (msg && msg.type === 'flush') {
             parentPort.postMessage({ type: 'result', data: accumulated });
             // Reset for potential reuse
-            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0 };
+            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], assignments: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0 };
             cumulativeProcessed = 0;
             return;
         }

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

@@ -1,5 +1,7 @@
 import lbug from '@ladybugdb/core';
 import { KnowledgeGraph } from '../graph/types.js';
+/** Expose the current Database for pool adapter reuse in tests. */
+export declare const getDatabase: () => lbug.Database | null;
 export declare const initLbug: (dbPath: string) => Promise<{
     db: lbug.Database;
     conn: lbug.Connection;

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

@@ -9,6 +9,8 @@ let db = null;
 let conn = null;
 let currentDbPath = null;
 let ftsLoaded = false;
+/** Expose the current Database for pool adapter reuse in tests. */
+export const getDatabase = () => db;
 // Global session lock for operations that touch module-level lbug globals.
 // This guarantees no DB switch can happen while an operation is running.
 let sessionLock = Promise.resolve();

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

@@ -11,7 +11,7 @@
 export declare const NODE_TABLES: readonly ["File", "Folder", "Function", "Class", "Interface", "Method", "CodeElement", "Community", "Process", "Struct", "Enum", "Macro", "Typedef", "Union", "Namespace", "Trait", "Impl", "TypeAlias", "Const", "Static", "Property", "Record", "Delegate", "Annotation", "Constructor", "Template", "Module"];
 export type NodeTableName = typeof NODE_TABLES[number];
 export declare const REL_TABLE_NAME = "CodeRelation";
-export declare const REL_TYPES: readonly ["CONTAINS", "DEFINES", "IMPORTS", "CALLS", "EXTENDS", "IMPLEMENTS", "HAS_METHOD", "OVERRIDES", "MEMBER_OF", "STEP_IN_PROCESS"];
+export declare const REL_TYPES: readonly ["CONTAINS", "DEFINES", "IMPORTS", "CALLS", "EXTENDS", "IMPLEMENTS", "HAS_METHOD", "HAS_PROPERTY", "ACCESSES", "OVERRIDES", "MEMBER_OF", "STEP_IN_PROCESS"];
 export type RelType = typeof REL_TYPES[number];
 export declare const EMBEDDING_TABLE_NAME = "CodeEmbedding";
 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)";

package/dist/core/lbug/schema.js

@@ -22,7 +22,7 @@ export const NODE_TABLES = [
 // ============================================================================
 export const REL_TABLE_NAME = 'CodeRelation';
 // Valid relation types
-export const REL_TYPES = ['CONTAINS', 'DEFINES', 'IMPORTS', 'CALLS', 'EXTENDS', 'IMPLEMENTS', 'HAS_METHOD', 'OVERRIDES', 'MEMBER_OF', 'STEP_IN_PROCESS'];
+export const REL_TYPES = ['CONTAINS', 'DEFINES', 'IMPORTS', 'CALLS', 'EXTENDS', 'IMPLEMENTS', 'HAS_METHOD', 'HAS_PROPERTY', 'ACCESSES', 'OVERRIDES', 'MEMBER_OF', 'STEP_IN_PROCESS'];
 // ============================================================================
 // EMBEDDING TABLE
 // ============================================================================

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

@@ -12,11 +12,29 @@
  * @see https://docs.ladybugdb.com/concurrency — multiple Connections
  * from the same Database is the officially supported concurrency pattern.
  */
+import lbug from '@ladybugdb/core';
+/** Saved real stdout.write — used to silence LadybugDB native output without race conditions */
+export declare const realStdoutWrite: any;
 /**
  * Initialize (or reuse) a Database + connection pool for a specific repo.
  * Retries on lock errors (e.g., when `gitnexus 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 declare const initLbug: (repoId: string, dbPath: string) => Promise<void>;
+/**
+ * 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 declare function initLbugWithDb(repoId: string, existingDb: lbug.Database, dbPath: string): Promise<void>;
 export declare const executeQuery: (repoId: string, cypher: string) => Promise<any[]>;
 /**
  * Execute a parameterized query on a specific repo's connection pool.
@@ -33,3 +51,7 @@ export declare const closeLbug: (repoId?: string) => Promise<void>;
  * Check if a specific repo's pool is active
  */
 export declare const isLbugReady: (repoId: string) => boolean;
+/** Regex to detect write operations in user-supplied Cypher queries */
+export declare const CYPHER_WRITE_RE: RegExp;
+/** Check if a Cypher query contains write operations */
+export declare function isWriteQuery(query: string): boolean;