cgraphx 2.0.2 → 2.0.6

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

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripUeMacros = stripUeMacros;
+/**
+ * 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.
+ */
+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/code/engine/core/ingestion/csharp-namespace-gate.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * Pure predicates gating C# `using` suffix-fallback resolution so BCL usings
+ * (e.g. `System.Threading.Tasks`) can't match a coincidentally-named local
+ * file (#1881).
+ *
+ * Lives in the shared `ingestion/` layer — NOT under `languages/csharp/` — so
+ * BOTH the registry-primary scope resolver (`languages/csharp/import-target.ts`)
+ * and the legacy DAG resolver (`import-resolvers/csharp.ts`) can import it
+ * without an `import-resolvers/ -> languages/` dependency inversion (#5).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csharpSuffixFallbackAllowed = csharpSuffixFallbackAllowed;
+exports.importAlignsWithDeclaredNamespaces = importAlignsWithDeclaredNamespaces;
+/**
+ * Top-level namespace segments that clearly belong to the BCL / runtime / a
+ * ubiquitous third-party package — i.e. roots a normal repo does NOT declare.
+ * These stay gated even when the namespace scan is truncated, so a single
+ * unreadable file / capped subtree can't silently re-enable BCL→local suffix
+ * matches repo-wide (#1881). A repo that legitimately declares one of these
+ * roots is still allowed via the alignment escape hatch below.
+ */
+const CSHARP_EXTERNAL_ROOTS = new Set([
+    // .NET BCL / runtime
+    'System',
+    'Microsoft',
+    'Windows',
+    'Mono',
+    // ubiquitous third-party NuGet roots
+    'Newtonsoft',
+    'Serilog',
+    'AutoMapper',
+    'MediatR',
+    'Polly',
+    'FluentValidation',
+    'Grpc',
+    'Google',
+    'Azure',
+    'Amazon',
+    'AWSSDK',
+    // common test frameworks
+    'Xunit',
+    'NUnit',
+    'Moq',
+    'FluentAssertions',
+    'NSubstitute',
+    'Shouldly',
+]);
+/** Whether `targetRaw`'s top-level segment is a clearly-external root. */
+function isExternalRoot(targetRaw) {
+    const dot = targetRaw.indexOf('.');
+    const top = dot === -1 ? targetRaw : targetRaw.slice(0, dot);
+    return CSHARP_EXTERNAL_ROOTS.has(top);
+}
+/**
+ * Whether the unanchored suffix fallback may run for `targetRaw`.
+ *
+ * Fails OPEN when the namespace scan was truncated (large repos must not
+ * silently lose legitimate edges, #1881 #11) and when no evidence was
+ * threaded at all (preserves legacy permissive behavior). The truncation
+ * fail-open is carved out for clearly-external roots (BCL / well-known
+ * packages) that the repo does not declare, so one incomplete scan can't
+ * re-open the #1881 hole repo-wide. Otherwise defers to
+ * {@link importAlignsWithDeclaredNamespaces}.
+ */
+function csharpSuffixFallbackAllowed(targetRaw, evidence) {
+    if (evidence === undefined)
+        return true;
+    if (evidence.truncated) {
+        // Keep clearly-external roots blocked through truncation UNLESS the repo
+        // actually declares an aligning namespace (the alignment check is the
+        // escape hatch — a repo that declares `namespace System;` still resolves).
+        if (isExternalRoot(targetRaw) &&
+            !importAlignsWithDeclaredNamespaces(targetRaw, evidence.declaredNamespaces, evidence.rootNamespaces)) {
+            return false;
+        }
+        return true;
+    }
+    return importAlignsWithDeclaredNamespaces(targetRaw, evidence.declaredNamespaces, evidence.rootNamespaces);
+}
+/** True when `targetRaw` plausibly refers to a namespace declared in-repo. */
+function importAlignsWithDeclaredNamespaces(targetRaw, declaredNamespaces, rootNamespaces) {
+    if (declaredNamespaces === undefined || declaredNamespaces.size === 0)
+        return false;
+    // Exact: the import IS a declared in-repo namespace.
+    if (declaredNamespaces.has(targetRaw))
+        return true;
+    // Child-of: the import's IMMEDIATE parent namespace is declared in-repo.
+    // Anchoring on the direct parent — not "any declared prefix" — is what stops
+    // a declared BCL prefix from green-lighting an unrelated BCL using: a repo
+    // that declares `namespace System;` must NOT make `using
+    // System.Threading.Tasks;` resolve to a coincidental local `Tasks.cs`,
+    // because the import's parent `System.Threading` is not itself declared
+    // (#1881). The case this still allows is a type / `using static` import under
+    // a declared namespace laid out without its full path on disk, e.g.
+    // `using static MyApp.Utils.Logger;` when `MyApp.Utils` is declared.
+    const lastDot = targetRaw.lastIndexOf('.');
+    if (lastDot > 0 && declaredNamespaces.has(targetRaw.slice(0, lastDot)))
+        return true;
+    // Ancestor-of: the import is a strict prefix of some declared namespace
+    // (e.g. `using MyApp;` when `MyApp.Models` is declared). Only honored when
+    // the import also sits at or above an in-repo root namespace, so a BCL prefix
+    // can't qualify merely because a file declares something deeper under it
+    // (e.g. `System.Threading.Tasks.Extensions`) (#1881).
+    const childPrefix = targetRaw + '.';
+    for (const ns of declaredNamespaces) {
+        if (ns.startsWith(childPrefix)) {
+            return isAtOrAboveInRepoRoot(targetRaw, declaredNamespaces, rootNamespaces);
+        }
+    }
+    return false;
+}
+function isAtOrAboveInRepoRoot(targetRaw, declaredNamespaces, rootNamespaces) {
+    const descendantPrefix = targetRaw + '.';
+    if (rootNamespaces !== undefined && rootNamespaces.size > 0) {
+        for (const root of rootNamespaces) {
+            // targetRaw equals a root, or is an ancestor of one (e.g. `using MyApp;`
+            // for csproj RootNamespace `MyApp.Core`).
+            if (root === targetRaw || root.startsWith(descendantPrefix))
+                return true;
+        }
+        return false;
+    }
+    // No explicit roots (e.g. no csproj): treat the top-level segment of each
+    // declared namespace as the implied root.
+    for (const ns of declaredNamespaces) {
+        const dot = ns.indexOf('.');
+        const top = dot === -1 ? ns : ns.slice(0, dot);
+        if (top === targetRaw)
+            return true;
+    }
+    return false;
+}

package/dist/core/code/engine/core/ingestion/di-extractors/index.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Per-language DI resolver registry — the lookup the generic `di` pipeline
+ * phase uses to discover injection sites and provider metadata on graph nodes.
+ *
+ * Mirrors `scope-resolution/pipeline/registry.ts` (`SCOPE_RESOLVERS`): a
+ * single-valued `ReadonlyMap<SupportedLanguages, DiResolver>` consumed by
+ * a framework-neutral phase, so no language or framework names leak into
+ * shared pipeline code. Adding a framework means implementing a `DiResolver`
+ * in `di-extractors/<framework>.ts` and registering it here.
+ *
+ * The registry is single-valued per language, matching the `SCOPE_RESOLVERS`
+ * shape; widen the value type to arrays only when a second same-language
+ * framework actually lands. Java and Kotlin share Spring's attached metadata
+ * contract while retaining language-specific syntax capture.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DI_RESOLVERS = void 0;
+exports.isSupportedLanguage = isSupportedLanguage;
+const index_js_1 = require("../../../../shared/index.js");
+const spring_js_1 = require("./spring.js");
+/** All `SupportedLanguages` string values, for narrowing raw graph strings. */
+const SUPPORTED_LANGUAGE_VALUES = new Set(Object.values(index_js_1.SupportedLanguages));
+/**
+ * Type guard narrowing an arbitrary graph `language` string to
+ * `SupportedLanguages`, so `DI_RESOLVERS.get()` needs no cast.
+ */
+function isSupportedLanguage(value) {
+    return SUPPORTED_LANGUAGE_VALUES.has(value);
+}
+/** Map of `SupportedLanguages` → `DiResolver`. The `di` phase routes each
+ *  graph node here by `node.properties.language`; no entry ⇒ the node is
+ *  skipped. This is the single source of truth for which languages (and,
+ *  transitively, frameworks) produce INJECTS edges. */
+exports.DI_RESOLVERS = new Map([
+    [index_js_1.SupportedLanguages.Java, spring_js_1.springDiResolver],
+    [index_js_1.SupportedLanguages.Kotlin, spring_js_1.springDiResolver],
+]);