gitnexus 1.4.7 → 1.4.9

package/dist/core/ingestion/workers/parse-worker.js

@@ -13,7 +13,7 @@ import PHP from 'tree-sitter-php';
 import Ruby from 'tree-sitter-ruby';
 import { createRequire } from 'node:module';
 import { SupportedLanguages } from '../../../config/supported-languages.js';
-import { LANGUAGE_QUERIES } from '../tree-sitter-queries.js';
+import { getProvider } from '../languages/index.js';
 import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from '../constants.js';
 // tree-sitter-swift is an optionalDependency — may not be installed
 const _require = createRequire(import.meta.url);
@@ -22,22 +22,26 @@ try {
     Swift = _require('tree-sitter-swift');
 }
 catch { }
+// tree-sitter-dart is an optionalDependency — may not be installed
+let Dart = null;
+try {
+    Dart = _require('tree-sitter-dart');
+}
+catch { }
 // tree-sitter-kotlin is an optionalDependency — may not be installed
 let Kotlin = null;
 try {
     Kotlin = _require('tree-sitter-kotlin');
 }
 catch { }
-import { getLanguageFromFilename, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, } from '../utils.js';
+import { getLanguageFromFilename } from '../utils/language-detection.js';
+import { FUNCTION_NODE_TYPES, extractFunctionName, getDefinitionNodeFromCaptures, findEnclosingClassId, getLabelFromCaptures, extractMethodSignature, findDescendant, extractStringContent, } from '../utils/ast-helpers.js';
+import { countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, } from '../utils/call-analysis.js';
 import { buildTypeEnv } from '../type-env.js';
-import { isNodeExported } from '../export-detection.js';
 import { detectFrameworkFromAST } from '../framework-detection.js';
-import { typeConfigs } from '../type-extractors/index.js';
 import { generateId } from '../../../lib/utils.js';
-import { extractNamedBindings } from '../named-binding-extraction.js';
-import { appendKotlinWildcard } from '../resolvers/index.js';
-import { callRouters } from '../call-routing.js';
-import { extractPropertyDeclaredType } from '../type-extractors/shared.js';
+import { preprocessImportPath } from '../import-processor.js';
+import { CLASS_CONTAINER_TYPES } from '../utils/ast-helpers.js';
 // ============================================================================
 // Worker-local parser + language map
 // ============================================================================
