cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/java/import-decomposer.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Decompose a Java `import_declaration` into a `CaptureMatch` carrying
+ * the synthesized markers `@import.kind` / `@import.source` /
+ * `@import.name` that `interpretJavaImport` consumes.
+ *
+ * Unlike C#'s using-directive decomposer, Java has four import forms:
+ *
+ *   import com.example.User;                     → named
+ *   import com.example.*;                         → wildcard
+ *   import static com.example.Utils.format;       → static
+ *   import static com.example.Utils.*;             → static-wildcard
+ *
+ * Each produces exactly one import. The decomposer inspects the raw
+ * source text and tree-sitter children to determine the flavor.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitImportDeclaration = splitImportDeclaration;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+function splitImportDeclaration(stmtNode) {
+    if (stmtNode.type !== 'import_declaration')
+        return null;
+    const spec = parseImportDeclaration(stmtNode);
+    if (spec === null)
+        return null;
+    return buildImportMatch(stmtNode, spec);
+}
+function parseImportDeclaration(node) {
+    // Detect `static` by checking for an anonymous `static` token child.
+    let isStatic = false;
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child !== null && child.type === 'static') {
+            isStatic = true;
+            break;
+        }
+    }
+    // Detect wildcard by checking for `asterisk` named child.
+    let isWildcard = false;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child !== null && child.type === 'asterisk') {
+            isWildcard = true;
+            break;
+        }
+    }
+    // Find the scoped_identifier (or identifier for single-segment imports).
+    let pathNode = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child !== null && (child.type === 'scoped_identifier' || child.type === 'identifier')) {
+            pathNode = child;
+            break;
+        }
+    }
+    if (pathNode === null)
+        return null;
+    const fullPath = pathNode.text;
+    if (fullPath === '')
+        return null;
+    if (isStatic && isWildcard) {
+        // `import static com.example.Utils.*;`
+        return { kind: 'static-wildcard', source: fullPath, name: '*', atNode: node };
+    }
+    if (isStatic) {
+        // `import static com.example.Utils.format;`
+        const lastDot = fullPath.lastIndexOf('.');
+        const name = lastDot >= 0 ? fullPath.slice(lastDot + 1) : fullPath;
+        return { kind: 'static', source: fullPath, name, atNode: node };
+    }
+    if (isWildcard) {
+        // `import com.example.*;`
+        return { kind: 'wildcard', source: fullPath, name: '*', atNode: node };
+    }
+    // `import com.example.User;`
+    const lastDot = fullPath.lastIndexOf('.');
+    const name = lastDot >= 0 ? fullPath.slice(lastDot + 1) : fullPath;
+    return { kind: 'named', source: fullPath, name, atNode: node };
+}
+function buildImportMatch(stmtNode, spec) {
+    const m = {
+        '@import.statement': (0, ast_helpers_js_1.nodeToCapture)('@import.statement', stmtNode),
+        '@import.kind': (0, ast_helpers_js_1.syntheticCapture)('@import.kind', spec.atNode, spec.kind),
+        '@import.source': (0, ast_helpers_js_1.syntheticCapture)('@import.source', spec.atNode, spec.source),
+        '@import.name': (0, ast_helpers_js_1.syntheticCapture)('@import.name', spec.atNode, spec.name),
+    };
+    return m;
+}

