gitnexus 1.6.4-rc.97 → 1.6.4-rc.99

package/dist/core/ingestion/field-extractors/configs/csharp.js

@@ -3,6 +3,11 @@ import { SupportedLanguages } from '../../../../_shared/index.js';
 import { findVisibility, hasKeyword, hasModifier, collectModifierTexts } from './helpers.js';
 import { extractSimpleTypeName } from '../../type-extractors/shared.js';
 const CSHARP_VIS = new Set(['public', 'private', 'protected', 'internal']);
+const extractCsharpDeclaredType = (typeNode) => {
+    if (typeNode.type === 'generic_name')
+        return typeNode.text.trim();
+    return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+};
 /**
  * C# field extraction config.
  *
@@ -47,18 +52,18 @@ export const csharpConfig = {
             if (child?.type === 'variable_declaration') {
                 const typeNode = child.childForFieldName('type');
                 if (typeNode)
-                    return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+                    return extractCsharpDeclaredType(typeNode);
                 // fallback: first child that is a type
                 const first = child.firstNamedChild;
                 if (first && first.type !== 'variable_declarator') {
-                    return extractSimpleTypeName(first) ?? first.text?.trim();
+                    return extractCsharpDeclaredType(first);
                 }
             }
         }
         // property_declaration: type is first named child
         const typeNode = node.childForFieldName('type');
         if (typeNode)
-            return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+            return extractCsharpDeclaredType(typeNode);
         return undefined;
     },
     extractVisibility(node) {

package/dist/core/ingestion/languages/csharp/captures.js

@@ -37,6 +37,37 @@ const FUNCTION_NODE_TYPES = [
     'conversion_operator_declaration',
     'local_function_statement',
 ];
+const BUILTIN_TYPE_NAMES = new Set([
+    'bool',
+    'byte',
+    'char',
+    'decimal',
+    'double',
+    'float',
+    'int',
+    'long',
+    'object',
+    'sbyte',
+    'short',
+    'string',
+    'uint',
+    'ulong',
+    'ushort',
+    'void',
+]);
+function shouldEmitReadMember(memberNode) {
+    const parent = memberNode.parent;
+    if (parent === null)
+        return true;
+    switch (parent.type) {
+        case 'invocation_expression':
+            return parent.childForFieldName('function')?.id !== memberNode.id;
+        case 'assignment_expression':
+            return parent.childForFieldName('left')?.id !== memberNode.id;
+        default:
+            return true;
+    }
+}
 export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
     // Skip the parse when the caller (parse phase's scopeTreeCache)
     // already produced a Tree for this source. Cache miss = re-parse,
@@ -83,6 +114,13 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
             out.push(grouped);
             continue;
         }
+        if (grouped['@reference.read.member'] !== undefined) {
+            const anchor = grouped['@reference.read.member'];
+            const memberNode = findNodeAtRange(tree.rootNode, anchor.range, 'member_access_expression');
+            if (memberNode === null || !shouldEmitReadMember(memberNode)) {
+                continue;
+            }
+        }
         // Synthesize `this` / `base` receiver type-bindings on every
         // instance method-like. Tree-sitter can't cleanly express "the
         // implicit receiver of a non-static member of a class/struct/
@@ -166,8 +204,63 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
             }
         }
     }
+    out.push(...synthesizeGenericTypeArgumentReferences(tree.rootNode));
+    return out;
+}
+function synthesizeGenericTypeArgumentReferences(root) {
+    const out = [];
+    // Treat all generic type arguments as static type references, including
+    // declaration signatures and call-site generic instantiations.
+    visit(root, (node) => {
+        if (node.type !== 'generic_name')
+            return;
+        const args = findNamedChild(node, 'type_argument_list');
+        if (args === null)
+            return;
+        for (const arg of args.namedChildren) {
+            if (arg === null)
+                continue;
+            const nameNode = terminalTypeNameNode(arg);
+            if (nameNode === null)
+                continue;
+            if (BUILTIN_TYPE_NAMES.has(nameNode.text))
+                continue;
+            out.push({
+                '@reference.type': nodeToCapture('@reference.type', nameNode),
+                '@reference.name': nodeToCapture('@reference.name', nameNode),
+            });
+        }
+    });
     return out;
 }
+function terminalTypeNameNode(node) {
+    switch (node.type) {
+        case 'identifier':
+            return node;
+        case 'nullable_type':
+            return node.firstNamedChild === null ? null : terminalTypeNameNode(node.firstNamedChild);
+        case 'qualified_name':
+            return node.lastNamedChild;
+        case 'generic_name':
+            return node.childForFieldName('name') ?? node.firstNamedChild;
+        default:
+            return null;
+    }
+}
+function findNamedChild(node, type) {
+    for (const child of node.namedChildren) {
+        if (child !== null && child.type === type)
+            return child;
+    }
+    return null;
+}
+function visit(node, cb) {
+    cb(node);
+    for (const child of node.namedChildren) {
+        if (child !== null)
+            visit(child, cb);
+    }
+}
 /** C# 12 primary constructor: `class X(a, b) { }` / `record X(a, b)`.
  *  The parameters are a bare `parameter_list` named child of the type
  *  declaration (no `constructor_declaration` node). Emit a synthetic

package/dist/core/ingestion/languages/csharp/query.js

@@ -497,6 +497,12 @@ const CSHARP_SCOPE_QUERY = `
   left: (member_access_expression
     expression: "base" @reference.receiver
     name: (identifier) @reference.name)) @reference.write.member
+
+;; References — field/property reads: \`obj.Name\`
+;; Emit-side filtering drops call targets and assignment left-hand sides.
+(member_access_expression
+  expression: (_) @reference.receiver
+  name: (identifier) @reference.name) @reference.read.member
 `;
 let _parser = null;
 let _query = null;

package/dist/core/lbug/csv-generator.js

@@ -237,9 +237,10 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
         'Template',
         'Module',
     ];
+    const propertyHeader = 'id,name,filePath,startLine,endLine,content,description,declaredType';
     const multiLangWriters = new Map();
     for (const t of MULTI_LANG_TYPES) {
-        multiLangWriters.set(t, new BufferedCSVWriter(path.join(csvDir, `${t.toLowerCase()}.csv`), multiLangHeader));
+        multiLangWriters.set(t, new BufferedCSVWriter(path.join(csvDir, `${t.toLowerCase()}.csv`), t === 'Property' ? propertyHeader : multiLangHeader));
     }
     const codeWriterMap = {
         Function: functionWriter,
@@ -390,6 +391,9 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
                             escapeCSVNumber(node.properties.endLine, -1),
                             escapeCSVField(content),
                             escapeCSVField(node.properties.description || ''),
+                            ...(node.label === 'Property'
+                                ? [escapeCSVField(node.properties.declaredType || '')]
+                                : []),
                         ].join(','));
                     }
                 }

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

@@ -520,6 +520,9 @@ const getCopyQuery = (table, filePath) => {
     if (table === 'Method') {
         return `COPY ${t}(id, name, filePath, startLine, endLine, isExported, content, description, parameterCount, returnType) FROM "${filePath}" ${COPY_CSV_OPTS}`;
     }
+    if (table === 'Property') {
+        return `COPY ${t}(id, name, filePath, startLine, endLine, content, description, declaredType) FROM "${filePath}" ${COPY_CSV_OPTS}`;
+    }
     // TypeScript/JS code element tables have isExported; multi-language tables do not
     if (TABLES_WITH_EXPORTED.has(table)) {
         return `COPY ${t}(id, name, filePath, startLine, endLine, isExported, content, description) FROM "${filePath}" ${COPY_CSV_OPTS}`;
@@ -569,6 +572,12 @@ export const insertNodeToLbug = async (label, properties, dbPath) => {
                 : '';
             query = `CREATE (n:${t} {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}, startLine: ${properties.startLine || 0}, endLine: ${properties.endLine || 0}, isExported: ${!!properties.isExported}, content: ${escapeValue(properties.content || '')}${descPart}})`;
         }
+        else if (label === 'Property') {
+            const descPart = properties.description
+                ? `, description: ${escapeValue(properties.description)}`
+                : '';
+            query = `CREATE (n:${t} {id: ${escapeValue(properties.id)}, name: ${escapeValue(properties.name)}, filePath: ${escapeValue(properties.filePath)}, startLine: ${properties.startLine || 0}, endLine: ${properties.endLine || 0}, content: ${escapeValue(properties.content || '')}${descPart}, declaredType: ${escapeValue(properties.declaredType || '')}})`;
+        }
         else {
             // Multi-language tables (Struct, Impl, Trait, Macro, etc.) — no isExported
             const descPart = properties.description
@@ -646,6 +655,12 @@ export const batchInsertNodesToLbug = async (nodes, dbPath) => {
                         : '';
                     query = `MERGE (n:${t} {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}, n.startLine = ${properties.startLine || 0}, n.endLine = ${properties.endLine || 0}, n.isExported = ${!!properties.isExported}, n.content = ${escapeValue(properties.content || '')}${descPart}`;
                 }
+                else if (label === 'Property') {
+                    const descPart = properties.description
+                        ? `, n.description = ${escapeValue(properties.description)}`
+                        : '';
+                    query = `MERGE (n:${t} {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}, n.startLine = ${properties.startLine || 0}, n.endLine = ${properties.endLine || 0}, n.content = ${escapeValue(properties.content || '')}${descPart}, n.declaredType = ${escapeValue(properties.declaredType || '')}`;
+                }
                 else {
                     const descPart = properties.description
                         ? `, n.description = ${escapeValue(properties.description)}`

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

@@ -32,7 +32,7 @@ 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: 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;

package/dist/core/lbug/schema.js

@@ -150,7 +150,18 @@ export const TYPE_ALIAS_SCHEMA = CODE_ELEMENT_BASE('TypeAlias');
 export const CONST_SCHEMA = CODE_ELEMENT_BASE('Const');
 export const STATIC_SCHEMA = CODE_ELEMENT_BASE('Static');
 export const VARIABLE_SCHEMA = CODE_ELEMENT_BASE('Variable');
-export const PROPERTY_SCHEMA = CODE_ELEMENT_BASE('Property');
+export const PROPERTY_SCHEMA = `
+CREATE NODE TABLE \`Property\` (
+  id STRING,
+  name STRING,
+  filePath STRING,
+  startLine INT64,
+  endLine INT64,
+  content STRING,
+  description STRING,
+  declaredType STRING,
+  PRIMARY KEY (id)
+)`;
 export const RECORD_SCHEMA = CODE_ELEMENT_BASE('Record');
 export const DELEGATE_SCHEMA = CODE_ELEMENT_BASE('Delegate');
 export const ANNOTATION_SCHEMA = CODE_ELEMENT_BASE('Annotation');

package/dist/mcp/local/local-backend.js

@@ -1443,10 +1443,11 @@ export class LocalBackend {
         // Categorized incoming refs
         const incomingRows = await executeParameterized(repo.id, `
       MATCH (caller)-[r:CodeRelation]->(n {id: $symId})
-      WHERE r.type IN ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'HAS_METHOD', 'HAS_PROPERTY', 'METHOD_OVERRIDES', 'OVERRIDES', 'METHOD_IMPLEMENTS', 'ACCESSES']
+      WHERE r.type IN ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'USES', 'HAS_METHOD', 'HAS_PROPERTY', 'METHOD_OVERRIDES', 'OVERRIDES', 'METHOD_IMPLEMENTS', 'ACCESSES']
       RETURN r.type AS relType, caller.id AS uid, caller.name AS name, caller.filePath AS filePath, labels(caller)[0] AS kind
       LIMIT 30
     `, { symId });
+        let typedPropertyRows = [];
         // Fix #480: Class/Interface nodes have no direct CALLS/IMPORTS edges —
         // those point to Constructor and File nodes respectively. Fetch those
         // extra incoming refs and merge them in so context() shows real callers.
@@ -1476,13 +1477,13 @@ export class LocalBackend {
         }
         if (isClassLike) {
             try {
-                // Run both incoming-ref queries in parallel — they are independent.
-                const [ctorIncoming, fileIncoming] = await Promise.all([
+                // Run incoming-ref queries in parallel — they are independent.
+                const [ctorIncoming, fileIncoming, typedPropertyIncoming, typedProperties] = await Promise.all([
                     executeParameterized(repo.id, `
             MATCH (n)-[hm:CodeRelation]->(ctor:Constructor)
             WHERE n.id = $symId AND hm.type = 'HAS_METHOD'
             MATCH (caller)-[r:CodeRelation]->(ctor)
-            WHERE r.type IN ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'ACCESSES']
+            WHERE r.type IN ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'USES', 'ACCESSES']
             RETURN r.type AS relType, caller.id AS uid, caller.name AS name, caller.filePath AS filePath, labels(caller)[0] AS kind
             LIMIT 30
           `, { symId }),
@@ -1494,12 +1495,40 @@ export class LocalBackend {
             RETURN r.type AS relType, caller.id AS uid, caller.name AS name, caller.filePath AS filePath, labels(caller)[0] AS kind
             LIMIT 30
           `, { symId }),
+                    executeParameterized(repo.id, `
+            MATCH (p:\`Property\`)
+            WHERE p.declaredType = $name
+               OR p.declaredType STARTS WITH $genericPrefix
+               OR p.declaredType CONTAINS $genericArg
+            MATCH (caller)-[r:CodeRelation]->(p)
+            WHERE r.type IN ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'USES', 'ACCESSES']
+            RETURN r.type AS relType, caller.id AS uid, caller.name AS name, caller.filePath AS filePath, labels(caller)[0] AS kind
+            LIMIT 30
+          `, {
+                        name: sym.name,
+                        genericPrefix: `${sym.name}<`,
+                        genericArg: `<${sym.name}>`,
+                    }),
+                    executeParameterized(repo.id, `
+            MATCH (p:\`Property\`)
+            WHERE p.declaredType = $name
+               OR p.declaredType STARTS WITH $genericPrefix
+               OR p.declaredType CONTAINS $genericArg
+            RETURN p.id AS uid, p.name AS name, p.filePath AS filePath, labels(p)[0] AS kind,
+                   p.declaredType AS declaredType
+            LIMIT 30
+          `, {
+                        name: sym.name,
+                        genericPrefix: `${sym.name}<`,
+                        genericArg: `<${sym.name}>`,
+                    }),
                 ]);
+                typedPropertyRows = typedProperties;
                 // Deduplicate by (relType, uid) — a caller can have multiple relation
                 // types to the same target (e.g. both IMPORTS and CALLS), and each
                 // must be preserved so every category appears in the output.
                 const seenKeys = new Set(incomingRows.map((r) => `${r.relType || r[0]}:${r.uid || r[1]}`));
-                for (const r of [...ctorIncoming, ...fileIncoming]) {
+                for (const r of [...ctorIncoming, ...fileIncoming, ...typedPropertyIncoming]) {
                     const key = `${r.relType || r[0]}:${r.uid || r[1]}`;
                     if (!seenKeys.has(key)) {
                         seenKeys.add(key);
@@ -1514,7 +1543,7 @@ export class LocalBackend {
         // Categorized outgoing refs
         const outgoingRows = await executeParameterized(repo.id, `
       MATCH (n {id: $symId})-[r:CodeRelation]->(target)
-      WHERE r.type IN ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'HAS_METHOD', 'HAS_PROPERTY', 'METHOD_OVERRIDES', 'OVERRIDES', 'METHOD_IMPLEMENTS', 'ACCESSES']
+      WHERE r.type IN ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS', 'USES', 'HAS_METHOD', 'HAS_PROPERTY', 'METHOD_OVERRIDES', 'OVERRIDES', 'METHOD_IMPLEMENTS', 'ACCESSES']
       RETURN r.type AS relType, target.id AS uid, target.name AS name, target.filePath AS filePath, labels(target)[0] AS kind
       LIMIT 30
     `, { symId });
@@ -1593,6 +1622,17 @@ export class LocalBackend {
             },
             incoming: categorize(incomingRows),
             outgoing: categorize(outgoingRows),
+            ...(typedPropertyRows.length > 0
+                ? {
+                    typed_properties: typedPropertyRows.map((r) => ({
+                        uid: r.uid || r[0],
+                        name: r.name || r[1],
+                        filePath: r.filePath || r[2],
+                        kind: r.kind || r[3],
+                        declaredType: r.declaredType || r[4],
+                    })),
+                }
+                : {}),
             processes: processRows.map((r) => ({
                 id: r.pid || r[0],
                 name: r.label || r[1],
@@ -2024,6 +2064,7 @@ export class LocalBackend {
         const maxDepth = params.maxDepth || 3;
         // Map legacy relation type names before filtering (backward compat for OVERRIDES → METHOD_OVERRIDES)
         const mappedRelTypes = params.relationTypes?.flatMap((t) => t === 'OVERRIDES' ? ['OVERRIDES', 'METHOD_OVERRIDES'] : [t]);
+        const hasExplicitRelationTypes = mappedRelTypes !== undefined && mappedRelTypes.length > 0;
         const rawRelTypes = mappedRelTypes && mappedRelTypes.length > 0
             ? mappedRelTypes.filter((t) => VALID_RELATION_TYPES.has(t))
             : [
@@ -2031,6 +2072,7 @@ export class LocalBackend {
                 'IMPORTS',
                 'EXTENDS',
                 'IMPLEMENTS',
+                'USES',
                 'METHOD_OVERRIDES',
                 'OVERRIDES',
                 'METHOD_IMPLEMENTS',
@@ -2042,6 +2084,7 @@ export class LocalBackend {
                 'IMPORTS',
                 'EXTENDS',
                 'IMPLEMENTS',
+                'USES',
                 'METHOD_OVERRIDES',
                 'OVERRIDES',
                 'METHOD_IMPLEMENTS',
@@ -2092,9 +2135,14 @@ export class LocalBackend {
             filePath: outcome.symbol.filePath,
         };
         const symType = outcome.resolvedLabel || outcome.symbol.type || '';
+        const effectiveRelationTypes = (symType === 'Class' || symType === 'Interface') &&
+            !hasExplicitRelationTypes &&
+            !relationTypes.includes('ACCESSES')
+            ? [...relationTypes, 'ACCESSES']
+            : relationTypes;
         return this._runImpactBFS(repo, sym, symType, direction, {
             maxDepth,
-            relationTypes,
+            relationTypes: effectiveRelationTypes,
             includeTests,
             minConfidence,
         });
@@ -2149,6 +2197,24 @@ export class LocalBackend {
                         frontier.push(rid);
                     }
                 }
+                const typedPropertyRows = await executeParameterized(repo.id, `
+          MATCH (p:\`Property\`)
+          WHERE p.declaredType = $name
+             OR p.declaredType STARTS WITH $genericPrefix
+             OR p.declaredType CONTAINS $genericArg
+          RETURN p.id AS id, p.name AS name, labels(p)[0] AS type, p.filePath AS filePath
+        `, {
+                    name: sym.name,
+                    genericPrefix: `${sym.name}<`,
+                    genericArg: `<${sym.name}>`,
+                });
+                for (const r of typedPropertyRows) {
+                    const rid = r.id || r[0];
+                    if (rid && !visited.has(rid)) {
+                        visited.add(rid);
+                        frontier.push(rid);
+                    }
+                }
             }
             catch (e) {
                 logQueryError('impact:class-node-expansion', e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.4-rc.97",
+  "version": "1.6.4-rc.99",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",