@@ -56,6 +60,7 @@ const languageMap = {
     ...(Kotlin ? { [SupportedLanguages.Kotlin]: Kotlin } : {}),
     [SupportedLanguages.PHP]: PHP.php_only,
     [SupportedLanguages.Ruby]: Ruby,
+    ...(Dart ? { [SupportedLanguages.Dart]: Dart } : {}),
     ...(Swift ? { [SupportedLanguages.Swift]: Swift } : {}),
 };
 /**
@@ -79,79 +84,131 @@ const setLanguage = (language, filePath) => {
         throw new Error(`Unsupported language: ${language}`);
     parser.setLanguage(lang);
 };
-// isNodeExported imported from ../export-detection.js (shared module)
 // ============================================================================
-// Enclosing function detection (for call extraction)
+// Per-file O(1) memoization — avoids repeated parent-chain walks per symbol.
+// Three bare Maps cleared at file boundaries. Map.get() returns undefined for
+// missing keys, so `cached !== undefined` distinguishes "not computed" from
+// a stored null (enclosing class/function not found = top-level).
+// ============================================================================
+const classIdCache = new Map();
+const functionIdCache = new Map();
+const exportCache = new Map();
+const clearCaches = () => { classIdCache.clear(); functionIdCache.clear(); exportCache.clear(); fieldInfoCache.clear(); };
+// ============================================================================
+// FieldExtractor cache — extract field metadata once per class, reuse for each property.
+// Keyed by class node startIndex (unique per AST node within a file).
 // ============================================================================
-/** Walk up AST to find enclosing function, return its generateId or null for top-level */
-const findEnclosingFunctionId = (node, filePath) => {
+const fieldInfoCache = new Map();
+/**
+ * Walk up from a definition node to find the nearest enclosing class/struct/interface
+ * AST node. Returns the SyntaxNode itself (not an ID) for passing to FieldExtractor.
+ */
+function findEnclosingClassNode(node) {
+    let current = node.parent;
+    while (current) {
+        if (CLASS_CONTAINER_TYPES.has(current.type)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+/**
+ * Minimal no-op SymbolTable stub for FieldExtractorContext in the worker.
+ * Field extraction only uses symbolTable.lookupExactAll for optional type resolution —
+ * returning [] causes the extractor to use the raw type string, which is fine for us.
+ */
+const NOOP_SYMBOL_TABLE = {
+    lookupExactAll: () => [],
+    lookupExact: () => undefined,
+    lookupExactFull: () => undefined,
+};
+/**
+ * Get (or extract and cache) field info for a class node.
+ * Returns a name→FieldInfo map, or undefined if the provider has no field extractor
+ * or the class yielded no fields.
+ */
+function getFieldInfo(classNode, provider, context) {
+    if (!provider.fieldExtractor)
+        return undefined;
+    const cacheKey = classNode.startIndex;
+    let cached = fieldInfoCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const result = provider.fieldExtractor.extract(classNode, context);
+    if (!result?.fields?.length)
+        return undefined;
+    cached = new Map();
+    for (const field of result.fields) {
+        cached.set(field.name, field);
+    }
+    fieldInfoCache.set(cacheKey, cached);
+    return cached;
+}
+/** Walk up AST to find enclosing function, return its generateId or null for top-level.
+ *  Applies provider.labelOverride so the label matches the definition phase (single source of truth). */
+const findEnclosingFunctionId = (node, filePath, provider) => {
+    const cached = functionIdCache.get(node);
+    if (cached !== undefined)
+        return cached;
     let current = node.parent;
     while (current) {
         if (FUNCTION_NODE_TYPES.has(current.type)) {
             const { funcName, label } = extractFunctionName(current);
             if (funcName) {
-                return generateId(label, `${filePath}:${funcName}`);
+                // Apply labelOverride so label matches definition phase (e.g., Kotlin Function→Method).
+                // null means "skip as definition" — keep original label for scope identification.
+                let finalLabel = label;
+                if (provider.labelOverride) {
+                    const override = provider.labelOverride(current, label);
+                    if (override !== null)
+                        finalLabel = override;
+                }
+                const result = generateId(finalLabel, `${filePath}:${funcName}`);
+                functionIdCache.set(node, result);
+                return result;
+            }
+        }
+        // Language-specific enclosing function resolution (e.g., Dart where
+        // function_body is a sibling of function_signature, not a child).
+        if (provider.enclosingFunctionFinder) {
+            const customResult = provider.enclosingFunctionFinder(current);
+            if (customResult) {
+                let finalLabel = customResult.label;
+                if (provider.labelOverride) {
+                    const override = provider.labelOverride(current.previousSibling, finalLabel);
+                    if (override !== null)
+                        finalLabel = override;
+                }
+                const result = generateId(finalLabel, `${filePath}:${customResult.funcName}`);
+                functionIdCache.set(node, result);
+                return result;
             }
         }
         current = current.parent;
     }
+    functionIdCache.set(node, null);
     return null;
 };
-// ============================================================================
-// Label detection from capture map
-// ============================================================================
-const getLabelFromCaptures = (captureMap) => {
-    // Skip imports (handled separately) and calls
-    if (captureMap['import'] || captureMap['call'])
-        return null;
-    if (!captureMap['name'])
-        return null;
-    if (captureMap['definition.function'])
-        return 'Function';
-    if (captureMap['definition.class'])
-        return 'Class';
-    if (captureMap['definition.interface'])
-        return 'Interface';
-    if (captureMap['definition.method'])
-        return 'Method';
-    if (captureMap['definition.struct'])
-        return 'Struct';
-    if (captureMap['definition.enum'])
-        return 'Enum';
-    if (captureMap['definition.namespace'])
-        return 'Namespace';
-    if (captureMap['definition.module'])
-        return 'Module';
-    if (captureMap['definition.trait'])
-        return 'Trait';
-    if (captureMap['definition.impl'])
-        return 'Impl';
-    if (captureMap['definition.type'])
-        return 'TypeAlias';
-    if (captureMap['definition.const'])
-        return 'Const';
-    if (captureMap['definition.static'])
-        return 'Static';
-    if (captureMap['definition.typedef'])
-        return 'Typedef';
-    if (captureMap['definition.macro'])
-        return 'Macro';
-    if (captureMap['definition.union'])
-        return 'Union';
-    if (captureMap['definition.property'])
-        return 'Property';
-    if (captureMap['definition.record'])
-        return 'Record';
-    if (captureMap['definition.delegate'])
-        return 'Delegate';
-    if (captureMap['definition.annotation'])
-        return 'Annotation';
-    if (captureMap['definition.constructor'])
-        return 'Constructor';
-    if (captureMap['definition.template'])
-        return 'Template';
-    return 'CodeElement';
+/** Cached wrapper for findEnclosingClassId — avoids repeated parent walks. */
+const cachedFindEnclosingClassId = (node, filePath) => {
+    const cached = classIdCache.get(node);
+    if (cached !== undefined)
+        return cached;
+    const result = findEnclosingClassId(node, filePath);
+    classIdCache.set(node, result);
+    return result;
+};
+/** Cached wrapper for export checking — avoids repeated parent walks per symbol. */
+const cachedExportCheck = (checker, node, name) => {
+    const cached = exportCache.get(node);
+    if (cached !== undefined)
+        return cached;
+    const result = checker(node, name);
+    exportCache.set(node, result);
+    return result;
 };
+// Label detection moved to shared getLabelFromCaptures in utils.ts
 // DEFINITION_CAPTURE_KEYS and getDefinitionNodeFromCaptures imported from ../utils.js
 // ============================================================================
 // Process a batch of files
@@ -166,7 +223,12 @@ const processBatch = (files, onProgress) => {
         assignments: [],
         heritage: [],
         routes: [],
+        fetchCalls: [],
+        decoratorRoutes: [],
+        toolDefs: [],
+        ormQueries: [],
         constructorBindings: [],
+        typeEnvBindings: [],
         skippedLanguages: {},
         fileCount: 0,
     };
@@ -194,7 +256,8 @@ const processBatch = (files, onProgress) => {
         }
     } : undefined;
     for (const [language, langFiles] of byLanguage) {
-        const queryString = LANGUAGE_QUERIES[language];
+        const provider = getProvider(language);
+        const queryString = provider.treeSitterQueries;
         if (!queryString)
             continue;
         // Track if we need to handle tsx separately
@@ -246,114 +309,23 @@ const processBatch = (files, onProgress) => {
     }
     return result;
 };
-// ============================================================================
-// PHP Eloquent metadata extraction
-// ============================================================================
-/** Eloquent model properties whose array values are worth indexing */
-const ELOQUENT_ARRAY_PROPS = new Set(['fillable', 'casts', 'hidden', 'guarded', 'with', 'appends']);
-/** Eloquent relationship method names */
-const ELOQUENT_RELATIONS = new Set([
-    'hasMany', 'hasOne', 'belongsTo', 'belongsToMany',
-    'morphTo', 'morphMany', 'morphOne', 'morphToMany', 'morphedByMany',
-    'hasManyThrough', 'hasOneThrough',
-]);
-function findDescendant(node, type) {
-    if (node.type === type)
-        return node;
-    for (const child of (node.children ?? [])) {
-        const found = findDescendant(child, type);
-        if (found)
-            return found;
-    }
-    return null;
-}
-function extractStringContent(node) {
-    if (!node)
-        return null;
-    const content = node.children?.find((c) => c.type === 'string_content');
-    if (content)
-        return content.text;
-    if (node.type === 'string_content')
-        return node.text;
-    return null;
-}
-/**
- * For a PHP property_declaration node, extract array values as a description string.
- * Returns null if not an Eloquent model property or no array values found.
- */
-function extractPhpPropertyDescription(propName, propDeclNode) {
-    if (!ELOQUENT_ARRAY_PROPS.has(propName))
-        return null;
-    const arrayNode = findDescendant(propDeclNode, 'array_creation_expression');
-    if (!arrayNode)
-        return null;
-    const items = [];
-    for (const child of (arrayNode.children ?? [])) {
-        if (child.type !== 'array_element_initializer')
-            continue;
-        const children = child.children ?? [];
-        const arrowIdx = children.findIndex((c) => c.type === '=>');
-        if (arrowIdx !== -1) {
-            // key => value pair (used in $casts)
-            const key = extractStringContent(children[arrowIdx - 1]);
-            const val = extractStringContent(children[arrowIdx + 1]);
-            if (key && val)
-                items.push(`${key}:${val}`);
-        }
-        else {
-            // Simple value (used in $fillable, $hidden, etc.)
-            const val = extractStringContent(children[0]);
-            if (val)
-                items.push(val);
-        }
-    }
-    return items.length > 0 ? items.join(', ') : null;
-}
-/**
- * For a PHP method_declaration node, detect if it defines an Eloquent relationship.
- * Returns description like "hasMany(Post)" or null.
- */
-function extractEloquentRelationDescription(methodNode) {
-    function findRelationCall(node) {
-        if (node.type === 'member_call_expression') {
-            const children = node.children ?? [];
-            const objectNode = children.find((c) => c.type === 'variable_name' && c.text === '$this');
-            const nameNode = children.find((c) => c.type === 'name');
-            if (objectNode && nameNode && ELOQUENT_RELATIONS.has(nameNode.text))
-                return node;
-        }
-        for (const child of (node.children ?? [])) {
-            const found = findRelationCall(child);
-            if (found)
-                return found;
-        }
-        return null;
-    }
-    const callNode = findRelationCall(methodNode);
-    if (!callNode)
-        return null;
-    const relType = callNode.children?.find((c) => c.type === 'name')?.text;
-    const argsNode = callNode.children?.find((c) => c.type === 'arguments');
-    let targetModel = null;
-    if (argsNode) {
-        const firstArg = argsNode.children?.find((c) => c.type === 'argument');
-        if (firstArg) {
-            const classConstant = firstArg.children?.find((c) => c.type === 'class_constant_access_expression');
-            if (classConstant) {
-                targetModel = classConstant.children?.find((c) => c.type === 'name')?.text ?? null;
-            }
-        }
-    }
-    if (relType && targetModel)
-        return `${relType}(${targetModel})`;
-    if (relType)
-        return relType;
-    return null;
-}
 const ROUTE_HTTP_METHODS = new Set([
     'get', 'post', 'put', 'patch', 'delete', 'options', 'any', 'match',
 ]);
 const ROUTE_RESOURCE_METHODS = new Set(['resource', 'apiResource']);
+// Express/Hono method names that register routes
+const EXPRESS_ROUTE_METHODS = new Set(['get', 'post', 'put', 'delete', 'patch', 'all', 'use', 'route']);
+// HTTP client methods that are ONLY used by clients, not Express route registration.
+// Methods like get/post/put/delete/patch overlap with Express — those are captured by
+// the express_route handler as route definitions, not consumers. The fetch() global
+// function is captured separately by the route.fetch query.
+const HTTP_CLIENT_ONLY_METHODS = new Set(['head', 'options', 'request', 'ajax']);
+// Decorator names that indicate HTTP route handlers (NestJS, Flask, FastAPI, Spring)
+const ROUTE_DECORATOR_NAMES = new Set([
+    'Get', 'Post', 'Put', 'Delete', 'Patch', 'Route',
+    'get', 'post', 'put', 'delete', 'patch', 'route',
+    'RequestMapping', 'GetMapping', 'PostMapping', 'PutMapping', 'DeleteMapping',
+]);
 const RESOURCE_ACTIONS = ['index', 'create', 'store', 'show', 'edit', 'update', 'destroy'];
 const API_RESOURCE_ACTIONS = ['index', 'store', 'show', 'update', 'destroy'];
 /** Check if node is a scoped_call_expression with object 'Route' */
@@ -697,6 +669,50 @@ function extractLaravelRoutes(tree, filePath) {
     walk(tree.rootNode, []);
     return routes;
 }
+// ============================================================================
+// ORM Query Detection (Prisma + Supabase)
+// ============================================================================
+const PRISMA_QUERY_RE = /\bprisma\.(\w+)\.(findMany|findFirst|findUnique|findUniqueOrThrow|findFirstOrThrow|create|createMany|update|updateMany|delete|deleteMany|upsert|count|aggregate|groupBy)\s*\(/g;
+const SUPABASE_QUERY_RE = /\bsupabase\.from\s*\(\s*['"](\w+)['"]\s*\)\s*\.(select|insert|update|delete|upsert)\s*\(/g;
+/**
+ * Extract ORM query calls from file content via regex.
+ * Appends results to the provided array (avoids allocation when no matches).
+ */
+export function extractORMQueries(filePath, content, out) {
+    const hasPrisma = content.includes('prisma.');
+    const hasSupabase = content.includes('supabase.from');
+    if (!hasPrisma && !hasSupabase)
+        return;
+    if (hasPrisma) {
+        PRISMA_QUERY_RE.lastIndex = 0;
+        let m;
+        while ((m = PRISMA_QUERY_RE.exec(content)) !== null) {
+            const model = m[1];
+            if (model.startsWith('$'))
+                continue;
+            out.push({
+                filePath,
+                orm: 'prisma',
+                model,
+                method: m[2],
+                lineNumber: content.substring(0, m.index).split('\n').length - 1,
+            });
+        }
+    }
+    if (hasSupabase) {
+        SUPABASE_QUERY_RE.lastIndex = 0;
+        let m;
+        while ((m = SUPABASE_QUERY_RE.exec(content)) !== null) {
+            out.push({
+                filePath,
+                orm: 'supabase',
+                model: m[1],
+                method: m[2],
+                lineNumber: content.substring(0, m.index).split('\n').length - 1,
+            });
+        }
+    }
+}
 const processFileGroup = (files, language, queryString, result, onFileProcessed) => {
     let query;
     try {
@@ -717,6 +733,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         // Skip files larger than the max tree-sitter buffer (32 MB)
         if (file.content.length > TREE_SITTER_MAX_BUFFER)
             continue;
+        clearCaches(); // Reset memoization before each new file
         let tree;
         try {
             tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
@@ -727,13 +744,6 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         }
         result.fileCount++;
         onFileProcessed?.();
-        // Build per-file type environment + constructor bindings in a single AST walk.
-        // Constructor bindings are verified against the SymbolTable in processCallsFromExtracted.
-        const typeEnv = buildTypeEnv(tree, language);
-        const callRouter = callRouters[language];
-        if (typeEnv.constructorBindings.length > 0) {
-            result.constructorBindings.push({ filePath: file.path, bindings: [...typeEnv.constructorBindings] });
-        }
         let matches;
         try {
             matches = query.matches(tree.rootNode);
@@ -742,6 +752,54 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             console.warn(`Query execution failed for ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
             continue;
         }
+        // Pre-pass: extract heritage from query matches to build parentMap for buildTypeEnv.
+        // Heritage edges (EXTENDS/IMPLEMENTS) are created by heritage-processor which runs
+        // in PARALLEL with call-processor, so the graph edges don't exist when buildTypeEnv
+        // runs. This pre-pass makes parent class information available for type resolution.
+        const fileParentMap = new Map();
+        for (const match of matches) {
+            const captureMap = {};
+            for (const c of match.captures) {
+                captureMap[c.name] = c.node;
+            }
+            if (captureMap['heritage.class'] && captureMap['heritage.extends']) {
+                const className = captureMap['heritage.class'].text;
+                const parentName = captureMap['heritage.extends'].text;
+                // Skip Go named fields (only anonymous fields are struct embedding)
+                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);
+            }
+        }
+        // Build per-file type environment + constructor bindings in a single AST walk.
+        // Constructor bindings are verified against the SymbolTable in processCallsFromExtracted.
+        const parentMap = fileParentMap;
+        const provider = getProvider(language);
+        const typeEnv = buildTypeEnv(tree, language, { parentMap, enclosingFunctionFinder: provider?.enclosingFunctionFinder });
+        const callRouter = provider.callRouter;
+        if (typeEnv.constructorBindings.length > 0) {
+            result.constructorBindings.push({ filePath: file.path, bindings: [...typeEnv.constructorBindings] });
+        }
+        // Extract file-scope bindings for ExportedTypeMap (closes worker/sequential quality gap).
+        // Sequential path uses collectExportedBindings(typeEnv) directly; worker path serializes
+        // these bindings so the main thread can merge them into ExportedTypeMap.
+        const fileScope = typeEnv.fileScope();
+        if (fileScope.size > 0) {
+            const bindings = [];
+            for (const [name, type] of fileScope)
+                bindings.push([name, type]);
+            result.typeEnvBindings.push({ filePath: file.path, bindings });
+        }
+        // Per-file map: decorator end-line → decorator info, for associating with definitions
+        const fileDecorators = new Map();
         for (const match of matches) {
             const captureMap = {};
             for (const c of match.captures) {
@@ -749,10 +807,11 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             }
             // Extract import paths before skipping
             if (captureMap['import'] && captureMap['import.source']) {
-                const rawImportPath = language === SupportedLanguages.Kotlin
-                    ? appendKotlinWildcard(captureMap['import.source'].text.replace(/['"<>]/g, ''), captureMap['import'])
-                    : captureMap['import.source'].text.replace(/['"<>]/g, '');
-                const namedBindings = extractNamedBindings(captureMap['import'], language);
+                const rawImportPath = preprocessImportPath(captureMap['import.source'].text, captureMap['import'], provider);
+                if (!rawImportPath)
+                    continue;
+                const extractor = provider.namedBindingExtractor;
+                const namedBindings = extractor ? extractor(captureMap['import']) : undefined;
                 result.imports.push({
                     filePath: file.path,
                     rawImportPath,
@@ -766,7 +825,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 const receiverText = captureMap['assignment.receiver'].text;
                 const propertyName = captureMap['assignment.property'].text;
                 if (receiverText && propertyName) {
-                    const srcId = findEnclosingFunctionId(captureMap['assignment'], file.path)
+                    const srcId = findEnclosingFunctionId(captureMap['assignment'], file.path, provider)
                         || generateId('File', file.path);
                     let receiverTypeName;
                     if (typeEnv) {
@@ -783,13 +842,82 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 if (!captureMap['call'])
                     continue;
             }
+            // Store decorator metadata for later association with definitions
+            if (captureMap['decorator'] && captureMap['decorator.name']) {
+                const decoratorName = captureMap['decorator.name'].text;
+                const decoratorArg = captureMap['decorator.arg']?.text;
+                const decoratorNode = captureMap['decorator'];
+                // Store by the decorator's end line — the definition follows immediately after
+                fileDecorators.set(decoratorNode.endPosition.row, { name: decoratorName, arg: decoratorArg });
+                if (ROUTE_DECORATOR_NAMES.has(decoratorName)) {
+                    const routePath = decoratorArg || '';
+                    const method = decoratorName.replace('Mapping', '').toUpperCase();
+                    const httpMethod = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'].includes(method) ? method : 'GET';
+                    result.decoratorRoutes.push({
+                        filePath: file.path,
+                        routePath,
+                        httpMethod,
+                        decoratorName,
+                        lineNumber: decoratorNode.startPosition.row,
+                    });
+                }
+                // MCP/RPC tool detection: @mcp.tool(), @app.tool(), @server.tool()
+                if (decoratorName === 'tool') {
+                    // Re-store with isTool flag for the definition handler
+                    fileDecorators.set(decoratorNode.endPosition.row, { name: decoratorName, arg: decoratorArg, isTool: true });
+                }
+                continue;
+            }
+            // Extract HTTP consumer URLs: fetch(), axios.get(), $.get(), requests.get(), etc.
+            if (captureMap['route.fetch']) {
+                const urlNode = captureMap['route.url'] ?? captureMap['route.template_url'];
+                if (urlNode) {
+                    result.fetchCalls.push({
+                        filePath: file.path,
+                        fetchURL: urlNode.text,
+                        lineNumber: captureMap['route.fetch'].startPosition.row,
+                    });
+                }
+                continue;
+            }
+            // HTTP client calls: axios.get('/path'), $.post('/path'), requests.get('/path')
+            // Skip methods also in EXPRESS_ROUTE_METHODS to avoid double-registering Express
+            // routes as both route definitions AND consumers (both queries match same AST node)
+            if (captureMap['http_client'] && captureMap['http_client.url']) {
+                const method = captureMap['http_client.method']?.text;
+                const url = captureMap['http_client.url'].text;
+                if (method && HTTP_CLIENT_ONLY_METHODS.has(method) && url.startsWith('/')) {
+                    result.fetchCalls.push({
+                        filePath: file.path,
+                        fetchURL: url,
+                        lineNumber: captureMap['http_client'].startPosition.row,
+                    });
+                }
+                continue;
+            }
+            // Express/Hono route registration: app.get('/path', handler)
+            if (captureMap['express_route'] && captureMap['express_route.method'] && captureMap['express_route.path']) {
+                const method = captureMap['express_route.method'].text;
+                const routePath = captureMap['express_route.path'].text;
+                if (EXPRESS_ROUTE_METHODS.has(method) && routePath.startsWith('/')) {
+                    const httpMethod = method === 'all' || method === 'use' || method === 'route' ? 'GET' : method.toUpperCase();
+                    result.decoratorRoutes.push({
+                        filePath: file.path,
+                        routePath,
+                        httpMethod,
+                        decoratorName: `express.${method}`,
+                        lineNumber: captureMap['express_route'].startPosition.row,
+                    });
+                }
+                continue;
+            }
             // Extract call sites
             if (captureMap['call']) {
                 const callNameNode = captureMap['call.name'];
                 if (callNameNode) {
                     const calledName = callNameNode.text;
                     // Dispatch: route language-specific calls (heritage, properties, imports)
-                    const routed = callRouter(calledName, captureMap['call']);
+                    const routed = callRouter?.(calledName, captureMap['call']);
                     if (routed) {
                         if (routed.kind === 'skip')
                             continue;
@@ -813,8 +941,19 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                             continue;
                         }
                         if (routed.kind === 'properties') {
-                            const propEnclosingClassId = findEnclosingClassId(captureMap['call'], file.path);
+                            const propEnclosingClassId = cachedFindEnclosingClassId(captureMap['call'], file.path);
+                            // Enrich routed properties with FieldExtractor metadata
+                            let routedFieldMap;
+                            if (provider.fieldExtractor && typeEnv) {
+                                const classNode = findEnclosingClassNode(captureMap['call']);
+                                if (classNode) {
+                                    routedFieldMap = getFieldInfo(classNode, provider, {
+                                        typeEnv, symbolTable: NOOP_SYMBOL_TABLE, filePath: file.path, language,
+                                    });
+                                }
+                            }
                             for (const item of routed.items) {
+                                const routedFieldInfo = routedFieldMap?.get(item.propName);
                                 const nodeId = generateId('Property', `${file.path}:${item.propName}`);
                                 result.nodes.push({
                                     id: nodeId,
@@ -827,6 +966,10 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                                         language,
                                         isExported: true,
                                         description: item.accessorType,
+                                        ...(item.declaredType ? { declaredType: item.declaredType } : routedFieldInfo?.type ? { declaredType: routedFieldInfo.type } : {}),
+                                        ...(routedFieldInfo?.visibility !== undefined ? { visibility: routedFieldInfo.visibility } : {}),
+                                        ...(routedFieldInfo?.isStatic !== undefined ? { isStatic: routedFieldInfo.isStatic } : {}),
+                                        ...(routedFieldInfo?.isReadonly !== undefined ? { isReadonly: routedFieldInfo.isReadonly } : {}),
                                     },
                                 });
                                 result.symbols.push({
@@ -835,7 +978,10 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                                     nodeId,
                                     type: 'Property',
                                     ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}),
-                                    ...(item.declaredType ? { declaredType: item.declaredType } : {}),
+                                    ...(item.declaredType ? { declaredType: item.declaredType } : routedFieldInfo?.type ? { declaredType: routedFieldInfo.type } : {}),
+                                    ...(routedFieldInfo?.visibility !== undefined ? { visibility: routedFieldInfo.visibility } : {}),
+                                    ...(routedFieldInfo?.isStatic !== undefined ? { isStatic: routedFieldInfo.isStatic } : {}),
+                                    ...(routedFieldInfo?.isReadonly !== undefined ? { isReadonly: routedFieldInfo.isReadonly } : {}),
                                 });
                                 const fileId = generateId('File', file.path);
                                 const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
@@ -862,9 +1008,9 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                         }
                         // kind === 'call' — fall through to normal call processing below
                     }
-                    if (!isBuiltInOrNoise(calledName)) {
+                    if (!provider.isBuiltInName(calledName)) {
                         const callNode = captureMap['call'];
-                        const sourceId = findEnclosingFunctionId(callNode, file.path)
+                        const sourceId = findEnclosingFunctionId(callNode, file.path, provider)
                             || generateId('File', file.path);
                         const callForm = inferCallForm(callNode, callNameNode);
                         let receiverName = callForm === 'member' ? extractReceiverName(callNameNode) : undefined;
@@ -941,24 +1087,9 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     continue;
                 }
             }
-            const nodeLabel = getLabelFromCaptures(captureMap);
+            const nodeLabel = getLabelFromCaptures(captureMap, provider);
             if (!nodeLabel)
                 continue;
-            // C/C++: @definition.function is broad and also matches inline class methods (inside
-            // a class/struct body). Those are already captured by @definition.method, so skip
-            // the duplicate Function entry to prevent double-indexing in globalIndex.
-            if ((language === SupportedLanguages.CPlusPlus || language === SupportedLanguages.C) &&
-                nodeLabel === 'Function') {
-                let ancestor = captureMap['definition.function']?.parent;
-                while (ancestor) {
-                    if (ancestor.type === 'class_specifier' || ancestor.type === 'struct_specifier') {
-                        break; // inside a class body — duplicate of @definition.method
-                    }
-                    ancestor = ancestor.parent;
-                }
-                if (ancestor)
-                    continue; // found a class/struct ancestor → skip
-            }
             const nameNode = captureMap['name'];
             // Synthesize name for constructors without explicit @name capture (e.g. Swift init)
             if (!nameNode && nodeLabel !== 'Constructor')
@@ -967,29 +1098,57 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             const definitionNode = getDefinitionNodeFromCaptures(captureMap);
             const startLine = definitionNode ? definitionNode.startPosition.row : (nameNode ? nameNode.startPosition.row : 0);
             const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`);
-            let description;
-            if (language === SupportedLanguages.PHP) {
-                if (nodeLabel === 'Property' && captureMap['definition.property']) {
-                    description = extractPhpPropertyDescription(nodeName, captureMap['definition.property']) ?? undefined;
-                }
-                else if (nodeLabel === 'Method' && captureMap['definition.method']) {
-                    description = extractEloquentRelationDescription(captureMap['definition.method']) ?? undefined;
-                }
-            }
-            const frameworkHint = definitionNode
+            const description = provider.descriptionExtractor?.(nodeLabel, nodeName, captureMap);
+            let frameworkHint = definitionNode
                 ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300))
                 : null;
+            // Decorators appear on lines immediately before their definition; allow up to
+            // MAX_DECORATOR_SCAN_LINES gap for blank lines / multi-line decorator stacks.
+            const MAX_DECORATOR_SCAN_LINES = 5;
+            if (definitionNode) {
+                const defStartLine = definitionNode.startPosition.row;
+                for (let checkLine = defStartLine - 1; checkLine >= Math.max(0, defStartLine - MAX_DECORATOR_SCAN_LINES); checkLine--) {
+                    const dec = fileDecorators.get(checkLine);
+                    if (dec) {
+                        // Use first (closest) decorator found for framework hint
+                        if (!frameworkHint) {
+                            frameworkHint = {
+                                framework: 'decorator',
+                                entryPointMultiplier: 1.2,
+                                reason: `@${dec.name}${dec.arg ? `("${dec.arg}")` : ''}`,
+                            };
+                        }
+                        // Emit tool definition if this is a @tool decorator
+                        if (dec.isTool) {
+                            result.toolDefs.push({
+                                filePath: file.path,
+                                toolName: nodeName,
+                                description: dec.arg || '',
+                                lineNumber: definitionNode.startPosition.row,
+                            });
+                        }
+                        fileDecorators.delete(checkLine);
+                    }
+                }
+            }
             let parameterCount;
+            let requiredParameterCount;
+            let parameterTypes;
             let returnType;
             let declaredType;
+            let visibility;
+            let isStatic;
+            let isReadonly;
             if (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor') {
                 const sig = extractMethodSignature(definitionNode);
                 parameterCount = sig.parameterCount;
+                requiredParameterCount = sig.requiredParameterCount;
+                parameterTypes = sig.parameterTypes;
                 returnType = sig.returnType;
                 // Language-specific return type fallback (e.g. Ruby YARD @return [Type])
                 // Also upgrades uninformative AST types like PHP `array` with PHPDoc `@return User[]`
                 if ((!returnType || returnType === 'array' || returnType === 'iterable') && definitionNode) {
-                    const tc = typeConfigs[language];
+                    const tc = provider.typeConfig;
                     if (tc?.extractReturnType) {
                         const docReturn = tc.extractReturnType(definitionNode);
                         if (docReturn)
@@ -998,9 +1157,22 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 }
             }
             else if (nodeLabel === 'Property' && definitionNode) {
-                // Extract the declared type for property/field nodes.
-                // Walk the definition node for type annotation children.
-                declaredType = extractPropertyDeclaredType(definitionNode);
+                // FieldExtractor is the single source of truth when available
+                if (provider.fieldExtractor && typeEnv) {
+                    const classNode = findEnclosingClassNode(definitionNode);
+                    if (classNode) {
+                        const fieldMap = getFieldInfo(classNode, provider, {
+                            typeEnv, symbolTable: NOOP_SYMBOL_TABLE, filePath: file.path, language,
+                        });
+                        const info = fieldMap?.get(nodeName);
+                        if (info) {
+                            declaredType = info.type ?? undefined;
+                            visibility = info.visibility;
+                            isStatic = info.isStatic;
+                            isReadonly = info.isReadonly;
+                        }
+                    }
+                }
             }
             result.nodes.push({
                 id: nodeId,
@@ -1011,29 +1183,40 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     startLine: definitionNode ? definitionNode.startPosition.row : startLine,
                     endLine: definitionNode ? definitionNode.endPosition.row : startLine,
                     language: language,
-                    isExported: isNodeExported(nameNode || definitionNode, nodeName, language),
+                    isExported: cachedExportCheck(provider.exportChecker, nameNode || definitionNode, nodeName),
                     ...(frameworkHint ? {
                         astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
                         astFrameworkReason: frameworkHint.reason,
                     } : {}),
                     ...(description !== undefined ? { description } : {}),
                     ...(parameterCount !== undefined ? { parameterCount } : {}),
+                    ...(requiredParameterCount !== undefined ? { requiredParameterCount } : {}),
+                    ...(parameterTypes !== undefined ? { parameterTypes } : {}),
                     ...(returnType !== undefined ? { returnType } : {}),
+                    ...(declaredType !== undefined ? { declaredType } : {}),
+                    ...(visibility !== undefined ? { visibility } : {}),
+                    ...(isStatic !== undefined ? { isStatic } : {}),
+                    ...(isReadonly !== undefined ? { isReadonly } : {}),
                 },
             });
             // Compute enclosing class for Method/Constructor/Property/Function — used for both ownerId and HAS_METHOD
             // Function is included because Kotlin/Rust/Python capture class methods as Function nodes
             const needsOwner = nodeLabel === 'Method' || nodeLabel === 'Constructor' || nodeLabel === 'Property' || nodeLabel === 'Function';
-            const enclosingClassId = needsOwner ? findEnclosingClassId(nameNode || definitionNode, file.path) : null;
+            const enclosingClassId = needsOwner ? cachedFindEnclosingClassId(nameNode || definitionNode, file.path) : null;
             result.symbols.push({
                 filePath: file.path,
                 name: nodeName,
                 nodeId,
                 type: nodeLabel,
                 ...(parameterCount !== undefined ? { parameterCount } : {}),
+                ...(requiredParameterCount !== undefined ? { requiredParameterCount } : {}),
+                ...(parameterTypes !== undefined ? { parameterTypes } : {}),
                 ...(returnType !== undefined ? { returnType } : {}),
                 ...(declaredType !== undefined ? { declaredType } : {}),
                 ...(enclosingClassId ? { ownerId: enclosingClassId } : {}),
+                ...(visibility !== undefined ? { visibility } : {}),
+                ...(isStatic !== undefined ? { isStatic } : {}),
+                ...(isReadonly !== undefined ? { isReadonly } : {}),
             });
             const fileId = generateId('File', file.path);
             const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
@@ -1058,11 +1241,13 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 });
             }
         }
-        // Extract Laravel routes from route files via procedural AST walk
-        if (language === SupportedLanguages.PHP && (file.path.includes('/routes/') || file.path.startsWith('routes/')) && file.path.endsWith('.php')) {
+        // Extract framework routes via provider detection (e.g., Laravel routes.php)
+        if (provider.isRouteFile?.(file.path)) {
             const extractedRoutes = extractLaravelRoutes(tree, file.path);
             result.routes.push(...extractedRoutes);
         }
+        // Extract ORM queries (Prisma, Supabase)
+        extractORMQueries(file.path, file.content, result.ormQueries);
     }
 };
 // ============================================================================
@@ -1071,7 +1256,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
 /** Accumulated result across sub-batches */
 let accumulated = {
     nodes: [], relationships: [], symbols: [],
-    imports: [], calls: [], assignments: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0,
+    imports: [], calls: [], assignments: [], heritage: [], routes: [], fetchCalls: [], decoratorRoutes: [], toolDefs: [], ormQueries: [], constructorBindings: [], typeEnvBindings: [], skippedLanguages: {}, fileCount: 0,
 };
 let cumulativeProcessed = 0;
 const mergeResult = (target, src) => {
@@ -1083,7 +1268,12 @@ const mergeResult = (target, src) => {
     target.assignments.push(...src.assignments);
     target.heritage.push(...src.heritage);
     target.routes.push(...src.routes);
+    target.fetchCalls.push(...src.fetchCalls);
+    target.decoratorRoutes.push(...src.decoratorRoutes);
+    target.toolDefs.push(...src.toolDefs);
+    target.ormQueries.push(...src.ormQueries);
     target.constructorBindings.push(...src.constructorBindings);
+    target.typeEnvBindings.push(...src.typeEnvBindings);
     for (const [lang, count] of Object.entries(src.skippedLanguages)) {
         target.skippedLanguages[lang] = (target.skippedLanguages[lang] || 0) + count;
     }
@@ -1106,7 +1296,7 @@ parentPort.on('message', (msg) => {
         if (msg && msg.type === 'flush') {
             parentPort.postMessage({ type: 'result', data: accumulated });
             // Reset for potential reuse
-            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], assignments: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0 };
+            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], assignments: [], heritage: [], routes: [], fetchCalls: [], decoratorRoutes: [], toolDefs: [], ormQueries: [], constructorBindings: [], typeEnvBindings: [], skippedLanguages: {}, fileCount: 0 };
             cumulativeProcessed = 0;
             return;
         }