gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/languages/vue/scope-resolver.js

@@ -0,0 +1,292 @@
+/**
+ * Vue `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
+ * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3, issue #940).
+ *
+ * ## Design rationale
+ *
+ * Vue SFCs compile down to TypeScript/JavaScript — the `<script>` /
+ * `<script setup>` block is pure TS/JS, parsed with the TypeScript
+ * grammar and captured by `emitVueScopeCaptures` (which delegates
+ * to `emitTsScopeCaptures`).  Because of this, nearly all hooks are
+ * identical to the TypeScript resolver:
+ *
+ *   - `mergeBindings` — TypeScript LEGB semantics apply in script blocks.
+ *   - `arityCompatibility` — same positional + rest rules.
+ *   - `buildMro` / `populateOwners` — shared with TypeScript.
+ *   - `isSuperReceiver` — `super(...)` / `super.foo` / `super[x]` pattern.
+ *   - `resolveImportTarget` — TypeScript resolver with `.vue` explicit-
+ *                             extension support; tsconfig paths loaded via
+ *                             `loadResolutionConfig`.
+ *
+ * ## Key differences from TypeScript
+ *
+ *   - `language: SupportedLanguages.Vue` — routes the resolver to Vue
+ *     files only; TypeScript files use the TypeScript resolver.
+ *   - `languageProvider: vueProvider` — the Vue-specific language
+ *     provider supplies the right built-ins and export checker for
+ *     `<script setup>` (all top-level bindings implicitly exported).
+ *   - `importEdgeReason: 'vue-scope: import'` — distinct tag for
+ *     debugging / edge provenance.
+ *   - `allowGlobalFreeCallFallback: false` — Vue uses explicit imports;
+ *     workspace-wide unique-name fallback is unnecessary and would
+ *     produce spurious edges for Vue built-ins (ref, reactive, …).
+ *
+ * ## Options API / this-binding
+ *
+ * Options API (`defineComponent({ methods: { … } })`) stores methods
+ * on the component instance, which tree-sitter sees as object property
+ * values.  `this.X()` inside a method resolves via the existing
+ * `tsReceiverBinding` hook (inherited from TypeScript), which walks to
+ * the enclosing Class scope.  For Options API the enclosing "class" is
+ * the `defineComponent({…})` object — not a true class — so `this`
+ * calls may not resolve through the type-binding layer.  `fieldFallbackOnMethodLookup`
+ * is therefore set to `true` so the field-name fallback catches common
+ * patterns even without an explicit type annotation.
+ *
+ * ## `<script setup>` macro calls
+ *
+ * `defineProps`, `defineEmits`, `defineExpose`, `withDefaults`, etc.
+ * are compiler macros available as globals inside `<script setup>`.
+ * They are listed in `vueProvider.builtInNames` and therefore treated
+ * as resolved without requiring an import edge.
+ */
+import { SupportedLanguages, getLanguageFromFilename } from '../../../../_shared/index.js';
+import { generateId } from '../../../../lib/utils.js';
+import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
+import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { simpleKey } from '../../scope-resolution/graph-bridge/node-lookup.js';
+import { vueProvider } from '../vue.js';
+import { loadTsconfigPaths } from '../../language-config.js';
+import { typescriptArityCompatibility, typescriptMergeBindings } from '../typescript/index.js';
+import { makeVueResolveImportTarget } from './import-target.js';
+import { extractVueTemplateEdgeData } from '../../vue-sfc-extractor.js';
+import { extractParsedFile } from '../../scope-extractor-bridge.js';
+// Languages whose files may be pulled into the Vue scope-resolution pass
+// as import-closure context (`.vue` → `.ts` / `.js` cross-file resolution).
+const VUE_SCOPE_CONTEXT_LANGUAGES = new Set([
+    SupportedLanguages.Vue,
+    SupportedLanguages.TypeScript,
+    SupportedLanguages.JavaScript,
+]);
+function isVueScopeContextLanguage(lang) {
+    return lang !== null && VUE_SCOPE_CONTEXT_LANGUAGES.has(lang);
+}
+const vueScopeResolver = {
+    language: SupportedLanguages.Vue,
+    languageProvider: vueProvider,
+    importEdgeReason: 'vue-scope: import',
+    resolveImportTarget: makeVueResolveImportTarget(),
+    // Vue projects universally use TypeScript — load tsconfig so path
+    // aliases (`@/`, `~/`, `#/`) resolve through the standard branch.
+    loadResolutionConfig: async (repoPath) => ({
+        tsconfigPaths: await loadTsconfigPaths(repoPath),
+    }),
+    // TypeScript LEGB semantics apply inside `<script>` / `<script setup>`.
+    mergeBindings: (existing, incoming) => [...typescriptMergeBindings([...existing, ...incoming])],
+    // Adapter: typescriptArityCompatibility uses (def, callsite); contract is (callsite, def).
+    arityCompatibility: (callsite, def) => typescriptArityCompatibility(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
+    populateOwners: (parsed) => populateClassOwnedMembers(parsed),
+    isSuperReceiver: (text) => /^super(\s*\(|\s*\.|\s*\[|\s*$)/.test(text.trim()),
+    // Options API `this.X()` calls may not resolve through the type-binding
+    // layer (no formal class declaration), so enable the field-fallback
+    // heuristic to catch them via declared field names.
+    fieldFallbackOnMethodLookup: true,
+    // Return-type propagation mirrors TypeScript.
+    propagatesReturnTypesAcrossImports: true,
+    hoistTypeBindingsToModule: true,
+    // Vue uses explicit imports for all external symbols; no global free-
+    // call fallback needed (would produce spurious edges for built-ins).
+    allowGlobalFreeCallFallback: false,
+    /**
+     * Expand the scope-resolution file universe for Vue by performing a
+     * transitive closure over imports starting from the primary `.vue` files.
+     *
+     * Vue SFCs import TypeScript/JavaScript modules (`import { fn } from './api'`),
+     * and those modules must be included in the Vue resolution pass for cross-file
+     * IMPORTS/CALLS edges to resolve correctly.  Without this expansion, only
+     * `.vue` files would be processed and all TS/JS imports would remain
+     * unresolved.
+     *
+     * Keeping this logic here (rather than hard-coding it in `phase.ts`) ensures
+     * that shared pipeline code remains language-agnostic.
+     */
+    collectScopeContextPaths({ primaryFilePaths, preExtractedByPath, entryFileContents, allScannedPaths, resolutionConfig, }) {
+        const resolveTargets = (targetRaw, fromFile) => {
+            const resolved = vueScopeResolver.resolveImportTarget(targetRaw, fromFile, allScannedPaths, resolutionConfig);
+            if (resolved === null)
+                return [];
+            if (typeof resolved === 'string')
+                return [resolved];
+            return resolved;
+        };
+        const visited = new Set(primaryFilePaths);
+        const queue = [...primaryFilePaths];
+        const fallbackParsed = new Map();
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (current === undefined)
+                break;
+            let parsed = preExtractedByPath.get(current) ?? fallbackParsed.get(current) ?? undefined;
+            if (parsed === undefined) {
+                const source = entryFileContents.get(current);
+                if (source !== undefined) {
+                    parsed = extractParsedFile(vueProvider, source, current);
+                    if (parsed !== undefined)
+                        fallbackParsed.set(current, parsed);
+                }
+            }
+            if (parsed === undefined)
+                continue;
+            for (const parsedImport of parsed.parsedImports) {
+                if (parsedImport.targetRaw.trim().length === 0)
+                    continue;
+                for (const targetPath of resolveTargets(parsedImport.targetRaw, current)) {
+                    if (!allScannedPaths.has(targetPath))
+                        continue;
+                    if (!isVueScopeContextLanguage(getLanguageFromFilename(targetPath)))
+                        continue;
+                    if (visited.has(targetPath))
+                        continue;
+                    visited.add(targetPath);
+                    queue.push(targetPath);
+                }
+            }
+        }
+        return visited;
+    },
+    /**
+     * Emit template-derived edges after standard scope-resolution passes.
+     *
+     * Six edge categories (all scoped to `.vue` files only):
+     *
+     *   1. **CALLS** (`vue-template-component`)
+     *      PascalCase component elements → the imported component's File node.
+     *      Source = the parent file (File node).
+     *
+     *   2. **CALLS** (`vue-template-callback`) — reserved for future use
+     *      (see category 3 below).
+     *
+     *   3. **CALLS** (`vue-template-callback`)
+     *      `@event="handler"` on a **native** HTML element (`<button>`, `<input>`).
+     *      Source = the parent file (File node). Target = handler Function/Method.
+     *
+     *   4. **BINDS_EVENT_HANDLER** (`vue-event: @<eventName>`)
+     *      `@event="handler"` on a **component** element.
+     *      Source = the handler Function/Method node in the parent file.
+     *      Target = the child component's File node.
+     *
+     *   5. **EMITS_EVENT** (`vue-emit: <eventName>`)
+     *      `emit('eventName', …)` / `this.$emit('eventName', …)` in script block.
+     *      Source = the file's own File node (self-referential annotation).
+     *      Target = the same File node.
+     *      These "hanging" edges join with BINDS_EVENT_HANDLER via Cypher query
+     *      on the shared component File node to reveal handler/emitter pairs.
+     *
+     *   6. **ACCESSES** (`vue-template-attribute`)
+     *      `:prop="varName"` bound-attribute references.
+     *      Source = the file's File node. Target = resolved variable node.
+     */
+    emitPostResolutionEdges(graph, parsedFiles, nodeLookup, indexes, ctx) {
+        for (const parsedFile of parsedFiles) {
+            if (!parsedFile.filePath.endsWith('.vue'))
+                continue;
+            const content = ctx.fileContents.get(parsedFile.filePath);
+            if (!content)
+                continue;
+            const fileId = generateId('File', parsedFile.filePath);
+            // Build localName → resolved targetFile from finalized import edges.
+            const importTargetByName = new Map();
+            for (const [scopeId, edges] of indexes.imports) {
+                const scope = indexes.scopeTree.getScope(scopeId);
+                if (scope?.filePath !== parsedFile.filePath)
+                    continue;
+                for (const edge of edges) {
+                    if (edge.targetFile !== null && edge.localName) {
+                        importTargetByName.set(edge.localName, edge.targetFile);
+                    }
+                }
+            }
+            // Extract all template/script edge data in a single pass — avoids
+            // re-running TEMPLATE_RE for each individual extractor call.
+            const { templateComponents, nativeEventHandlers, componentEventBindings, scriptEmitCalls, templateAttributeBindings, } = extractVueTemplateEdgeData(content, { sourceKind: 'full-sfc' });
+            // 1 — Component-reference CALLS
+            for (const componentName of templateComponents) {
+                const targetFile = importTargetByName.get(componentName);
+                if (!targetFile)
+                    continue;
+                const targetFileId = generateId('File', targetFile);
+                if (!graph.getNode(targetFileId))
+                    continue;
+                graph.addRelationship({
+                    id: generateId('CALLS', `${fileId}:${componentName}->${targetFileId}`),
+                    sourceId: fileId,
+                    targetId: targetFileId,
+                    type: 'CALLS',
+                    confidence: 0.9,
+                    reason: 'vue-template-component',
+                });
+            }
+            // 3 — Native-element event-handler CALLS (@click="method" on <button> etc.)
+            for (const handlerName of nativeEventHandlers) {
+                const handlerNodeId = nodeLookup.get(simpleKey(parsedFile.filePath, handlerName));
+                if (!handlerNodeId)
+                    continue;
+                graph.addRelationship({
+                    id: generateId('CALLS', `${fileId}:@native:${handlerName}->${handlerNodeId}`),
+                    sourceId: fileId,
+                    targetId: handlerNodeId,
+                    type: 'CALLS',
+                    confidence: 0.9,
+                    reason: 'vue-template-callback',
+                });
+            }
+            // 4 — BINDS_EVENT_HANDLER: component event bindings (@event="handler" on component elements)
+            for (const { componentName, eventName, handlerName } of componentEventBindings) {
+                const targetFile = importTargetByName.get(componentName);
+                if (!targetFile)
+                    continue;
+                const targetFileId = generateId('File', targetFile);
+                if (!graph.getNode(targetFileId))
+                    continue;
+                const handlerNodeId = nodeLookup.get(simpleKey(parsedFile.filePath, handlerName));
+                if (!handlerNodeId)
+                    continue;
+                graph.addRelationship({
+                    id: generateId('BINDS_EVENT_HANDLER', `${handlerNodeId}:@${eventName}->${targetFileId}`),
+                    sourceId: handlerNodeId,
+                    targetId: targetFileId,
+                    type: 'BINDS_EVENT_HANDLER',
+                    confidence: 0.9,
+                    reason: `vue-event: @${eventName}`,
+                });
+            }
+            // 5 — EMITS_EVENT: emit() / this.$emit() calls (self-referential annotation)
+            for (const { eventName } of scriptEmitCalls) {
+                graph.addRelationship({
+                    id: generateId('EMITS_EVENT', `${fileId}:emit:${eventName}`),
+                    sourceId: fileId,
+                    targetId: fileId,
+                    type: 'EMITS_EVENT',
+                    confidence: 0.9,
+                    reason: `vue-emit: ${eventName}`,
+                });
+            }
+            // 6 — ACCESSES: bound-attribute references (:prop="varName")
+            for (const varName of templateAttributeBindings) {
+                const varNodeId = nodeLookup.get(simpleKey(parsedFile.filePath, varName));
+                if (!varNodeId)
+                    continue;
+                graph.addRelationship({
+                    id: generateId('ACCESSES', `${fileId}:bind:${varName}->${varNodeId}`),
+                    sourceId: fileId,
+                    targetId: varNodeId,
+                    type: 'ACCESSES',
+                    confidence: 0.8,
+                    reason: 'vue-template-attribute',
+                });
+            }
+        }
+    },
+};
+export { vueScopeResolver };

package/dist/core/ingestion/languages/vue.js

@@ -18,7 +18,6 @@ import { typeConfig as typescriptConfig } from '../type-extractors/typescript.js
 import { tsExportChecker } from '../export-detection.js';
 import { createImportResolver } from '../import-resolvers/resolver-factory.js';
 import { vueImportConfig } from '../import-resolvers/configs/typescript-javascript.js';
-import { extractTsNamedBindings } from '../named-bindings/typescript.js';
 import { TYPESCRIPT_QUERIES } from '../tree-sitter-queries.js';
 import { typescriptFieldExtractor } from '../field-extractors/typescript.js';
 import { BUILT_INS as TS_BUILT_INS } from './typescript.js';
@@ -26,7 +25,8 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { typescriptVariableConfig } from '../variable-extractors/configs/typescript-javascript.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { typescriptCallConfig } from '../call-extractors/configs/typescript-javascript.js';
-import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { interpretTsImport, interpretTsTypeBinding, tsBindingScopeFor, tsImportOwningScope, tsReceiverBinding, typescriptMergeBindings, typescriptArityCompatibility, resolveTsImportTarget, } from './typescript/index.js';
+import { emitVueScopeCaptures } from './vue/captures.js';
 const VUE_SPECIFIC_BUILT_INS = [
     'ref',
     'reactive',
@@ -69,11 +69,19 @@ export const vueProvider = defineLanguage({
     typeConfig: typescriptConfig,
     exportChecker: tsExportChecker,
     importResolver: createImportResolver(vueImportConfig),
-    namedBindingExtractor: extractTsNamedBindings,
     callExtractor: createCallExtractor(typescriptCallConfig),
     fieldExtractor: typescriptFieldExtractor,
     variableExtractor: createVariableExtractor(typescriptVariableConfig),
     classExtractor: vueClassExtractor,
-    heritageExtractor: createHeritageExtractor(SupportedLanguages.TypeScript),
     builtInNames: VUE_BUILT_INS,
+    // Scope-resolution pipeline hooks (RFC #909 Ring 3)
+    emitScopeCaptures: emitVueScopeCaptures,
+    interpretImport: interpretTsImport,
+    interpretTypeBinding: interpretTsTypeBinding,
+    bindingScopeFor: tsBindingScopeFor,
+    importOwningScope: tsImportOwningScope,
+    receiverBinding: tsReceiverBinding,
+    mergeBindings: (_scope, bindings) => typescriptMergeBindings(bindings),
+    arityCompatibility: typescriptArityCompatibility,
+    resolveImportTarget: resolveTsImportTarget,
 });

package/dist/core/ingestion/local-symbol-pruner.d.ts

@@ -0,0 +1,11 @@
+import type { KnowledgeGraph } from '../graph/types.js';
+export interface LocalSymbolPruneStats {
+    candidateNodes: number;
+    prunedNodes: number;
+    keptWithSemanticEdges: number;
+    skippedByEnv: boolean;
+}
+export declare const shouldKeepLocalValueSymbols: () => boolean;
+export declare const pruneLocalValueSymbols: (graph: KnowledgeGraph, options?: {
+    keepLocalValueSymbols?: boolean;
+}) => LocalSymbolPruneStats;

package/dist/core/ingestion/local-symbol-pruner.js

@@ -0,0 +1,63 @@
+import { parseTruthyEnv } from './utils/env.js';
+const LOCAL_VALUE_LABELS = new Set(['Const', 'Variable', 'Static']);
+const KEEP_LOCAL_VALUE_SYMBOLS_ENV = 'GITNEXUS_KEEP_LOCAL_VALUE_SYMBOLS';
+export const shouldKeepLocalValueSymbols = () => parseTruthyEnv(process.env[KEEP_LOCAL_VALUE_SYMBOLS_ENV]);
+const emptyStats = (skippedByEnv) => ({
+    candidateNodes: 0,
+    prunedNodes: 0,
+    keptWithSemanticEdges: 0,
+    skippedByEnv,
+});
+const isLocalValueCandidate = (node) => {
+    if (!LOCAL_VALUE_LABELS.has(node.label))
+        return false;
+    return node.properties.scope === 'block';
+};
+// True when `rel` is the structural `File -> DEFINES -> candidate` edge. Callers
+// guard on the candidate already being the edge target, so only the source label
+// needs checking here.
+const isFileDefinesEdge = (graph, rel) => {
+    if (rel.type !== 'DEFINES')
+        return false;
+    return graph.getNode(rel.sourceId)?.label === 'File';
+};
+export const pruneLocalValueSymbols = (graph, options = {}) => {
+    if (options.keepLocalValueSymbols ?? shouldKeepLocalValueSymbols()) {
+        return emptyStats(true);
+    }
+    const candidateIds = new Set();
+    for (const node of graph.iterNodes()) {
+        if (isLocalValueCandidate(node))
+            candidateIds.add(node.id);
+    }
+    if (candidateIds.size === 0)
+        return emptyStats(false);
+    const candidatesWithSemanticEdges = new Set();
+    for (const rel of graph.iterRelationships()) {
+        // Any outgoing edge from a candidate is a semantic edge: the only structural
+        // edge a block-local value symbol carries is the incoming File -> DEFINES, on
+        // which the candidate is the target, never the source.
+        if (candidateIds.has(rel.sourceId)) {
+            candidatesWithSemanticEdges.add(rel.sourceId);
+        }
+        // An incoming edge is semantic unless it is the structural File -> DEFINES.
+        if (candidateIds.has(rel.targetId)) {
+            if (!isFileDefinesEdge(graph, rel)) {
+                candidatesWithSemanticEdges.add(rel.targetId);
+            }
+        }
+    }
+    let prunedNodes = 0;
+    for (const candidateId of candidateIds) {
+        if (candidatesWithSemanticEdges.has(candidateId))
+            continue;
+        if (graph.removeNode(candidateId))
+            prunedNodes++;
+    }
+    return {
+        candidateNodes: candidateIds.size,
+        prunedNodes,
+        keptWithSemanticEdges: candidatesWithSemanticEdges.size,
+        skippedByEnv: false,
+    };
+};

package/dist/core/ingestion/method-extractors/configs/dart.js

@@ -8,7 +8,6 @@ import { extractSimpleTypeName } from '../../type-extractors/shared.js';
 /** Type node types that represent a return type in function/getter/setter signatures. */
 const TYPE_NODE_TYPES = new Set([
     'type_identifier',
-    'generic_type',
     'function_type',
     'nullable_type',
     'void_type',
@@ -23,6 +22,20 @@ const TYPE_NODE_TYPES = new Set([
  * method_signature itself.
  */
 function getInnerSignature(node) {
+    // A bare signature node IS its own inner signature. The scope-resolution
+    // path passes top-level `function_signature` (and constructor/getter/setter
+    // signatures) directly, unlike the legacy method extractor which always
+    // hands in a `method_signature`/`declaration` wrapper — so the descent loop
+    // below never sees a bare signature on the legacy path and this early return
+    // leaves legacy behavior byte-identical.
+    if (node.type === 'function_signature' ||
+        node.type === 'constructor_signature' ||
+        node.type === 'getter_signature' ||
+        node.type === 'setter_signature' ||
+        node.type === 'operator_signature' ||
+        node.type === 'factory_constructor_signature') {
+        return node;
+    }
     for (let i = 0; i < node.namedChildCount; i++) {
         const child = node.namedChild(i);
         if (child &&

package/dist/core/ingestion/method-extractors/configs/jvm.js

@@ -155,9 +155,42 @@ export const javaMethodConfig = {
 // Kotlin
 // ---------------------------------------------------------------------------
 const KOTLIN_VIS = new Set(['public', 'private', 'protected', 'internal']);
+function kotlinParameterHasDefaultValue(param) {
+    // tree-sitter-kotlin inlines `_function_value_parameter`, so `=` and its
+    // expression are siblings of `parameter`, not children of the parameter.
+    for (let sibling = param.nextSibling; sibling !== null; sibling = sibling.nextSibling) {
+        if (sibling.type === ',' || sibling.type === ')')
+            return false;
+        if (sibling.type === '=')
+            return true;
+    }
+    return false;
+}
+/**
+ * Member name for a Kotlin method node. A `secondary_constructor`
+ * (`constructor(...) { }`) has no name child — its only identity token is
+ * the anonymous `constructor` keyword — so it is named "constructor" (F48,
+ * issue #1919), matching the @name the KOTLIN_QUERIES structure rule captures
+ * off that keyword so method-extractor enrichment keys (`name:line`) align.
+ * Multiple secondary constructors collide on this name but are disambiguated
+ * downstream by the `#<arity>` ID suffix the worker appends to Constructors.
+ */
+function extractKotlinMethodName(node) {
+    if (node.type === 'secondary_constructor')
+        return 'constructor';
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'simple_identifier')
+            return child.text;
+    }
+    return undefined;
+}
 function extractKotlinParameters(node) {
     const params = [];
-    // Kotlin: function_declaration > function_value_parameters > parameter
+    // Kotlin: function_declaration / secondary_constructor >
+    // function_value_parameters > parameter. Both node types nest the
+    // parameter list the same way, so the same walk extracts a secondary
+    // constructor's parameters (F48).
     for (let i = 0; i < node.namedChildCount; i++) {
         const child = node.namedChild(i);
         if (child && child.type === 'function_value_parameters') {
@@ -180,7 +213,6 @@ function extractKotlinParameters(node) {
                 let paramName;
                 let paramType = null;
                 let paramRawType = null;
-                let hasDefault = false;
                 const isVariadic = nextIsVariadic;
                 nextIsVariadic = false;
                 for (let k = 0; k < param.namedChildCount; k++) {
@@ -197,20 +229,12 @@ function extractKotlinParameters(node) {
                         paramType = extractSimpleTypeName(part) ?? paramRawType;
                     }
                 }
-                // Check for default value: `= expr`
-                for (let k = 0; k < param.childCount; k++) {
-                    const c = param.child(k);
-                    if (c && c.text === '=') {
-                        hasDefault = true;
-                        break;
-                    }
-                }
                 if (paramName) {
                     params.push({
                         name: paramName,
                         type: paramType,
                         rawType: paramRawType,
-                        isOptional: hasDefault,
+                        isOptional: kotlinParameterHasDefaultValue(param),
                         isVariadic: isVariadic,
                     });
                 }
@@ -246,17 +270,10 @@ function extractKotlinReturnType(node) {
 export const kotlinMethodConfig = {
     language: SupportedLanguages.Kotlin,
     typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'],
-    methodNodeTypes: ['function_declaration'],
+    methodNodeTypes: ['function_declaration', 'secondary_constructor'],
     bodyNodeTypes: ['class_body'],
     staticOwnerTypes: new Set(['companion_object', 'object_declaration']),
-    extractName(node) {
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'simple_identifier')
-                return child.text;
-        }
-        return undefined;
-    },
+    extractName: extractKotlinMethodName,
     extractReturnType: extractKotlinReturnType,
     extractParameters: extractKotlinParameters,
     extractVisibility(node) {

package/dist/core/ingestion/method-extractors/configs/php.js

@@ -101,7 +101,6 @@ function extractPhpReturnType(node) {
         'named_type',
         'union_type',
         'optional_type',
-        'nullable_type',
         'intersection_type',
     ]);
     let astType;

package/dist/core/ingestion/method-extractors/configs/swift.js

@@ -242,14 +242,21 @@ function extractSwiftAnnotations(node) {
 // ---------------------------------------------------------------------------
 export const swiftMethodConfig = {
     language: SupportedLanguages.Swift,
-    // Keep this conservative until Swift type-shape coverage is expanded.
-    // TODO: Verify struct_declaration, enum_declaration, extension_declaration, actor_declaration
-    // node types once tree-sitter-swift loads on Node 22, and add them here if they are distinct.
+    // tree-sitter-swift collapses class / struct / enum / extension / actor into a
+    // single `class_declaration` node (distinguished by the `declaration_kind`
+    // field) — verified by real parse. There is NO separate `enum_declaration`
+    // node type, so it must NOT be listed here (it would fail the grammar-drift
+    // gate). The enum's owner node is therefore already covered by
+    // `class_declaration`; F79 only needed the enum BODY node added below.
     // protocol_declaration is a separate, confirmed node type.
     typeDeclarationNodes: ['class_declaration', 'protocol_declaration'],
     // function_declaration for class/struct methods, protocol_function_declaration for protocol methods
     methodNodeTypes: ['function_declaration', 'protocol_function_declaration'],
-    bodyNodeTypes: ['class_body', 'protocol_body'],
+    // class_body for class/struct/extension/actor, protocol_body for protocols,
+    // enum_class_body for enums (F79). Without enum_class_body the factory only
+    // reached enum methods via the generic findBodies fallback, which logs a
+    // dev-mode "body field type not in bodyNodeTypes" warning.
+    bodyNodeTypes: ['class_body', 'protocol_body', 'enum_class_body'],
     extractName: extractSwiftName,
     extractReturnType: extractSwiftReturnType,
     extractParameters: extractSwiftParameters,

package/dist/core/ingestion/method-types.d.ts

@@ -50,7 +50,7 @@ export interface MethodExtractor {
      *  unwrapping, Swift init/deinit, Rust impl_item) provide this hook
      *  to replace the generic name-field lookup.
      *  Return null to fall through to the generic extractor. */
-    extractFunctionName?(node: SyntaxNode): {
+    extractFunctionName?(node: SyntaxNode, filePath?: string): {
         funcName: string | null;
         label: import('../../_shared/index.js').NodeLabel;
     } | null;
@@ -84,7 +84,7 @@ export interface MethodExtractionConfig {
     extractPrimaryConstructor?: (ownerNode: SyntaxNode, context: MethodExtractorContext) => MethodInfo | null;
     /** Extract function name + label from an AST node during parent-walk.
      *  Passed through to the MethodExtractor by createMethodExtractor. */
-    extractFunctionName?: (node: SyntaxNode) => {
+    extractFunctionName?: (node: SyntaxNode, filePath?: string) => {
         funcName: string | null;
         label: import('../../_shared/index.js').NodeLabel;
     } | null;

package/dist/core/ingestion/model/index.d.ts

@@ -14,7 +14,4 @@ export { type SymbolTableReader, type SymbolTableWriter, createSymbolTable, type
 export { type TypeRegistry, type MutableTypeRegistry, createTypeRegistry, } from './type-registry.js';
 export { type MethodRegistry, type MutableMethodRegistry, createMethodRegistry, } from './method-registry.js';
 export { type FieldRegistry, type MutableFieldRegistry, createFieldRegistry, } from './field-registry.js';
-export { lookupMethodByOwnerWithMRO } from './resolve.js';
-export { type NamedImportBinding, type NamedImportMap, isFileInPackageDir, } from './resolution-context.js';
-export { type ExtractedHeritage, type HeritageMap, type HeritageResolutionStrategy, type HeritageStrategyLookup, } from './heritage-map.js';
 export { CALLABLE_ONLY_LABELS, INERT_LABELS, DISPATCH_LABELS, ALL_NODE_LABELS, type LabelBehavior, } from './registration-table.js';

package/dist/core/ingestion/model/index.js

@@ -25,14 +25,6 @@ export { createTypeRegistry, } from './type-registry.js';
 export { createMethodRegistry, } from './method-registry.js';
 // Field registry (owner-scoped fields/properties)
 export { createFieldRegistry, } from './field-registry.js';
-// MRO-aware method resolution (C3, first-wins, leftmost-base, implements-split,
-// qualified-syntax). Pure function that depends only on the model + HeritageMap.
-// `MroStrategy` itself lives in `gitnexus-shared`; re-exported here for
-// consumers that reach model behavior through the barrel.
-export { lookupMethodByOwnerWithMRO } from './resolve.js';
-// Named-import types and package-dir helper. Re-exported so barrel
-// consumers don't need to reach into a specific model file.
-export { isFileInPackageDir, } from './resolution-context.js';
 // Behavior-grouped dispatch table for SymbolTable.add() routing.
 // See registration-table.ts module JSDoc for the behavior group taxonomy
 // and "how to add a new NodeLabel" checklist.