@compilr-dev/agents-coding-ts 0.1.0

package/dist/tools/find-implementations.js

@@ -0,0 +1,436 @@
+/**
+ * findImplementations Tool
+ *
+ * Find classes that implement an interface or extend an abstract class.
+ * Useful for understanding interface usage and finding concrete implementations.
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as ts from 'typescript';
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { detectLanguage, isLanguageSupported } from '../parser/typescript-parser.js';
+// Tool description
+const TOOL_DESCRIPTION = `Find classes that implement an interface or extend an abstract class.
+Returns information about each implementation including which methods are implemented.
+Useful for understanding how interfaces are used across the codebase.`;
+// Tool input schema
+const TOOL_INPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        name: {
+            type: 'string',
+            description: 'Interface or abstract class 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 file patterns
+const DEFAULT_INCLUDE = ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'];
+const DEFAULT_EXCLUDE = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.git/**'];
+/**
+ * findImplementations tool - Find implementations of interfaces/abstract classes
+ */
+export const findImplementationsTool = defineTool({
+    name: 'find_implementations',
+    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('Interface or class 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, DEFAULT_INCLUDE, DEFAULT_EXCLUDE, 10, maxFiles)
+            : [scopePath];
+        // Find the target interface/abstract class definition
+        let targetLocation;
+        let targetMethods = [];
+        let isInterface = false;
+        let isAbstractClass = false;
+        // 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;
+                isInterface = result.isInterface;
+                isAbstractClass = result.isAbstractClass;
+                break;
+            }
+        }
+        // Second pass: find implementations
+        const implementations = [];
+        for (const file of files) {
+            const fileImplementations = await findImplementationsInFile(file, name, targetMethods, isInterface, isAbstractClass, 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)}`);
+    }
+}
+/**
+ * Find the target interface or abstract class definition
+ */
+async function findTargetDefinition(filePath, targetName) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const detection = detectLanguage(filePath);
+        if (!detection.language) {
+            return null;
+        }
+        if (!isLanguageSupported(detection.language)) {
+            return null;
+        }
+        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, filePath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+        let result = null;
+        const visit = (node) => {
+            // Check for interface declaration
+            if (ts.isInterfaceDeclaration(node) && node.name.text === targetName) {
+                const methods = extractInterfaceMethods(node);
+                const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                result = {
+                    line: line + 1,
+                    methods,
+                    isInterface: true,
+                    isAbstractClass: false,
+                };
+                return;
+            }
+            // Check for abstract class declaration
+            if (ts.isClassDeclaration(node) && node.name?.text === targetName) {
+                const isAbstract = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword) ?? false;
+                if (isAbstract) {
+                    const methods = extractClassMethods(node, true);
+                    const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                    result = {
+                        line: line + 1,
+                        methods,
+                        isInterface: false,
+                        isAbstractClass: true,
+                    };
+                }
+                return;
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extract method names from an interface
+ */
+function extractInterfaceMethods(node) {
+    const methods = [];
+    for (const member of node.members) {
+        if (ts.isMethodSignature(member)) {
+            const name = member.name.getText();
+            methods.push(name);
+        }
+        if (ts.isPropertySignature(member)) {
+            // Check if it's a function type property
+            if (member.type && ts.isFunctionTypeNode(member.type)) {
+                const name = member.name.getText();
+                methods.push(name);
+            }
+        }
+    }
+    return methods;
+}
+/**
+ * Extract method names from a class
+ */
+function extractClassMethods(node, abstractOnly) {
+    const methods = [];
+    for (const member of node.members) {
+        if (ts.isMethodDeclaration(member)) {
+            const isAbstract = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword) ?? false;
+            if (!abstractOnly || isAbstract) {
+                const name = member.name.getText();
+                methods.push(name);
+            }
+        }
+    }
+    return methods;
+}
+/**
+ * Find implementations in a single file
+ */
+async function findImplementationsInFile(filePath, targetName, targetMethods, isInterface, isAbstractClass, includeAbstract) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const detection = detectLanguage(filePath);
+        if (!detection.language) {
+            return [];
+        }
+        if (!isLanguageSupported(detection.language)) {
+            return [];
+        }
+        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, filePath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+        const implementations = [];
+        const visit = (node) => {
+            // Check for class declaration
+            if (ts.isClassDeclaration(node) && node.name) {
+                const implementation = checkClassImplementation(node, sourceFile, filePath, targetName, targetMethods, isInterface, isAbstractClass, includeAbstract);
+                if (implementation) {
+                    implementations.push(implementation);
+                }
+            }
+            // Check for type alias that implements the interface (for structural typing)
+            if (ts.isTypeAliasDeclaration(node) && isInterface) {
+                const typeImpl = checkTypeImplementation(node, sourceFile, filePath, targetName);
+                if (typeImpl) {
+                    implementations.push(typeImpl);
+                }
+            }
+            // Check for object literal with type annotation
+            if (ts.isVariableStatement(node) && isInterface) {
+                for (const decl of node.declarationList.declarations) {
+                    if (decl.type && ts.isTypeLiteralNode(decl.type)) {
+                        continue;
+                    }
+                    if (decl.type && ts.isTypeReferenceNode(decl.type)) {
+                        const typeName = decl.type.typeName.getText();
+                        if (typeName === targetName && ts.isIdentifier(decl.name)) {
+                            const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                            const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                            implementations.push({
+                                name: decl.name.text,
+                                path: filePath,
+                                line: line + 1,
+                                column: character + 1,
+                                kind: 'object',
+                                exported: isExported,
+                                implementedMethods: targetMethods,
+                                missingMethods: [],
+                            });
+                        }
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        return implementations;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Check if a class implements the target interface/abstract class
+ */
+function checkClassImplementation(node, sourceFile, filePath, targetName, targetMethods, isInterface, isAbstractClass, includeAbstract) {
+    if (!node.name)
+        return null;
+    const className = node.name.text;
+    // Skip the target class itself
+    if (className === targetName)
+        return null;
+    // Check if it's abstract
+    const classIsAbstract = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword) ?? false;
+    // Skip abstract classes if not including them
+    if (classIsAbstract && !includeAbstract)
+        return null;
+    // Check heritage clauses (implements and extends)
+    let implementsTarget = false;
+    let extendsTarget = false;
+    if (node.heritageClauses) {
+        for (const clause of node.heritageClauses) {
+            if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+                for (const type of clause.types) {
+                    const typeName = type.expression.getText();
+                    if (typeName === targetName) {
+                        implementsTarget = true;
+                        break;
+                    }
+                }
+            }
+            if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
+                for (const type of clause.types) {
+                    const typeName = type.expression.getText();
+                    if (typeName === targetName) {
+                        extendsTarget = true;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    // Must either implement or extend the target
+    if (!implementsTarget && !extendsTarget)
+        return null;
+    // Get implemented methods
+    const implementedMethods = [];
+    for (const member of node.members) {
+        if (ts.isMethodDeclaration(member)) {
+            const methodName = member.name.getText();
+            if (targetMethods.includes(methodName)) {
+                implementedMethods.push(methodName);
+            }
+        }
+        // Also check getters/setters
+        if (ts.isGetAccessor(member) || ts.isSetAccessor(member)) {
+            const methodName = member.name.getText();
+            if (targetMethods.includes(methodName)) {
+                implementedMethods.push(methodName);
+            }
+        }
+    }
+    // Calculate missing methods
+    const missingMethods = targetMethods.filter((m) => !implementedMethods.includes(m));
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+    return {
+        name: className,
+        path: filePath,
+        line: line + 1,
+        column: character + 1,
+        kind: 'class',
+        isAbstract: classIsAbstract,
+        exported: isExported,
+        implementedMethods,
+        missingMethods,
+    };
+}
+/**
+ * Check if a type alias structurally implements an interface
+ */
+function checkTypeImplementation(node, sourceFile, filePath, targetName) {
+    // Check if type extends/intersects with the target
+    const typeText = node.type.getText();
+    // Simple check: does it reference the target type?
+    if (!typeText.includes(targetName))
+        return null;
+    // Check for intersection or extension patterns
+    const isIntersection = ts.isIntersectionTypeNode(node.type);
+    const extendsTarget = typeText === targetName ||
+        (isIntersection && node.type.types.some((t) => t.getText() === targetName));
+    if (!extendsTarget)
+        return null;
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+    return {
+        name: node.name.text,
+        path: filePath,
+        line: line + 1,
+        column: character + 1,
+        kind: 'type',
+        exported: isExported,
+    };
+}
+/**
+ * Collect files matching patterns
+ */
+async function collectFiles(dirPath, include, exclude, maxDepth, maxFiles, currentDepth = 0) {
+    if (currentDepth > maxDepth)
+        return [];
+    const files = [];
+    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);
+            const relativePath = fullPath;
+            // Check exclusions
+            const isExcluded = exclude.some((pattern) => {
+                if (pattern.includes('**')) {
+                    const simplePattern = pattern.replace(/\*\*/g, '');
+                    return relativePath.includes(simplePattern.replace(/\*/g, ''));
+                }
+                return entry.name === pattern || relativePath.includes(pattern);
+            });
+            if (isExcluded)
+                continue;
+            if (entry.isDirectory()) {
+                const subFiles = await collectFiles(fullPath, include, exclude, maxDepth, maxFiles - files.length, currentDepth + 1);
+                files.push(...subFiles);
+            }
+            else if (entry.isFile()) {
+                // Check if file matches include patterns
+                const isIncluded = include.some((pattern) => {
+                    if (pattern.includes('*')) {
+                        const ext = pattern.replace('**/', '').replace('*', '');
+                        return entry.name.endsWith(ext);
+                    }
+                    return entry.name === pattern;
+                });
+                if (isIncluded) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore permission errors
+    }
+    return files;
+}
+/**
+ * Create customizable findImplementations tool
+ */
+export function createFindImplementationsTool(options) {
+    return defineTool({
+        name: options?.name ?? 'find_implementations',
+        description: options?.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,21 @@
+/**
+ * findPatterns Tool
+ *
+ * Find code patterns, anti-patterns, and code smells in the codebase.
+ * Uses regex and AST-based pattern matching.
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { FindPatternsInput, CodePattern } from './types.js';
+/**
+ * findPatterns tool
+ */
+export declare const findPatternsTool: Tool<FindPatternsInput>;
+/**
+ * Create customizable findPatterns tool
+ */
+export declare function createFindPatternsTool(options?: {
+    name?: string;
+    description?: string;
+    defaultMaxFiles?: number;
+    additionalPatterns?: CodePattern[];
+}): Tool<FindPatternsInput>;