@compilr-dev/agents-coding-python 0.1.0

package/dist/tools/find-duplicates.js

@@ -0,0 +1,289 @@
+/**
+ * findDuplicates Tool
+ *
+ * Detect duplicate code blocks in Python files using content hashing.
+ * Helps identify opportunities for refactoring and code reuse.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+import { defineTool, createSuccessResult, createErrorResult, } from "@compilr-dev/agents";
+// Tool description
+const TOOL_DESCRIPTION = `Detect duplicate code blocks in Python files.
+Uses content hashing to find similar code patterns.
+Useful for identifying refactoring opportunities and reducing code duplication.`;
+// Tool input schema
+const TOOL_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        path: {
+            type: "string",
+            description: "Directory to analyze",
+        },
+        minLines: {
+            type: "number",
+            description: "Minimum lines for a duplicate (default: 6)",
+            default: 6,
+        },
+        minTokens: {
+            type: "number",
+            description: "Minimum tokens for a duplicate (default: 50)",
+            default: 50,
+        },
+        ignoreIdenticalFiles: {
+            type: "boolean",
+            description: "Ignore identical files (default: true)",
+            default: true,
+        },
+        maxFiles: {
+            type: "number",
+            description: "Maximum files to analyze (default: 100)",
+            default: 100,
+        },
+    },
+    required: ["path"],
+};
+// Default exclusions
+const DEFAULT_EXCLUDE = [
+    "node_modules",
+    "__pycache__",
+    ".git",
+    "venv",
+    ".venv",
+    "env",
+    "dist",
+    "build",
+    ".tox",
+    ".eggs",
+];
+/**
+ * findDuplicates tool
+ */
+export const findDuplicatesTool = defineTool({
+    name: "find_duplicates_python",
+    description: TOOL_DESCRIPTION,
+    inputSchema: TOOL_INPUT_SCHEMA,
+    execute: executeFindDuplicates,
+});
+/**
+ * Execute the findDuplicates tool
+ */
+async function executeFindDuplicates(input) {
+    const { path: inputPath, minLines = 6, minTokens = 50, ignoreIdenticalFiles = true, maxFiles = 100, } = 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);
+        if (!stats.isDirectory()) {
+            return createErrorResult("findDuplicates requires a directory path");
+        }
+        // Collect files
+        const files = [];
+        await collectFiles(resolvedPath, files, maxFiles);
+        // Check for identical files first (if not ignoring)
+        const fileHashes = new Map();
+        if (!ignoreIdenticalFiles) {
+            for (const file of files) {
+                const content = await fs.readFile(file, "utf-8");
+                const hash = crypto.createHash("md5").update(content).digest("hex");
+                const existing = fileHashes.get(hash) ?? [];
+                existing.push(file);
+                fileHashes.set(hash, existing);
+            }
+        }
+        // Extract code blocks from each file
+        const allBlocks = [];
+        let totalLines = 0;
+        for (const file of files) {
+            const blocks = await extractCodeBlocks(file, minLines, minTokens);
+            allBlocks.push(...blocks);
+            // Count total lines
+            const content = await fs.readFile(file, "utf-8");
+            totalLines += content.split("\n").length;
+        }
+        // Group by hash
+        const hashGroups = new Map();
+        for (const block of allBlocks) {
+            const existing = hashGroups.get(block.hash) ?? [];
+            existing.push(block);
+            hashGroups.set(block.hash, existing);
+        }
+        // Filter to only groups with duplicates
+        const duplicateGroups = [];
+        let groupId = 1;
+        let totalDuplicateLines = 0;
+        for (const [_hash, blocks] of hashGroups) {
+            if (blocks.length < 2)
+                continue;
+            // Skip if all from same file
+            const uniqueFiles = new Set(blocks.map((b) => b.path));
+            if (uniqueFiles.size < 2)
+                continue;
+            const locations = blocks.map((b) => ({
+                path: b.path,
+                startLine: b.startLine,
+                endLine: b.endLine,
+            }));
+            const lines = blocks[0].endLine - blocks[0].startLine + 1;
+            totalDuplicateLines += lines * (blocks.length - 1); // Count extra copies
+            duplicateGroups.push({
+                id: `DUP-${String(groupId++)}`,
+                lines,
+                tokens: blocks[0].tokens,
+                locations,
+                sample: truncateSample(blocks[0].content, 5), // First 5 lines
+            });
+        }
+        // Sort by lines (largest first)
+        duplicateGroups.sort((a, b) => b.lines - a.lines);
+        // Limit results
+        const limitedGroups = duplicateGroups.slice(0, 20);
+        const percentageDuplicate = totalLines > 0
+            ? Math.round((totalDuplicateLines / totalLines) * 10000) / 100
+            : 0;
+        const result = {
+            path: resolvedPath,
+            duplicates: limitedGroups,
+            stats: {
+                filesAnalyzed: files.length,
+                duplicateGroups: duplicateGroups.length,
+                totalDuplicateLines,
+                percentageDuplicate,
+            },
+        };
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        return createErrorResult(`Failed to find duplicates: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Collect files to analyze
+ */
+async function collectFiles(dirPath, files, maxFiles, currentDepth = 0) {
+    if (currentDepth > 10 || 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);
+            if (entry.isDirectory()) {
+                if (DEFAULT_EXCLUDE.includes(entry.name))
+                    continue;
+                await collectFiles(fullPath, files, maxFiles, currentDepth + 1);
+            }
+            else if (entry.isFile()) {
+                // Only include Python files
+                if (fullPath.endsWith(".py") && !fullPath.endsWith(".pyi")) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore permission errors
+    }
+}
+/**
+ * Extract code blocks from a file using sliding window
+ */
+async function extractCodeBlocks(filePath, minLines, minTokens) {
+    try {
+        const content = await fs.readFile(filePath, "utf-8");
+        const lines = content.split("\n");
+        const blocks = [];
+        // Use sliding window approach
+        for (let start = 0; start <= lines.length - minLines; start++) {
+            // Try different block sizes
+            for (let size = minLines; size <= Math.min(minLines * 3, lines.length - start); size++) {
+                const blockLines = lines.slice(start, start + size);
+                const blockContent = blockLines.join("\n");
+                // Normalize content for comparison
+                const normalized = normalizeCode(blockContent);
+                // Count tokens (simplified: split on whitespace and punctuation)
+                const tokens = countTokens(normalized);
+                if (tokens < minTokens)
+                    continue;
+                // Skip if mostly empty/comments
+                const significantLines = blockLines.filter((l) => l.trim() && !l.trim().startsWith("#"));
+                if (significantLines.length < minLines / 2)
+                    continue;
+                const hash = crypto.createHash("md5").update(normalized).digest("hex");
+                blocks.push({
+                    hash,
+                    path: filePath,
+                    startLine: start + 1,
+                    endLine: start + size,
+                    content: blockContent,
+                    tokens,
+                });
+            }
+        }
+        return blocks;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Normalize code for comparison (remove variable names, whitespace differences)
+ */
+function normalizeCode(code) {
+    return (code
+        // Remove comments
+        .replace(/#.*$/gm, "")
+        // Remove docstrings (simplified)
+        .replace(/"""[\s\S]*?"""/g, '""')
+        .replace(/'''[\s\S]*?'''/g, "''")
+        // Normalize whitespace
+        .replace(/\s+/g, " ")
+        // Remove string literals (replace with placeholder)
+        .replace(/"[^"]*"/g, '""')
+        .replace(/'[^']*'/g, "''")
+        // Normalize numbers
+        .replace(/\b\d+\b/g, "0")
+        .trim());
+}
+/**
+ * Count tokens in code
+ */
+function countTokens(code) {
+    // Split on whitespace and common punctuation
+    return code.split(/[\s{}()[\];,.:=+\-*/<>]+/).filter((t) => t.length > 0)
+        .length;
+}
+/**
+ * Truncate sample to first N lines
+ */
+function truncateSample(content, maxLines) {
+    const lines = content.split("\n");
+    if (lines.length <= maxLines)
+        return content;
+    return lines.slice(0, maxLines).join("\n") + "\n...";
+}
+/**
+ * Factory function to create a customized findDuplicates tool
+ */
+export function createFindDuplicatesTool(options) {
+    return defineTool({
+        name: "find_duplicates_python",
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            const modifiedInput = {
+                ...input,
+                minLines: input.minLines ?? options?.defaultMinLines,
+                maxFiles: input.maxFiles ?? options?.defaultMaxFiles,
+            };
+            return executeFindDuplicates(modifiedInput);
+        },
+    });
+}

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

@@ -0,0 +1,71 @@
+/**
+ * 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 type { Tool } from "@compilr-dev/agents";
+/**
+ * Input for findImplementations tool
+ */
+export interface FindImplementationsInput {
+    /** Base class, ABC, or Protocol name to find implementations of */
+    name: string;
+    /** Directory or file to search in (defaults to current directory) */
+    scope?: string;
+    /** Include abstract classes that partially implement (default: false) */
+    includeAbstract?: boolean;
+    /** Maximum files to search (default: 100) */
+    maxFiles?: number;
+}
+/**
+ * Implementation info
+ */
+export interface ImplementationInfo {
+    /** Class name */
+    name: string;
+    /** File path */
+    path: string;
+    /** Line number */
+    line: number;
+    /** Kind of implementation */
+    kind: "class" | "dataclass";
+    /** Is abstract */
+    isAbstract?: boolean;
+    /** List of implemented methods */
+    implementedMethods?: string[];
+    /** List of missing abstract methods */
+    missingMethods?: string[];
+}
+/**
+ * Result of findImplementations
+ */
+export interface FindImplementationsResult {
+    /** Target base class/protocol name */
+    target: string;
+    /** Location of target definition */
+    targetLocation?: {
+        path: string;
+        line: number;
+    };
+    /** Found implementations */
+    implementations: ImplementationInfo[];
+    /** Statistics */
+    stats: {
+        filesSearched: number;
+        implementationsFound: number;
+        timeMs: number;
+    };
+}
+/**
+ * findImplementations tool
+ */
+export declare const findImplementationsTool: Tool<FindImplementationsInput>;
+/**
+ * Factory function to create a customized findImplementations tool
+ */
+export declare function createFindImplementationsTool(options?: {
+    defaultScope?: string;
+    defaultMaxFiles?: number;
+}): Tool<FindImplementationsInput>;
+//# sourceMappingURL=find-implementations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"find-implementations.d.ts","sourceRoot":"","sources":["../../src/tools/find-implementations.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,KAAK,EAAE,IAAI,EAAuB,MAAM,qBAAqB,CAAC;AAOrE;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;IACb,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,iBAAiB;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,kBAAkB;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,6BAA6B;IAC7B,IAAI,EAAE,OAAO,GAAG,WAAW,CAAC;IAC5B,kBAAkB;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,kCAAkC;IAClC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,uCAAuC;IACvC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,oCAAoC;IACpC,cAAc,CAAC,EAAE;QACf,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,4BAA4B;IAC5B,eAAe,EAAE,kBAAkB,EAAE,CAAC;IACtC,iBAAiB;IACjB,KAAK,EAAE;QACL,aAAa,EAAE,MAAM,CAAC;QACtB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AAgDD;;GAEG;AACH,eAAO,MAAM,uBAAuB,gCAKlC,CAAC;AAwYH;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,CAAC,EAAE;IACtD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,GAAG,IAAI,CAAC,wBAAwB,CAAC,CAcjC"}