package/dist/core/code/engine/core/ingestion/languages/java/import-target.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Adapter from `(ParsedImport, WorkspaceIndex)` → concrete file path.
+ *
+ * Converts Java package paths (dots → slashes) and tries:
+ *   1. Exact file match: `com/example/User.java`
+ *   2. Suffix match for nested layouts
+ *   3. Directory match (wildcard imports)
+ *   4. Progressive prefix stripping for non-standard layouts
+ *
+ * Returns `null` for unresolvable / JDK imports.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveJavaImportTarget = resolveJavaImportTarget;
+function resolveJavaImportTarget(parsedImport, workspaceIndex) {
+    const ctx = workspaceIndex;
+    if (ctx === undefined ||
+        typeof ctx.fromFile !== 'string' ||
+        !(ctx.allFilePaths instanceof Set)) {
+        return null;
+    }
+    if (parsedImport.kind === 'dynamic-unresolved')
+        return null;
+    if (parsedImport.targetRaw === null || parsedImport.targetRaw === '')
+        return null;
+    // Strip trailing `.*` for wildcard imports: `com.example.*` → `com.example`
+    let target = parsedImport.targetRaw;
+    if (target.endsWith('.*')) {
+        target = target.slice(0, -2);
+    }
+    // Package path: `com.example.User` → `com/example/User`
+    const pathLike = target.replace(/\./g, '/');
+    const suffix = `/${pathLike}`;
+    let exactFile = null;
+    let suffixFile = null;
+    let directoryChild = null;
+    const dirPrefix = `${pathLike}/`;
+    const suffixDirPrefix = `/${dirPrefix}`;
+    for (const raw of ctx.allFilePaths) {
+        const f = raw.replace(/\\/g, '/');
+        if (!f.endsWith('.java'))
+            continue;
+        if (f === `${pathLike}.java`) {
+            exactFile = raw;
+            break;
+        }
+        if (suffixFile === null && f.endsWith(`${suffix}.java`)) {
+            suffixFile = raw;
+        }
+        if (directoryChild === null) {
+            const atRoot = f.startsWith(dirPrefix);
+            const atNested = f.includes(suffixDirPrefix);
+            if (atRoot || atNested) {
+                const idx = atRoot ? 0 : f.indexOf(suffixDirPrefix) + 1;
+                const after = f.slice(idx + dirPrefix.length);
+                if (after.length > 0 && !after.includes('/')) {
+                    directoryChild = raw;
+                }
+            }
+        }
+    }
+    if (exactFile !== null)
+        return exactFile;
+    if (suffixFile !== null)
+        return suffixFile;
+    if (directoryChild !== null)
+        return directoryChild;
+    // Progressive prefix stripping — handles `import com.example.User;`
+    // in a repo laid out `User.java` (no `com/example/` prefix).
+    const segments = pathLike.split('/').filter(Boolean);
+    for (let skip = 1; skip < segments.length; skip++) {
+        const tail = segments.slice(skip).join('/');
+        if (tail === '')
+            continue;
+        const tailFile = `${tail}.java`;
+        const tailSuffix = `/${tailFile}`;
+        const tailDir = `${tail}/`;
+        const tailSuffixDir = `/${tailDir}`;
+        let tailDirectChild = null;
+        for (const raw of ctx.allFilePaths) {
+            const f = raw.replace(/\\/g, '/');
+            if (!f.endsWith('.java'))
+                continue;
+            if (f === tailFile)
+                return raw;
+            if (f.endsWith(tailSuffix))
+                return raw;
+            if (tailDirectChild === null) {
+                const atRoot = f.startsWith(tailDir);
+                const atNested = f.includes(tailSuffixDir);
+                if (atRoot || atNested) {
+                    const idx = atRoot ? 0 : f.indexOf(tailSuffixDir) + 1;
+                    const after = f.slice(idx + tailDir.length);
+                    if (after.length > 0 && !after.includes('/'))
+                        tailDirectChild = raw;
+                }
+            }
+        }
+        if (tailDirectChild !== null)
+            return tailDirectChild;
+    }
+    return null;
+}

