gitnexus 1.3.6 → 1.3.8

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

@@ -9,9 +9,11 @@ import CPP from 'tree-sitter-cpp';
 import CSharp from 'tree-sitter-c-sharp';
 import Go from 'tree-sitter-go';
 import Rust from 'tree-sitter-rust';
+import Kotlin from 'tree-sitter-kotlin';
 import PHP from 'tree-sitter-php';
 import { createRequire } from 'node:module';
 import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { LANGUAGE_QUERIES } from '../tree-sitter-queries.js';
 // tree-sitter-swift is an optionalDependency — may not be installed
 const _require = createRequire(import.meta.url);
 let Swift = null;
@@ -19,8 +21,7 @@ try {
     Swift = _require('tree-sitter-swift');
 }
 catch { }
-import { LANGUAGE_QUERIES } from '../tree-sitter-queries.js';
-import { getLanguageFromFilename } from '../utils.js';
+import { findSiblingChild, getLanguageFromFilename } from '../utils.js';
 import { detectFrameworkFromAST } from '../framework-detection.js';
 import { generateId } from '../../../lib/utils.js';
 // ============================================================================
@@ -38,6 +39,7 @@ const languageMap = {
     [SupportedLanguages.CSharp]: CSharp,
     [SupportedLanguages.Go]: Go,
     [SupportedLanguages.Rust]: Rust,
+    [SupportedLanguages.Kotlin]: Kotlin,
     [SupportedLanguages.PHP]: PHP.php_only,
     ...(Swift ? { [SupportedLanguages.Swift]: Swift } : {}),
 };
@@ -115,18 +117,26 @@ const isNodeExported = (node, name, language) => {
                 current = current.parent;
             }
             return false;
-        case 'c':
-        case 'cpp':
-            return false;
-        case 'swift':
+        // Kotlin: Default visibility is public (unlike Java)
+        // visibility_modifier is inside modifiers, a sibling of the name node within the declaration
+        case 'kotlin':
             while (current) {
-                if (current.type === 'modifiers' || current.type === 'visibility_modifier') {
-                    const text = current.text || '';
-                    if (text.includes('public') || text.includes('open'))
-                        return true;
+                if (current.parent) {
+                    const visMod = findSiblingChild(current.parent, 'modifiers', 'visibility_modifier');
+                    if (visMod) {
+                        const text = visMod.text;
+                        if (text === 'private' || text === 'internal' || text === 'protected')
+                            return false;
+                        if (text === 'public')
+                            return true;
+                    }
                 }
                 current = current.parent;
             }
+            // No visibility modifier = public (Kotlin default)
+            return true;
+        case 'c':
+        case 'cpp':
             return false;
         case 'php':
             // Top-level classes/interfaces/traits are always accessible
@@ -145,6 +155,16 @@ const isNodeExported = (node, name, language) => {
             }
             // Top-level functions (no parent class) are globally accessible
             return true;
+        case 'swift':
+            while (current) {
+                if (current.type === 'modifiers' || current.type === 'visibility_modifier') {
+                    const text = current.text || '';
+                    if (text.includes('public') || text.includes('open'))
+                        return true;
+                }
+                current = current.parent;
+            }
+            return false;
         default:
             return false;
     }
