@compilr-dev/agents-coding-python 0.1.0

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

@@ -0,0 +1,289 @@
+/**
+ * getClassHierarchy Tool
+ *
+ * Analyze class inheritance hierarchy in Python codebases.
+ * Finds parent classes (ancestors) and child classes (descendants).
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { defineTool, createSuccessResult, createErrorResult, } from "@compilr-dev/agents";
+import { parseFile, parseClass, parseDecorators, } from "../parser/python-parser.js";
+// Tool description
+const TOOL_DESCRIPTION = `Analyze the class inheritance hierarchy for a Python class.
+Returns parent classes (ancestors) and child classes (descendants).
+Includes Method Resolution Order (MRO) for multiple inheritance.`;
+// Tool input schema
+const TOOL_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        name: {
+            type: "string",
+            description: "Class name to analyze",
+        },
+        file: {
+            type: "string",
+            description: "File where the class is defined (improves accuracy)",
+        },
+        direction: {
+            type: "string",
+            enum: ["ancestors", "descendants", "both"],
+            description: "Direction of hierarchy traversal (default: both)",
+            default: "both",
+        },
+        maxDepth: {
+            type: "number",
+            description: "Maximum depth to traverse (default: 5)",
+            default: 5,
+        },
+        scope: {
+            type: "string",
+            description: "Directory scope for finding descendants",
+        },
+    },
+    required: ["name"],
+};
+/**
+ * getClassHierarchy tool - Analyze class inheritance
+ */
+export const getClassHierarchyTool = defineTool({
+    name: "get_class_hierarchy_python",
+    description: TOOL_DESCRIPTION,
+    inputSchema: TOOL_INPUT_SCHEMA,
+    execute: executeGetClassHierarchy,
+});
+/**
+ * Execute the getClassHierarchy tool
+ */
+async function executeGetClassHierarchy(input) {
+    const { name: className, file, direction = "both", maxDepth = 5, scope, } = input;
+    if (!className || className.trim().length === 0) {
+        return createErrorResult("Class name is required");
+    }
+    try {
+        // Find the class definition
+        let classFile;
+        let classLine;
+        let classBases;
+        if (file) {
+            // Search in the specified file
+            const classInfo = await findClassInFile(file, className);
+            if (classInfo) {
+                classFile = file;
+                classLine = classInfo.line;
+                classBases = classInfo.bases;
+            }
+            else {
+                return createErrorResult(`Class '${className}' not found in ${file}`);
+            }
+        }
+        else {
+            // Search in scope or current directory
+            const searchPath = scope || process.cwd();
+            const found = await findClassInDirectory(searchPath, className);
+            if (found) {
+                classFile = found.path;
+                classLine = found.line;
+                classBases = found.bases;
+            }
+            else {
+                return createErrorResult(`Class '${className}' not found`);
+            }
+        }
+        // Build parent list
+        const parents = [];
+        if (direction === "ancestors" || direction === "both") {
+            for (const base of classBases) {
+                // Try to find the parent class definition
+                const parentInfo = await findClassInDirectory(scope || path.dirname(classFile), base);
+                parents.push({
+                    name: base,
+                    path: parentInfo?.path,
+                    isExternal: !parentInfo,
+                });
+            }
+        }
+        // Find descendants
+        const children = [];
+        if (direction === "descendants" || direction === "both") {
+            const searchDir = scope || path.dirname(classFile);
+            const descendants = await findDescendants(searchDir, className, maxDepth);
+            children.push(...descendants);
+        }
+        // Build MRO (simplified - just the class + bases + object)
+        const mro = buildSimpleMRO(className, classBases);
+        const result = {
+            className,
+            path: classFile,
+            line: classLine,
+            parents,
+            children,
+            mro,
+        };
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createErrorResult(`Failed to analyze class hierarchy: ${message}`);
+    }
+}
+/**
+ * Find a class in a specific file
+ */
+async function findClassInFile(filePath, className) {
+    try {
+        const parseResult = await parseFile(filePath);
+        const { tree, source } = parseResult;
+        for (const child of tree.rootNode.children) {
+            if (child.type === "class_definition") {
+                const classInfo = parseClass(child, source);
+                if (classInfo.name === className) {
+                    return { line: classInfo.line, bases: classInfo.bases };
+                }
+            }
+            if (child.type === "decorated_definition") {
+                const decorators = parseDecorators(child, source);
+                const classNode = child.children.find((c) => c.type === "class_definition");
+                if (classNode) {
+                    const classInfo = parseClass(classNode, source, decorators);
+                    if (classInfo.name === className) {
+                        return { line: classInfo.line, bases: classInfo.bases };
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Skip files that can't be parsed
+    }
+    return null;
+}
+/**
+ * Find a class in a directory
+ */
+async function findClassInDirectory(dir, className) {
+    const files = await collectPythonFiles(dir);
+    for (const filePath of files) {
+        const result = await findClassInFile(filePath, className);
+        if (result) {
+            return { path: filePath, ...result };
+        }
+    }
+    return null;
+}
+/**
+ * Find all classes that inherit from a given class
+ */
+async function findDescendants(dir, className, maxDepth) {
+    const descendants = [];
+    const files = await collectPythonFiles(dir);
+    for (const filePath of files) {
+        try {
+            const parseResult = await parseFile(filePath);
+            const { tree, source } = parseResult;
+            for (const child of tree.rootNode.children) {
+                if (child.type === "class_definition") {
+                    const classInfo = parseClass(child, source);
+                    if (classInfo.bases.includes(className)) {
+                        descendants.push({
+                            name: classInfo.name,
+                            path: filePath,
+                            line: classInfo.line,
+                        });
+                    }
+                }
+                if (child.type === "decorated_definition") {
+                    const classNode = child.children.find((c) => c.type === "class_definition");
+                    if (classNode) {
+                        const classInfo = parseClass(classNode, source);
+                        if (classInfo.bases.includes(className)) {
+                            descendants.push({
+                                name: classInfo.name,
+                                path: filePath,
+                                line: classInfo.line,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip files that can't be parsed
+        }
+    }
+    // Recursively find descendants of descendants (up to maxDepth)
+    if (maxDepth > 1) {
+        const childNames = descendants.map((d) => d.name);
+        for (const childName of childNames) {
+            const childDescendants = await findDescendants(dir, childName, maxDepth - 1);
+            for (const desc of childDescendants) {
+                if (!descendants.some((d) => d.name === desc.name)) {
+                    descendants.push(desc);
+                }
+            }
+        }
+    }
+    return descendants;
+}
+/**
+ * Build a simplified MRO (Method Resolution Order)
+ */
+function buildSimpleMRO(className, bases) {
+    // Simplified MRO: class -> bases (in order) -> object
+    const mro = [className];
+    mro.push(...bases);
+    if (!bases.includes("object")) {
+        mro.push("object");
+    }
+    return mro;
+}
+/**
+ * Collect Python files in a directory
+ */
+async function collectPythonFiles(dir) {
+    const files = [];
+    async function walk(currentDir) {
+        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.startsWith(".") ||
+                        entry.name === "__pycache__" ||
+                        entry.name === "venv" ||
+                        entry.name === ".venv" ||
+                        entry.name === "node_modules") {
+                        continue;
+                    }
+                    await walk(fullPath);
+                }
+                else if (entry.isFile() &&
+                    (fullPath.endsWith(".py") || fullPath.endsWith(".pyi"))) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // Skip directories we can't read
+        }
+    }
+    await walk(dir);
+    return files;
+}
+/**
+ * Factory function to create a customized getClassHierarchy tool
+ */
+export function createGetClassHierarchyTool(options) {
+    const { defaultDirection = "both", defaultMaxDepth = 5 } = options ?? {};
+    return defineTool({
+        name: "get_class_hierarchy_python",
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            return executeGetClassHierarchy({
+                ...input,
+                direction: input.direction ?? defaultDirection,
+                maxDepth: input.maxDepth ?? defaultMaxDepth,
+            });
+        },
+    });
+}

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

@@ -0,0 +1,61 @@
+/**
+ * getComplexity Tool
+ *
+ * Calculate cyclomatic and cognitive complexity for Python 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;
+    /** File-level complexity */
+    files: FileComplexityResult[];
+    /** Summary statistics */
+    summary: {
+        totalFiles: number;
+        totalFunctions: number;
+        averageComplexity: number;
+        maxComplexity: number;
+        aboveThreshold: number;
+        threshold: number;
+    };
+    /** Most complex functions (top 5) */
+    hotspots: Array<{
+        name: string;
+        path: string;
+        line: number;
+        cyclomatic: number;
+        cognitive: 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;
+    defaultRecursive?: boolean;
+}): 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,4BAA4B;IAC5B,KAAK,EAAE,oBAAoB,EAAE,CAAC;IAC9B,yBAAyB;IACzB,OAAO,EAAE;QACP,UAAU,EAAE,MAAM,CAAC;QACnB,cAAc,EAAE,MAAM,CAAC;QACvB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC;QACvB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,qCAAqC;IACrC,QAAQ,EAAE,KAAK,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC,CAAC;CACJ;AAuCD;;GAEG;AACH,eAAO,MAAM,iBAAiB,0BAK5B,CAAC;AAmZH;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,CAAC,EAAE;IAChD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAiB3B"}