@compilr-dev/agents-coding-go 0.1.0

package/dist/tools/get-class-hierarchy.js

@@ -0,0 +1,250 @@
+/**
+ * getClassHierarchy Tool
+ *
+ * Analyze type hierarchies in Go code.
+ * Go uses composition (embedding) rather than inheritance.
+ * This tool finds embedded types and types that embed a given type.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { defineTool, createSuccessResult, createErrorResult, } from "@compilr-dev/agents";
+import { parseFile, parseClass, walkTree } from "../parser/go-parser.js";
+// Tool description
+const TOOL_DESCRIPTION = `Analyze type hierarchies in Go code.
+Go uses composition (embedding) rather than inheritance.
+Returns embedded types and types that embed the target type.`;
+// Tool input schema
+const TOOL_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        name: {
+            type: "string",
+            description: "Type name to analyze (struct or interface)",
+        },
+        path: {
+            type: "string",
+            description: "File containing the type (optional - will search if not provided)",
+        },
+        scope: {
+            type: "string",
+            description: "Directory to search for type relationships",
+        },
+        direction: {
+            type: "string",
+            enum: ["embeds", "embeddedBy", "both"],
+            description: "Direction of hierarchy (default: both)",
+            default: "both",
+        },
+        maxDepth: {
+            type: "number",
+            description: "Maximum depth to traverse (default: 3)",
+            default: 3,
+        },
+    },
+    required: ["name"],
+};
+/**
+ * getClassHierarchy tool - Analyze type embedding in Go
+ */
+export const getClassHierarchyTool = defineTool({
+    name: "get_class_hierarchy_go",
+    description: TOOL_DESCRIPTION,
+    inputSchema: TOOL_INPUT_SCHEMA,
+    execute: executeGetClassHierarchy,
+});
+/**
+ * Execute the getClassHierarchy tool
+ */
+async function executeGetClassHierarchy(input) {
+    const { name: typeName, path: inputPath, scope, direction = "both", maxDepth = 3, } = input;
+    if (!typeName) {
+        return createErrorResult("Type name is required");
+    }
+    try {
+        // Find the type definition
+        let typeFile;
+        let typeLine;
+        let isInterface = false;
+        let isStruct = false;
+        let embeds = [];
+        if (inputPath) {
+            // Check specified file
+            const typeInfo = await findTypeInFile(inputPath, typeName);
+            if (!typeInfo) {
+                return createErrorResult(`Type ${typeName} not found in ${inputPath}`);
+            }
+            typeFile = inputPath;
+            typeLine = typeInfo.line;
+            isInterface = typeInfo.isInterface;
+            isStruct = typeInfo.isStruct;
+            embeds = typeInfo.embeds;
+        }
+        else {
+            // Search in scope or current directory
+            const searchDir = scope || process.cwd();
+            const found = await findTypeInDirectory(searchDir, typeName);
+            if (!found) {
+                return createErrorResult(`Type ${typeName} not found in ${searchDir}`);
+            }
+            typeFile = found.path;
+            typeLine = found.line;
+            isInterface = found.isInterface;
+            isStruct = found.isStruct;
+            embeds = found.embeds;
+        }
+        // Find types that embed this type
+        const embeddedBy = [];
+        if (direction === "embeddedBy" || direction === "both") {
+            const searchDir = scope || path.dirname(typeFile);
+            const embedders = await findEmbedders(searchDir, typeName, maxDepth);
+            embeddedBy.push(...embedders);
+        }
+        const result = {
+            typeName,
+            path: typeFile,
+            line: typeLine,
+            isInterface,
+            isStruct,
+            embeds,
+            embeddedBy,
+        };
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createErrorResult(`Failed to analyze type hierarchy: ${message}`);
+    }
+}
+/**
+ * Find a type in a specific file
+ */
+async function findTypeInFile(filePath, typeName) {
+    try {
+        const parseResult = await parseFile(filePath);
+        const { tree, source } = parseResult;
+        for (const node of walkTree(tree.rootNode, ["type_declaration"])) {
+            const typeInfo = parseClass(node, source);
+            if (typeInfo.name === typeName) {
+                return {
+                    line: typeInfo.line,
+                    isInterface: typeInfo.isInterface ?? false,
+                    isStruct: typeInfo.isStruct ?? false,
+                    embeds: typeInfo.bases.map((name) => ({
+                        name,
+                        isExternal: name.includes("."),
+                        isPointer: false, // Would need more parsing to detect
+                    })),
+                };
+            }
+        }
+    }
+    catch {
+        // Skip files that can't be parsed
+    }
+    return null;
+}
+/**
+ * Find a type in a directory
+ */
+async function findTypeInDirectory(dir, typeName) {
+    async function search(currentDir) {
+        const entries = await fs.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                // Skip vendor and hidden directories
+                if (entry.name === "vendor" ||
+                    entry.name.startsWith(".") ||
+                    entry.name === "testdata") {
+                    continue;
+                }
+                const found = await search(fullPath);
+                if (found)
+                    return found;
+            }
+            else if (entry.isFile() && entry.name.endsWith(".go")) {
+                const info = await findTypeInFile(fullPath, typeName);
+                if (info) {
+                    return { ...info, path: fullPath };
+                }
+            }
+        }
+        return null;
+    }
+    return search(dir);
+}
+/**
+ * Find types that embed a given type
+ */
+async function findEmbedders(dir, typeName, maxDepth) {
+    const results = [];
+    let depth = 0;
+    async function search(currentDir) {
+        if (depth >= maxDepth)
+            return;
+        depth++;
+        try {
+            const entries = await fs.readdir(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    if (entry.name === "vendor" ||
+                        entry.name.startsWith(".") ||
+                        entry.name === "testdata") {
+                        continue;
+                    }
+                    await search(fullPath);
+                }
+                else if (entry.isFile() && entry.name.endsWith(".go")) {
+                    await searchFileForEmbedders(fullPath, typeName, results);
+                }
+            }
+        }
+        catch {
+            // Skip directories that can't be read
+        }
+        depth--;
+    }
+    await search(dir);
+    return results;
+}
+/**
+ * Search a file for types that embed the target type
+ */
+async function searchFileForEmbedders(filePath, typeName, results) {
+    try {
+        const parseResult = await parseFile(filePath);
+        const { tree, source } = parseResult;
+        for (const node of walkTree(tree.rootNode, ["type_declaration"])) {
+            const typeInfo = parseClass(node, source);
+            // Check if this type embeds the target
+            if (typeInfo.bases.includes(typeName)) {
+                results.push({
+                    name: typeInfo.name,
+                    path: filePath,
+                    line: typeInfo.line,
+                });
+            }
+        }
+    }
+    catch {
+        // Skip files that can't be parsed
+    }
+}
+/**
+ * Factory function to create a customized getClassHierarchy tool
+ */
+export function createGetClassHierarchyTool(options) {
+    const { defaultMaxDepth = 3 } = options ?? {};
+    return defineTool({
+        name: "get_class_hierarchy_go",
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            return executeGetClassHierarchy({
+                ...input,
+                maxDepth: input.maxDepth ?? defaultMaxDepth,
+            });
+        },
+    });
+}

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

