gitnexus 1.4.7 → 1.4.8

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

@@ -4,10 +4,136 @@ import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/pa
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, findEnclosingClassId, extractMixedChain, } from './utils.js';
-import { buildTypeEnv } from './type-env.js';
+import { buildTypeEnv, isSubclassOf } from './type-env.js';
 import { getTreeSitterBufferSize } from './constants.js';
 import { callRouters } from './call-routing.js';
 import { extractReturnTypeName, stripNullable } from './type-extractors/shared.js';
+import { typeConfigs } from './type-extractors/index.js';
+const MAX_EXPORTS_PER_FILE = 500;
+const MAX_TYPE_NAME_LENGTH = 256;
+/** Build a map of imported callee names → return types for cross-file call-result binding.
+ *  Consulted ONLY when SymbolTable has no unambiguous local match (local-first principle). */
+export function buildImportedReturnTypes(filePath, namedImportMap, symbolTable) {
+    const result = new Map();
+    const fileImports = namedImportMap.get(filePath);
+    if (!fileImports)
+        return result;
+    for (const [localName, binding] of fileImports) {
+        const def = symbolTable.lookupExactFull(binding.sourcePath, binding.exportedName);
+        if (!def?.returnType)
+            continue;
+        const simpleReturn = extractReturnTypeName(def.returnType);
+        if (simpleReturn)
+            result.set(localName, simpleReturn);
+    }
+    return result;
+}
+/** Build cross-file RAW return types for imported callables.
+ *  Unlike buildImportedReturnTypes (which stores extractReturnTypeName output),
+ *  this stores the raw declared return type string (e.g., 'User[]', 'List<User>').
+ *  Used by lookupRawReturnType for for-loop element extraction via extractElementTypeFromString. */
+export function buildImportedRawReturnTypes(filePath, namedImportMap, symbolTable) {
+    const result = new Map();
+    const fileImports = namedImportMap.get(filePath);
+    if (!fileImports)
+        return result;
+    for (const [localName, binding] of fileImports) {
+        const def = symbolTable.lookupExactFull(binding.sourcePath, binding.exportedName);
+        if (!def?.returnType)
+            continue;
+        result.set(localName, def.returnType);
+    }
+    return result;
+}
+/** Collect resolved type bindings for exported file-scope symbols.
+ *  Uses graph node isExported flag — does NOT require isExported on SymbolDefinition. */
+function collectExportedBindings(typeEnv, filePath, symbolTable, graph) {
+    const fileScope = typeEnv.env.get('');
+    if (!fileScope || fileScope.size === 0)
+        return null;
+    const exported = new Map();
+    for (const [varName, typeName] of fileScope) {
+        if (exported.size >= MAX_EXPORTS_PER_FILE)
+            break;
+        if (!typeName || typeName.length > MAX_TYPE_NAME_LENGTH)
+            continue;
+        const nodeId = symbolTable.lookupExact(filePath, varName);
+        if (!nodeId)
+            continue;
+        const node = graph.getNode(nodeId);
+        if (node?.properties?.isExported) {
+            exported.set(varName, typeName);
+        }
+    }
+    return exported.size > 0 ? exported : null;
+}
+/** Build ExportedTypeMap from graph nodes — used for worker path where TypeEnv
+ *  is not available in the main thread. Collects returnType/declaredType from
+ *  exported symbols that have callables with known return types. */
+export function buildExportedTypeMapFromGraph(graph, symbolTable) {
+    const result = new Map();
+    graph.forEachNode(node => {
+        if (!node.properties?.isExported)
+            return;
+        if (!node.properties?.filePath || !node.properties?.name)
+            return;
+        const filePath = node.properties.filePath;
+        const name = node.properties.name;
+        if (!name || name.length > MAX_TYPE_NAME_LENGTH)
+            return;
+        // For callable symbols, use returnType; for properties/variables, use declaredType
+        const def = symbolTable.lookupExactFull(filePath, name);
+        if (!def)
+            return;
+        const typeName = def.returnType ?? def.declaredType;
+        if (!typeName || typeName.length > MAX_TYPE_NAME_LENGTH)
+            return;
+        // Extract simple type name (strip Promise<>, etc.) — reuse shared utility
+        const simpleType = extractReturnTypeName(typeName) ?? typeName;
+        if (!simpleType)
+            return;
+        let fileExports = result.get(filePath);
+        if (!fileExports) {
+            fileExports = new Map();
+            result.set(filePath, fileExports);
+        }
+        if (fileExports.size < MAX_EXPORTS_PER_FILE) {
+            fileExports.set(name, simpleType);
+        }
+    });
+    return result;
+}
+/** Seed cross-file receiver types into pre-extracted call records.
+ *  Fills missing receiverTypeName for single-hop imported variables
+ *  using ExportedTypeMap + namedImportMap — zero disk I/O, zero AST re-parsing.
+ *  Mutates calls in-place. Runs BEFORE processCallsFromExtracted. */
+export function seedCrossFileReceiverTypes(calls, namedImportMap, exportedTypeMap) {
+    if (namedImportMap.size === 0 || exportedTypeMap.size === 0) {
+        return { enrichedCount: 0 };
+    }
+    let enrichedCount = 0;
+    for (const call of calls) {
+        if (call.receiverTypeName || !call.receiverName)
+            continue;
+        if (call.callForm !== 'member')
+            continue;
+        const fileImports = namedImportMap.get(call.filePath);
+        if (!fileImports)
+            continue;
+        const binding = fileImports.get(call.receiverName);
+        if (!binding)
+            continue;
+        const upstream = exportedTypeMap.get(binding.sourcePath);
+        if (!upstream)
+            continue;
+        const type = upstream.get(binding.exportedName);
+        if (type) {
+            call.receiverTypeName = type;
+            enrichedCount++;
+        }
+    }
+    return { enrichedCount };
+}
 // Stdlib methods that preserve the receiver's type identity. When TypeEnv already
 // strips nullable wrappers (Option<User> → User), these chain steps are no-ops
 // for type resolution — the current type passes through unchanged.
