@codeflow-map/core 0.1.0

package/dist/analyzer/languages/jsx.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsxAnalyzer = void 0;
+const extractorUtils_1 = require("../extractorUtils");
+exports.jsxAnalyzer = {
+    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
+
+(jsx_element
+  open_tag: (jsx_opening_element
+    name: (identifier) @call.name
+    (#match? @call.name "^[A-Z]"))) @call.expr
+
+(jsx_self_closing_element
+  name: (identifier) @call.name
+  (#match? @call.name "^[A-Z]")) @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 (rawName.length > 0 && rawName[0] === rawName[0].toUpperCase())
+                kind = 'component';
+        }
+        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') {
+                        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/python.d.ts

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

package/dist/analyzer/languages/python.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythonAnalyzer = void 0;
+const extractorUtils_1 = require("../extractorUtils");
+/** Extract a function-reference name from an AST node (identifier or attribute). */
+function extractFunctionRef(node) {
+    if (!node)
+        return null;
+    if (node.type === 'identifier')
+        return node.text;
+    if (node.type === 'attribute') {
+        const attr = node.childForFieldName('attribute');
+        return attr ? attr.text : null;
+    }
+    return null;
+}
+/** Get the function reference from a keyword argument by keyword name. */
+function getKeywordArgRef(argsNode, keyword) {
+    if (!argsNode)
+        return null;
+    for (const child of argsNode.namedChildren) {
+        if (child.type === 'keyword_argument') {
+            const nameNode = child.childForFieldName('name');
+            if (nameNode?.text === keyword) {
+                return extractFunctionRef(child.childForFieldName('value'));
+            }
+        }
+    }
+    return null;
+}
+/** Get the function reference from the nth positional argument (skipping keyword args). */
+function getPositionalArgRef(argsNode, index) {
+    if (!argsNode)
+        return null;
+    let pos = 0;
+    for (const child of argsNode.namedChildren) {
+        if (child.type === 'keyword_argument')
+            continue;
+        if (pos === index)
+            return extractFunctionRef(child);
+        pos++;
+    }
+    return null;
+}
+/** Check if a call node is a direct argument to asyncio.gather(). */
+function isInsideAsyncioGather(node) {
+    const parent = node.parent;
+    if (!parent || parent.type !== 'argument_list')
+        return false;
+    const callNode = parent.parent;
+    if (!callNode || callNode.type !== 'call')
+        return false;
+    const fn = callNode.childForFieldName('function');
+    if (fn?.type === 'attribute') {
+        const obj = fn.childForFieldName('object');
+        const attr = fn.childForFieldName('attribute');
+        return obj?.text === 'asyncio' && attr?.text === 'gather';
+    }
+    return false;
+}
+/** Check if a call node is the argument to asyncio.create_task(). */
+function isArgumentToCreateTask(node) {
+    const parent = node.parent;
+    if (!parent || parent.type !== 'argument_list')
+        return false;
+    const callNode = parent.parent;
+    if (!callNode || callNode.type !== 'call')
+        return false;
+    const fn = callNode.childForFieldName('function');
+    if (fn?.type === 'attribute') {
+        const obj = fn.childForFieldName('object');
+        const attr = fn.childForFieldName('attribute');
+        return obj?.text === 'asyncio' && attr?.text === 'create_task';
+    }
+    return false;
+}
+exports.pythonAnalyzer = {
+    functionQuery: `
+(function_definition
+  name: (identifier) @fn.name
+  parameters: (parameters) @fn.params
+  return_type: (type)? @fn.return_type) @fn.decl
+
+  `,
+    callQuery: `
+(call
+  function: [(identifier) (attribute attribute: (identifier))] @call.name) @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 = "anonymous";
+        let kind = 'function';
+        if (nameCapture) {
+            fnName = nameCapture.node.text;
+        }
+        else {
+            return null;
+        }
+        // Check for enclosing scopes (classes and parent functions)
+        const scopeChain = (0, extractorUtils_1.getEnclosingScopeChain)(declCapture.node, ['function_definition'], ['class_definition']);
+        if (scopeChain.length > 0) {
+            fnName = `${scopeChain.map(s => s.name).join('.')}.${fnName}`;
+            if (scopeChain[scopeChain.length - 1].type === 'class') {
+                kind = 'method';
+            }
+        }
+        const paramsCapture = match.captures.find((c) => c.name === 'fn.params');
+        const returnCapture = match.captures.find((c) => c.name === 'fn.return_type');
+        // Python doesn't have explicit export keywords, but names not starting with _ are generally public API
+        const originalName = nameCapture.node.text;
+        const isExported = !originalName.startsWith('_');
+        // Parse parameters properly into name/type objects
+        const paramsList = [];
+        if (paramsCapture && paramsCapture.node) {
+            for (const child of paramsCapture.node.children) {
+                if (child.type === 'identifier') {
+                    paramsList.push({ name: child.text, type: null });
+                }
+                else if (child.type === 'typed_parameter') {
+                    const pName = child.childForFieldName('name') || child.children[0];
+                    const pType = child.childForFieldName('type') || child.children[2];
+                    paramsList.push({
+                        name: pName ? pName.text : child.text,
+                        type: pType ? pType.text : null
+                    });
+                }
+                else if (child.type === 'default_parameter') {
+                    const pName = child.childForFieldName('name') || child.children[0];
+                    paramsList.push({
+                        name: pName ? pName.text : child.text,
+                        type: null
+                    });
+                }
+                else if (child.type === 'typed_default_parameter') {
+                    const pName = child.childForFieldName('name') || child.children[0];
+                    const pType = child.childForFieldName('type') || child.children[2];
+                    paramsList.push({
+                        name: pName ? pName.text : child.text,
+                        type: pType ? pType.text : null
+                    });
+                }
+                else if (child.type === 'list_splat_pattern') {
+                    const nameNode = child.namedChildren.find((c) => c.type === 'identifier');
+                    if (nameNode) {
+                        paramsList.push({ name: `*${nameNode.text}`, type: null });
+                    }
+                }
+                else if (child.type === 'dictionary_splat_pattern') {
+                    const nameNode = child.namedChildren.find((c) => c.type === 'identifier');
+                    if (nameNode) {
+                        paramsList.push({ name: `**${nameNode.text}`, type: null });
+                    }
+                }
+            }
+        }
+        // Strip Python implementation-detail parameters
+        const filteredParams = paramsList.filter(p => p.name !== 'self' && p.name !== 'cls');
+        let finalReturnType = returnCapture ? returnCapture.node.text : null;
+        if (!finalReturnType) {
+            const returnValues = (0, extractorUtils_1.getReturnValues)(declCapture.node, extractorUtils_1.PYTHON_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: filteredParams,
+            returnType: finalReturnType,
+            isAsync: (0, extractorUtils_1.checkIsAsync)(declCapture.node),
+            isExported,
+            isEntryPoint: false,
+            language: languageId,
+            kind
+        };
+    },
+    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)
+            return null;
+        const nameNode = nameCapture.node;
+        const callNode = exprCapture.node;
+        const isMethodCall = nameNode.type === 'attribute';
+        let calleeName = nameNode.text;
+        if (isMethodCall) {
+            const attr = nameNode.childForFieldName('attribute');
+            if (attr)
+                calleeName = attr.text;
+        }
+        const argsNode = callNode.childForFieldName('arguments');
+        // threading.Thread(target=fn) or Thread(target=fn)
+        if (calleeName === 'Thread') {
+            const ref = getKeywordArgRef(argsNode, 'target');
+            if (ref) {
+                return { callerFilePath: filePath, calleeName: ref, line: callNode.startPosition.row, callType: 'concurrent', isRef: true };
+            }
+        }
+        // executor.submit(fn, ...)
+        if (calleeName === 'submit' && isMethodCall) {
+            const ref = getPositionalArgRef(argsNode, 0);
+            if (ref) {
+                return { callerFilePath: filePath, calleeName: ref, line: callNode.startPosition.row, callType: 'concurrent', isRef: true };
+            }
+        }
+        // executor.map(fn, iterable)
+        if (calleeName === 'map' && isMethodCall) {
+            const ref = getPositionalArgRef(argsNode, 0);
+            if (ref) {
+                return { callerFilePath: filePath, calleeName: ref, line: callNode.startPosition.row, callType: 'concurrent', isRef: true };
+            }
+        }
+        // loop.run_in_executor(executor, fn, ...)
+        if (calleeName === 'run_in_executor' && isMethodCall) {
+            const ref = getPositionalArgRef(argsNode, 1);
+            if (ref) {
+                return { callerFilePath: filePath, calleeName: ref, line: callNode.startPosition.row, callType: 'concurrent', isRef: true };
+            }
+        }
+        // Calls inside asyncio.gather() or asyncio.create_task() are concurrent
+        let callType;
+        if (isInsideAsyncioGather(callNode) || isArgumentToCreateTask(callNode)) {
+            callType = 'concurrent';
+        }
+        const result = { callerFilePath: filePath, calleeName, line: callNode.startPosition.row };
+        if (callType)
+            result.callType = callType;
+        return result;
+    }
+};

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

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