@codeflow-map/core 0.1.0

package/dist/analyzer/languages/go.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goAnalyzer = void 0;
+const extractorUtils_1 = require("../extractorUtils");
+exports.goAnalyzer = {
+    functionQuery: `
+(function_declaration
+  name: (identifier) @fn.name
+  parameters: (parameter_list) @fn.params
+  result: [(parameter_list) (type_identifier)]? @fn.return_type) @fn.decl
+
+(method_declaration
+  name: (field_identifier) @fn.name
+  parameters: (parameter_list) @fn.params
+  result: [(parameter_list) (type_identifier)]? @fn.return_type) @fn.decl
+
+(func_literal
+  parameters: (parameter_list) @fn.params
+  result: [(parameter_list) (type_identifier)]? @fn.return_type) @fn.decl
+  `,
+    callQuery: `
+(call_expression
+  function: [(identifier) (selector_expression field: (field_identifier))] @call.name) @call.expr
+
+(go_statement
+  (call_expression
+    function: [(identifier) (selector_expression field: (field_identifier))] @call.name)) @call.expr
+
+(go_statement
+  (call_expression
+    function: (func_literal) @call.anon_fn)) @call.expr
+  `,
+    extractFunction(match, filePath, languageId) {
+        const declCapture = match.captures.find((c) => c.name === 'fn.decl');
+        if (!declCapture)
+            return null;
+        const nameCapture = match.captures.find((c) => c.name === 'fn.name');
+        let fnName;
+        let kind = 'function';
+        let isExported = false;
+        if (nameCapture) {
+            fnName = nameCapture.node.text;
+            isExported = fnName.length > 0 && fnName[0] === fnName[0].toUpperCase();
+            if (declCapture.node.type === 'method_declaration') {
+                kind = 'method';
+                const receiver = declCapture.node.childForFieldName('receiver');
+                if (receiver) {
+                    for (const child of receiver.namedChildren) {
+                        if (child.type === 'parameter_declaration') {
+                            const typeNode = child.childForFieldName('type');
+                            if (typeNode) {
+                                fnName = `${typeNode.text.replace(/^\*/, '')}.${fnName}`;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else if (declCapture.node.type === 'func_literal') {
+            // func_literal: find variable name from short_var_declaration or use anonymous
+            fnName = `anonymous_${declCapture.node.startPosition.row}`;
+            const parent = declCapture.node.parent;
+            if (parent?.type === 'expression_list') {
+                const grandparent = parent.parent;
+                if (grandparent?.type === 'short_var_declaration') {
+                    const left = grandparent.childForFieldName('left');
+                    const nameNode = left?.namedChildren?.find((n) => n.type === 'identifier');
+                    if (nameNode)
+                        fnName = nameNode.text;
+                }
+                else if (grandparent?.type === 'var_spec') {
+                    const nameNode = grandparent.childForFieldName('name');
+                    if (nameNode)
+                        fnName = nameNode.text;
+                }
+            }
+            // Prefix with enclosing function/method
+            let current = declCapture.node.parent;
+            while (current) {
+                if (current.type === 'function_declaration') {
+                    const name = current.childForFieldName('name');
+                    if (name)
+                        fnName = `${name.text}.${fnName}`;
+                    break;
+                }
+                if (current.type === 'method_declaration') {
+                    const name = current.childForFieldName('name');
+                    if (name) {
+                        let prefix = name.text;
+                        const recv = current.childForFieldName('receiver');
+                        if (recv) {
+                            for (const child of recv.namedChildren) {
+                                if (child.type === 'parameter_declaration') {
+                                    const typeNode = child.childForFieldName('type');
+                                    if (typeNode) {
+                                        prefix = `${typeNode.text.replace(/^\*/, '')}.${prefix}`;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        fnName = `${prefix}.${fnName}`;
+                    }
+                    break;
+                }
+                current = current.parent;
+            }
+        }
+        else {
+            return null;
+        }
+        const paramsCapture = match.captures.find((c) => c.name === 'fn.params');
+        const returnCapture = match.captures.find((c) => c.name === 'fn.return_type');
+        // Parse parameters — only collect identifier children, skip all type nodes
+        const paramsList = [];
+        if (paramsCapture && paramsCapture.node) {
+            for (const child of paramsCapture.node.namedChildren) {
+                if (child.type === 'parameter_declaration') {
+                    const typeNode = child.childForFieldName('type');
+                    const typeStr = typeNode ? typeNode.text : null;
+                    const nameNodes = child.namedChildren.filter((n) => n.type === 'identifier');
+                    if (nameNodes.length > 0) {
+                        for (const n of nameNodes) {
+                            paramsList.push({ name: n.text, type: typeStr });
+                        }
+                    }
+                    else {
+                        paramsList.push({ name: child.text, type: null });
+                    }
+                }
+                else if (child.type === 'variadic_parameter_declaration') {
+                    const nameNode = child.namedChildren.find((n) => n.type === 'identifier');
+                    const typeNode = child.childForFieldName('type');
+                    paramsList.push({
+                        name: nameNode ? nameNode.text : child.text,
+                        type: typeNode ? `...${typeNode.text}` : null
+                    });
+                }
+            }
+        }
+        let finalReturnType = returnCapture ? returnCapture.node.text : null;
+        if (!finalReturnType) {
+            const returnValues = (0, extractorUtils_1.getReturnValues)(declCapture.node, extractorUtils_1.GO_NESTED_FN_TYPES);
+            if (returnValues.length > 0) {
+                finalReturnType = returnValues.join(' | ');
+            }
+        }
+        return {
+            id: `${filePath}::${fnName}::${declCapture.node.startPosition.row}`,
+            name: fnName,
+            filePath,
+            startLine: declCapture.node.startPosition.row,
+            endLine: declCapture.node.endPosition.row,
+            params: paramsList,
+            returnType: finalReturnType,
+            isAsync: false,
+            isExported,
+            isEntryPoint: false,
+            language: languageId,
+            kind
+        };
+    },
+    extractCall(match, filePath) {
+        const nameCapture = match.captures.find((c) => c.name === 'call.name');
+        const anonCapture = match.captures.find((c) => c.name === 'call.anon_fn');
+        const exprCapture = match.captures.find((c) => c.name === 'call.expr');
+        if (!exprCapture)
+            return null;
+        // Handle go func(){...}() — immediately-invoked anonymous goroutine
+        if (anonCapture && exprCapture.node.type === 'go_statement') {
+            const funcLit = anonCapture.node;
+            let anonName = `anonymous_${funcLit.startPosition.row}`;
+            // Prefix with enclosing function/method name to match FunctionNode naming
+            let current = funcLit.parent;
+            while (current) {
+                if (current.type === 'function_declaration') {
+                    const name = current.childForFieldName('name');
+                    if (name)
+                        anonName = `${name.text}.${anonName}`;
+                    break;
+                }
+                if (current.type === 'method_declaration') {
+                    const name = current.childForFieldName('name');
+                    if (name) {
+                        let prefix = name.text;
+                        const recv = current.childForFieldName('receiver');
+                        if (recv) {
+                            for (const child of recv.namedChildren) {
+                                if (child.type === 'parameter_declaration') {
+                                    const typeNode = child.childForFieldName('type');
+                                    if (typeNode) {
+                                        prefix = `${typeNode.text.replace(/^\*/, '')}.${prefix}`;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        anonName = `${prefix}.${anonName}`;
+                    }
+                    break;
+                }
+                current = current.parent;
+            }
+            return {
+                callerFilePath: filePath,
+                calleeName: anonName,
+                line: exprCapture.node.startPosition.row,
+                callType: 'goroutine'
+            };
+        }
+        if (!nameCapture)
+            return null;
+        // Skip regular call_expression inside go_statement — the go_statement pattern handles it
+        if (exprCapture.node.type === 'call_expression' && exprCapture.node.parent?.type === 'go_statement') {
+            return null;
+        }
+        let calleeName = nameCapture.node.text;
+        if (nameCapture.node.type === 'selector_expression') {
+            const field = nameCapture.node.childForFieldName('field');
+            if (field)
+                calleeName = field.text;
+        }
+        const isGoroutine = exprCapture.node.type === 'go_statement';
+        return {
+            callerFilePath: filePath,
+            calleeName,
+            line: exprCapture.node.startPosition.row,
+            ...(isGoroutine ? { callType: 'goroutine' } : {})
+        };
+    }
+};

package/dist/analyzer/languages/javascript.d.ts

@@ -0,0 +1,2 @@
+import { LanguageAnalyzer } from '../../types';
+export declare const javascriptAnalyzer: LanguageAnalyzer;

package/dist/analyzer/languages/javascript.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javascriptAnalyzer = void 0;
+const extractorUtils_1 = require("../extractorUtils");
+exports.javascriptAnalyzer = {
+    functionQuery: `
+(function_declaration
+  name: (identifier) @fn.name
+  parameters: (formal_parameters) @fn.params) @fn.decl
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @fn.name
+    value: [(arrow_function) (function_expression)] @fn.decl))
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @fn.name
+      value: [(arrow_function) (function_expression)] @fn.decl)))
+
+(method_definition
+  name: (property_identifier) @fn.name
+  parameters: (formal_parameters) @fn.params) @fn.decl
+
+(call_expression
+  function: (identifier) @hook.name
+  arguments: (arguments
+    [(arrow_function) (function_expression)] @fn.decl)
+  (#match? @hook.name "^use"))
+
+(generator_function_declaration
+  name: (identifier) @fn.name
+  parameters: (formal_parameters) @fn.params) @fn.decl
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @fn.name
+    value: (generator_function) @fn.decl))
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @fn.name
+      value: (generator_function) @fn.decl)))
+
+(function_expression
+  name: (identifier) @fn.name
+  parameters: (formal_parameters) @fn.params) @fn.decl
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @fn.name
+    value: (call_expression
+      function: [(parenthesized_expression
+                   [(function_expression)(arrow_function)] @fn.decl)
+                 (arrow_function) @fn.decl
+                 (function_expression) @fn.decl])))
+
+(expression_statement
+  (call_expression
+    function: (parenthesized_expression
+      [(function_expression)(arrow_function)] @fn.decl)))
+
+(assignment_expression
+  left: (member_expression
+    object: (identifier) @worker.obj
+    property: (property_identifier) @worker.prop)
+  right: [(arrow_function) (function_expression)] @worker.fn
+  (#match? @worker.obj "^self$")
+  (#match? @worker.prop "^onmessage$"))
+
+(call_expression
+  function: (member_expression
+    object: (identifier) @worker.obj
+    property: (property_identifier) @worker.method)
+  arguments: (arguments
+    (string) @worker.event
+    [(arrow_function) (function_expression)] @worker.fn)
+  (#match? @worker.obj "^self$")
+  (#match? @worker.method "^addEventListener$")
+  (#match? @worker.event "message"))
+  `,
+    callQuery: `
+(call_expression
+  function: [(identifier)(member_expression)] @call.name) @call.expr
+
+(new_expression
+  constructor: (identifier) @call.name) @call.expr
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @call.name
+    (#match? @call.name "^(then|catch|finally)$"))) @call.expr
+  `,
+    extractFunction(match, filePath, languageId) {
+        const declCapture = match.captures.find((c) => c.name === 'fn.decl');
+        if (!declCapture) {
+            const workerFn = match.captures.find((c) => c.name === 'worker.fn');
+            if (workerFn) {
+                const workerProp = match.captures.find((c) => c.name === 'worker.prop');
+                const node = workerFn.node;
+                const rawName = workerProp ? 'onmessage_handler' : `message_handler_${node.startPosition.row}`;
+                const paramsList = (0, extractorUtils_1.getParamsFromFunctionNode)(node, false);
+                return {
+                    id: `${filePath}::${rawName}::${node.startPosition.row}`,
+                    name: rawName,
+                    filePath,
+                    startLine: node.startPosition.row,
+                    endLine: node.endPosition.row,
+                    params: paramsList,
+                    returnType: null,
+                    isAsync: (0, extractorUtils_1.checkIsAsync)(node),
+                    isExported: false,
+                    isEntryPoint: true,
+                    language: languageId,
+                    kind: 'function'
+                };
+            }
+            return null;
+        }
+        const nameCapture = match.captures.find((c) => c.name === 'fn.name');
+        const hookNameCapture = match.captures.find((c) => c.name === 'hook.name');
+        let rawName = "anonymous";
+        let kind = 'function';
+        let parentFunctionId;
+        if (nameCapture) {
+            rawName = nameCapture.node.text;
+            if (declCapture.node.type === 'function_expression' && nameCapture.node.parent?.id === declCapture.node.id) {
+                if (declCapture.node.parent?.type === 'variable_declarator') {
+                    return null;
+                }
+                parentFunctionId = (0, extractorUtils_1.getEnclosingFunctionId)(declCapture.node, filePath) ?? undefined;
+            }
+            if (declCapture.node.type === 'method_definition') {
+                kind = 'method';
+            }
+        }
+        else if (hookNameCapture) {
+            const startLine = declCapture.node.startPosition.row;
+            rawName = `${hookNameCapture.node.text}_callback_${startLine}`;
+            kind = 'hook';
+        }
+        // Detect IIFE: fn.decl is inside a call_expression (the IIFE invocation)
+        const declParent = declCapture.node.parent;
+        const isParenWrapped = declParent?.type === 'parenthesized_expression';
+        const callParent = isParenWrapped ? declParent.parent : declParent;
+        if (callParent?.type === 'call_expression') {
+            if (rawName === 'anonymous') {
+                rawName = `iife_${declCapture.node.startPosition.row}`;
+            }
+            kind = 'iife';
+        }
+        else if (rawName === "anonymous" && !hookNameCapture) {
+            return null;
+        }
+        // Prefix with enclosing scope chain (parent functions, classes, and object literals)
+        const scopeChain = (0, extractorUtils_1.getEnclosingScopeChain)(declCapture.node, extractorUtils_1.JS_FN_SCOPE_TYPES, extractorUtils_1.JS_CLASS_SCOPE_TYPES);
+        if (scopeChain.length > 0) {
+            rawName = `${scopeChain.map(s => s.name).join('.')}.${rawName}`;
+        }
+        const paramsCapture = match.captures.find((c) => c.name === 'fn.params');
+        const isExported = (0, extractorUtils_1.checkExportedByParentWalk)(declCapture.node);
+        const paramsList = paramsCapture
+            ? (0, extractorUtils_1.buildJsParams)(paramsCapture.node, false)
+            : (0, extractorUtils_1.getParamsFromFunctionNode)(declCapture.node, false);
+        let finalReturnType = null;
+        const returnValues = (0, extractorUtils_1.getReturnValues)(declCapture.node, extractorUtils_1.JS_NESTED_FN_TYPES);
+        if (returnValues.length > 0) {
+            finalReturnType = returnValues.join(' | ');
+        }
+        return {
+            id: `${filePath}::${rawName}::${declCapture.node.startPosition.row}`,
+            name: rawName,
+            filePath,
+            startLine: declCapture.node.startPosition.row,
+            endLine: declCapture.node.endPosition.row,
+            params: paramsList,
+            returnType: finalReturnType,
+            isAsync: (0, extractorUtils_1.checkIsAsync)(declCapture.node),
+            isExported,
+            isEntryPoint: false,
+            language: languageId,
+            kind,
+            ...(parentFunctionId ? { parentFunctionId } : {})
+        };
+    },
+    extractCall(match, filePath) {
+        const nameCapture = match.captures.find((c) => c.name === 'call.name');
+        const exprCapture = match.captures.find((c) => c.name === 'call.expr');
+        if (nameCapture && exprCapture) {
+            let calleeName = nameCapture.node.text;
+            if (nameCapture.node.type === 'member_expression') {
+                const prop = nameCapture.node.childForFieldName('property');
+                if (prop)
+                    calleeName = prop.text;
+            }
+            // Unwrap .bind(): handleWorkerMessage.bind(this) → ref to handleWorkerMessage
+            if (calleeName === 'bind' && nameCapture.node.type === 'member_expression') {
+                const obj = nameCapture.node.childForFieldName('object');
+                if (obj?.type === 'identifier') {
+                    return {
+                        callerFilePath: filePath,
+                        calleeName: obj.text,
+                        line: exprCapture.node.startPosition.row,
+                        callType: (0, extractorUtils_1.isInsidePromiseCombinator)(exprCapture.node) ? 'concurrent' : 'ref',
+                        isRef: true
+                    };
+                }
+            }
+            const callType = (0, extractorUtils_1.isInsidePromiseCombinator)(exprCapture.node) ? 'concurrent' : undefined;
+            const directCall = {
+                callerFilePath: filePath,
+                calleeName,
+                line: exprCapture.node.startPosition.row,
+                ...(callType ? { callType } : {})
+            };
+            // Extract function reference arguments from any call
+            const refCalls = [];
+            const callNode = exprCapture.node;
+            const argsNode = callNode.childForFieldName('arguments');
+            if (argsNode) {
+                for (const arg of argsNode.namedChildren) {
+                    let refName = null;
+                    if (arg.type === 'identifier') {
+                        refName = arg.text;
+                    }
+                    else if (arg.type === 'member_expression') {
+                        const obj = arg.childForFieldName('object');
+                        const prop = arg.childForFieldName('property');
+                        if (obj?.type === 'this' && prop) {
+                            refName = prop.text;
+                        }
+                    }
+                    else if (arg.type === 'call_expression') {
+                        // Unwrap .bind(): handleWorkerMessage.bind(this) -> handleWorkerMessage
+                        const fn = arg.childForFieldName('function');
+                        if (fn?.type === 'member_expression') {
+                            const prop = fn.childForFieldName('property');
+                            const obj = fn.childForFieldName('object');
+                            if (prop?.text === 'bind' && obj?.type === 'identifier') {
+                                refName = obj.text;
+                            }
+                        }
+                    }
+                    if (refName) {
+                        const refCallType = (0, extractorUtils_1.isInsidePromiseCombinator)(callNode) ? 'concurrent' : 'ref';
+                        refCalls.push({
+                            callerFilePath: filePath,
+                            calleeName: refName,
+                            line: callNode.startPosition.row,
+                            callType: refCallType,
+                            isRef: true
+                        });
+                    }
+                }
+            }
+            if (refCalls.length > 0) {
+                return [directCall, ...refCalls];
+            }
+            return directCall;
+        }
+        return null;
+    }
+};

package/dist/analyzer/languages/jsx.d.ts

@@ -0,0 +1,2 @@
+import { LanguageAnalyzer } from '../../types';
+export declare const jsxAnalyzer: LanguageAnalyzer;