@compilr-dev/agents-coding-python 0.1.0

package/dist/tools/find-implementations.js

@@ -0,0 +1,342 @@
+/**
+ * findImplementations Tool
+ *
+ * Find classes that inherit from a base class, ABC, or implement a Protocol.
+ * Useful for understanding inheritance hierarchies and finding concrete implementations.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { defineTool, createSuccessResult, createErrorResult, } from "@compilr-dev/agents";
+import { parseFile, parseClass, parseFunction, } from "../parser/python-parser.js";
+// Tool description
+const TOOL_DESCRIPTION = `Find classes that inherit from a base class, ABC, or implement a Protocol.
+Returns information about each implementation including which methods are implemented.
+Useful for understanding how base classes are used across the codebase.`;
+// Tool input schema
+const TOOL_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        name: {
+            type: "string",
+            description: "Base class, ABC, or Protocol name to find implementations of",
+        },
+        scope: {
+            type: "string",
+            description: "Directory or file to search in (defaults to current directory)",
+        },
+        includeAbstract: {
+            type: "boolean",
+            description: "Include abstract classes that partially implement (default: false)",
+            default: false,
+        },
+        maxFiles: {
+            type: "number",
+            description: "Maximum files to search (default: 100)",
+            default: 100,
+        },
+    },
+    required: ["name"],
+};
+// Default exclusions
+const DEFAULT_EXCLUDE = [
+    "node_modules",
+    "__pycache__",
+    ".git",
+    "venv",
+    ".venv",
+    "env",
+    "dist",
+    "build",
+];
+/**
+ * findImplementations tool
+ */
+export const findImplementationsTool = defineTool({
+    name: "find_implementations_python",
+    description: TOOL_DESCRIPTION,
+    inputSchema: TOOL_INPUT_SCHEMA,
+    execute: executeFindImplementations,
+});
+/**
+ * Execute the findImplementations tool
+ */
+async function executeFindImplementations(input) {
+    const { name, scope = ".", includeAbstract = false, maxFiles = 100 } = input;
+    const startTime = Date.now();
+    // Validate input
+    if (!name || name.trim().length === 0) {
+        return createErrorResult("Base class or Protocol name is required");
+    }
+    try {
+        // Resolve scope path
+        const scopePath = path.resolve(scope);
+        // Check if scope exists
+        try {
+            await fs.access(scopePath);
+        }
+        catch {
+            return createErrorResult(`Scope path not found: ${scopePath}`);
+        }
+        const stats = await fs.stat(scopePath);
+        // Collect files to search
+        const files = stats.isDirectory()
+            ? await collectFiles(scopePath, maxFiles)
+            : [scopePath];
+        // Find the target class definition
+        let targetLocation;
+        let targetMethods = [];
+        // First pass: find the target definition
+        for (const file of files) {
+            const result = await findTargetDefinition(file, name);
+            if (result) {
+                targetLocation = { path: file, line: result.line };
+                targetMethods = result.methods;
+                // Note: result.isABC and result.isProtocol are available for future use
+                break;
+            }
+        }
+        // Second pass: find implementations
+        const implementations = [];
+        for (const file of files) {
+            const fileImplementations = await findImplementationsInFile(file, name, targetMethods, includeAbstract);
+            implementations.push(...fileImplementations);
+        }
+        const timeMs = Date.now() - startTime;
+        const result = {
+            target: name,
+            targetLocation,
+            implementations,
+            stats: {
+                filesSearched: files.length,
+                implementationsFound: implementations.length,
+                timeMs,
+            },
+        };
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        return createErrorResult(`Failed to find implementations: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Collect Python files
+ */
+async function collectFiles(dir, maxFiles, currentDepth = 0) {
+    if (currentDepth > 10)
+        return [];
+    const files = [];
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (files.length >= maxFiles)
+                break;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (DEFAULT_EXCLUDE.includes(entry.name))
+                    continue;
+                const subFiles = await collectFiles(fullPath, maxFiles - files.length, currentDepth + 1);
+                files.push(...subFiles);
+            }
+            else if (entry.isFile()) {
+                if (fullPath.endsWith(".py") && !fullPath.endsWith(".pyi")) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore permission errors
+    }
+    return files;
+}
+/**
+ * Find the target class/protocol definition
+ */
+async function findTargetDefinition(filePath, targetName) {
+    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 === targetName) {
+                    // Check if it's an ABC or Protocol
+                    const isABC = classInfo.bases.includes("ABC") ||
+                        classInfo.bases.some((b) => b.includes("abc.ABC") || b.includes("ABCMeta"));
+                    const isProtocol = classInfo.bases.includes("Protocol");
+                    // Extract abstract methods
+                    const methods = extractAbstractMethods(child, source);
+                    return {
+                        line: classInfo.line,
+                        methods,
+                        isABC,
+                        isProtocol,
+                    };
+                }
+            }
+            // Check decorated class definitions
+            if (child.type === "decorated_definition") {
+                const classNode = child.children.find((c) => c.type === "class_definition");
+                if (classNode) {
+                    const classInfo = parseClass(classNode, source);
+                    if (classInfo.name === targetName) {
+                        const isABC = classInfo.bases.includes("ABC") ||
+                            classInfo.bases.some((b) => b.includes("abc.ABC") || b.includes("ABCMeta"));
+                        const isProtocol = classInfo.bases.includes("Protocol");
+                        const methods = extractAbstractMethods(classNode, source);
+                        return {
+                            line: classInfo.line,
+                            methods,
+                            isABC,
+                            isProtocol,
+                        };
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Skip files that can't be parsed
+    }
+    return null;
+}
+/**
+ * Extract abstract method names from a class
+ */
+function extractAbstractMethods(classNode, source) {
+    const methods = [];
+    const body = classNode.childForFieldName("body");
+    if (body) {
+        for (const member of body.children) {
+            // Check decorated methods
+            if (member.type === "decorated_definition") {
+                const decorators = [];
+                for (const c of member.children) {
+                    if (c.type === "decorator") {
+                        decorators.push(c.text);
+                    }
+                }
+                const hasAbstractMethod = decorators.some((d) => d.includes("abstractmethod") ||
+                    d.includes("abstractproperty") ||
+                    d.includes("abstractclassmethod") ||
+                    d.includes("abstractstaticmethod"));
+                if (hasAbstractMethod) {
+                    const funcNode = member.children.find((c) => c.type === "function_definition" ||
+                        c.type === "async_function_definition");
+                    if (funcNode) {
+                        const funcInfo = parseFunction(funcNode, source);
+                        methods.push(funcInfo.name);
+                    }
+                }
+            }
+        }
+    }
+    return methods;
+}
+/**
+ * Find implementations in a single file
+ */
+async function findImplementationsInFile(filePath, targetName, targetMethods, includeAbstract) {
+    try {
+        const parseResult = await parseFile(filePath);
+        const { tree, source } = parseResult;
+        const implementations = [];
+        for (const child of tree.rootNode.children) {
+            if (child.type === "class_definition") {
+                const impl = checkClassImplementation(child, source, filePath, targetName, targetMethods, includeAbstract, false);
+                if (impl) {
+                    implementations.push(impl);
+                }
+            }
+            // Check decorated class definitions
+            if (child.type === "decorated_definition") {
+                const classNode = child.children.find((c) => c.type === "class_definition");
+                if (classNode) {
+                    // Check for dataclass decorator
+                    const isDataclass = child.children.some((c) => c.type === "decorator" && c.text.includes("dataclass"));
+                    const impl = checkClassImplementation(classNode, source, filePath, targetName, targetMethods, includeAbstract, isDataclass);
+                    if (impl) {
+                        implementations.push(impl);
+                    }
+                }
+            }
+        }
+        return implementations;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Check if a class implements the target
+ */
+function checkClassImplementation(classNode, source, filePath, targetName, targetMethods, includeAbstract, isDataclass) {
+    const classInfo = parseClass(classNode, source);
+    // Skip the target class itself
+    if (classInfo.name === targetName)
+        return null;
+    // Check if it inherits from the target
+    const inheritsTarget = classInfo.bases.some((base) => base === targetName || base.endsWith(`.${targetName}`));
+    if (!inheritsTarget)
+        return null;
+    // Check if it's abstract
+    const isAbstract = classInfo.decorators.some((d) => d.name.includes("ABC") ||
+        d.name.includes("abstractmethod") ||
+        d.name.includes("ABCMeta"));
+    // Skip abstract classes if not including them
+    if (isAbstract && !includeAbstract)
+        return null;
+    // Get implemented methods
+    const implementedMethods = [];
+    const body = classNode.childForFieldName("body");
+    if (body) {
+        for (const member of body.children) {
+            if (member.type === "function_definition" ||
+                member.type === "async_function_definition") {
+                const methodInfo = parseFunction(member, source);
+                if (targetMethods.includes(methodInfo.name)) {
+                    implementedMethods.push(methodInfo.name);
+                }
+            }
+            if (member.type === "decorated_definition") {
+                const funcNode = member.children.find((c) => c.type === "function_definition" ||
+                    c.type === "async_function_definition");
+                if (funcNode) {
+                    const methodInfo = parseFunction(funcNode, source);
+                    if (targetMethods.includes(methodInfo.name)) {
+                        implementedMethods.push(methodInfo.name);
+                    }
+                }
+            }
+        }
+    }
+    // Calculate missing methods
+    const missingMethods = targetMethods.filter((m) => !implementedMethods.includes(m));
+    return {
+        name: classInfo.name,
+        path: filePath,
+        line: classInfo.line,
+        kind: isDataclass ? "dataclass" : "class",
+        isAbstract,
+        implementedMethods: implementedMethods.length > 0 ? implementedMethods : undefined,
+        missingMethods: missingMethods.length > 0 ? missingMethods : undefined,
+    };
+}
+/**
+ * Factory function to create a customized findImplementations tool
+ */
+export function createFindImplementationsTool(options) {
+    return defineTool({
+        name: "find_implementations_python",
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            const modifiedInput = {
+                ...input,
+                scope: input.scope ?? options?.defaultScope,
+                maxFiles: input.maxFiles ?? options?.defaultMaxFiles,
+            };
+            return executeFindImplementations(modifiedInput);
+        },
+    });
+}

package/dist/tools/find-patterns.d.ts

@@ -0,0 +1,71 @@
+/**
+ * findPatterns Tool
+ *
+ * Find code patterns, anti-patterns, and code smells in Python code.
+ * Uses regex and AST-based pattern matching.
+ */
+import type { Tool } from "@compilr-dev/agents";
+/**
+ * Code pattern definition
+ */
+export interface CodePattern {
+    name: string;
+    description: string;
+    type: "anti-pattern" | "smell" | "pattern";
+    matcher: string;
+    severity: "error" | "warning" | "info";
+}
+/**
+ * Pattern match
+ */
+export interface PatternMatch {
+    pattern: string;
+    description: string;
+    severity: "error" | "warning" | "info";
+    path: string;
+    line: number;
+    snippet: string;
+    suggestion?: string;
+}
+/**
+ * Input for findPatterns tool
+ */
+export interface FindPatternsInput {
+    /** Directory to analyze */
+    path: string;
+    /** Custom patterns to search for (uses built-in if not specified) */
+    patterns?: CodePattern[];
+    /** Pattern categories to include (default: all) */
+    categories?: Array<"security" | "performance" | "maintainability" | "all">;
+    /** Maximum files to analyze (default: 100) */
+    maxFiles?: number;
+}
+/**
+ * Result of findPatterns
+ */
+export interface FindPatternsResult {
+    path: string;
+    matches: PatternMatch[];
+    stats: {
+        filesAnalyzed: number;
+        totalMatches: number;
+        byPattern: Record<string, number>;
+        bySeverity: {
+            error: number;
+            warning: number;
+            info: number;
+        };
+    };
+}
+/**
+ * findPatterns tool
+ */
+export declare const findPatternsTool: Tool<FindPatternsInput>;
+/**
+ * Factory function to create a customized findPatterns tool
+ */
+export declare function createFindPatternsTool(options?: {
+    defaultMaxFiles?: number;
+    additionalPatterns?: CodePattern[];
+}): Tool<FindPatternsInput>;
+//# sourceMappingURL=find-patterns.d.ts.map

package/dist/tools/find-patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-patterns.d.ts","sourceRoot":"","sources":["../../src/tools/find-patterns.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,KAAK,EAAE,IAAI,EAAuB,MAAM,qBAAqB,CAAC;AAGrE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,cAAc,GAAG,OAAO,GAAG,SAAS,CAAC;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,qEAAqE;IACrE,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC;IACzB,mDAAmD;IACnD,UAAU,CAAC,EAAE,KAAK,CAAC,UAAU,GAAG,aAAa,GAAG,iBAAiB,GAAG,KAAK,CAAC,CAAC;IAC3E,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,KAAK,EAAE;QACL,aAAa,EAAE,MAAM,CAAC;QACtB,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAClC,UAAU,EAAE;YACV,KAAK,EAAE,MAAM,CAAC;YACd,OAAO,EAAE,MAAM,CAAC;YAChB,IAAI,EAAE,MAAM,CAAC;SACd,CAAC;KACH,CAAC;CACH;AA4ND;;GAEG;AACH,eAAO,MAAM,gBAAgB,yBAK3B,CAAC;AAiTH;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE;IAC/C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,WAAW,EAAE,CAAC;CACpC,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAiB1B"}