gitnexus 1.6.4-rc.101 → 1.6.4-rc.103

package/dist/core/ingestion/call-processor.js

@@ -612,9 +612,10 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
         await loadLanguage(language, file.path);
         let tree = astCache.get(file.path);
         if (!tree) {
+            const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(file.content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(file.content),
+                tree = parser.parse(parseContent, undefined, {
+                    bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }
             catch (parseError) {
@@ -2583,9 +2584,10 @@ export const extractFetchCallsFromFiles = async (files, astCache) => {
         await loadLanguage(language, file.path);
         let tree = astCache.get(file.path);
         if (!tree) {
+            const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(file.content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(file.content),
+                tree = parser.parse(parseContent, undefined, {
+                    bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }
             catch {

package/dist/core/ingestion/cpp-ue-preprocessor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Strip Unreal Engine reflection macros from C++ source, length-preserving.
+ *
+ * Returns the original string unchanged if no strong UE marker is detected,
+ * so non-UE C++ files (including ones that contain `*_API`-suffixed
+ * identifiers like `REST_API` or `HTTP_API`) incur only a single regex test.
+ *
+ * The `_filePath` parameter is part of the `LanguageProvider.preprocessSource`
+ * contract but is unused — UE detection is purely content-based. Accepted and
+ * ignored here so the function matches the hook signature exactly.
+ */
+export declare function stripUeMacros(source: string, _filePath?: string): string;

package/dist/core/ingestion/cpp-ue-preprocessor.js

@@ -0,0 +1,260 @@
+/**
+ * Unreal Engine reflection-macro preprocessor for C++ source.
+ *
+ * Tree-sitter does not expand C preprocessor macros, so Unreal's reflection
+ * markers (`UCLASS(...)`, `UFUNCTION(...)`, `MODULENAME_API`, ...) are parsed
+ * verbatim. The result is mis-parsed declarations: in `class BRAWLUI_API
+ * UMyClass : public UObject`, tree-sitter-cpp captures `BRAWLUI_API` as the
+ * class name and the rest of the declaration becomes structurally wrong.
+ *
+ * This module elides those macros from the source text BEFORE tree-sitter
+ * parses it. Replacement is **length-preserving** (each elided byte becomes
+ * a space, newlines preserved) so byte offsets and line/column positions
+ * tree-sitter reports remain identical to the original file. Symbol
+ * locations in the graph stay accurate.
+ *
+ * A cheap detection guard short-circuits files that don't look like UE
+ * sources, so non-UE C++ codebases pay no cost.
+ *
+ * Pure function — no tree-sitter dependency, safe for worker threads.
+ */
+/**
+ * Strong UE markers — reflection macros that only Unreal Engine projects use.
+ * Presence of one of these is sufficient evidence that the file is a UE source
+ * and that `MODULENAME_API` tokens in it are intended as export macros.
+ *
+ * Importantly, `_API` tokens are NOT in this guard — `REST_API`, `HTTP_API`,
+ * `MY_LIB_API` and similar identifiers appear in plenty of non-UE C++ codebases
+ * as constants/enums/parameter names. We must not erase them just because the
+ * file mentions an `_API` token.
+ */
+const HAS_UE_HINT = /\b(?:UCLASS|UFUNCTION|UPROPERTY|USTRUCT|UENUM|UINTERFACE|GENERATED_BODY|GENERATED_[A-Z_]+_BODY|UE_DEPRECATED|DECLARE_(?:DYNAMIC_)?(?:MULTICAST_)?DELEGATE)/;
+const SIMPLE_MACROS_NO_ARGS = [
+    'GENERATED_BODY',
+    'GENERATED_UCLASS_BODY',
+    'GENERATED_USTRUCT_BODY',
+    'GENERATED_UINTERFACE_BODY',
+    'GENERATED_IINTERFACE_BODY',
+    'DECLARE_CLASS',
+    'GENERATED_BODY_LEGACY',
+];
+const PARENTHESIZED_MACROS = [
+    'UCLASS',
+    'UFUNCTION',
+    'UPROPERTY',
+    'USTRUCT',
+    'UENUM',
+    'UINTERFACE',
+    'UMETA',
+    'UE_DEPRECATED',
+];
+const DELEGATE_MACRO_RE = /\bDECLARE_(?:DYNAMIC_)?(?:MULTICAST_)?DELEGATE(?:_(?:RetVal_OneParam|RetVal_TwoParams|RetVal_ThreeParams|RetVal_FourParams|RetVal_FiveParams|RetVal_SixParams|RetVal_SevenParams|RetVal_EightParams|RetVal_NineParams|RetVal|OneParam|TwoParams|ThreeParams|FourParams|FiveParams|SixParams|SevenParams|EightParams|NineParams|TenParams))?(?=\s*\()/g;
+/**
+ * Module export tokens like `BRAWLUI_API`, `ENGINE_API`, `COREUOBJECT_API`.
+ * Pattern: ALL_CAPS identifier ending in `_API`. The leading word boundary
+ * (`\b`) prevents matching mid-identifier.
+ */
+const API_MACRO_RE = /\b[A-Z][A-Z0-9_]*_API\b/g;
+/** Replace `[start, end)` of `chars` with spaces, preserving newlines. */
+function eraseRange(chars, start, end) {
+    for (let i = start; i < end; i++) {
+        if (chars[i] !== '\n' && chars[i] !== '\r') {
+            chars[i] = ' ';
+        }
+    }
+}
+/**
+ * Find the matching close paren for an opening paren at index `openIdx`.
+ * Returns the index of `)` (inclusive end), or -1 if unbalanced.
+ *
+ * Handles nested parens and string/char literals so commas/parens inside
+ * strings don't throw off the match. Does not attempt to handle raw string
+ * literals (`R"(...)"`); UE reflection-macro arguments do not use them in
+ * practice.
+ */
+function findMatchingParen(source, openIdx) {
+    if (source.charCodeAt(openIdx) !== 0x28)
+        return -1;
+    let depth = 1;
+    let i = openIdx + 1;
+    const len = source.length;
+    while (i < len && depth > 0) {
+        const ch = source.charCodeAt(i);
+        // String literal
+        if (ch === 0x22) {
+            i++;
+            while (i < len) {
+                const c = source.charCodeAt(i);
+                if (c === 0x5c) {
+                    i += 2;
+                    continue;
+                }
+                if (c === 0x22) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            continue;
+        }
+        // Char literal
+        if (ch === 0x27) {
+            i++;
+            while (i < len) {
+                const c = source.charCodeAt(i);
+                if (c === 0x5c) {
+                    i += 2;
+                    continue;
+                }
+                if (c === 0x27) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            continue;
+        }
+        // Line comment
+        if (ch === 0x2f && source.charCodeAt(i + 1) === 0x2f) {
+            while (i < len && source.charCodeAt(i) !== 0x0a)
+                i++;
+            continue;
+        }
+        // Block comment
+        if (ch === 0x2f && source.charCodeAt(i + 1) === 0x2a) {
+            i += 2;
+            while (i < len) {
+                if (source.charCodeAt(i) === 0x2a && source.charCodeAt(i + 1) === 0x2f) {
+                    i += 2;
+                    break;
+                }
+                i++;
+            }
+            continue;
+        }
+        if (ch === 0x28)
+            depth++;
+        else if (ch === 0x29) {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+        i++;
+    }
+    return -1;
+}
+/** Match a whole-word identifier at `idx`. Returns the byte after the identifier, or -1 on miss. */
+function matchIdentifierAt(source, idx, name) {
+    if (idx > 0) {
+        const prev = source.charCodeAt(idx - 1);
+        if ((prev >= 0x30 && prev <= 0x39) ||
+            (prev >= 0x41 && prev <= 0x5a) ||
+            (prev >= 0x61 && prev <= 0x7a) ||
+            prev === 0x5f) {
+            return -1;
+        }
+    }
+    for (let k = 0; k < name.length; k++) {
+        if (source.charCodeAt(idx + k) !== name.charCodeAt(k))
+            return -1;
+    }
+    const after = idx + name.length;
+    if (after < source.length) {
+        const next = source.charCodeAt(after);
+        if ((next >= 0x30 && next <= 0x39) ||
+            (next >= 0x41 && next <= 0x5a) ||
+            (next >= 0x61 && next <= 0x7a) ||
+            next === 0x5f) {
+            return -1;
+        }
+    }
+    return after;
+}
+/** Skip ASCII whitespace forward from `idx`. Returns the next non-whitespace byte index. */
+function skipWhitespace(source, idx) {
+    const len = source.length;
+    while (idx < len) {
+        const ch = source.charCodeAt(idx);
+        if (ch === 0x20 || ch === 0x09 || ch === 0x0a || ch === 0x0d) {
+            idx++;
+            continue;
+        }
+        break;
+    }
+    return idx;
+}
+/**
+ * Strip Unreal Engine reflection macros from C++ source, length-preserving.
+ *
+ * Returns the original string unchanged if no strong UE marker is detected,
+ * so non-UE C++ files (including ones that contain `*_API`-suffixed
+ * identifiers like `REST_API` or `HTTP_API`) incur only a single regex test.
+ *
+ * The `_filePath` parameter is part of the `LanguageProvider.preprocessSource`
+ * contract but is unused — UE detection is purely content-based. Accepted and
+ * ignored here so the function matches the hook signature exactly.
+ */
+export function stripUeMacros(source, _filePath) {
+    if (!HAS_UE_HINT.test(source))
+        return source;
+    const chars = source.split('');
+    for (const macro of PARENTHESIZED_MACROS) {
+        let searchFrom = 0;
+        while (true) {
+            const hit = source.indexOf(macro, searchFrom);
+            if (hit < 0)
+                break;
+            searchFrom = hit + 1;
+            const after = matchIdentifierAt(source, hit, macro);
+            if (after < 0)
+                continue;
+            const parenIdx = skipWhitespace(source, after);
+            if (source.charCodeAt(parenIdx) !== 0x28)
+                continue;
+            const close = findMatchingParen(source, parenIdx);
+            if (close < 0)
+                continue;
+            eraseRange(chars, hit, close + 1);
+        }
+    }
+    for (const macro of SIMPLE_MACROS_NO_ARGS) {
+        let searchFrom = 0;
+        while (true) {
+            const hit = source.indexOf(macro, searchFrom);
+            if (hit < 0)
+                break;
+            searchFrom = hit + 1;
+            const after = matchIdentifierAt(source, hit, macro);
+            if (after < 0)
+                continue;
+            const parenIdx = skipWhitespace(source, after);
+            if (source.charCodeAt(parenIdx) === 0x28) {
+                const close = findMatchingParen(source, parenIdx);
+                if (close < 0)
+                    continue;
+                eraseRange(chars, hit, close + 1);
+            }
+            else {
+                eraseRange(chars, hit, after);
+            }
+        }
+    }
+    for (const re of [DELEGATE_MACRO_RE, API_MACRO_RE]) {
+        re.lastIndex = 0;
+        let match;
+        while ((match = re.exec(source)) !== null) {
+            const start = match.index;
+            let end = start + match[0].length;
+            if (re === DELEGATE_MACRO_RE) {
+                const parenIdx = skipWhitespace(source, end);
+                if (source.charCodeAt(parenIdx) === 0x28) {
+                    const close = findMatchingParen(source, parenIdx);
+                    if (close >= 0)
+                        end = close + 1;
+                }
+            }
+            eraseRange(chars, start, end);
+        }
+    }
+    return chars.join('');
+}

package/dist/core/ingestion/heritage-processor.js

@@ -147,9 +147,13 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
         let tree = astCache.get(file.path);
         if (!tree) {
             // Use larger bufferSize for files > 32KB
+            // Per-language source preprocessor (length-preserving, e.g. UE macro
+            // stripping for C++). MUST mirror parsing-processor on cache miss so
+            // re-parses see the same input as the cached AST.
+            const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(file.content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(file.content),
+                tree = parser.parse(parseContent, undefined, {
+                    bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }
             catch (parseError) {
@@ -294,9 +298,10 @@ export async function extractExtractedHeritageFromFiles(files, astCache) {
         await loadLanguage(language, file.path);
         let tree = astCache.get(file.path);
         if (!tree) {
+            const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(file.content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(file.content),
+                tree = parser.parse(parseContent, undefined, {
+                    bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }
             catch {

package/dist/core/ingestion/import-processor.js

@@ -241,9 +241,10 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
         let tree = astCache.get(file.path);
         let wasReparsed = false;
         if (!tree) {
+            const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
             try {
-                tree = parser.parse(file.content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(file.content),
+                tree = parser.parse(parseContent, undefined, {
+                    bufferSize: getTreeSitterBufferSize(parseContent),
                 });
             }
             catch (parseError) {

package/dist/core/ingestion/language-provider.d.ts

@@ -74,6 +74,38 @@ interface LanguageProviderConfig {
     /** Tree-sitter query strings for definitions, imports, calls, heritage.
      *  Required for tree-sitter languages; empty string for standalone processors. */
     readonly treeSitterQueries: string;
+    /**
+     * Optional source-text transform that runs **before** tree-sitter parses the file.
+     *
+     * Used to elide language constructs that confuse the grammar without affecting
+     * source-position fidelity — e.g., Unreal Engine reflection macros (`UCLASS`,
+     * `UFUNCTION`, `MODULENAME_API`) in C++ headers that prevent the parser from
+     * recognising class/function names correctly.
+     *
+     * **Length / position preservation:** the returned string MUST have the same
+     * JavaScript `.length` as the input AND preserve every newline (`\n`/`\r`)
+     * position byte-for-byte. Implementations replace elided characters with
+     * ASCII spaces while leaving newlines untouched. With this contract:
+     *
+     *   - tree-sitter's reported `startPosition.row`/`startPosition.column`
+     *     match the original file exactly (line/column come from newline counts)
+     *   - `startIndex`/`endIndex` byte offsets match the original file exactly
+     *     **when the elided range is pure ASCII** (UTF-16 `.length` equals UTF-8
+     *     byte length only for ASCII).
+     *
+     * Implementations targeting languages where elided ranges may contain
+     * non-ASCII content must therefore preserve byte length, not just `.length`,
+     * if downstream code uses `startIndex` to slice the original UTF-8 bytes.
+     * The current C++ UE-macro preprocessor relies on the practical fact that
+     * UE reflection macros and module-export tokens are ASCII-only.
+     *
+     * Must be a pure function — same input always yields the same output. Called
+     * once per file, on every code path that re-parses (parsing-processor, import
+     * processor, heritage processor, call processor, parse worker).
+     *
+     * Default: undefined (no preprocessing — `file.content` is parsed verbatim).
+     */
+    readonly preprocessSource?: (sourceText: string, filePath: string) => string;
     /** Type extraction: declarations, initializers, for-loop bindings */
     readonly typeConfig: LanguageTypeConfig;
     /** Export detection: is this AST node a public/exported symbol? */

package/dist/core/ingestion/languages/c-cpp.js

@@ -36,6 +36,7 @@ import { cVariableConfig, cppVariableConfig } from '../variable-extractors/confi
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { cCallConfig, cppCallConfig } from '../call-extractors/configs/c-cpp.js';
 import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { stripUeMacros } from '../cpp-ue-preprocessor.js';
 const C_BUILT_INS = new Set([
     'printf',
     'fprintf',
@@ -380,6 +381,7 @@ export const cppProvider = defineLanguage({
         },
     ],
     treeSitterQueries: CPP_QUERIES,
+    preprocessSource: stripUeMacros,
     typeConfig: cCppConfig,
     exportChecker: cCppExportChecker,
     importResolver: createImportResolver(cppImportConfig),

package/dist/core/ingestion/parsing-processor.js

@@ -262,6 +262,10 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
             lineOffset = extracted.lineOffset;
             isVueSetup = extracted.isSetup;
         }
+        // Per-language source-text transform (e.g., UE macro stripping for C++).
+        // Length-preserving — see LanguageProvider.preprocessSource contract.
+        parseContent =
+            getProvider(language).preprocessSource?.(parseContent, file.path) ?? parseContent;
         try {
             await loadLanguage(language, file.path);
         }

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

@@ -1019,6 +1019,10 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             lineOffset = extracted.lineOffset;
             isVueSetup = extracted.isSetup;
         }
+        // Per-language source-text transform (e.g., UE macro stripping for C++).
+        // Length-preserving — see LanguageProvider.preprocessSource contract.
+        parseContent =
+            getProvider(language).preprocessSource?.(parseContent, file.path) ?? parseContent;
         clearCaches(); // Reset memoization before each new file
         let tree;
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.4-rc.101",
+  "version": "1.6.4-rc.103",
   "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",