@compilr-dev/agents-coding-ts 0.1.0

package/dist/tools/get-call-graph.js

@@ -0,0 +1,469 @@
+/**
+ * getCallGraph Tool
+ *
+ * Analyze function call relationships using TypeScript Compiler API.
+ * Returns a call graph showing what functions call what.
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as ts from 'typescript';
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { detectLanguage, isLanguageSupported } from '../parser/typescript-parser.js';
+// Tool description
+const TOOL_DESCRIPTION = `Analyze function call relationships in source code.
+Returns a call graph showing which functions call which other functions.
+Use this to understand code flow, dependencies, and refactoring impact.`;
+// Tool input schema
+const TOOL_INPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        path: {
+            type: 'string',
+            description: 'File to analyze',
+        },
+        functionName: {
+            type: 'string',
+            description: 'Specific function to analyze (optional)',
+        },
+        direction: {
+            type: 'string',
+            enum: ['callers', 'callees', 'both'],
+            description: "Direction: 'callers' | 'callees' | 'both' (default: 'both')",
+        },
+        maxDepth: {
+            type: 'number',
+            description: 'Maximum depth to traverse (default: 2)',
+            default: 2,
+        },
+        includeExternal: {
+            type: 'boolean',
+            description: 'Include external package calls (default: false)',
+            default: false,
+        },
+        scope: {
+            type: 'string',
+            description: "Scope directory for finding callers (default: file's directory)",
+        },
+    },
+    required: ['path'],
+};
+/**
+ * getCallGraph tool - Analyze function call relationships
+ */
+export const getCallGraphTool = defineTool({
+    name: 'get_call_graph',
+    description: TOOL_DESCRIPTION,
+    inputSchema: TOOL_INPUT_SCHEMA,
+    execute: executeGetCallGraph,
+});
+/**
+ * Execute the getCallGraph tool
+ */
+async function executeGetCallGraph(input) {
+    const { path: inputPath, functionName, direction = 'both', maxDepth = 2, includeExternal = false, scope, } = input;
+    // Validate input
+    if (!inputPath || inputPath.trim().length === 0) {
+        return createErrorResult('Path is required');
+    }
+    try {
+        // Check if path exists
+        try {
+            await fs.access(inputPath);
+        }
+        catch {
+            return createErrorResult(`Path not found: ${inputPath}`);
+        }
+        const stats = await fs.stat(inputPath);
+        if (!stats.isFile()) {
+            return createErrorResult(`Path must be a file: ${inputPath}`);
+        }
+        // Check for supported language
+        const detection = detectLanguage(inputPath);
+        if (!detection.language || !isLanguageSupported(detection.language)) {
+            return createErrorResult(`Unsupported file type: ${path.extname(inputPath)}`);
+        }
+        // Analyze the file
+        const scopeDir = scope ?? path.dirname(inputPath);
+        const result = await analyzeCallGraph(inputPath, functionName, direction, maxDepth, includeExternal, scopeDir);
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createErrorResult(`Failed to analyze call graph: ${message}`);
+    }
+}
+/**
+ * Analyze call graph for a file
+ */
+async function analyzeCallGraph(filePath, functionName, direction, maxDepth, includeExternal, _scopeDir) {
+    const sourceCode = await fs.readFile(filePath, 'utf-8');
+    const scriptKind = getScriptKind(filePath);
+    const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true, scriptKind);
+    // Find all functions in the file
+    const functions = extractFunctions(sourceFile, filePath);
+    // Build the call graph
+    const graphNodes = new Map();
+    let rootNode;
+    let externalCallCount = 0;
+    // If functionName is specified, find it
+    if (functionName) {
+        const targetFunc = functions.find((f) => f.node.name === functionName);
+        if (!targetFunc) {
+            // Return empty result if function not found
+            return {
+                graph: [],
+                stats: {
+                    totalFunctions: 0,
+                    totalCalls: 0,
+                    maxDepthReached: 0,
+                },
+            };
+        }
+        rootNode = targetFunc.node;
+    }
+    // Analyze callees (what each function calls)
+    if (direction === 'callees' || direction === 'both') {
+        const functionsToAnalyze = functionName
+            ? functions.filter((f) => f.node.name === functionName)
+            : functions;
+        for (const func of functionsToAnalyze) {
+            const callees = extractCallees(sourceFile, func, functions, includeExternal);
+            let graphNode = graphNodes.get(func.node.name);
+            if (!graphNode) {
+                graphNode = {
+                    function: func.node,
+                    calls: [],
+                    calledBy: [],
+                };
+                graphNodes.set(func.node.name, graphNode);
+            }
+            graphNode.calls = callees;
+            // Count external calls
+            if (includeExternal) {
+                externalCallCount += callees.filter((c) => c.function.path === 'external').length;
+            }
+        }
+    }
+    // Analyze callers (what calls each function)
+    if (direction === 'callers' || direction === 'both') {
+        const functionsToAnalyze = functionName
+            ? functions.filter((f) => f.node.name === functionName)
+            : functions;
+        for (const func of functionsToAnalyze) {
+            // Find callers within the same file
+            const callers = findCallersInFile(sourceFile, func.node.name, functions, filePath);
+            let graphNode = graphNodes.get(func.node.name);
+            if (!graphNode) {
+                graphNode = {
+                    function: func.node,
+                    calls: [],
+                    calledBy: [],
+                };
+                graphNodes.set(func.node.name, graphNode);
+            }
+            graphNode.calledBy = callers;
+        }
+    }
+    // Calculate statistics
+    const graph = Array.from(graphNodes.values());
+    const totalCalls = graph.reduce((sum, node) => sum + node.calls.length, 0);
+    const callGraphStats = {
+        totalFunctions: graph.length,
+        totalCalls,
+        maxDepthReached: Math.min(maxDepth, 1), // Currently we only go 1 level deep
+        externalCalls: includeExternal ? externalCallCount : undefined,
+    };
+    return {
+        root: rootNode,
+        graph,
+        stats: callGraphStats,
+    };
+}
+/**
+ * Extract all functions from a source file
+ */
+function extractFunctions(sourceFile, filePath) {
+    const functions = [];
+    function visit(node, className) {
+        // Function declarations
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+            const isExported = hasExportModifier(node);
+            const isAsync = hasAsyncModifier(node);
+            functions.push({
+                node: {
+                    name: node.name.text,
+                    path: filePath,
+                    line: line + 1,
+                    column: character + 1,
+                    async: isAsync,
+                    exported: isExported,
+                },
+                bodyStart: node.body?.getStart(sourceFile) ?? node.getStart(sourceFile),
+                bodyEnd: node.body?.getEnd() ?? node.getEnd(),
+            });
+        }
+        // Arrow functions assigned to variables
+        if (ts.isVariableStatement(node)) {
+            const decls = node.declarationList.declarations;
+            for (const decl of decls) {
+                if (ts.isIdentifier(decl.name) && decl.initializer) {
+                    if (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) {
+                        const { line, character } = sourceFile.getLineAndCharacterOfPosition(decl.getStart(sourceFile));
+                        const isExported = hasExportModifier(node);
+                        const isAsync = hasAsyncModifier(decl.initializer);
+                        functions.push({
+                            node: {
+                                name: decl.name.text,
+                                path: filePath,
+                                line: line + 1,
+                                column: character + 1,
+                                async: isAsync,
+                                exported: isExported,
+                            },
+                            bodyStart: decl.initializer.body.getStart(sourceFile),
+                            bodyEnd: decl.initializer.body.getEnd(),
+                        });
+                    }
+                }
+            }
+        }
+        // Class methods
+        if (ts.isClassDeclaration(node) && node.name) {
+            const currentClassName = node.name.text;
+            for (const member of node.members) {
+                if (ts.isMethodDeclaration(member) && ts.isIdentifier(member.name)) {
+                    const { line, character } = sourceFile.getLineAndCharacterOfPosition(member.getStart(sourceFile));
+                    const isAsync = hasAsyncModifier(member);
+                    functions.push({
+                        node: {
+                            name: member.name.text,
+                            path: filePath,
+                            line: line + 1,
+                            column: character + 1,
+                            className: currentClassName,
+                            async: isAsync,
+                            exported: hasExportModifier(node), // Class export implies method access
+                        },
+                        bodyStart: member.body?.getStart(sourceFile) ?? member.getStart(sourceFile),
+                        bodyEnd: member.body?.getEnd() ?? member.getEnd(),
+                    });
+                }
+            }
+        }
+        ts.forEachChild(node, (child) => {
+            visit(child, className);
+        });
+    }
+    visit(sourceFile);
+    return functions;
+}
+/**
+ * Extract callees (functions called by a function)
+ */
+function extractCallees(sourceFile, func, allFunctions, includeExternal) {
+    const callCounts = new Map();
+    function visit(node) {
+        // Skip nodes outside the function body
+        const nodeStart = node.getStart(sourceFile);
+        const nodeEnd = node.getEnd();
+        if (nodeStart < func.bodyStart || nodeEnd > func.bodyEnd) {
+            ts.forEachChild(node, visit);
+            return;
+        }
+        if (ts.isCallExpression(node)) {
+            const callInfo = extractCallInfo(node, sourceFile, allFunctions, includeExternal);
+            if (callInfo) {
+                const key = `${callInfo.function.name}:${callInfo.function.path}`;
+                const existing = callCounts.get(key);
+                if (existing) {
+                    existing.count++;
+                }
+                else {
+                    callCounts.set(key, callInfo);
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return Array.from(callCounts.values());
+}
+/**
+ * Extract call info from a call expression
+ */
+function extractCallInfo(node, sourceFile, allFunctions, includeExternal) {
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    let funcName;
+    let callType = 'direct';
+    let className;
+    // Simple function call: funcName()
+    if (ts.isIdentifier(node.expression)) {
+        funcName = node.expression.text;
+    }
+    // Method call: obj.method() or this.method() or promise chain
+    else if (ts.isPropertyAccessExpression(node.expression)) {
+        funcName = node.expression.name.text;
+        const propName = node.expression.name.text;
+        // Check for promise chain
+        if (propName === 'then' || propName === 'catch' || propName === 'finally') {
+            callType = 'promise';
+        }
+        else {
+            callType = 'method';
+            if (ts.isIdentifier(node.expression.expression)) {
+                const objName = node.expression.expression.text;
+                if (objName !== 'this') {
+                    // Could be instance.method or ClassName.staticMethod
+                    className = objName;
+                }
+            }
+        }
+    }
+    if (!funcName) {
+        return null;
+    }
+    // Check if it's a known function in the file
+    const knownFunc = allFunctions.find((f) => f.node.name === funcName);
+    if (knownFunc) {
+        return {
+            function: knownFunc.node,
+            callLine: line + 1,
+            callColumn: character + 1,
+            type: callType,
+            count: 1,
+        };
+    }
+    // External call (not in this file)
+    if (includeExternal) {
+        return {
+            function: {
+                name: funcName,
+                path: 'external',
+                line: 0,
+                column: 0,
+                className,
+            },
+            callLine: line + 1,
+            callColumn: character + 1,
+            type: callType,
+            count: 1,
+        };
+    }
+    return null;
+}
+/**
+ * Find callers of a function within the same file
+ */
+function findCallersInFile(sourceFile, targetFuncName, allFunctions, _filePath) {
+    const callerCounts = new Map();
+    for (const func of allFunctions) {
+        // Skip the function itself
+        if (func.node.name === targetFuncName) {
+            continue;
+        }
+        // Check if this function calls the target
+        let callsTarget = false;
+        let callLine = 0;
+        let callColumn = 0;
+        let callCount = 0;
+        function visit(node) {
+            // Skip nodes outside the function body
+            const nodeStart = node.getStart(sourceFile);
+            const nodeEnd = node.getEnd();
+            if (nodeStart < func.bodyStart || nodeEnd > func.bodyEnd) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            if (ts.isCallExpression(node)) {
+                let calledName;
+                if (ts.isIdentifier(node.expression)) {
+                    calledName = node.expression.text;
+                }
+                else if (ts.isPropertyAccessExpression(node.expression)) {
+                    calledName = node.expression.name.text;
+                }
+                if (calledName === targetFuncName) {
+                    callsTarget = true;
+                    callCount++;
+                    if (callLine === 0) {
+                        const pos = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+                        callLine = pos.line + 1;
+                        callColumn = pos.character + 1;
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(sourceFile);
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Modified in nested visit function
+        if (callsTarget) {
+            const key = func.node.name;
+            callerCounts.set(key, {
+                function: func.node,
+                callLine,
+                callColumn,
+                type: 'direct',
+                count: callCount,
+            });
+        }
+    }
+    return Array.from(callerCounts.values());
+}
+/**
+ * Check if a node has export modifier
+ */
+function hasExportModifier(node) {
+    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+    return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+/**
+ * Check if a node has async modifier
+ */
+function hasAsyncModifier(node) {
+    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+    return modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+}
+/**
+ * Get TypeScript script kind from file extension
+ */
+function getScriptKind(filePath) {
+    const ext = filePath.toLowerCase().split('.').pop();
+    switch (ext) {
+        case 'ts':
+            return ts.ScriptKind.TS;
+        case 'tsx':
+            return ts.ScriptKind.TSX;
+        case 'js':
+            return ts.ScriptKind.JS;
+        case 'jsx':
+            return ts.ScriptKind.JSX;
+        case 'mts':
+        case 'cts':
+            return ts.ScriptKind.TS;
+        case 'mjs':
+        case 'cjs':
+            return ts.ScriptKind.JS;
+        default:
+            return ts.ScriptKind.TS;
+    }
+}
+/**
+ * Factory function to create a customized getCallGraph tool
+ */
+export function createGetCallGraphTool(options) {
+    const { defaultDirection = 'both', defaultMaxDepth = 2, defaultIncludeExternal = false, } = options ?? {};
+    return defineTool({
+        name: 'get_call_graph',
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            return executeGetCallGraph({
+                ...input,
+                direction: input.direction ?? defaultDirection,
+                maxDepth: input.maxDepth ?? defaultMaxDepth,
+                includeExternal: input.includeExternal ?? defaultIncludeExternal,
+            });
+        },
+    });
+}

package/dist/tools/get-complexity.d.ts

@@ -0,0 +1,21 @@
+/**
+ * getComplexity Tool
+ *
+ * Calculate code complexity metrics including cyclomatic complexity,
+ * cognitive complexity, nesting depth, and identify complexity hotspots.
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { GetComplexityInput } from './types.js';
+/**
+ * getComplexity tool
+ */
+export declare const getComplexityTool: Tool<GetComplexityInput>;
+/**
+ * Create customizable getComplexity tool
+ */
+export declare function createGetComplexityTool(options?: {
+    name?: string;
+    description?: string;
+    defaultThreshold?: number;
+    defaultMaxFiles?: number;
+}): Tool<GetComplexityInput>;