@@ -87,10 +213,23 @@ const verifyConstructorBindings = (bindings, filePath, ctx, graph) => {
     }
     return verified;
 };
-export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
+export const processCalls = async (graph, files, astCache, ctx, onProgress, exportedTypeMap, 
+/** Phase 14: pre-resolved cross-file bindings to seed into buildTypeEnv. Keyed by filePath → Map<localName, typeName>. */
+importedBindingsMap, 
+/** Phase 14 E3: cross-file return types for imported callables. Keyed by filePath → Map<calleeName, returnType>.
+ *  Consulted ONLY when SymbolTable has no unambiguous match (local-first principle). */
+importedReturnTypesMap, 
+/** Phase 14 E3: cross-file RAW return types for for-loop element extraction. Keyed by filePath → Map<calleeName, rawReturnType>. */
+importedRawReturnTypesMap) => {
     const parser = await loadParser();
     const collectedHeritage = [];
     const pendingWrites = [];
+    // Phase P cross-file: accumulate heritage across files for cross-file isSubclassOf.
+    // Used as a secondary check when per-file parentMap lacks the relationship — helps
+    // when the heritage-declaring file is processed before the call site file.
+    // For remaining cases (reverse file order), the SymbolTable class-type fallback applies.
+    const globalParentMap = new Map();
+    const globalParentSeen = new Map();
     const logSkipped = isVerboseIngestionEnabled();
     const skippedByLang = logSkipped ? new Map() : null;
     for (let i = 0; i < files.length; i++) {
@@ -133,7 +272,58 @@ export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
             continue;
         }
         const lang = getLanguageFromFilename(file.path);
-        const typeEnv = lang ? buildTypeEnv(tree, lang, ctx.symbols) : null;
+        // Pre-pass: extract heritage from query matches to build parentMap for buildTypeEnv.
+        // Heritage-processor runs in PARALLEL, so graph edges don't exist when buildTypeEnv runs.
+        const fileParentMap = new Map();
+        for (const match of matches) {
+            const captureMap = {};
+            match.captures.forEach(c => captureMap[c.name] = c.node);
+            if (captureMap['heritage.class'] && captureMap['heritage.extends']) {
+                const className = captureMap['heritage.class'].text;
+                const parentName = captureMap['heritage.extends'].text;
+                const extendsNode = captureMap['heritage.extends'];
+                const fieldDecl = extendsNode.parent;
+                if (fieldDecl?.type === 'field_declaration' && fieldDecl.childForFieldName('name'))
+                    continue;
+                let parents = fileParentMap.get(className);
+                if (!parents) {
+                    parents = [];
+                    fileParentMap.set(className, parents);
+                }
+                if (!parents.includes(parentName))
+                    parents.push(parentName);
+            }
+        }
+        const parentMap = fileParentMap;
+        // Merge per-file heritage into globalParentMap for cross-file isSubclassOf lookups.
+        // Uses a parallel Set (globalParentSeen) for O(1) deduplication instead of O(n) includes().
+        for (const [cls, parents] of fileParentMap) {
+            let global = globalParentMap.get(cls);
+            let seen = globalParentSeen.get(cls);
+            if (!global) {
+                global = [];
+                globalParentMap.set(cls, global);
+            }
+            if (!seen) {
+                seen = new Set();
+                globalParentSeen.set(cls, seen);
+            }
+            for (const p of parents) {
+                if (!seen.has(p)) {
+                    seen.add(p);
+                    global.push(p);
+                }
+            }
+        }
+        const importedBindings = importedBindingsMap?.get(file.path);
+        const importedReturnTypes = importedReturnTypesMap?.get(file.path);
+        const importedRawReturnTypes = importedRawReturnTypesMap?.get(file.path);
+        const typeEnv = lang ? buildTypeEnv(tree, lang, { symbolTable: ctx.symbols, parentMap, importedBindings, importedReturnTypes, importedRawReturnTypes }) : null;
+        if (typeEnv && exportedTypeMap) {
+            const fileExports = collectExportedBindings(typeEnv, file.path, ctx.symbols, graph);
+            if (fileExports)
+                exportedTypeMap.set(file.path, fileExports);
+        }
         const callRouter = callRouters[language];
         const verifiedReceivers = typeEnv && typeEnv.constructorBindings.length > 0
             ? verifyConstructorBindings(typeEnv.constructorBindings, file.path, ctx)
@@ -245,6 +435,44 @@ export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
             const callForm = inferCallForm(callNode, nameNode);
             const receiverName = callForm === 'member' ? extractReceiverName(nameNode) : undefined;
             let receiverTypeName = receiverName && typeEnv ? typeEnv.lookup(receiverName, callNode) : undefined;
+            // Phase P: virtual dispatch override — when the declared type is a base class but
+            // the constructor created a known subclass, prefer the more specific type.
+            // Checks per-file parentMap first, then falls back to globalParentMap for
+            // cross-file heritage (e.g. Dog extends Animal declared in a different file).
+            // Reconstructs the exact scope key (funcName@startIndex\0varName) from the
+            // enclosing function AST node for a correct, O(1) map lookup.
+            if (receiverTypeName && receiverName && typeEnv && typeEnv.constructorTypeMap.size > 0) {
+                // Reconstruct scope key to match constructorTypeMap's scope\0varName format
+                let scope = '';
+                let p = callNode.parent;
+                while (p) {
+                    if (FUNCTION_NODE_TYPES.has(p.type)) {
+                        const { funcName } = extractFunctionName(p);
+                        if (funcName) {
+                            scope = `${funcName}@${p.startIndex}`;
+                            break;
+                        }
+                    }
+                    p = p.parent;
+                }
+                const ctorType = typeEnv.constructorTypeMap.get(`${scope}\0${receiverName}`);
+                if (ctorType && ctorType !== receiverTypeName) {
+                    // Verify subclass relationship: per-file parentMap first, then cross-file
+                    // globalParentMap, then fall back to SymbolTable class verification.
+                    // The SymbolTable fallback handles cross-file cases where heritage is declared
+                    // in a file not yet processed (e.g. Dog extends Animal in models/Dog.kt when
+                    // processing services/App.kt). Since constructorTypeMap only records entries
+                    // when a type annotation AND constructor are both present (val x: Base = Sub()),
+                    // confirming both are class-like types is sufficient — the original code would
+                    // not compile if Sub didn't extend Base.
+                    if (isSubclassOf(ctorType, receiverTypeName, parentMap)
+                        || isSubclassOf(ctorType, receiverTypeName, globalParentMap)
+                        || (ctx.symbols.lookupFuzzy(ctorType).some(d => d.type === 'Class' || d.type === 'Struct')
+                            && ctx.symbols.lookupFuzzy(receiverTypeName).some(d => d.type === 'Class' || d.type === 'Struct' || d.type === 'Interface'))) {
+                        receiverTypeName = ctorType;
+                    }
+                }
+            }
             // Fall back to verified constructor bindings for return type inference
             if (!receiverTypeName && receiverName && receiverIndex.size > 0) {
                 const enclosingFunc = findEnclosingFunction(callNode, file.path, ctx);
@@ -290,12 +518,19 @@ export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
                     }
                 }
             }
