cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/go/type-binding.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeGoTypeBindings = synthesizeGoTypeBindings;
+exports.extractSimpleTypeNameText = extractSimpleTypeNameText;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const COMPOSITE_LITERAL_TYPE_NODE_TYPES = new Set([
+    'type_identifier',
+    'qualified_type',
+    'generic_type',
+]);
+function synthesizeGoTypeBindings(rootNode) {
+    const out = [];
+    for (const node of rootNode.descendantsOfType('var_spec')) {
+        const name = node.childForFieldName('name');
+        const value = node.childForFieldName('value');
+        if (name?.type !== 'identifier' || value === null)
+            continue;
+        const rhsExpr = value.namedChildren[0];
+        if (rhsExpr === undefined)
+            continue;
+        const typeNode = extractCompositeLiteralTypeNode(rhsExpr);
+        if (typeNode === null)
+            continue;
+        out.push({
+            '@type-binding.constructor': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.constructor', node, node.text),
+            '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', name, name.text),
+            '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', typeNode, extractSimpleTypeNameText(typeNode)),
+        });
+    }
+    for (const node of rootNode.descendantsOfType('short_var_declaration')) {
+        const right = node.childForFieldName('right');
+        if (right === null)
+            continue;
+        const lhs = node.childForFieldName('left');
+        if (lhs === null)
+            continue;
+        // Multi-assignment: pair LHS identifiers positionally with RHS
+        // expressions. The tree-sitter query produces all LHS/RHS
+        // combinations; emit only the positions whose RHS carries an
+        // inferable type.
+        const lhsIds = lhs.namedChildren.filter((c) => c.type === 'identifier');
+        const rhsExprs = right.namedChildren;
+        if (lhsIds.length >= 2 && rhsExprs.length >= 2) {
+            for (let i = 0; i < Math.min(lhsIds.length, rhsExprs.length); i++) {
+                const lhsId = lhsIds[i];
+                const rhsExpr = rhsExprs[i];
+                const typeNode = extractTypeNode(rhsExpr);
+                if (typeNode === null)
+                    continue;
+                const typeName = extractSimpleTypeNameText(typeNode);
+                out.push({
+                    '@type-binding.multi-assign': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.multi-assign', node, lhsId.text),
+                    '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', lhsId, lhsId.text),
+                    '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', typeNode ?? rhsExpr, typeName),
+                });
+            }
+            continue; // synthesized matches replace tree-sitter combinations
+        }
+        // Walk the expression_list for call_expression function == "new" or "make"
+        for (let i = 0; i < right.namedChildCount; i++) {
+            const expr = right.namedChild(i);
+            if (expr?.type === 'call_expression') {
+                const fn = expr.childForFieldName('function');
+                const args = expr.childForFieldName('arguments');
+                if (fn?.type === 'identifier' && fn.text === 'new' && args !== null) {
+                    const typeArg = args.namedChildren.find((c) => ['type_identifier', 'qualified_type'].includes(c.type));
+                    if (typeArg !== undefined) {
+                        const typeName = extractSimpleTypeNameText(typeArg);
+                        const nameNodes = lhs.namedChildren.filter((c) => c.type === 'identifier');
+                        if (nameNodes.length > 0) {
+                            out.push({
+                                '@type-binding.new': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.new', node, 'new'),
+                                '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', nameNodes[0], nameNodes[0].text),
+                                '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', typeArg, typeName),
+                            });
+                        }
+                    }
+                }
+                if (fn?.type === 'identifier' && fn.text === 'make' && args !== null) {
+                    const sliceOrMap = args.namedChildren.find((c) => 
+                    // V1: channel_type not handled — make(chan T) produces no typeBinding.
+                    ['slice_type', 'map_type'].includes(c.type));
+                    if (sliceOrMap !== undefined) {
+                        let typeName = '';
+                        if (sliceOrMap.type === 'slice_type') {
+                            const elem = sliceOrMap.namedChildren.find((c) => ['type_identifier', 'qualified_type'].includes(c.type));
+                            if (elem !== undefined)
+                                typeName = extractSimpleTypeNameText(elem);
+                        }
+                        else if (sliceOrMap.type === 'map_type') {
+                            const typeChildren = sliceOrMap.namedChildren.filter((c) => ['type_identifier', 'qualified_type'].includes(c.type));
+                            const valueType = typeChildren[1] ?? typeChildren[0];
+                            if (valueType !== undefined)
+                                typeName = extractSimpleTypeNameText(valueType);
+                        }
+                        if (typeName !== '') {
+                            const nameNodes = lhs.namedChildren.filter((c) => c.type === 'identifier');
+                            if (nameNodes.length > 0) {
+                                out.push({
+                                    '@type-binding.make': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.make', node, 'make'),
+                                    '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', nameNodes[0], nameNodes[0].text),
+                                    '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', sliceOrMap, typeName),
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Synthesize typeBindings for for-range loop variables and index
+    // expressions (sl[0], m["key"]) so member calls on them resolve.
+    synthesizeElementAccessBindings(rootNode, out);
+    return out;
+}
+function synthesizeElementAccessBindings(rootNode, out) {
+    // Build a map of variable → element type from make/new/range.
+    const varElementType = new Map();
+    for (const node of rootNode.descendantsOfType('short_var_declaration')) {
+        const right = node.childForFieldName('right');
+        const lhs = node.childForFieldName('left');
+        if (right === null || lhs === null)
+            continue;
+        const lhsIds = lhs.namedChildren.filter((c) => c.type === 'identifier');
+        if (lhsIds.length === 0)
+            continue;
+        for (const expr of right.namedChildren) {
+            let typeName;
+            if (expr.type === 'call_expression') {
+                const fn = expr.childForFieldName('function');
+                if (fn?.type === 'identifier' && (fn.text === 'make' || fn.text === 'new')) {
+                    const args = expr.childForFieldName('arguments');
+                    const typeNode = args?.namedChildren.find((c) => ['type_identifier', 'qualified_type', 'slice_type', 'map_type'].includes(c.type));
+                    if (typeNode) {
+                        if (typeNode.type === 'slice_type') {
+                            const elem = typeNode.namedChildren.find((c) => ['type_identifier', 'qualified_type'].includes(c.type));
+                            if (elem)
+                                typeName = extractSimpleTypeNameText(elem);
+                        }
+                        else if (typeNode.type === 'map_type') {
+                            const tc = typeNode.namedChildren.filter((c) => ['type_identifier', 'qualified_type'].includes(c.type));
+                            typeName = tc[1]
+                                ? extractSimpleTypeNameText(tc[1])
+                                : tc[0]
+                                    ? extractSimpleTypeNameText(tc[0])
+                                    : undefined;
+                        }
+                        else {
+                            typeName = extractSimpleTypeNameText(typeNode);
+                        }
+                    }
+                }
+            }
+            if (typeName !== undefined && lhsIds.length > 0) {
+                varElementType.set(lhsIds[0].text, typeName);
+            }
+        }
+    }
+    // Handle for-range: for _, user := range GetUsers() / range slice / range map
+    for (const rangeClause of rootNode.descendantsOfType('range_clause')) {
+        const right = rangeClause.childForFieldName('right');
+        if (right === null || right.namedChildren.length === 0)
+            continue;
+        const left = rangeClause.childForFieldName('left');
+        if (left === null)
+            continue;
+        // The right side IS the range expression (call_expression, identifier, etc.)
+        const rangeExpr = right;
+        let elemType;
+        // Call expression: range GetUsers()
+        if (rangeExpr.type === 'call_expression') {
+            const fn = rangeExpr.childForFieldName('function');
+            if (fn !== null) {
+                elemType = fn.text;
+            }
+        }
+        // Identifier: range userMap / range users
+        if (rangeExpr.type === 'identifier' || rangeExpr.type === 'selector_expression') {
+            const existing = varElementType.get(rangeExpr.text);
+            if (existing !== undefined)
+                elemType = existing;
+        }
+        if (elemType === undefined)
+            continue;
+        // Capture the loop variable (skip blank_identifier like _)
+        for (const child of left.namedChildren) {
+            if (child.type === 'identifier') {
+                // Create a typeBinding: loopVar → elemType
+                out.push({
+                    '@type-binding.range': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.range', rangeClause, child.text),
+                    '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', child, child.text),
+                    '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', rangeExpr, elemType),
+                });
+            }
+        }
+    }
+    // Handle index expressions: sl[0], m["key"]
+    for (const node of rootNode.descendantsOfType('call_expression')) {
+        const fn = node.childForFieldName('function');
+        if (fn?.type !== 'selector_expression')
+            continue;
+        const operand = fn.childForFieldName('operand');
+        if (operand === null)
+            continue;
+        if (operand.type === 'index_expression') {
+            const base = operand.childForFieldName('operand');
+            if (base?.type === 'identifier' && varElementType.has(base.text)) {
+                const elemType = varElementType.get(base.text);
+                out.push({
+                    '@type-binding.index': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.index', node, operand.text),
+                    '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', operand, operand.text),
+                    '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', operand, elemType),
+                });
+            }
+        }
+    }
+}
+function extractSimpleTypeNameText(node) {
+    if (node.type === 'qualified_type') {
+        const parts = node.text.split('.');
+        return parts[parts.length - 1] ?? node.text;
+    }
+    if (node.type === 'generic_type') {
+        const base = node.childForFieldName('type');
+        return base === null ? node.text : extractSimpleTypeNameText(base);
+    }
+    return node.text;
+}
+/** Extract the type/signature node from a RHS expression. */
+function extractCompositeLiteralTypeNode(expr) {
+    if (expr.type === 'composite_literal') {
+        return (expr.childForFieldName('type') ??
+            expr.namedChildren.find((c) => COMPOSITE_LITERAL_TYPE_NODE_TYPES.has(c.type)) ??
+            null);
+    }
+    if (expr.type === 'unary_expression') {
+        const operand = expr.childForFieldName('operand');
+        return operand === null ? null : extractCompositeLiteralTypeNode(operand);
+    }
+    return null;
+}
+function extractTypeNode(expr) {
+    if (expr.type === 'composite_literal') {
+        return (expr.childForFieldName('type') ??
+            expr.namedChildren.find((c) => COMPOSITE_LITERAL_TYPE_NODE_TYPES.has(c.type)) ??
+            null);
+    }
+    if (expr.type === 'unary_expression') {
+        const operand = expr.childForFieldName('operand');
+        return operand === null ? null : extractTypeNode(operand);
+    }
+    if (expr.type === 'call_expression') {
+        const fn = expr.childForFieldName('function');
+        if (fn?.type === 'identifier' && fn.text === 'new') {
+            const args = expr.childForFieldName('arguments');
+            return (args?.namedChildren.find((c) => ['type_identifier', 'qualified_type', 'pointer_type'].includes(c.type)) ?? null);
+        }
+        if (fn?.type === 'identifier' && fn.text === 'make') {
+            const args = expr.childForFieldName('arguments');
+            const container = args?.namedChildren.find((c) => ['slice_type', 'map_type'].includes(c.type));
+            if (container?.type === 'slice_type') {
+                return (container.namedChildren.find((c) => ['type_identifier', 'qualified_type'].includes(c.type)) ?? null);
+            }
+            if (container?.type === 'map_type') {
+                const typeChildren = container.namedChildren.filter((c) => ['type_identifier', 'qualified_type'].includes(c.type));
+                return typeChildren[1] ?? typeChildren[0] ?? null;
+            }
+        }
+        if (fn?.type === 'identifier')
+            return fn;
+        if (fn?.type === 'selector_expression') {
+            return fn.childForFieldName('field') ?? fn;
+        }
+    }
+    if (expr.type === 'type_assertion_expression') {
+        return expr.childForFieldName('type');
+    }
+    return null;
+}