@@ -0,0 +1,53 @@
+/**
+ * getComplexity Tool
+ *
+ * Calculate cyclomatic and cognitive complexity for Go functions.
+ * Identifies complex code that may need refactoring.
+ */
+import type { Tool } from "@compilr-dev/agents";
+import type { FileComplexityResult } from "./types.js";
+/**
+ * Input for getComplexity tool
+ */
+export interface GetComplexityInput {
+    /** File or directory to analyze */
+    path: string;
+    /** Recursive analysis for directories (default: false) */
+    recursive?: boolean;
+    /** Complexity threshold for warnings (default: 10) */
+    threshold?: number;
+    /** Only return items above threshold (default: false) */
+    onlyAboveThreshold?: boolean;
+    /** Maximum files to analyze (default: 50) */
+    maxFiles?: number;
+}
+/**
+ * Complexity result for multiple files
+ */
+export interface GetComplexityResult {
+    /** Analyzed path */
+    path: string;
+    /** Results per file */
+    files: FileComplexityResult[];
+    /** Overall stats */
+    stats: {
+        totalFiles: number;
+        totalFunctions: number;
+        complexFunctions: number;
+        averageComplexity: number;
+        maxComplexity: number;
+        threshold: number;
+    };
+}
+/**
+ * getComplexity tool - Calculate code complexity
+ */
+export declare const getComplexityTool: Tool<GetComplexityInput>;
+/**
+ * Factory function to create a customized getComplexity tool
+ */
+export declare function createGetComplexityTool(options?: {
+    defaultThreshold?: number;
+    defaultMaxFiles?: number;
+}): Tool<GetComplexityInput>;
+//# sourceMappingURL=get-complexity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-complexity.d.ts","sourceRoot":"","sources":["../../src/tools/get-complexity.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,KAAK,EAAE,IAAI,EAAuB,MAAM,qBAAqB,CAAC;AAQrE,OAAO,KAAK,EACV,oBAAoB,EAGrB,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,uBAAuB;IACvB,KAAK,EAAE,oBAAoB,EAAE,CAAC;IAC9B,oBAAoB;IACpB,KAAK,EAAE;QACL,UAAU,EAAE,MAAM,CAAC;QACnB,cAAc,EAAE,MAAM,CAAC;QACvB,gBAAgB,EAAE,MAAM,CAAC;QACzB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,aAAa,EAAE,MAAM,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAuCD;;GAEG;AACH,eAAO,MAAM,iBAAiB,0BAK5B,CAAC;AAuWH;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,CAAC,EAAE;IAChD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAiB3B"}