@@ -158,8 +178,12 @@ const FUNCTION_NODE_TYPES = new Set([
     'function_definition', 'async_function_declaration', 'async_arrow_function',
     'method_declaration', 'constructor_declaration',
     'local_function_statement', 'function_item', 'impl_item',
-    'anonymous_function_creation_expression', // PHP anonymous functions
-    'init_declaration', 'deinit_declaration', // Swift initializers/deinitializers
+    // Kotlin
+    'lambda_literal',
+    // PHP
+    'anonymous_function',
+    // Swift initializers/deinitializers
+    'init_declaration', 'deinit_declaration',
 ]);
 /** Walk up AST to find enclosing function, return its generateId or null for top-level */
 const findEnclosingFunctionId = (node, filePath) => {
@@ -241,6 +265,22 @@ const BUILT_INS = new Set([
     'open', 'read', 'write', 'close', 'append', 'extend', 'update',
     'super', 'type', 'isinstance', 'issubclass', 'getattr', 'setattr', 'hasattr',
     'enumerate', 'zip', 'sorted', 'reversed', 'min', 'max', 'sum', 'abs',
+    // Kotlin stdlib (IMPORTANT: keep in sync with call-processor.ts BUILT_IN_NAMES)
+    'println', 'print', 'readLine', 'require', 'requireNotNull', 'check', 'assert', 'lazy', 'error',
+    'listOf', 'mapOf', 'setOf', 'mutableListOf', 'mutableMapOf', 'mutableSetOf',
+    'arrayOf', 'sequenceOf', 'also', 'apply', 'run', 'with', 'takeIf', 'takeUnless',
+    'TODO', 'buildString', 'buildList', 'buildMap', 'buildSet',
+    'repeat', 'synchronized',
+    // Kotlin coroutine builders & scope functions
+    'launch', 'async', 'runBlocking', 'withContext', 'coroutineScope',
+    'supervisorScope', 'delay',
+    // Kotlin Flow operators
+    'flow', 'flowOf', 'collect', 'emit', 'onEach', 'catch',
+    'buffer', 'conflate', 'distinctUntilChanged',
+    'flatMapLatest', 'flatMapMerge', 'combine',
+    'stateIn', 'shareIn', 'launchIn',
+    // Kotlin infix stdlib functions
+    'to', 'until', 'downTo', 'step',
     // C/C++ standard library
     'printf', 'fprintf', 'sprintf', 'snprintf', 'vprintf', 'vfprintf', 'vsprintf', 'vsnprintf',
     'scanf', 'fscanf', 'sscanf',
@@ -366,37 +406,49 @@ const getLabelFromCaptures = (captureMap) => {
         return 'Template';
     return 'CodeElement';
 };
+const DEFINITION_CAPTURE_KEYS = [
+    'definition.function',
+    'definition.class',
+    'definition.interface',
+    'definition.method',
+    'definition.struct',
+    'definition.enum',
+    'definition.namespace',
+    'definition.module',
+    'definition.trait',
+    'definition.impl',
+    'definition.type',
+    'definition.const',
+    'definition.static',
+    'definition.typedef',
+    'definition.macro',
+    'definition.union',
+    'definition.property',
+    'definition.record',
+    'definition.delegate',
+    'definition.annotation',
+    'definition.constructor',
+    'definition.template',
+];
 const getDefinitionNodeFromCaptures = (captureMap) => {
-    const definitionKeys = [
-        'definition.function',
-        'definition.class',
-        'definition.interface',
-        'definition.method',
-        'definition.struct',
-        'definition.enum',
-        'definition.namespace',
-        'definition.module',
-        'definition.trait',
-        'definition.impl',
-        'definition.type',
-        'definition.const',
-        'definition.static',
-        'definition.typedef',
-        'definition.macro',
-        'definition.union',
-        'definition.property',
-        'definition.record',
-        'definition.delegate',
-        'definition.annotation',
-        'definition.constructor',
-        'definition.template',
-    ];
-    for (const key of definitionKeys) {
+    for (const key of DEFINITION_CAPTURE_KEYS) {
         if (captureMap[key])
             return captureMap[key];
     }
     return null;
 };
+/**
+ * Append .* to a Kotlin import path if the AST has a wildcard_import sibling node.
+ * Pure function — returns a new string without mutating the input.
+ */
+const appendKotlinWildcard = (importPath, importNode) => {
+    for (let i = 0; i < importNode.childCount; i++) {
+        if (importNode.child(i)?.type === 'wildcard_import') {
+            return importPath.endsWith('.*') ? importPath : `${importPath}.*`;
+        }
+    }
+    return importPath;
+};
 // ============================================================================
 // Process a batch of files
 // ============================================================================
@@ -408,6 +460,7 @@ const processBatch = (files, onProgress) => {
         imports: [],
         calls: [],
         heritage: [],
+        routes: [],
         fileCount: 0,
     };
     // Group by language to minimize setLanguage calls
@@ -455,13 +508,23 @@ const processBatch = (files, onProgress) => {
         }
         // Process regular files for this language
         if (regularFiles.length > 0) {
-            setLanguage(language, regularFiles[0].path);
-            processFileGroup(regularFiles, language, queryString, result, onFileProcessed);
+            try {
+                setLanguage(language, regularFiles[0].path);
+                processFileGroup(regularFiles, language, queryString, result, onFileProcessed);
+            }
+            catch {
+                // parser unavailable — skip this language group
+            }
         }
         // Process tsx files separately (different grammar)
         if (tsxFiles.length > 0) {
-            setLanguage(language, tsxFiles[0].path);
-            processFileGroup(tsxFiles, language, queryString, result, onFileProcessed);
+            try {
+                setLanguage(language, tsxFiles[0].path);
+                processFileGroup(tsxFiles, language, queryString, result, onFileProcessed);
+            }
+            catch {
+                // parser unavailable — skip this language group
+            }
         }
     }
     return result;
@@ -570,6 +633,353 @@ function extractEloquentRelationDescription(methodNode) {
         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']);
+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' */
+function isRouteStaticCall(node) {
+    if (node.type !== 'scoped_call_expression')
+        return false;
+    const obj = node.childForFieldName?.('object') ?? node.children?.[0];
+    return obj?.text === 'Route';
+}
+/** Get the method name from a scoped_call_expression or member_call_expression */
+function getCallMethodName(node) {
+    const nameNode = node.childForFieldName?.('name') ??
+        node.children?.find((c) => c.type === 'name');
+    return nameNode?.text ?? null;
+}
+/** Get the arguments node from a call expression */
+function getArguments(node) {
+    return node.children?.find((c) => c.type === 'arguments') ?? null;
+}
+/** Find the closure body inside arguments */
+function findClosureBody(argsNode) {
+    if (!argsNode)
+        return null;
+    for (const child of argsNode.children ?? []) {
+        if (child.type === 'argument') {
+            for (const inner of child.children ?? []) {
+                if (inner.type === 'anonymous_function' ||
+                    inner.type === 'arrow_function') {
+                    return inner.childForFieldName?.('body') ??
+                        inner.children?.find((c) => c.type === 'compound_statement');
+                }
+            }
+        }
+        if (child.type === 'anonymous_function' ||
+            child.type === 'arrow_function') {
+            return child.childForFieldName?.('body') ??
+                child.children?.find((c) => c.type === 'compound_statement');
+        }
+    }
+    return null;
+}
+/** Extract first string argument from arguments node */
+function extractFirstStringArg(argsNode) {
+    if (!argsNode)
+        return null;
+    for (const child of argsNode.children ?? []) {
+        const target = child.type === 'argument' ? child.children?.[0] : child;
+        if (!target)
+            continue;
+        if (target.type === 'string' || target.type === 'encapsed_string') {
+            return extractStringContent(target);
+        }
+    }
+    return null;
+}
+/** Extract middleware from arguments — handles string or array */
+function extractMiddlewareArg(argsNode) {
+    if (!argsNode)
+        return [];
+    for (const child of argsNode.children ?? []) {
+        const target = child.type === 'argument' ? child.children?.[0] : child;
+        if (!target)
+            continue;
+        if (target.type === 'string' || target.type === 'encapsed_string') {
+            const val = extractStringContent(target);
+            return val ? [val] : [];
+        }
+        if (target.type === 'array_creation_expression') {
+            const items = [];
+            for (const el of target.children ?? []) {
+                if (el.type === 'array_element_initializer') {
+                    const str = el.children?.find((c) => c.type === 'string' || c.type === 'encapsed_string');
+                    const val = str ? extractStringContent(str) : null;
+                    if (val)
+                        items.push(val);
+                }
+            }
+            return items;
+        }
+    }
+    return [];
+}
+/** Extract Controller::class from arguments */
+function extractClassArg(argsNode) {
+    if (!argsNode)
+        return null;
+    for (const child of argsNode.children ?? []) {
+        const target = child.type === 'argument' ? child.children?.[0] : child;
+        if (target?.type === 'class_constant_access_expression') {
+            return target.children?.find((c) => c.type === 'name')?.text ?? null;
+        }
+    }
+    return null;
+}
+/** Extract controller class name from arguments: [Controller::class, 'method'] or 'Controller@method' */
+function extractControllerTarget(argsNode) {
+    if (!argsNode)
+        return { controller: null, method: null };
+    const args = [];
+    for (const child of argsNode.children ?? []) {
+        if (child.type === 'argument')
+            args.push(child.children?.[0]);
+        else if (child.type !== '(' && child.type !== ')' && child.type !== ',')
+            args.push(child);
+    }
+    // Second arg is the handler
+    const handlerNode = args[1];
+    if (!handlerNode)
+        return { controller: null, method: null };
+    // Array syntax: [UserController::class, 'index']
+    if (handlerNode.type === 'array_creation_expression') {
+        let controller = null;
+        let method = null;
+        const elements = [];
+        for (const el of handlerNode.children ?? []) {
+            if (el.type === 'array_element_initializer')
+                elements.push(el);
+        }
+        if (elements[0]) {
+            const classAccess = findDescendant(elements[0], 'class_constant_access_expression');
+            if (classAccess) {
+                controller = classAccess.children?.find((c) => c.type === 'name')?.text ?? null;
+            }
+        }
+        if (elements[1]) {
+            const str = findDescendant(elements[1], 'string');
+            method = str ? extractStringContent(str) : null;
+        }
+        return { controller, method };
+    }
+    // String syntax: 'UserController@index'
+    if (handlerNode.type === 'string' || handlerNode.type === 'encapsed_string') {
+        const text = extractStringContent(handlerNode);
+        if (text?.includes('@')) {
+            const [controller, method] = text.split('@');
+            return { controller, method };
+        }
+    }
+    // Class reference: UserController::class (invokable controller)
+    if (handlerNode.type === 'class_constant_access_expression') {
+        const controller = handlerNode.children?.find((c) => c.type === 'name')?.text ?? null;
+        return { controller, method: '__invoke' };
+    }
+    return { controller: null, method: null };
+}
+/**
+ * Unwrap a chained call like Route::middleware('auth')->prefix('api')->group(fn)
+ */
+function unwrapRouteChain(node) {
+    if (node.type !== 'member_call_expression')
+        return null;
+    const terminalMethod = getCallMethodName(node);
+    if (!terminalMethod)
+        return null;
+    const terminalArgs = getArguments(node);
+    const attributes = [];
+    let current = node.children?.[0];
+    while (current) {
+        if (current.type === 'member_call_expression') {
+            const method = getCallMethodName(current);
+            const args = getArguments(current);
+            if (method)
+                attributes.unshift({ method, argsNode: args });
+            current = current.children?.[0];
+        }
+        else if (current.type === 'scoped_call_expression') {
+            const obj = current.childForFieldName?.('object') ?? current.children?.[0];
+            if (obj?.text !== 'Route')
+                return null;
+            const method = getCallMethodName(current);
+            const args = getArguments(current);
+            if (method)
+                attributes.unshift({ method, argsNode: args });
+            return { isRouteFacade: true, terminalMethod, attributes, terminalArgs, node };
+        }
+        else {
+            break;
+        }
+    }
+    return null;
+}
+/** Parse Route::group(['middleware' => ..., 'prefix' => ...], fn) array syntax */
+function parseArrayGroupArgs(argsNode) {
+    const ctx = { middleware: [], prefix: null, controller: null };
+    if (!argsNode)
+        return ctx;
+    for (const child of argsNode.children ?? []) {
+        const target = child.type === 'argument' ? child.children?.[0] : child;
+        if (target?.type === 'array_creation_expression') {
+            for (const el of target.children ?? []) {
+                if (el.type !== 'array_element_initializer')
+                    continue;
+                const children = el.children ?? [];
+                const arrowIdx = children.findIndex((c) => c.type === '=>');
+                if (arrowIdx === -1)
+                    continue;
+                const key = extractStringContent(children[arrowIdx - 1]);
+                const val = children[arrowIdx + 1];
+                if (key === 'middleware') {
+                    if (val?.type === 'string') {
+                        const s = extractStringContent(val);
+                        if (s)
+                            ctx.middleware.push(s);
+                    }
+                    else if (val?.type === 'array_creation_expression') {
+                        for (const item of val.children ?? []) {
+                            if (item.type === 'array_element_initializer') {
+                                const str = item.children?.find((c) => c.type === 'string');
+                                const s = str ? extractStringContent(str) : null;
+                                if (s)
+                                    ctx.middleware.push(s);
+                            }
+                        }
+                    }
+                }
+                else if (key === 'prefix') {
+                    ctx.prefix = extractStringContent(val) ?? null;
+                }
+                else if (key === 'controller') {
+                    if (val?.type === 'class_constant_access_expression') {
+                        ctx.controller = val.children?.find((c) => c.type === 'name')?.text ?? null;
+                    }
+                }
+            }
+        }
+    }
+    return ctx;
+}
+function extractLaravelRoutes(tree, filePath) {
+    const routes = [];
+    function resolveStack(stack) {
+        const middleware = [];
+        let prefix = null;
+        let controller = null;
+        for (const ctx of stack) {
+            middleware.push(...ctx.middleware);
+            if (ctx.prefix)
+                prefix = prefix ? `${prefix}/${ctx.prefix}`.replace(/\/+/g, '/') : ctx.prefix;
+            if (ctx.controller)
+                controller = ctx.controller;
+        }
+        return { middleware, prefix, controller };
+    }
+    function emitRoute(httpMethod, argsNode, lineNumber, groupStack, chainAttrs) {
+        const effective = resolveStack(groupStack);
+        for (const attr of chainAttrs) {
+            if (attr.method === 'middleware')
+                effective.middleware.push(...extractMiddlewareArg(attr.argsNode));
+            if (attr.method === 'prefix') {
+                const p = extractFirstStringArg(attr.argsNode);
+                if (p)
+                    effective.prefix = effective.prefix ? `${effective.prefix}/${p}` : p;
+            }
+            if (attr.method === 'controller') {
+                const cls = extractClassArg(attr.argsNode);
+                if (cls)
+                    effective.controller = cls;
+            }
+        }
+        const routePath = extractFirstStringArg(argsNode);
+        if (ROUTE_RESOURCE_METHODS.has(httpMethod)) {
+            const target = extractControllerTarget(argsNode);
+            const actions = httpMethod === 'apiResource' ? API_RESOURCE_ACTIONS : RESOURCE_ACTIONS;
+            for (const action of actions) {
+                routes.push({
+                    filePath, httpMethod, routePath,
+                    controllerName: target.controller ?? effective.controller,
+                    methodName: action,
+                    middleware: [...effective.middleware],
+                    prefix: effective.prefix,
+                    lineNumber,
+                });
+            }
+        }
+        else {
+            const target = extractControllerTarget(argsNode);
+            routes.push({
+                filePath, httpMethod, routePath,
+                controllerName: target.controller ?? effective.controller,
+                methodName: target.method,
+                middleware: [...effective.middleware],
+                prefix: effective.prefix,
+                lineNumber,
+            });
+        }
+    }
+    function walk(node, groupStack) {
+        // Case 1: Simple Route::get(...), Route::post(...), etc.
+        if (isRouteStaticCall(node)) {
+            const method = getCallMethodName(node);
+            if (method && (ROUTE_HTTP_METHODS.has(method) || ROUTE_RESOURCE_METHODS.has(method))) {
+                emitRoute(method, getArguments(node), node.startPosition.row, groupStack, []);
+                return;
+            }
+            if (method === 'group') {
+                const argsNode = getArguments(node);
+                const groupCtx = parseArrayGroupArgs(argsNode);
+                const body = findClosureBody(argsNode);
+                if (body) {
+                    groupStack.push(groupCtx);
+                    walkChildren(body, groupStack);
+                    groupStack.pop();
+                }
+                return;
+            }
+        }
+        // Case 2: Fluent chain — Route::middleware(...)->group(...) or Route::middleware(...)->get(...)
+        const chain = unwrapRouteChain(node);
+        if (chain) {
+            if (chain.terminalMethod === 'group') {
+                const groupCtx = { middleware: [], prefix: null, controller: null };
+                for (const attr of chain.attributes) {
+                    if (attr.method === 'middleware')
+                        groupCtx.middleware.push(...extractMiddlewareArg(attr.argsNode));
+                    if (attr.method === 'prefix')
+                        groupCtx.prefix = extractFirstStringArg(attr.argsNode);
+                    if (attr.method === 'controller')
+                        groupCtx.controller = extractClassArg(attr.argsNode);
+                }
+                const body = findClosureBody(chain.terminalArgs);
+                if (body) {
+                    groupStack.push(groupCtx);
+                    walkChildren(body, groupStack);
+                    groupStack.pop();
+                }
+                return;
+            }
+            if (ROUTE_HTTP_METHODS.has(chain.terminalMethod) || ROUTE_RESOURCE_METHODS.has(chain.terminalMethod)) {
+                emitRoute(chain.terminalMethod, chain.terminalArgs, node.startPosition.row, groupStack, chain.attributes);
+                return;
+            }
+        }
+        // Default: recurse into children
+        walkChildren(node, groupStack);
+    }
+    function walkChildren(node, groupStack) {
+        for (const child of node.children ?? []) {
+            walk(child, groupStack);
+        }
+    }
+    walk(tree.rootNode, []);
+    return routes;
+}
 const processFileGroup = (files, language, queryString, result, onFileProcessed) => {
     let query;
     try {
@@ -606,7 +1016,9 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             }
             // Extract import paths before skipping
             if (captureMap['import'] && captureMap['import.source']) {
-                const rawImportPath = captureMap['import.source'].text.replace(/['"<>]/g, '');
+                const rawImportPath = language === SupportedLanguages.Kotlin
+                    ? appendKotlinWildcard(captureMap['import.source'].text.replace(/['"<>]/g, ''), captureMap['import'])
+                    : captureMap['import.source'].text.replace(/['"<>]/g, '');
                 result.imports.push({
                     filePath: file.path,
                     rawImportPath,
@@ -662,8 +1074,13 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             if (!nodeLabel)
                 continue;
             const nameNode = captureMap['name'];
-            const nodeName = nameNode.text;
-            const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`);
+            // Synthesize name for constructors without explicit @name capture (e.g. Swift init)
+            if (!nameNode && nodeLabel !== 'Constructor')
+                continue;
+            const nodeName = nameNode ? nameNode.text : 'init';
+            const definitionNode = getDefinitionNodeFromCaptures(captureMap);
+            const startLine = definitionNode ? definitionNode.startPosition.row : (nameNode ? nameNode.startPosition.row : 0);
+            const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}:${startLine}`);
             let description;
             if (language === SupportedLanguages.PHP) {
                 if (nodeLabel === 'Property' && captureMap['definition.property']) {
@@ -673,9 +1090,8 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     description = extractEloquentRelationDescription(captureMap['definition.method']) ?? undefined;
                 }
             }
-            const definitionNode = getDefinitionNodeFromCaptures(captureMap);
             const frameworkHint = definitionNode
-                ? detectFrameworkFromAST(language, definitionNode.text || '')
+                ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300))
                 : null;
             result.nodes.push({
                 id: nodeId,
@@ -683,10 +1099,10 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 properties: {
                     name: nodeName,
                     filePath: file.path,
-                    startLine: nameNode.startPosition.row,
-                    endLine: nameNode.endPosition.row,
+                    startLine: definitionNode ? definitionNode.startPosition.row : startLine,
+                    endLine: definitionNode ? definitionNode.endPosition.row : startLine,
                     language: language,
-                    isExported: isNodeExported(nameNode, nodeName, language),
+                    isExported: isNodeExported(nameNode || definitionNode, nodeName, language),
                     ...(frameworkHint ? {
                         astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
                         astFrameworkReason: frameworkHint.reason,
@@ -711,6 +1127,11 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 reason: '',
             });
         }
+        // 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')) {
+            const extractedRoutes = extractLaravelRoutes(tree, file.path);
+            result.routes.push(...extractedRoutes);
+        }
     }
 };
 // ============================================================================
@@ -719,7 +1140,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
 /** Accumulated result across sub-batches */
 let accumulated = {
     nodes: [], relationships: [], symbols: [],
-    imports: [], calls: [], heritage: [], fileCount: 0,
+    imports: [], calls: [], heritage: [], routes: [], fileCount: 0,
 };
 let cumulativeProcessed = 0;
 const mergeResult = (target, src) => {
@@ -729,6 +1150,7 @@ const mergeResult = (target, src) => {
     target.imports.push(...src.imports);
     target.calls.push(...src.calls);
     target.heritage.push(...src.heritage);
+    target.routes.push(...src.routes);
     target.fileCount += src.fileCount;
 };
 parentPort.on('message', (msg) => {
@@ -748,7 +1170,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: [], heritage: [], fileCount: 0 };
+            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], heritage: [], routes: [], fileCount: 0 };
             cumulativeProcessed = 0;
             return;
         }

package/dist/core/kuzu/csv-generator.d.ts

@@ -13,6 +13,10 @@
  */
 import { KnowledgeGraph } from '../graph/types.js';
 import { NodeTableName } from './schema.js';
+export declare const sanitizeUTF8: (str: string) => string;
+export declare const escapeCSVField: (value: string | number | undefined | null) => string;
+export declare const escapeCSVNumber: (value: number | undefined | null, defaultValue?: number) => string;
+export declare const isBinaryContent: (content: string) => boolean;
 export interface StreamedCSVResult {
     nodeFiles: Map<NodeTableName, {
         csvPath: string;