+            // Build overload hints for languages with inferLiteralType (Java/Kotlin/C#/C++).
+            // Only used when multiple candidates survive arity filtering — ~1-3% of calls.
+            const langConfig = lang ? typeConfigs[lang] : undefined;
+            const hints = langConfig?.inferLiteralType
+                ? { callNode, inferLiteralType: langConfig.inferLiteralType }
+                : undefined;
             const resolved = resolveCallTarget({
                 calledName,
                 argCount: countCallArguments(callNode),
                 callForm,
                 receiverTypeName,
-            }, file.path, ctx);
+                receiverName,
+            }, file.path, ctx, hints);
             if (!resolved)
                 return;
             const relId = generateId('CALLS', `${sourceId}:${calledName}->${resolved.nodeId}`);
@@ -362,7 +597,9 @@ const filterCallableCandidates = (candidates, argCount, callForm) => {
     const hasParameterMetadata = kindFiltered.some(candidate => candidate.parameterCount !== undefined);
     if (!hasParameterMetadata)
         return kindFiltered;
-    return kindFiltered.filter(candidate => candidate.parameterCount === undefined || candidate.parameterCount === argCount);
+    return kindFiltered.filter(candidate => candidate.parameterCount === undefined
+        || (argCount >= (candidate.requiredParameterCount ?? candidate.parameterCount)
+            && argCount <= candidate.parameterCount));
 };
 const toResolveResult = (definition, tier) => ({
     nodeId: definition.nodeId,
@@ -370,20 +607,129 @@ const toResolveResult = (definition, tier) => ({
     reason: tier === 'same-file' ? 'same-file' : tier === 'import-scoped' ? 'import-resolved' : 'global',
     returnType: definition.returnType,
 });
+/**
+ * Kotlin (and JVM in general) uses boxed type names in parameter declarations
+ * (e.g. `Int`, `Long`, `Boolean`) while inferJvmLiteralType returns unboxed
+ * primitives (`int`, `long`, `boolean`). Normalise both sides to lowercase so
+ * that the comparison `'Int' === 'int'` does not fail.
+ *
+ * Only applied to single-word identifiers that look like a JVM primitive alias;
+ * multi-word or qualified names are left untouched.
+ */
+const KOTLIN_BOXED_TO_PRIMITIVE = {
+    Int: 'int',
+    Long: 'long',
+    Short: 'short',
+    Byte: 'byte',
+    Float: 'float',
+    Double: 'double',
+    Boolean: 'boolean',
+    Char: 'char',
+};
+const normalizeJvmTypeName = (name) => KOTLIN_BOXED_TO_PRIMITIVE[name] ?? name;
+/**
+ * Try to disambiguate overloaded candidates using argument literal types.
+ * Only invoked when filteredCandidates.length > 1 and at least one has parameterTypes.
+ * Returns the single matching candidate, or null if ambiguous/inconclusive.
+ */
+const tryOverloadDisambiguation = (candidates, hints) => {
+    if (!candidates.some(c => c.parameterTypes))
+        return null;
+    // Find the argument list node in the call expression.
+    // Kotlin wraps value_arguments inside a call_suffix child, so we must also
+    // search one level deeper when a direct match is not found.
+    let argList = hints.callNode.childForFieldName?.('arguments')
+        ?? hints.callNode.children.find((c) => c.type === 'arguments' || c.type === 'argument_list' || c.type === 'value_arguments');
+    if (!argList) {
+        // Kotlin: call_expression → call_suffix → value_arguments
+        const callSuffix = hints.callNode.children.find((c) => c.type === 'call_suffix');
+        if (callSuffix) {
+            argList = callSuffix.children.find((c) => c.type === 'value_arguments');
+        }
+    }
+    if (!argList)
+        return null;
+    const argTypes = [];
+    for (const arg of argList.namedChildren) {
+        if (arg.type === 'comment')
+            continue;
+        // Unwrap argument wrapper nodes before passing to inferLiteralType:
+        //   - Kotlin value_argument: has 'value' field containing the literal
+        //   - C# argument: has 'expression' field (handles named args like `name: "alice"`
+        //     where firstNamedChild would return name_colon instead of the value)
+        //   - Java/others: arg IS the literal directly (no unwrapping needed)
+        const valueNode = arg.childForFieldName?.('value')
+            ?? arg.childForFieldName?.('expression')
+            ?? (arg.type === 'argument' || arg.type === 'value_argument'
+                ? arg.firstNamedChild ?? arg
+                : arg);
+        argTypes.push(hints.inferLiteralType(valueNode));
+    }
+    // If no literal types could be inferred, can't disambiguate
+    if (argTypes.every(t => t === undefined))
+        return null;
+    const matched = candidates.filter(c => {
+        // Keep candidates without type info — conservative: partially-annotated codebases
+        // (e.g. C++ with some missing declarations) may have mixed typed/untyped overloads.
+        // If one typed and one untyped both survive, matched.length > 1 → returns null (no edge).
+        if (!c.parameterTypes)
+            return true;
+        return c.parameterTypes.every((pType, i) => {
+            if (i >= argTypes.length || !argTypes[i])
+                return true;
+            // Normalise Kotlin boxed type names (Int→int, Boolean→boolean, etc.) so
+            // that the stored declaration type matches the inferred literal type.
+            return normalizeJvmTypeName(pType) === argTypes[i];
+        });
+    });
+    if (matched.length === 1)
+        return matched[0];
+    // Multiple survivors may share the same nodeId (e.g. TypeScript overload signatures +
+    // implementation body all collide via generateId). Deduplicate by nodeId — if all
+    // matched candidates resolve to the same graph node, disambiguation succeeded.
+    if (matched.length > 1) {
+        const uniqueIds = new Set(matched.map(c => c.nodeId));
+        if (uniqueIds.size === 1)
+            return matched[0];
+    }
+    return null;
+};
 /**
  * Resolve a function call to its target node ID using priority strategy:
  * A. Narrow candidates by scope tier via ctx.resolve()
  * B. Filter to callable symbol kinds (constructor-aware when callForm is set)
  * C. Apply arity filtering when parameter metadata is available
  * D. Apply receiver-type filtering for member calls with typed receivers
+ * E. Apply overload disambiguation via argument literal types (when available)
  *
  * If filtering still leaves multiple candidates, refuse to emit a CALLS edge.
  */
-const resolveCallTarget = (call, currentFile, ctx) => {
+const resolveCallTarget = (call, currentFile, ctx, overloadHints) => {
     const tiered = ctx.resolve(call.calledName, currentFile);
     if (!tiered)
         return null;
-    const filteredCandidates = filterCallableCandidates(tiered.candidates, call.argCount, call.callForm);
+    let filteredCandidates = filterCallableCandidates(tiered.candidates, call.argCount, call.callForm);
+    // Module-qualified constructor pattern: e.g. Python `import models; models.User()`.
+    // The attribute access gives callForm='member', but the callee may be a Class — a valid
+    // constructor target. Re-try with constructor-form filtering so that `module.ClassName()`
+    // emits a CALLS edge to the class node.
+    if (filteredCandidates.length === 0 && call.callForm === 'member') {
+        filteredCandidates = filterCallableCandidates(tiered.candidates, call.argCount, 'constructor');
+    }
+    // Module-alias disambiguation: Python `import auth; auth.User()` — when both models.py and
+    // auth.py export User, receiverName='auth' selects auth.py via moduleAliasMap.
+    // Runs when multiple candidates survive filtering and the receiver is a known module alias.
+    if (filteredCandidates.length > 1 && call.callForm === 'member' && call.receiverName) {
+        const aliasMap = ctx.moduleAliasMap?.get(currentFile);
+        if (aliasMap) {
+            const moduleFile = aliasMap.get(call.receiverName);
+            if (moduleFile) {
+                const aliasFiltered = filteredCandidates.filter(c => c.filePath === moduleFile);
+                if (aliasFiltered.length > 0)
+                    filteredCandidates = aliasFiltered;
+            }
+        }
+    }
     // D. Receiver-type filtering: for member calls with a known receiver type,
     // resolve the type through the same tiered import infrastructure, then
     // filter method candidates to the type's defining file. Fall back to
@@ -415,10 +761,25 @@ const resolveCallTarget = (call, currentFile, ctx) => {
             if (ownerFiltered.length === 1) {
                 return toResolveResult(ownerFiltered[0], tiered.tier);
             }
+            // E. Try overload disambiguation on the narrowed pool
+            if ((fileFiltered.length > 1 || ownerFiltered.length > 1) && overloadHints) {
+                const overloadPool = ownerFiltered.length > 1 ? ownerFiltered : fileFiltered;
+                const disambiguated = tryOverloadDisambiguation(overloadPool, overloadHints);
+                if (disambiguated)
+                    return toResolveResult(disambiguated, tiered.tier);
+            }
             if (fileFiltered.length > 1 || ownerFiltered.length > 1)
                 return null;
         }
     }
+    // E. Overload disambiguation: when multiple candidates survive arity + receiver filtering,
+    // try matching argument literal types against parameter types (Phase P).
+    // Only available on sequential path (has AST); worker path falls through gracefully.
+    if (filteredCandidates.length > 1 && overloadHints) {
+        const disambiguated = tryOverloadDisambiguation(filteredCandidates, overloadHints);
+        if (disambiguated)
+            return toResolveResult(disambiguated, tiered.tier);
+    }
     if (filteredCandidates.length !== 1)
         return null;
     return toResolveResult(filteredCandidates[0], tiered.tier);

package/dist/core/ingestion/call-routing.d.ts

@@ -12,6 +12,12 @@
  */
 /** null = this call was not routed; fall through to default call handling */
 export type CallRoutingResult = RubyCallRouting | null;
+/**
+ * Per-language call router.
+ * IMPORTANT: Call-routed imports bypass preprocessImportPath(), so any router that
+ * returns an importPath MUST validate it independently (length cap, control-char
+ * rejection). See routeRubyCall for the reference implementation.
+ */
 export type CallRouter = (calledName: string, callNode: any) => CallRoutingResult;
 /** Per-language call routing. noRouting = no special routing (normal call processing) */
 export declare const callRouters: {

package/dist/core/ingestion/entry-point-scoring.js

@@ -12,28 +12,31 @@
 import { detectFrameworkFromPath } from './framework-detection.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 // ============================================================================
-// NAME PATTERNS - All 11 supported languages
+// NAME PATTERNS - All 13 supported languages
 // ============================================================================
 /**
- * Common entry point naming patterns by language
- * These patterns indicate functions that are likely feature entry points
+ * Common entry point naming patterns by language.
+ * These patterns indicate functions that are likely feature entry points.
+ *
+ * Universal patterns are separated from per-language patterns so the per-language
+ * table can use `satisfies Record<SupportedLanguages, RegExp[]>` for compile-time
+ * exhaustiveness — the compiler catches any missing language entry.
  */
+const UNIVERSAL_ENTRY_POINT_PATTERNS = [
+    /^(main|init|bootstrap|start|run|setup|configure)$/i,
+    /^handle[A-Z]/, // handleLogin, handleSubmit
+    /^on[A-Z]/, // onClick, onSubmit
+    /Handler$/, // RequestHandler
+    /Controller$/, // UserController
+    /^process[A-Z]/, // processPayment
+    /^execute[A-Z]/, // executeQuery
+    /^perform[A-Z]/, // performAction
+    /^dispatch[A-Z]/, // dispatchEvent
+    /^trigger[A-Z]/, // triggerAction
+    /^fire[A-Z]/, // fireEvent
+    /^emit[A-Z]/, // emitEvent
+];
 const ENTRY_POINT_PATTERNS = {
-    // Universal patterns (apply to all languages)
-    '*': [
-        /^(main|init|bootstrap|start|run|setup|configure)$/i,
-        /^handle[A-Z]/, // handleLogin, handleSubmit
-        /^on[A-Z]/, // onClick, onSubmit
-        /Handler$/, // RequestHandler
-        /Controller$/, // UserController
-        /^process[A-Z]/, // processPayment
-        /^execute[A-Z]/, // executeQuery
-        /^perform[A-Z]/, // performAction
-        /^dispatch[A-Z]/, // dispatchEvent
-        /^trigger[A-Z]/, // triggerAction
-        /^fire[A-Z]/, // fireEvent
-        /^emit[A-Z]/, // emitEvent
-    ],
     // JavaScript/TypeScript
     [SupportedLanguages.JavaScript]: [
         /^use[A-Z]/, // React hooks (useEffect, etc.)
@@ -55,6 +58,16 @@ const ENTRY_POINT_PATTERNS = {
         /^build[A-Z]/, // Builder patterns
         /Service$/, // UserService
     ],
+    // Kotlin
+    [SupportedLanguages.Kotlin]: [
+        /^on(Create|Start|Resume|Pause|Stop|Destroy)$/, // Android lifecycle
+        /^do[A-Z]/, // doGet, doPost (shared JVM Servlet pattern)
+        /^create[A-Z]/, // Factory patterns
+        /^build[A-Z]/, // Builder patterns
+        /ViewModel$/, // MVVM pattern (Android)
+        /^module$/, // Ktor module entry point
+        /Service$/, // Service classes
+    ],
     // C#
     [SupportedLanguages.CSharp]: [
         /^(Get|Post|Put|Delete|Patch)/, // ASP.NET action methods
@@ -186,13 +199,10 @@ const ENTRY_POINT_PATTERNS = {
     ],
 };
 /** Pre-computed merged patterns (universal + language-specific) to avoid per-call array allocation. */
-const MERGED_ENTRY_POINT_PATTERNS = {};
-const UNIVERSAL_PATTERNS = ENTRY_POINT_PATTERNS['*'] || [];
-for (const [lang, patterns] of Object.entries(ENTRY_POINT_PATTERNS)) {
-    if (lang === '*')
-        continue;
-    MERGED_ENTRY_POINT_PATTERNS[lang] = [...UNIVERSAL_PATTERNS, ...patterns];
-}
+const MERGED_ENTRY_POINT_PATTERNS = Object.fromEntries(Object.keys(ENTRY_POINT_PATTERNS).map(lang => [
+    lang,
+    [...UNIVERSAL_ENTRY_POINT_PATTERNS, ...ENTRY_POINT_PATTERNS[lang]],
+]));
 // ============================================================================
 // UTILITY PATTERNS - Functions that should be penalized
 // ============================================================================
@@ -258,7 +268,7 @@ export function calculateEntryPointScore(name, language, isExported, callerCount
     }
     else {
         // Check positive patterns
-        const allPatterns = MERGED_ENTRY_POINT_PATTERNS[language] || UNIVERSAL_PATTERNS;
+        const allPatterns = MERGED_ENTRY_POINT_PATTERNS[language];
         if (allPatterns.some(p => p.test(name))) {
             nameMultiplier = 1.5; // Bonus for matching entry point pattern
             reasons.push('entry-pattern');

package/dist/core/ingestion/framework-detection.d.ts

@@ -9,6 +9,7 @@
  * DESIGN: Returns null for unknown frameworks, which causes a 1.0 multiplier
  * (no bonus, no penalty) - same behavior as before this feature.
  */
+import { SupportedLanguages } from '../../config/supported-languages.js';
 export interface FrameworkHint {
     framework: string;
     entryPointMultiplier: number;
@@ -37,15 +38,22 @@ export declare const FRAMEWORK_AST_PATTERNS: {
     blazor: string[];
     efcore: string[];
     'go-http': string[];
+    gin: string[];
+    echo: string[];
+    fiber: string[];
+    'go-grpc': string[];
     laravel: string[];
     actix: string[];
     axum: string[];
     rocket: string[];
+    tokio: string[];
+    qt: string[];
     uikit: string[];
     swiftui: string[];
-    combine: string[];
+    vapor: string[];
+    rails: string[];
+    sinatra: string[];
 };
-import { SupportedLanguages } from '../../config/supported-languages.js';
 /**
  * Detect framework entry points from AST definition text (decorators/annotations/attributes).
  * Returns null if no known pattern is found.