@compilr-dev/agents-coding-ts 0.1.0

package/dist/tools/find-duplicates.js

@@ -0,0 +1,274 @@
+/**
+ * findDuplicates Tool
+ *
+ * Detect duplicate code blocks across the codebase 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 across the codebase.
+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', 'dist', 'build', '.git', 'coverage'];
+/**
+ * findDuplicates tool
+ */
+export const findDuplicatesTool = defineTool({
+    name: 'find_duplicates',
+    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 TypeScript/JavaScript files
+                if (/\.(ts|tsx|js|jsx)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
+                    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('//') && !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, '')
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        // Normalize whitespace
+        .replace(/\s+/g, ' ')
+        // Remove string literals (replace with placeholder)
+        .replace(/"[^"]*"/g, '""')
+        .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...';
+}
+/**
+ * Create customizable findDuplicates tool
+ */
+export function createFindDuplicatesTool(options) {
+    return defineTool({
+        name: options?.name ?? 'find_duplicates',
+        description: options?.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,21 @@
+/**
+ * findImplementations Tool
+ *
+ * Find classes that implement an interface or extend an abstract class.
+ * Useful for understanding interface usage and finding concrete implementations.
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { FindImplementationsInput } from './types.js';
+/**
+ * findImplementations tool - Find implementations of interfaces/abstract classes
+ */
+export declare const findImplementationsTool: Tool<FindImplementationsInput>;
+/**
+ * Create customizable findImplementations tool
+ */
+export declare function createFindImplementationsTool(options?: {
+    name?: string;
+    description?: string;
+    defaultScope?: string;
+    defaultMaxFiles?: number;
+}): Tool<FindImplementationsInput>;