package/dist/core/code/engine/core/ingestion/languages/java/index.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Java scope-resolution hooks (RFC #909 Ring 3).
+ *
+ * Public API barrel. Consumers should import from this file rather than
+ * the individual modules.
+ *
+ * Module layout:
+ *
+ *   - `query.ts`               — tree-sitter query + lazy parser/query singletons
+ *   - `captures.ts`            — `emitJavaScopeCaptures` orchestrator
+ *   - `import-decomposer.ts`   — each `import` → ParsedImport-shaped captures
+ *   - `interpret.ts`           — capture-match → `ParsedImport` / `ParsedTypeBinding`
+ *   - `simple-hooks.ts`        — small hooks made explicit
+ *   - `receiver-binding.ts`    — synthesize `this`/`super` type-bindings on
+ *                                instance-method entry
+ *   - `merge-bindings.ts`      — Java import precedence
+ *   - `arity.ts`               — Java arity compatibility (varargs)
+ *   - `arity-metadata.ts`      — synthesize arity metadata from declarations
+ *   - `import-target.ts`       — `(ParsedImport, WorkspaceIndex) → file path` adapter
+ *   - `scope-resolver.ts`      — `ScopeResolver` registered in `SCOPE_RESOLVERS`
+ *   - `cache-stats.ts`         — PROF_SCOPE_RESOLUTION cache hit/miss counters
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javaReceiverBinding = exports.javaImportOwningScope = exports.javaBindingScopeFor = exports.resolveJavaImportTarget = exports.javaArityCompatibility = exports.javaMergeBindings = exports.interpretJavaTypeBinding = exports.interpretJavaImport = exports.resetJavaCaptureCacheStats = exports.getJavaCaptureCacheStats = exports.emitJavaScopeCaptures = void 0;
+var captures_js_1 = require("./captures.js");
+Object.defineProperty(exports, "emitJavaScopeCaptures", { enumerable: true, get: function () { return captures_js_1.emitJavaScopeCaptures; } });
+var cache_stats_js_1 = require("./cache-stats.js");
+Object.defineProperty(exports, "getJavaCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.getJavaCaptureCacheStats; } });
+Object.defineProperty(exports, "resetJavaCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.resetJavaCaptureCacheStats; } });
+var interpret_js_1 = require("./interpret.js");
+Object.defineProperty(exports, "interpretJavaImport", { enumerable: true, get: function () { return interpret_js_1.interpretJavaImport; } });
+Object.defineProperty(exports, "interpretJavaTypeBinding", { enumerable: true, get: function () { return interpret_js_1.interpretJavaTypeBinding; } });
+var merge_bindings_js_1 = require("./merge-bindings.js");
+Object.defineProperty(exports, "javaMergeBindings", { enumerable: true, get: function () { return merge_bindings_js_1.javaMergeBindings; } });
+var arity_js_1 = require("./arity.js");
+Object.defineProperty(exports, "javaArityCompatibility", { enumerable: true, get: function () { return arity_js_1.javaArityCompatibility; } });
+var import_target_js_1 = require("./import-target.js");
+Object.defineProperty(exports, "resolveJavaImportTarget", { enumerable: true, get: function () { return import_target_js_1.resolveJavaImportTarget; } });
+var simple_hooks_js_1 = require("./simple-hooks.js");
+Object.defineProperty(exports, "javaBindingScopeFor", { enumerable: true, get: function () { return simple_hooks_js_1.javaBindingScopeFor; } });
+Object.defineProperty(exports, "javaImportOwningScope", { enumerable: true, get: function () { return simple_hooks_js_1.javaImportOwningScope; } });
+Object.defineProperty(exports, "javaReceiverBinding", { enumerable: true, get: function () { return simple_hooks_js_1.javaReceiverBinding; } });

package/dist/core/code/engine/core/ingestion/languages/java/interpret.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Capture-match → semantic-shape interpreters for Java.
+ *
+ *   - `interpretJavaImport`       → `ParsedImport`
+ *   - `interpretJavaTypeBinding`  → `ParsedTypeBinding`
+ *
+ * Import matches arrive pre-decomposed by `emitJavaScopeCaptures`
+ * (one import per match, with synthesized `@import.kind/source/name`
+ * markers). Type-binding matches arrive from the raw query captures.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpretJavaImport = interpretJavaImport;
+exports.interpretJavaTypeBinding = interpretJavaTypeBinding;
+// ─── interpretImport ──────────────────────────────────────────────────────
+function interpretJavaImport(captures) {
+    const kindCap = captures['@import.kind'];
+    const sourceCap = captures['@import.source'];
+    const nameCap = captures['@import.name'];
+    const kind = kindCap?.text;
+    if (kind === undefined || sourceCap === undefined)
+        return null;
+    switch (kind) {
+        case 'named': {
+            // `import com.example.User;`
+            const simpleName = sourceCap.text.split('.').pop() ?? sourceCap.text;
+            return {
+                kind: 'named',
+                localName: nameCap?.text ?? simpleName,
+                importedName: simpleName,
+                targetRaw: sourceCap.text,
+                targetIncludesImportedName: true,
+            };
+        }
+        case 'wildcard': {
+            // `import com.example.*;`
+            return {
+                kind: 'wildcard',
+                targetRaw: sourceCap.text + '.*',
+            };
+        }
+        case 'static': {
+            // `import static com.example.Utils.format;`
+            const fullSource = sourceCap.text;
+            const lastDot = fullSource.lastIndexOf('.');
+            const memberName = lastDot >= 0 ? fullSource.slice(lastDot + 1) : fullSource;
+            const classPath = lastDot >= 0 ? fullSource.slice(0, lastDot) : fullSource;
+            return {
+                kind: 'named',
+                localName: nameCap?.text ?? memberName,
+                importedName: memberName,
+                targetRaw: classPath,
+            };
+        }
+        case 'static-wildcard': {
+            // `import static com.example.Utils.*;`
+            // The source is the class path (e.g. `com.example.Utils`).
+            // Resolution should target the class file, not a wildcard directory
+            // scan — `Utils.java` is the file that contains the static members.
+            return {
+                kind: 'wildcard',
+                targetRaw: sourceCap.text + '.*',
+            };
+        }
+        default:
+            return null;
+    }
+}
+// ─── interpretTypeBinding ─────────────────────────────────────────────────
+function interpretJavaTypeBinding(captures) {
+    const nameCap = captures['@type-binding.name'];
+    const typeCap = captures['@type-binding.type'];
+    if (nameCap === undefined || typeCap === undefined)
+        return null;
+    // Strip generics BEFORE the qualifier (F41 #1928). Stripping the qualifier
+    // first uses `lastIndexOf('.')`, which for a qualified *type argument*
+    // (`Map<String, com.example.User>`) cuts inside the generic and yields a
+    // corrupted `User>`. Unwrapping generics first reduces the string to a single
+    // (possibly qualified) class name, then the qualifier strip leaves the bare
+    // simple name. `stripGeneric`'s erasure fallback is qualifier-tolerant so a
+    // qualified generic base (`com.example.BaseModel<T>`) still reduces correctly.
+    const rawType = stripQualifier(stripGeneric(typeCap.text.trim()));
+    // Skip `var` — tree-sitter-java parses `var` as type_identifier with
+    // text "var". When used without a constructor initializer, there's no
+    // concrete type to bind.
+    if (rawType === 'var')
+        return null;
+    let source = 'parameter-annotation';
+    if (captures['@type-binding.self'] !== undefined)
+        source = 'self';
+    else if (captures['@type-binding.constructor'] !== undefined)
+        source = 'constructor-inferred';
+    else if (captures['@type-binding.pattern'] !== undefined)
+        source = 'annotation';
+    else if (captures['@type-binding.call-result'] !== undefined)
+        source = 'annotation';
+    else if (captures['@type-binding.alias'] !== undefined)
+        source = 'annotation';
+    else if (captures['@type-binding.annotation'] !== undefined)
+        source = 'annotation';
+    else if (captures['@type-binding.return'] !== undefined)
+        source = 'return-annotation';
+    return { boundName: nameCap.text, rawTypeName: rawType, source };
+}
+/**
+ * Unwrap generic type parameters from Java types.
+ *
+ * Three tiers, checked in order:
+ *   1. Known single-arg collection wrappers → extract the element type
+ *      (`List<User>` → `User`, `Optional<User>` → `User`).
+ *   2. Known two-arg map/container types → extract the value type
+ *      (`Map<String, User>` → `User`).
+ *   3. **Fallback (JVM type erasure):** any other generic type →
+ *      strip the generic parameters and keep the raw class name
+ *      (`BaseModel<T>` → `BaseModel`, `CustomList<Foo>` → `CustomList`).
+ *      This ensures receiver bindings (`this`/`super`) on classes with
+ *      generic superclasses resolve to the correct class file.
+ */
+function stripGeneric(text) {
+    // Single-type-argument containers — extract the element type.
+    const single = text.match(/^(?:[A-Za-z_][A-Za-z0-9_.]*\.)?(?:List|ArrayList|LinkedList|Set|HashSet|TreeSet|SortedSet|LinkedHashSet|Collection|Iterable|Iterator|Optional|Stream|CompletableFuture|Future|Queue|Deque|ArrayDeque|PriorityQueue|Vector|Stack|Supplier|Consumer|Predicate|Function)<([^,<>]+)>$/);
+    if (single !== null)
+        return single[1].trim();
+    // Two-type-argument map/container types — extract the value type (second arg).
+    const twoArg = text.match(/^(?:[A-Za-z_][A-Za-z0-9_.]*\.)?(?:Map|HashMap|TreeMap|LinkedHashMap|ConcurrentHashMap|ConcurrentMap|SortedMap|NavigableMap|Hashtable|EnumMap|WeakHashMap|IdentityHashMap|BiFunction|BiConsumer|BiPredicate|Pair|Entry)<[^,<>]+,\s*([^,<>]+)>$/);
+    if (twoArg !== null)
+        return twoArg[1].trim();
+    // Fallback: strip generic parameters from any unrecognized generic type.
+    // `BaseModel<T>` → `BaseModel`, `Builder<Self>` → `Builder`.
+    // This mirrors JVM type erasure — the raw class name is the resolvable symbol.
+    // The pattern matches up to the first `<` to handle nested generics safely
+    // (e.g. `BaseModel<List<String>>` → `BaseModel`). The base is allowed to be
+    // qualified (`com.example.BaseModel<T>` → `com.example.BaseModel`) since the
+    // caller strips the qualifier afterwards (F41 #1928).
+    const fallback = text.match(/^((?:[A-Za-z_$][A-Za-z0-9_$]*\.)*[A-Za-z_$][A-Za-z0-9_$]*)<.+>$/s);
+    if (fallback !== null)
+        return fallback[1].trim();
+    return text;
+}
+/** `com.example.User` → `User`. */
+function stripQualifier(text) {
+    const lastDot = text.lastIndexOf('.');
+    if (lastDot === -1)
+        return text;
+    return text.slice(lastDot + 1);
+}

package/dist/core/code/engine/core/ingestion/languages/java/merge-bindings.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Java shadowing precedence for the `mergeBindings` hook.
+ *
+ * Tier ranking (lower wins):
+ *   - 0: `local` — class member, method, local variable, parameter
+ *   - 1: `import` / `namespace` / `reexport` — explicit imports
+ *   - 2: `wildcard` — wildcard imports (`import x.y.*`)
+ *
+ * Within a surviving tier: de-dup by DefId, last-write-wins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javaMergeBindings = javaMergeBindings;
+const TIER_LOCAL = 0;
+const TIER_IMPORT = 1;
+const TIER_WILDCARD = 2;
+const TIER_UNKNOWN = 3;
+function tierOf(b) {
+    switch (b.origin) {
+        case 'local':
+            return TIER_LOCAL;
+        case 'reexport':
+        case 'import':
+        case 'namespace':
+            return TIER_IMPORT;
+        case 'wildcard':
+            return TIER_WILDCARD;
+        default:
+            return TIER_UNKNOWN;
+    }
+}
+function javaMergeBindings(bindings) {
+    if (bindings.length === 0)
+        return bindings;
+    let bestTier = Number.POSITIVE_INFINITY;
+    for (const b of bindings)
+        bestTier = Math.min(bestTier, tierOf(b));
+    const survivors = bindings.filter((b) => tierOf(b) === bestTier);
+    const seen = new Map();
+    for (const b of survivors)
+        seen.set(b.def.nodeId, b);
+    return [...seen.values()];
+}

package/dist/core/code/engine/core/ingestion/languages/java/package-facts.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJavaPackageFact = exports.setJavaPackageFact = exports.captureJavaPackageFact = exports.clearJavaPackageFacts = void 0;
+const package_facts_js_1 = require("../jvm/package-facts.js");
+const javaPackageFacts = (0, package_facts_js_1.createJvmPackageFactStore)({
+    packageNodeType: 'package_declaration',
+    packageNameNodeTypes: ['scoped_identifier', 'identifier'],
+});
+const clearJavaPackageFacts = () => javaPackageFacts.clear();
+exports.clearJavaPackageFacts = clearJavaPackageFacts;
+const captureJavaPackageFact = (filePath, root) => javaPackageFacts.capture(filePath, root);
+exports.captureJavaPackageFact = captureJavaPackageFact;
+const setJavaPackageFact = (filePath, fact) => javaPackageFacts.set(filePath, fact);
+exports.setJavaPackageFact = setJavaPackageFact;
+const getJavaPackageFact = (filePath) => javaPackageFacts.get(filePath);
+exports.getJavaPackageFact = getJavaPackageFact;

package/dist/core/code/engine/core/ingestion/languages/java/package-siblings.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJavaPackageSiblingVisibilityIncomplete = exports.populateJavaPackageSiblings = void 0;
+const package_siblings_js_1 = require("../jvm/package-siblings.js");
+const package_facts_js_1 = require("./package-facts.js");
+const javaPackageSiblingVisibility = (0, package_siblings_js_1.createJvmPackageSiblingVisibility)({
+    languageLabel: 'java',
+    getPackageFact: package_facts_js_1.getJavaPackageFact,
+});
+exports.populateJavaPackageSiblings = javaPackageSiblingVisibility.populateNamespaceSiblings;
+exports.isJavaPackageSiblingVisibilityIncomplete = javaPackageSiblingVisibility.isVisibilityIncomplete;