@compilr-dev/agents-coding-ts 0.1.0

package/dist/tools/get-complexity.js

@@ -0,0 +1,394 @@
+/**
+ * getComplexity Tool
+ *
+ * Calculate code complexity metrics including cyclomatic complexity,
+ * cognitive complexity, nesting depth, and identify complexity hotspots.
+ */
+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 = `Calculate code complexity metrics for files or directories.
+Returns cyclomatic complexity, cognitive complexity, nesting depth, and identifies hotspots.
+Useful for finding functions that may need refactoring.`;
+// Tool input schema
+const TOOL_INPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        path: {
+            type: 'string',
+            description: 'File or directory to analyze',
+        },
+        recursive: {
+            type: 'boolean',
+            description: 'Recursive analysis for directories (default: false)',
+            default: false,
+        },
+        threshold: {
+            type: 'number',
+            description: 'Complexity threshold for warnings (default: 10)',
+            default: 10,
+        },
+        onlyAboveThreshold: {
+            type: 'boolean',
+            description: 'Only return items above threshold (default: false)',
+            default: false,
+        },
+        maxFiles: {
+            type: 'number',
+            description: 'Maximum files to analyze (default: 50)',
+            default: 50,
+        },
+    },
+    required: ['path'],
+};
+// Default exclusions
+const DEFAULT_EXCLUDE = ['node_modules', 'dist', 'build', '.git', 'coverage'];
+/**
+ * getComplexity tool
+ */
+export const getComplexityTool = defineTool({
+    name: 'get_complexity',
+    description: TOOL_DESCRIPTION,
+    inputSchema: TOOL_INPUT_SCHEMA,
+    execute: executeGetComplexity,
+});
+/**
+ * Execute the getComplexity tool
+ */
+async function executeGetComplexity(input) {
+    const { path: inputPath, recursive = false, threshold = 10, onlyAboveThreshold = false, maxFiles = 50, } = input;
+    try {
+        const resolvedPath = path.resolve(inputPath);
+        // Check if path exists
+        try {
+            await fs.access(resolvedPath);
+        }
+        catch {
+            return createErrorResult(`Path not found: ${resolvedPath}`);
+        }
+        const stats = await fs.stat(resolvedPath);
+        const files = [];
+        if (stats.isDirectory()) {
+            await collectFiles(resolvedPath, files, recursive ? 10 : 1, maxFiles);
+        }
+        else if (stats.isFile()) {
+            files.push(resolvedPath);
+        }
+        // Analyze each file
+        const fileResults = [];
+        let totalFunctions = 0;
+        let totalComplexity = 0;
+        let maxComplexity = 0;
+        let aboveThresholdCount = 0;
+        const hotspots = [];
+        for (const file of files) {
+            const fileResult = await analyzeFile(file, threshold);
+            if (fileResult) {
+                // Filter if onlyAboveThreshold
+                if (onlyAboveThreshold) {
+                    fileResult.functions = fileResult.functions.filter((f) => f.aboveThreshold);
+                    if (fileResult.functions.length === 0)
+                        continue;
+                }
+                fileResults.push(fileResult);
+                // Update stats
+                totalFunctions += fileResult.functions.length;
+                for (const func of fileResult.functions) {
+                    totalComplexity += func.cyclomatic;
+                    if (func.cyclomatic > maxComplexity) {
+                        maxComplexity = func.cyclomatic;
+                    }
+                    if (func.aboveThreshold) {
+                        aboveThresholdCount++;
+                    }
+                    // Track hotspots
+                    hotspots.push({
+                        name: func.name,
+                        path: file,
+                        line: func.line,
+                        cyclomatic: func.cyclomatic,
+                        cognitive: func.cognitive,
+                    });
+                }
+            }
+        }
+        // Sort hotspots by complexity and take top 5
+        hotspots.sort((a, b) => b.cyclomatic - a.cyclomatic);
+        const topHotspots = hotspots.slice(0, 5);
+        const result = {
+            path: resolvedPath,
+            files: fileResults,
+            summary: {
+                totalFiles: fileResults.length,
+                totalFunctions,
+                averageComplexity: totalFunctions > 0 ? Math.round((totalComplexity / totalFunctions) * 100) / 100 : 0,
+                maxComplexity,
+                aboveThreshold: aboveThresholdCount,
+                threshold,
+            },
+            hotspots: topHotspots,
+        };
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        return createErrorResult(`Failed to analyze complexity: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Collect files to analyze
+ */
+async function collectFiles(dirPath, files, maxDepth, maxFiles, currentDepth = 0) {
+    if (currentDepth > maxDepth || files.length >= maxFiles)
+        return;
+    try {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (files.length >= maxFiles)
+                break;
+            const fullPath = path.join(dirPath, entry.name);
+            // Skip excluded directories
+            if (entry.isDirectory()) {
+                if (DEFAULT_EXCLUDE.includes(entry.name))
+                    continue;
+                await collectFiles(fullPath, files, maxDepth, maxFiles, currentDepth + 1);
+            }
+            else if (entry.isFile()) {
+                // Only include TypeScript/JavaScript files
+                if (/\.(ts|tsx|js|jsx)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore permission errors
+    }
+}
+/**
+ * Analyze complexity of a single file
+ */
+async function analyzeFile(filePath, threshold) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const detection = detectLanguage(filePath);
+        if (!detection.language || !isLanguageSupported(detection.language)) {
+            return null;
+        }
+        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, filePath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+        const functions = [];
+        let classCount = 0;
+        // Visit all nodes
+        const visit = (node) => {
+            // Track classes
+            if (ts.isClassDeclaration(node)) {
+                classCount++;
+            }
+            // Analyze functions
+            if (ts.isFunctionDeclaration(node) ||
+                ts.isMethodDeclaration(node) ||
+                ts.isFunctionExpression(node) ||
+                ts.isArrowFunction(node)) {
+                const funcComplexity = analyzeFunctionComplexity(node, sourceFile, threshold);
+                if (funcComplexity) {
+                    functions.push(funcComplexity);
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        // Calculate file metrics
+        const lines = content.split('\n');
+        const totalLines = lines.length;
+        const blankLines = lines.filter((l) => l.trim() === '').length;
+        const linesOfCode = totalLines - blankLines;
+        const avgComplexity = functions.length > 0
+            ? Math.round((functions.reduce((sum, f) => sum + f.cyclomatic, 0) / functions.length) * 100) / 100
+            : 0;
+        const maxComplexity = functions.length > 0 ? Math.max(...functions.map((f) => f.cyclomatic)) : 0;
+        return {
+            path: filePath,
+            metrics: {
+                lines: totalLines,
+                linesOfCode,
+                functions: functions.length,
+                classes: classCount,
+                avgComplexity,
+                maxComplexity,
+            },
+            functions,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Analyze complexity of a single function
+ */
+function analyzeFunctionComplexity(node, sourceFile, threshold) {
+    // Get function name
+    let name = '<anonymous>';
+    if (ts.isFunctionDeclaration(node) && node.name) {
+        name = node.name.text;
+    }
+    else if (ts.isMethodDeclaration(node)) {
+        name = ts.isIdentifier(node.name) ? node.name.text : '<computed>';
+    }
+    else if (ts.isFunctionExpression(node) && node.name) {
+        name = node.name.text;
+    }
+    else if (ts.isArrowFunction(node)) {
+        // Try to get name from parent variable declaration
+        const parent = node.parent;
+        if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+            name = parent.name.text;
+        }
+        else if (ts.isPropertyAssignment(parent) && ts.isIdentifier(parent.name)) {
+            name = parent.name.text;
+        }
+    }
+    // Skip anonymous functions in certain contexts
+    if (name === '<anonymous>') {
+        // Only include top-level anonymous functions or named expressions
+        const parent = node.parent;
+        if (!ts.isVariableDeclaration(parent) && !ts.isPropertyAssignment(parent)) {
+            return null;
+        }
+    }
+    const body = ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isFunctionExpression(node)
+        ? node.body
+        : node.body;
+    if (!body)
+        return null;
+    // Get position info
+    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+    // Calculate complexities
+    const contributors = [];
+    let cyclomatic = 1; // Start at 1
+    let cognitive = 0;
+    let maxNesting = 0;
+    const analyzeNode = (n, nestingLevel) => {
+        const { line } = sourceFile.getLineAndCharacterOfPosition(n.getStart());
+        // Track max nesting
+        if (nestingLevel > maxNesting) {
+            maxNesting = nestingLevel;
+        }
+        // Cyclomatic complexity contributors
+        if (ts.isIfStatement(n)) {
+            cyclomatic++;
+            cognitive += 1 + nestingLevel; // Cognitive adds nesting penalty
+            contributors.push({ type: 'if', line: line + 1, contribution: 1 + nestingLevel });
+        }
+        else if (ts.isConditionalExpression(n)) {
+            cyclomatic++;
+            cognitive += 1 + nestingLevel;
+            contributors.push({ type: 'ternary', line: line + 1, contribution: 1 + nestingLevel });
+        }
+        else if (ts.isForStatement(n) || ts.isForInStatement(n) || ts.isForOfStatement(n)) {
+            cyclomatic++;
+            cognitive += 1 + nestingLevel;
+            contributors.push({ type: 'for', line: line + 1, contribution: 1 + nestingLevel });
+        }
+        else if (ts.isWhileStatement(n)) {
+            cyclomatic++;
+            cognitive += 1 + nestingLevel;
+            contributors.push({ type: 'while', line: line + 1, contribution: 1 + nestingLevel });
+        }
+        else if (ts.isDoStatement(n)) {
+            cyclomatic++;
+            cognitive += 1 + nestingLevel;
+            contributors.push({ type: 'do', line: line + 1, contribution: 1 + nestingLevel });
+        }
+        else if (ts.isSwitchStatement(n)) {
+            cyclomatic++;
+            cognitive += 1 + nestingLevel;
+            contributors.push({ type: 'switch', line: line + 1, contribution: 1 + nestingLevel });
+        }
+        else if (ts.isCaseClause(n)) {
+            cyclomatic++;
+            contributors.push({ type: 'case', line: line + 1, contribution: 1 });
+        }
+        else if (ts.isCatchClause(n)) {
+            cyclomatic++;
+            cognitive += 1 + nestingLevel;
+            contributors.push({ type: 'catch', line: line + 1, contribution: 1 + nestingLevel });
+        }
+        else if (ts.isBinaryExpression(n)) {
+            if (n.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+                cyclomatic++;
+                cognitive++;
+                contributors.push({ type: 'logical_and', line: line + 1, contribution: 1 });
+            }
+            else if (n.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+                cyclomatic++;
+                cognitive++;
+                contributors.push({ type: 'logical_or', line: line + 1, contribution: 1 });
+            }
+            else if (n.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+                cyclomatic++;
+                cognitive++;
+                contributors.push({ type: 'nullish', line: line + 1, contribution: 1 });
+            }
+        }
+        // Increase nesting for blocks
+        const newNesting = isNestingNode(n) ? nestingLevel + 1 : nestingLevel;
+        ts.forEachChild(n, (child) => {
+            analyzeNode(child, newNesting);
+        });
+    };
+    analyzeNode(body, 0);
+    // Calculate LOC
+    const bodyText = body.getText(sourceFile);
+    const bodyLines = bodyText.split('\n').filter((l) => l.trim() !== '').length;
+    // Parameter count
+    const parameterCount = node.parameters.length;
+    const aboveThreshold = cyclomatic >= threshold;
+    return {
+        name,
+        line: startLine + 1,
+        endLine: endLine + 1,
+        cyclomatic,
+        cognitive,
+        maxNesting,
+        loc: bodyLines,
+        parameterCount,
+        aboveThreshold,
+        contributors: aboveThreshold ? contributors : undefined,
+    };
+}
+/**
+ * Check if a node increases nesting level
+ */
+function isNestingNode(node) {
+    return (ts.isIfStatement(node) ||
+        ts.isForStatement(node) ||
+        ts.isForInStatement(node) ||
+        ts.isForOfStatement(node) ||
+        ts.isWhileStatement(node) ||
+        ts.isDoStatement(node) ||
+        ts.isSwitchStatement(node) ||
+        ts.isTryStatement(node) ||
+        ts.isCatchClause(node));
+}
+/**
+ * Create customizable getComplexity tool
+ */
+export function createGetComplexityTool(options) {
+    return defineTool({
+        name: options?.name ?? 'get_complexity',
+        description: options?.description ?? TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            const modifiedInput = {
+                ...input,
+                threshold: input.threshold ?? options?.defaultThreshold,
+                maxFiles: input.maxFiles ?? options?.defaultMaxFiles,
+            };
+            return executeGetComplexity(modifiedInput);
+        },
+    });
+}

package/dist/tools/get-dependency-graph.d.ts

@@ -0,0 +1,23 @@
+/**
+ * getDependencyGraph Tool
+ *
+ * Analyze module-level dependencies across a directory.
+ * Builds a dependency graph and detects circular dependencies.
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { GetDependencyGraphInput } from './types.js';
+/**
+ * getDependencyGraph tool - Analyze module dependencies
+ */
+export declare const getDependencyGraphTool: Tool<GetDependencyGraphInput>;
+/**
+ * Factory function to create a customized getDependencyGraph tool
+ */
+export declare function createGetDependencyGraphTool(options?: {
+    /** Default includeExternal */
+    defaultIncludeExternal?: boolean;
+    /** Default includeTypeOnly */
+    defaultIncludeTypeOnly?: boolean;
+    /** Default maxDepth */
+    defaultMaxDepth?: number;
+}): Tool<GetDependencyGraphInput>;