package/dist/core/code/engine/core/ingestion/languages/go.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Go Language Provider
+ *
+ * Assembles all Go-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Go traits:
+ *   - callRouter: present (Go method calls may need routing)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goProvider = void 0;
+const index_js_1 = require("../../../../shared/index.js");
+const generic_js_1 = require("../class-extractors/generic.js");
+const go_js_1 = require("../class-extractors/configs/go.js");
+const ast_helpers_js_1 = require("../utils/ast-helpers.js");
+const go_js_2 = require("../cfg/visitors/go.js");
+const language_provider_js_1 = require("../language-provider.js");
+const go_js_3 = require("../type-extractors/go.js");
+const export_detection_js_1 = require("../export-detection.js");
+const resolver_factory_js_1 = require("../import-resolvers/resolver-factory.js");
+const go_js_4 = require("../import-resolvers/configs/go.js");
+const tree_sitter_queries_js_1 = require("../tree-sitter-queries.js");
+const generic_js_2 = require("../field-extractors/generic.js");
+const go_js_5 = require("../field-extractors/configs/go.js");
+const generic_js_3 = require("../method-extractors/generic.js");
+const go_js_6 = require("../method-extractors/configs/go.js");
+const generic_js_4 = require("../variable-extractors/generic.js");
+const go_js_7 = require("../variable-extractors/configs/go.js");
+const generic_js_5 = require("../call-extractors/generic.js");
+const go_js_8 = require("../call-extractors/configs/go.js");
+const index_js_2 = require("./go/index.js");
+const GO_BUILT_INS = new Set([
+    // built-in functions
+    'make',
+    'new',
+    'len',
+    'cap',
+    'append',
+    'copy',
+    'delete',
+    'close',
+    'panic',
+    'recover',
+    'print',
+    'println',
+    'complex',
+    'real',
+    'imag',
+    'clear',
+    'min',
+    'max',
+    // built-in types
+    'error',
+    'bool',
+    'string',
+    'int',
+    'int8',
+    'int16',
+    'int32',
+    'int64',
+    'uint',
+    'uint8',
+    'uint16',
+    'uint32',
+    'uint64',
+    'uintptr',
+    'float32',
+    'float64',
+    'complex64',
+    'complex128',
+    'byte',
+    'rune',
+    'any',
+    'comparable',
+    // built-in values
+    'true',
+    'false',
+    'nil',
+    'iota',
+]);
+exports.goProvider = (0, language_provider_js_1.defineLanguage)({
+    id: index_js_1.SupportedLanguages.Go,
+    extensions: ['.go'],
+    entryPointPatterns: [/Handler$/, /^Serve/, /^New[A-Z]/, /^Make[A-Z]/],
+    astFrameworkPatterns: [
+        {
+            framework: 'go-http',
+            entryPointMultiplier: 2.5,
+            reason: 'go-http-handler',
+            patterns: [
+                'http.Handler',
+                'http.HandlerFunc',
+                'ServeHTTP',
+                'http.ResponseWriter',
+                'http.Request',
+            ],
+        },
+        {
+            framework: 'gin',
+            entryPointMultiplier: 3.0,
+            reason: 'gin-handler',
+            patterns: ['gin.Context', 'gin.Default', 'gin.New'],
+        },
+        {
+            framework: 'echo',
+            entryPointMultiplier: 3.0,
+            reason: 'echo-handler',
+            patterns: ['echo.Context', 'echo.New'],
+        },
+        {
+            framework: 'fiber',
+            entryPointMultiplier: 3.0,
+            reason: 'fiber-handler',
+            patterns: ['fiber.Ctx', 'fiber.New', 'fiber.App'],
+        },
+        {
+            framework: 'go-grpc',
+            entryPointMultiplier: 2.8,
+            reason: 'grpc-service',
+            patterns: ['grpc.Server', 'RegisterServer', 'pb.Unimplemented'],
+        },
+    ],
+    treeSitterQueries: tree_sitter_queries_js_1.GO_QUERIES,
+    typeConfig: go_js_3.typeConfig,
+    exportChecker: export_detection_js_1.goExportChecker,
+    importResolver: (0, resolver_factory_js_1.createImportResolver)(go_js_4.goImportConfig),
+    callExtractor: (0, generic_js_5.createCallExtractor)(go_js_8.goCallConfig),
+    fieldExtractor: (0, generic_js_2.createFieldExtractor)(go_js_5.goConfig),
+    methodExtractor: (0, generic_js_3.createMethodExtractor)(go_js_6.goMethodConfig),
+    variableExtractor: (0, generic_js_4.createVariableExtractor)(go_js_7.goVariableConfig),
+    classExtractor: (0, generic_js_1.createClassExtractor)(go_js_1.goClassConfig),
+    // ── godoc (`//` leading comments) → description (issue #2270). Build/tool
+    //    directives (//go:…, // +build, //nolint, //line) are not documentation. ──
+    descriptionExtractor: (0, ast_helpers_js_1.createLeadingDocDescriptionExtractor)({
+        lineCommentPrefixes: ['//'],
+        lineDirectivePrefixes: ['//go:', '// +build', '//nolint', '//line'],
+        // #2837: Go type declarations anchor on the `type_spec`, whose
+        // `previousNamedSibling` is null for the ordinary `type T struct{…}` form —
+        // the godoc comment is a sibling of the enclosing `type_declaration`, one
+        // level up. Without this the doc silently vanished for EVERY Go struct and
+        // interface (measured: pre-#2837 `desc=YES`, post `none`), taking #2270's
+        // description out of both the embedding header and the FTS column.
+        // Functions/methods are unaffected — they anchor on their own declaration
+        // node, which does carry the comment as a previous sibling.
+        wrapperNodeTypes: ['type_declaration'],
+    }),
+    builtInNames: GO_BUILT_INS,
+    // ── RFC #909 Ring 3: scope-based resolution hooks ──────────
+    emitScopeCaptures: index_js_2.emitGoScopeCaptures,
+    cfgVisitor: (0, go_js_2.createGoCfgVisitor)(),
+    interpretImport: index_js_2.interpretGoImport,
+    interpretTypeBinding: index_js_2.interpretGoTypeBinding,
+    bindingScopeFor: index_js_2.goBindingScopeFor,
+    importOwningScope: index_js_2.goImportOwningScope,
+    receiverBinding: index_js_2.goReceiverBinding,
+    arityCompatibility: index_js_2.goArityCompatibility,
+    // resolveImportTarget lives on ScopeResolver (4-param signature),
+    // not on LanguageProvider (2-param signature). See go/scope-resolver.ts.
+});

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

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Language Provider Registry — compile-time exhaustive provider table.
+ *
+ * To add a new language:
+ * 1. Add enum member to SupportedLanguages
+ * 2. Create `languages/<lang>.ts` exporting a LanguageProvider
+ * 3. Add one line to the `providers` table below
+ * 4. Run `tsc --noEmit` to verify
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providers = void 0;
+exports.getProvider = getProvider;
+exports.getProviderForFile = getProviderForFile;
+const index_js_1 = require("../../../../shared/index.js");
+const typescript_js_1 = require("./typescript.js");
+const python_js_1 = require("./python.js");
+const java_js_1 = require("./java.js");
+const kotlin_js_1 = require("./kotlin.js");
+const go_js_1 = require("./go.js");
+const rust_js_1 = require("./rust.js");
+const csharp_js_1 = require("./csharp.js");
+const c_cpp_js_1 = require("./c-cpp.js");
+const php_js_1 = require("./php.js");
+const ruby_js_1 = require("./ruby.js");
+const swift_js_1 = require("./swift.js");
+const dart_js_1 = require("./dart.js");
+const vue_js_1 = require("./vue.js");
+exports.providers = {
+    [index_js_1.SupportedLanguages.JavaScript]: typescript_js_1.javascriptProvider,
+    [index_js_1.SupportedLanguages.TypeScript]: typescript_js_1.typescriptProvider,
+    [index_js_1.SupportedLanguages.Python]: python_js_1.pythonProvider,
+    [index_js_1.SupportedLanguages.Java]: java_js_1.javaProvider,
+    [index_js_1.SupportedLanguages.Kotlin]: kotlin_js_1.kotlinProvider,
+    [index_js_1.SupportedLanguages.Go]: go_js_1.goProvider,
+    [index_js_1.SupportedLanguages.Rust]: rust_js_1.rustProvider,
+    [index_js_1.SupportedLanguages.CSharp]: csharp_js_1.csharpProvider,
+    [index_js_1.SupportedLanguages.C]: c_cpp_js_1.cProvider,
+    [index_js_1.SupportedLanguages.CPlusPlus]: c_cpp_js_1.cppProvider,
+    [index_js_1.SupportedLanguages.PHP]: php_js_1.phpProvider,
+    [index_js_1.SupportedLanguages.Ruby]: ruby_js_1.rubyProvider,
+    [index_js_1.SupportedLanguages.Swift]: swift_js_1.swiftProvider,
+    [index_js_1.SupportedLanguages.Dart]: dart_js_1.dartProvider,
+    [index_js_1.SupportedLanguages.Vue]: vue_js_1.vueProvider,
+};
+/** Get provider by language enum (always succeeds for SupportedLanguages). */
+function getProvider(language) {
+    return exports.providers[language];
+}
+/** Pre-built extension → provider lookup (built once at module load). */
+const extensionMap = new Map();
+for (const provider of Object.values(exports.providers)) {
+    for (const ext of provider.extensions) {
+        extensionMap.set(ext, provider);
+    }
+}
+/** Look up a language provider from a file path by extension.
+ *  Returns null if the file extension is not recognized. */
+function getProviderForFile(filePath) {
+    if ((0, index_js_1.isBladeTemplateFilename)(filePath))
+        return null;
+    const lastDot = filePath.lastIndexOf('.');
+    const ext = lastDot >= 0 ? filePath.slice(lastDot).toLowerCase() : '';
+    const basename = filePath.slice(filePath.lastIndexOf('/') + 1);
+    return extensionMap.get(ext) ?? extensionMap.get(basename) ?? null;
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPRING_CONFIG_BINDINGS_FEATURE = void 0;
+function isSpringApplicationConfig(filePath) {
+    const base = filePath.replaceAll('\\', '/').split('/').pop() ?? '';
+    return /^application(?:-[^.]+)?\.(?:properties|ya?ml)$/i.test(base);
+}
+/** Durable completeness contract for Java Spring configuration bindings. */
+exports.SPRING_CONFIG_BINDINGS_FEATURE = {
+    id: 'spring.config-bindings',
+    version: 1,
+    // Java sources need consumer extraction even without config files (missing
+    // placeholders still get unresolved markers). Config-only repositories also
+    // need a one-time rebuild to backfill language-agnostic Property nodes.
+    appliesTo: (filePaths) => filePaths.some((filePath) => filePath.toLowerCase().endsWith('.java') || isSpringApplicationConfig(filePath)),
+};

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

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Extract Java arity metadata from a method-like tree-sitter node —
+ * `method_declaration` or `constructor_declaration`.
+ *
+ * Reuses `javaMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - varargs (`...`) collapses `parameterCount` to `undefined`
+ *   - `parameterTypes` collects declared type names; a literal
+ *     `'varargs'` marker is appended for variadic methods so
+ *     `javaArityCompatibility` can detect them.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeJavaArityMetadata = computeJavaArityMetadata;
+const jvm_js_1 = require("../../method-extractors/configs/jvm.js");
+function computeJavaArityMetadata(fnNode) {
+    const params = jvm_js_1.javaMethodConfig.extractParameters?.(fnNode) ?? [];
+    let hasVariadic = false;
+    const types = [];
+    for (const p of params) {
+        if (p.isVariadic)
+            hasVariadic = true;
+        if (p.type !== null)
+            types.push(p.type);
+    }
+    if (hasVariadic)
+        types.push('varargs');
+    const total = params.length;
+    // For varargs methods, `parameterCount` (max) is unknown — any number of
+    // trailing arguments is valid.  But the fixed-prefix parameters (everything
+    // before the variadic `...` param) are still required, so we preserve that
+    // count in `requiredParameterCount` so `javaArityCompatibility` can reject
+    // calls that undersupply the fixed prefix (e.g. `f(int x, String... args)`
+    // called with 0 args).
+    const fixedCount = params.filter((p) => !p.isVariadic).length;
+    const parameterCount = hasVariadic ? undefined : total;
+    const requiredParameterCount = hasVariadic ? fixedCount : total;
+    return {
+        parameterCount,
+        requiredParameterCount,
+        parameterTypes: types.length > 0 ? types : undefined,
+    };
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Java arity check, accommodating varargs (`...`).
+ *
+ * Verdicts:
+ *   - `'compatible'`   — argCount matches parameterCount, OR varargs present.
+ *   - `'incompatible'` — argCount mismatches with no varargs.
+ *   - `'unknown'`      — metadata absent / incomplete.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javaArityCompatibility = javaArityCompatibility;
+function javaArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    const argCount = callsite.arity;
+    if (!Number.isFinite(argCount) || argCount < 0)
+        return 'unknown';
+    const hasVarArgs = def.parameterTypes !== undefined &&
+        def.parameterTypes.some((t) => t === 'varargs' || t.includes('...'));
+    if (min !== undefined && argCount < min)
+        return 'incompatible';
+    if (max !== undefined && argCount > max && !hasVarArgs)
+        return 'incompatible';
+    return 'compatible';
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Dev-mode counters for the cross-phase scope-captures parse cache
+ * (Java mirror of `languages/csharp/cache-stats.ts`).
+ *
+ * Gated by `PROF_SCOPE_RESOLUTION=1`. Production builds fold every
+ * increment into dead code via the module-level `PROF` constant, so
+ * the hot path in `captures.ts` stays branch-free.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordCacheHit = recordCacheHit;
+exports.recordCacheMiss = recordCacheMiss;
+exports.getJavaCaptureCacheStats = getJavaCaptureCacheStats;
+exports.resetJavaCaptureCacheStats = resetJavaCaptureCacheStats;
+const PROF = process.env.PROF_SCOPE_RESOLUTION === '1';
+let CACHE_HITS = 0;
+let CACHE_MISSES = 0;
+function recordCacheHit() {
+    if (PROF)
+        CACHE_HITS++;
+}
+function recordCacheMiss() {
+    if (PROF)
+        CACHE_MISSES++;
+}
+function getJavaCaptureCacheStats() {
+    return { hits: CACHE_HITS, misses: CACHE_MISSES };
+}
+function resetJavaCaptureCacheStats() {
+    CACHE_HITS = 0;
+    CACHE_MISSES = 0;
+}