codeguardian-mcp 1.0.0

package/dist/analyzers/builtinTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtinTypes.js","sourceRoot":"","sources":["../../src/analyzers/builtinTypes.ts"],"names":[],"mappings":"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"}

package/dist/analyzers/complexity.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Code Complexity Analyzer (AST-based)
+ *
+ * Calculates cyclomatic complexity and identifies complex code patterns
+ * using proper AST parsing instead of regex-based indentation counting
+ *
+ * @format
+ */
+import { Issue } from "../types/tools.js";
+/**
+ * Analyze code complexity using AST
+ */
+export declare function analyzeComplexity(code: string, language: string): Promise<Issue[]>;
+//# sourceMappingURL=complexity.d.ts.map

package/dist/analyzers/complexity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complexity.d.ts","sourceRoot":"","sources":["../../src/analyzers/complexity.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAI1C;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,KAAK,EAAE,CAAC,CAsBlB"}

package/dist/analyzers/complexity.js

@@ -0,0 +1,610 @@
+/**
+ * Code Complexity Analyzer (AST-based)
+ *
+ * Calculates cyclomatic complexity and identifies complex code patterns
+ * using proper AST parsing instead of regex-based indentation counting
+ *
+ * @format
+ */
+import { logger } from "../utils/logger.js";
+import { getParser } from "../tools/validation/parser.js";
+/**
+ * Analyze code complexity using AST
+ */
+export async function analyzeComplexity(code, language) {
+    logger.debug("Analyzing complexity with AST...");
+    try {
+        if (language === "javascript" || language === "typescript") {
+            return await analyzeJavaScriptComplexityAST(code, language);
+        }
+        else if (language === "python") {
+            return await analyzePythonComplexity(code);
+        }
+        else {
+            // Fallback to simple analysis for unsupported languages
+            return await analyzeComplexityFallback(code, language);
+        }
+    }
+    catch (error) {
+        logger.error("Error in AST-based complexity analysis, falling back:", error);
+        return await analyzeComplexityFallback(code, language);
+    }
+}
+/**
+ * Analyze JavaScript/TypeScript complexity using Tree-sitter AST.
+ */
+async function analyzeJavaScriptComplexityAST(code, language) {
+    const issues = [];
+    try {
+        const parser = getParser(language);
+        const tree = parser.parse(code);
+        const root = tree.rootNode;
+        // Track functions and their complexity
+        const functions = [];
+        const getText = (node) => code.substring(node.startIndex, node.endIndex);
+        const isFunctionLikeNode = (type) => type === "function_declaration" ||
+            type === "function" ||
+            type === "function_expression" ||
+            type === "arrow_function" ||
+            type === "method_definition";
+        const isNestedDefNode = (type) => isFunctionLikeNode(type) ||
+            type === "class_declaration" ||
+            type === "class";
+        const isBlockNestingNode = (type) => type === "if_statement" ||
+            type === "for_statement" ||
+            type === "for_in_statement" ||
+            type === "for_of_statement" ||
+            type === "while_statement" ||
+            type === "do_statement" ||
+            type === "switch_statement" ||
+            type === "try_statement" ||
+            type === "catch_clause";
+        const resolveFunctionName = (node) => {
+            const nameNode = node.childForFieldName?.("name");
+            if (nameNode)
+                return getText(nameNode);
+            if (node.type === "arrow_function") {
+                const parent = node.parent;
+                if (parent?.type === "variable_declarator") {
+                    const n = parent.childForFieldName?.("name");
+                    if (n)
+                        return getText(n);
+                }
+                if (parent?.type === "pair") {
+                    const key = parent.childForFieldName?.("key");
+                    if (key)
+                        return getText(key);
+                }
+                if (parent?.type === "assignment_expression") {
+                    const left = parent.childForFieldName?.("left");
+                    if (left?.type === "identifier")
+                        return getText(left);
+                }
+            }
+            return "anonymous";
+        };
+        const computeFunctionComplexity = (bodyNode, functionNodeId) => {
+            let complexity = 1;
+            let maxNesting = 0;
+            const traverse = (node, nesting) => {
+                if (!node)
+                    return;
+                // Do not include nested defs in the parent function's complexity.
+                if (node.id !== functionNodeId && isNestedDefNode(node.type)) {
+                    return;
+                }
+                switch (node.type) {
+                    case "if_statement":
+                        complexity++;
+                        break;
+                    case "for_statement":
+                    case "for_in_statement":
+                    case "for_of_statement":
+                    case "while_statement":
+                    case "do_statement":
+                        complexity++;
+                        break;
+                    case "catch_clause":
+                        complexity++;
+                        break;
+                    case "conditional_expression":
+                    case "ternary_expression":
+                        complexity++;
+                        break;
+                    case "switch_case":
+                        complexity++;
+                        break;
+                    case "binary_expression":
+                    case "logical_expression": {
+                        for (const child of node.children || []) {
+                            const t = child?.type;
+                            if (t === "&&" || t === "||")
+                                complexity++;
+                        }
+                        break;
+                    }
+                }
+                const nextNesting = isBlockNestingNode(node.type) ? nesting + 1 : nesting;
+                maxNesting = Math.max(maxNesting, nextNesting);
+                for (const child of node.children || []) {
+                    traverse(child, nextNesting);
+                }
+            };
+            traverse(bodyNode, 0);
+            return { complexity, nestingLevel: maxNesting };
+        };
+        const collectFunctions = (node) => {
+            if (!node)
+                return;
+            if (isFunctionLikeNode(node.type)) {
+                const bodyNode = node.childForFieldName?.("body");
+                const name = resolveFunctionName(node);
+                const line = node.startPosition?.row + 1 || 0;
+                const lineCount = node.endPosition && node.startPosition
+                    ? node.endPosition.row - node.startPosition.row + 1
+                    : 0;
+                const { complexity, nestingLevel } = bodyNode
+                    ? computeFunctionComplexity(bodyNode, node.id)
+                    : { complexity: 1, nestingLevel: 0 };
+                functions.push({ name, line, complexity, nestingLevel, lineCount });
+            }
+            for (const child of node.children || []) {
+                collectFunctions(child);
+            }
+        };
+        collectFunctions(root);
+        // Generate issues from function analysis
+        for (const func of functions) {
+            // High cyclomatic complexity
+            if (func.complexity > 10) {
+                issues.push({
+                    type: "highComplexity",
+                    severity: func.complexity > 20 ? "high" : "medium",
+                    message: `Function '${func.name}' has high cyclomatic complexity (${func.complexity})`,
+                    line: func.line,
+                    column: 0,
+                    code: `function ${func.name}`,
+                    suggestion: "Consider breaking this function into smaller functions",
+                    autoFixable: false,
+                    confidence: 95,
+                });
+            }
+            // Long functions
+            if (func.lineCount > 50) {
+                issues.push({
+                    type: "longFunction",
+                    severity: "medium",
+                    message: `Function '${func.name}' is too long (${func.lineCount} lines)`,
+                    line: func.line,
+                    column: 0,
+                    code: `function ${func.name}`,
+                    suggestion: "Functions should typically be under 50 lines",
+                    autoFixable: false,
+                    confidence: 90,
+                });
+            }
+            // Deep nesting (only flag if > 4 levels, which is reasonable)
+            if (func.nestingLevel > 4) {
+                issues.push({
+                    type: "deepNesting",
+                    severity: "medium",
+                    message: `Function '${func.name}' has deep nesting (level ${func.nestingLevel})`,
+                    line: func.line,
+                    column: 0,
+                    code: `function ${func.name}`,
+                    suggestion: "Consider extracting nested logic into separate functions or using early returns",
+                    autoFixable: false,
+                    confidence: 85,
+                });
+            }
+        }
+        logger.debug(`Found ${issues.length} complexity issues (JS/TS AST-based)`);
+    }
+    catch (error) {
+        logger.error("Error parsing JavaScript/TypeScript Tree-sitter AST:", error);
+    }
+    return issues;
+}
+/**
+ * Analyze Python complexity using Tree-sitter AST.
+ */
+async function analyzePythonComplexity(code) {
+    try {
+        return analyzePythonComplexityAST(code);
+    }
+    catch (error) {
+        logger.error("Error analyzing Python complexity with Tree-sitter AST; falling back to heuristics:", error);
+        return analyzePythonComplexityHeuristic(code);
+    }
+}
+function analyzePythonComplexityAST(code) {
+    const issues = [];
+    const parser = getParser("python");
+    const tree = parser.parse(code);
+    const functions = [];
+    const root = tree.rootNode;
+    const getText = (node) => code.substring(node.startIndex, node.endIndex);
+    const isBlockNestingNode = (type) => type === "if_statement" ||
+        type === "for_statement" ||
+        type === "while_statement" ||
+        type === "try_statement" ||
+        type === "with_statement" ||
+        type === "match_statement";
+    const computeFunctionComplexity = (bodyNode, functionNodeId) => {
+        let complexity = 1;
+        let maxNesting = 0;
+        const traverse = (node, nesting) => {
+            if (!node)
+                return;
+            // Do not include nested defs in the parent function's complexity.
+            if (node.id !== functionNodeId &&
+                (node.type === "function_definition" || node.type === "class_definition")) {
+                return;
+            }
+            // Decision points
+            switch (node.type) {
+                case "if_statement":
+                    complexity++;
+                    break;
+                case "elif_clause":
+                    complexity++;
+                    break;
+                case "for_statement":
+                case "while_statement":
+                    complexity++;
+                    break;
+                case "except_clause":
+                    complexity++;
+                    break;
+                case "conditional_expression":
+                    complexity++;
+                    break;
+                case "case_clause":
+                    // Count each case as a decision point (similar to switch cases)
+                    complexity++;
+                    break;
+                case "boolean_operator": {
+                    // Count boolean operator occurrences (and/or). Tree-sitter represents these as nodes.
+                    // The operator itself is usually a child token.
+                    for (const child of node.children || []) {
+                        const t = child.type;
+                        if (t === "and" || t === "or")
+                            complexity++;
+                    }
+                    break;
+                }
+            }
+            const nextNesting = isBlockNestingNode(node.type) ? nesting + 1 : nesting;
+            maxNesting = Math.max(maxNesting, nextNesting);
+            for (const child of node.children || []) {
+                traverse(child, nextNesting);
+            }
+        };
+        traverse(bodyNode, 0);
+        return { complexity, nestingLevel: maxNesting };
+    };
+    const collectFunctions = (node) => {
+        if (!node)
+            return;
+        if (node.type === "function_definition") {
+            const nameNode = node.childForFieldName?.("name");
+            const bodyNode = node.childForFieldName?.("body");
+            const name = nameNode ? getText(nameNode) : "anonymous";
+            const line = node.startPosition?.row + 1 || 0;
+            const lineCount = node.endPosition && node.startPosition
+                ? node.endPosition.row - node.startPosition.row + 1
+                : 0;
+            const { complexity, nestingLevel } = bodyNode
+                ? computeFunctionComplexity(bodyNode, node.id)
+                : { complexity: 1, nestingLevel: 0 };
+            functions.push({ name, line, complexity, nestingLevel, lineCount });
+            // Still recurse to find nested functions (each will be analyzed independently)
+            for (const child of node.children || []) {
+                collectFunctions(child);
+            }
+            return;
+        }
+        for (const child of node.children || []) {
+            collectFunctions(child);
+        }
+    };
+    collectFunctions(root);
+    for (const func of functions) {
+        if (func.complexity > 10) {
+            issues.push({
+                type: "highComplexity",
+                severity: func.complexity > 20 ? "high" : "medium",
+                message: `Function '${func.name}' has high cyclomatic complexity (${func.complexity})`,
+                line: func.line,
+                column: 0,
+                code: `def ${func.name}(...)`,
+                suggestion: "Consider breaking this function into smaller functions",
+                autoFixable: false,
+                confidence: 90,
+            });
+        }
+        if (func.lineCount > 50) {
+            issues.push({
+                type: "longFunction",
+                severity: "medium",
+                message: `Function '${func.name}' is too long (${func.lineCount} lines)`,
+                line: func.line,
+                column: 0,
+                code: `def ${func.name}(...)`,
+                suggestion: "Functions should typically be under 50 lines",
+                autoFixable: false,
+                confidence: 90,
+            });
+        }
+        if (func.nestingLevel > 4) {
+            issues.push({
+                type: "deepNesting",
+                severity: "medium",
+                message: `Function '${func.name}' has deep nesting (level ${func.nestingLevel})`,
+                line: func.line,
+                column: 0,
+                code: `def ${func.name}(...)`,
+                suggestion: "Consider extracting nested logic into separate functions or using early returns",
+                autoFixable: false,
+                confidence: 85,
+            });
+        }
+    }
+    logger.debug(`Found ${issues.length} complexity issues (Python AST-based)`);
+    return issues;
+}
+function analyzePythonComplexityHeuristic(code) {
+    const issues = [];
+    const functions = extractPythonFunctions(code);
+    for (const func of functions) {
+        const complexity = calculatePythonComplexity(func.body);
+        if (complexity > 10) {
+            issues.push({
+                type: "highComplexity",
+                severity: complexity > 20 ? "high" : "medium",
+                message: `Function '${func.name}' has high cyclomatic complexity (${complexity})`,
+                line: func.line,
+                column: 0,
+                code: func.signature,
+                suggestion: "Consider breaking this function into smaller functions",
+                autoFixable: false,
+                confidence: 75,
+            });
+        }
+        const lineCount = func.body.split("\n").length;
+        if (lineCount > 50) {
+            issues.push({
+                type: "longFunction",
+                severity: "medium",
+                message: `Function '${func.name}' is too long (${lineCount} lines)`,
+                line: func.line,
+                column: 0,
+                code: func.signature,
+                suggestion: "Functions should typically be under 50 lines",
+                autoFixable: false,
+                confidence: 80,
+            });
+        }
+        const maxNesting = calculatePythonNesting(func.body);
+        if (maxNesting > 4) {
+            issues.push({
+                type: "deepNesting",
+                severity: "medium",
+                message: `Function '${func.name}' has deep nesting (level ${maxNesting})`,
+                line: func.line,
+                column: 0,
+                code: func.signature,
+                suggestion: "Consider extracting nested logic into separate functions or using early returns",
+                autoFixable: false,
+                confidence: 75,
+            });
+        }
+    }
+    logger.debug(`Found ${issues.length} complexity issues (Python heuristic)`);
+    return issues;
+}
+/**
+ * Extract Python functions from code
+ */
+function extractPythonFunctions(code) {
+    const functions = [];
+    const lines = code.split("\n");
+    let currentFunction = null;
+    let functionIndent = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Skip empty lines and comments
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        // Detect function definition
+        const funcMatch = trimmed.match(/^(?:async\s+)?def\s+(\w+)\s*\(/);
+        if (funcMatch) {
+            // Save previous function if exists
+            if (currentFunction) {
+                functions.push(currentFunction);
+            }
+            // Start new function
+            const indent = line.match(/^(\s*)/)?.[1].length || 0;
+            currentFunction = {
+                name: funcMatch[1],
+                signature: trimmed,
+                body: "",
+                line: i + 1,
+            };
+            functionIndent = indent;
+            continue;
+        }
+        // Add to current function body
+        if (currentFunction) {
+            const indent = line.match(/^(\s*)/)?.[1].length || 0;
+            // If we're back to the same or less indentation, function ended
+            if (trimmed && indent <= functionIndent) {
+                functions.push(currentFunction);
+                currentFunction = null;
+            }
+            else {
+                currentFunction.body += line + "\n";
+            }
+        }
+    }
+    // Don't forget the last function
+    if (currentFunction) {
+        functions.push(currentFunction);
+    }
+    return functions;
+}
+/**
+ * Calculate Python complexity heuristically
+ */
+function calculatePythonComplexity(code) {
+    let complexity = 1; // Base complexity
+    // Count decision points
+    const patterns = [
+        /\bif\b/g,
+        /\belif\b/g,
+        /\bfor\b/g,
+        /\bwhile\b/g,
+        /\band\b/g,
+        /\bor\b/g,
+        /\bexcept\b/g,
+    ];
+    for (const pattern of patterns) {
+        const matches = code.match(pattern);
+        if (matches) {
+            complexity += matches.length;
+        }
+    }
+    return complexity;
+}
+/**
+ * Calculate Python nesting level (relative to function body)
+ */
+function calculatePythonNesting(code) {
+    const lines = code.split("\n");
+    let maxNesting = 0;
+    let baseIndent = -1;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip empty lines, comments, and docstrings
+        if (!trimmed ||
+            trimmed.startsWith("#") ||
+            trimmed.startsWith('"""') ||
+            trimmed.startsWith("'''")) {
+            continue;
+        }
+        const indent = line.match(/^(\s*)/)?.[1].length || 0;
+        // Set base indent from first non-empty line
+        if (baseIndent === -1 && trimmed) {
+            baseIndent = indent;
+        }
+        // Calculate nesting relative to base
+        if (baseIndent >= 0) {
+            const relativeIndent = indent - baseIndent;
+            const nestingLevel = Math.floor(relativeIndent / 4); // Python uses 4-space indent
+            maxNesting = Math.max(maxNesting, nestingLevel);
+        }
+    }
+    return maxNesting;
+}
+/**
+ * Fallback complexity analysis for unsupported languages
+ */
+async function analyzeComplexityFallback(code, language) {
+    const issues = [];
+    // Simple line-based analysis as fallback
+    const functions = extractFunctions(code, language);
+    for (const func of functions) {
+        const complexity = calculateCyclomaticComplexity(func.body);
+        if (complexity > 10) {
+            issues.push({
+                type: "highComplexity",
+                severity: complexity > 20 ? "high" : "medium",
+                message: `Function '${func.name}' has high cyclomatic complexity (${complexity})`,
+                line: func.line,
+                column: 0,
+                code: func.signature,
+                suggestion: "Consider breaking this function into smaller functions",
+                autoFixable: false,
+                confidence: 75,
+            });
+        }
+        const lineCount = func.body.split("\n").length;
+        if (lineCount > 50) {
+            issues.push({
+                type: "longFunction",
+                severity: "medium",
+                message: `Function '${func.name}' is too long (${lineCount} lines)`,
+                line: func.line,
+                column: 0,
+                code: func.signature,
+                suggestion: "Functions should typically be under 50 lines",
+                autoFixable: false,
+                confidence: 80,
+            });
+        }
+    }
+    return issues;
+}
+/**
+ * Extract functions from code (fallback method)
+ */
+function extractFunctions(code, language) {
+    const functions = [];
+    const lines = code.split("\n");
+    let currentFunction = null;
+    let braceCount = 0;
+    lines.forEach((line, index) => {
+        if (language === "javascript" || language === "typescript") {
+            const funcMatch = line.match(/function\s+(\w+)\s*\(|const\s+(\w+)\s*=.*=>/);
+            if (funcMatch) {
+                currentFunction = {
+                    name: funcMatch[1] || funcMatch[2],
+                    signature: line.trim(),
+                    body: "",
+                    line: index + 1,
+                };
+                braceCount = 0;
+            }
+            if (currentFunction) {
+                currentFunction.body += line + "\n";
+                braceCount += (line.match(/{/g) || []).length;
+                braceCount -= (line.match(/}/g) || []).length;
+                if (braceCount === 0 && currentFunction.body.includes("{")) {
+                    functions.push(currentFunction);
+                    currentFunction = null;
+                }
+            }
+        }
+    });
+    return functions;
+}
+/**
+ * Calculate cyclomatic complexity (fallback method)
+ */
+function calculateCyclomaticComplexity(code) {
+    let complexity = 1;
+    const decisionKeywords = [
+        "if",
+        "else if",
+        "for",
+        "while",
+        "case",
+        "&&",
+        "||",
+    ];
+    for (const keyword of decisionKeywords) {
+        const escapedKeyword = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(`\\b${escapedKeyword}\\b`, "g");
+        const matches = code.match(regex);
+        if (matches) {
+            complexity += matches.length;
+        }
+    }
+    const ternaryMatches = code.match(/\?/g);
+    if (ternaryMatches) {
+        complexity += ternaryMatches.length;
+    }
+    return complexity;
+}
+//# sourceMappingURL=complexity.js.map