package/dist/tools/get-complexity.js

@@ -0,0 +1,357 @@
+/**
+ * getComplexity Tool
+ *
+ * Calculate cyclomatic and cognitive complexity for Go functions.
+ * Identifies complex code that may need refactoring.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { defineTool, createSuccessResult, createErrorResult, } from "@compilr-dev/agents";
+import { parseFile, parseFunction, parseMethod, walkTree, } from "../parser/go-parser.js";
+// Tool description
+const TOOL_DESCRIPTION = `Calculate cyclomatic and cognitive complexity for Go functions.
+Returns complexity metrics and identifies functions that may need refactoring.
+Helps find overly complex code that's hard to test and maintain.`;
+// Tool input schema
+const TOOL_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        path: {
+            type: "string",
+            description: "Go file or directory to analyze",
+        },
+        recursive: {
+            type: "boolean",
+            description: "Recursively analyze directories (default: false)",
+            default: false,
+        },
+        threshold: {
+            type: "number",
+            description: "Cyclomatic complexity threshold for warnings (default: 10)",
+            default: 10,
+        },
+        onlyAboveThreshold: {
+            type: "boolean",
+            description: "Only return functions above threshold (default: false)",
+            default: false,
+        },
+        maxFiles: {
+            type: "number",
+            description: "Maximum files to analyze (default: 50)",
+            default: 50,
+        },
+    },
+    required: ["path"],
+};
+/**
+ * getComplexity tool - Calculate code complexity
+ */
+export const getComplexityTool = defineTool({
+    name: "get_complexity_go",
+    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;
+    if (!inputPath) {
+        return createErrorResult("Path is required");
+    }
+    try {
+        const stats = await fs.stat(inputPath);
+        const files = [];
+        if (stats.isFile()) {
+            if (inputPath.endsWith(".go")) {
+                const result = await analyzeFileComplexity(inputPath, threshold, onlyAboveThreshold);
+                files.push(result);
+            }
+            else {
+                return createErrorResult("File must be a .go file");
+            }
+        }
+        else if (stats.isDirectory()) {
+            const goFiles = await collectGoFiles(inputPath, recursive, maxFiles);
+            for (const filePath of goFiles) {
+                const result = await analyzeFileComplexity(filePath, threshold, onlyAboveThreshold);
+                files.push(result);
+            }
+        }
+        else {
+            return createErrorResult("Path must be a file or directory");
+        }
+        // Calculate overall stats
+        const allFunctions = files.flatMap((f) => f.functions);
+        const complexFunctions = allFunctions.filter((f) => f.isComplex);
+        const avgComplexity = allFunctions.length > 0
+            ? allFunctions.reduce((sum, f) => sum + f.metrics.cyclomatic, 0) /
+                allFunctions.length
+            : 0;
+        const maxComplexity = allFunctions.length > 0
+            ? Math.max(...allFunctions.map((f) => f.metrics.cyclomatic))
+            : 0;
+        const result = {
+            path: inputPath,
+            files,
+            stats: {
+                totalFiles: files.length,
+                totalFunctions: allFunctions.length,
+                complexFunctions: complexFunctions.length,
+                averageComplexity: Math.round(avgComplexity * 100) / 100,
+                maxComplexity,
+                threshold,
+            },
+        };
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createErrorResult(`Failed to analyze complexity: ${message}`);
+    }
+}
+/**
+ * Collect Go files from a directory
+ */
+async function collectGoFiles(dir, recursive, maxFiles) {
+    const files = [];
+    async function walk(currentDir) {
+        if (files.length >= maxFiles)
+            return;
+        const entries = await fs.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (files.length >= maxFiles)
+                break;
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                if (recursive &&
+                    !entry.name.startsWith(".") &&
+                    entry.name !== "vendor" &&
+                    entry.name !== "testdata") {
+                    await walk(fullPath);
+                }
+            }
+            else if (entry.isFile() && entry.name.endsWith(".go")) {
+                files.push(fullPath);
+            }
+        }
+    }
+    await walk(dir);
+    return files;
+}
+/**
+ * Analyze complexity for a single file
+ */
+async function analyzeFileComplexity(filePath, threshold, onlyAboveThreshold) {
+    const parseResult = await parseFile(filePath);
+    const { tree, source } = parseResult;
+    const rootNode = tree.rootNode;
+    const functions = [];
+    // Find all functions and methods
+    for (const node of walkTree(rootNode)) {
+        // Regular functions
+        if (node.type === "function_declaration") {
+            const funcInfo = parseFunction(node, source);
+            const metrics = calculateComplexity(node, source);
+            const isComplex = metrics.cyclomatic >= threshold;
+            if (!onlyAboveThreshold || isComplex) {
+                functions.push({
+                    name: funcInfo.name,
+                    path: filePath,
+                    line: funcInfo.line,
+                    metrics,
+                    isComplex,
+                });
+            }
+        }
+        // Methods (functions with receivers)
+        if (node.type === "method_declaration") {
+            const methodInfo = parseMethod(node, source);
+            const metrics = calculateComplexity(node, source);
+            const isComplex = metrics.cyclomatic >= threshold;
+            if (!onlyAboveThreshold || isComplex) {
+                const name = methodInfo.receiverType
+                    ? `${methodInfo.receiverType}.${methodInfo.name}`
+                    : methodInfo.name;
+                functions.push({
+                    name,
+                    path: filePath,
+                    line: methodInfo.line,
+                    metrics,
+                    isComplex,
+                    receiverType: methodInfo.receiverType,
+                });
+            }
+        }
+    }
+    // Calculate file-level averages
+    const totalCyclomatic = functions.reduce((sum, f) => sum + f.metrics.cyclomatic, 0);
+    const avgComplexity = functions.length > 0 ? totalCyclomatic / functions.length : 0;
+    const maxComplexity = functions.length > 0
+        ? Math.max(...functions.map((f) => f.metrics.cyclomatic))
+        : 0;
+    return {
+        path: filePath,
+        functions,
+        averageComplexity: Math.round(avgComplexity * 100) / 100,
+        maxComplexity,
+        stats: {
+            totalFunctions: functions.length,
+            complexFunctions: functions.filter((f) => f.isComplex).length,
+            simpleAverage: avgComplexity,
+        },
+    };
+}
+/**
+ * Calculate complexity metrics for a function/method
+ */
+function calculateComplexity(node, _source) {
+    let cyclomatic = 1; // Start with 1 for the function itself
+    let cognitive = 0;
+    let maxNesting = 0;
+    let parameters = 0;
+    // Count parameters
+    const params = node.childForFieldName("parameters");
+    if (params) {
+        for (const child of params.children) {
+            if (child.type === "parameter_declaration") {
+                // Count identifiers in parameter declaration
+                for (const c of child.children) {
+                    if (c.type === "identifier") {
+                        parameters++;
+                    }
+                }
+            }
+        }
+    }
+    // Walk the function body to count complexity
+    function walk(n, nesting) {
+        maxNesting = Math.max(maxNesting, nesting);
+        switch (n.type) {
+            // Control flow - add to cyclomatic
+            case "if_statement":
+                cyclomatic++;
+                cognitive += 1 + nesting; // Cognitive adds nesting penalty
+                for (const child of n.children) {
+                    walk(child, nesting + 1);
+                }
+                return;
+            case "else_clause":
+                // "else" doesn't add to cyclomatic but adds to cognitive
+                cognitive += 1;
+                for (const child of n.children) {
+                    walk(child, nesting);
+                }
+                return;
+            case "for_statement":
+            case "range_clause":
+                cyclomatic++;
+                cognitive += 1 + nesting;
+                for (const child of n.children) {
+                    walk(child, nesting + 1);
+                }
+                return;
+            case "switch_statement":
+            case "type_switch_statement":
+                cyclomatic++;
+                cognitive += 1 + nesting;
+                for (const child of n.children) {
+                    walk(child, nesting + 1);
+                }
+                return;
+            case "case_clause":
+            case "default_case":
+                cyclomatic++;
+                for (const child of n.children) {
+                    walk(child, nesting);
+                }
+                return;
+            case "select_statement":
+                cyclomatic++;
+                cognitive += 1 + nesting;
+                for (const child of n.children) {
+                    walk(child, nesting + 1);
+                }
+                return;
+            case "communication_case":
+                cyclomatic++;
+                for (const child of n.children) {
+                    walk(child, nesting);
+                }
+                return;
+            // Boolean operators
+            case "binary_expression": {
+                const operator = n.children.find((c) => c.type === "&&" || c.type === "||");
+                if (operator) {
+                    cyclomatic++;
+                    cognitive++;
+                }
+                for (const child of n.children) {
+                    walk(child, nesting);
+                }
+                return;
+            }
+            // Go keyword (goroutine)
+            case "go_statement":
+                cognitive += 1 + nesting; // Concurrency adds cognitive load
+                for (const child of n.children) {
+                    walk(child, nesting);
+                }
+                return;
+            // Defer
+            case "defer_statement":
+                cognitive++; // Defer adds cognitive load (execution order)
+                for (const child of n.children) {
+                    walk(child, nesting);
+                }
+                return;
+            // Recover (error handling)
+            case "call_expression": {
+                const funcName = n.childForFieldName("function");
+                if (funcName?.text === "recover") {
+                    cognitive++; // Panic/recover adds cognitive load
+                }
+                for (const child of n.children) {
+                    walk(child, nesting);
+                }
+                return;
+            }
+            default:
+                for (const child of n.children) {
+                    walk(child, nesting);
+                }
+        }
+    }
+    const body = node.childForFieldName("body");
+    if (body) {
+        walk(body, 0);
+    }
+    // Count lines of code
+    const linesOfCode = node.endPosition.row - node.startPosition.row + 1;
+    return {
+        cyclomatic,
+        cognitive,
+        linesOfCode,
+        parameters,
+        nestingDepth: maxNesting,
+    };
+}
+/**
+ * Factory function to create a customized getComplexity tool
+ */
+export function createGetComplexityTool(options) {
+    const { defaultThreshold = 10, defaultMaxFiles = 50 } = options ?? {};
+    return defineTool({
+        name: "get_complexity_go",
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            return executeGetComplexity({
+                ...input,
+                threshold: input.threshold ?? defaultThreshold,
+                maxFiles: input.maxFiles ?? defaultMaxFiles,
+            });
+        },
+    });
+}