@compilr-dev/agents-coding-ts 0.1.0

package/dist/tools/find-patterns.js

@@ -0,0 +1,457 @@
+/**
+ * findPatterns Tool
+ *
+ * Find code patterns, anti-patterns, and code smells in the codebase.
+ * Uses regex and AST-based pattern matching.
+ */
+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 code patterns, anti-patterns, and code smells.
+Searches for common issues like security vulnerabilities, performance problems, and maintainability concerns.
+Supports built-in patterns or custom pattern definitions.`;
+// Tool input schema
+const TOOL_INPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        path: {
+            type: 'string',
+            description: 'Directory to analyze',
+        },
+        patterns: {
+            type: 'array',
+            description: 'Custom patterns to search for (uses built-in if not specified)',
+            items: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    description: { type: 'string' },
+                    type: { type: 'string' },
+                    matcher: { type: 'string' },
+                    severity: { type: 'string' },
+                },
+            },
+        },
+        categories: {
+            type: 'array',
+            description: 'Pattern categories to include (default: all)',
+            items: {
+                type: 'string',
+                enum: ['security', 'performance', 'maintainability', 'all'],
+            },
+        },
+        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'];
+// Built-in patterns
+const BUILTIN_PATTERNS = [
+    // Security patterns
+    {
+        name: 'eval-usage',
+        description: 'Use of eval() can lead to code injection vulnerabilities',
+        type: 'anti-pattern',
+        matcher: '\\beval\\s*\\(',
+        severity: 'error',
+        category: 'security',
+    },
+    {
+        name: 'innerHTML-usage',
+        description: 'innerHTML can lead to XSS vulnerabilities',
+        type: 'anti-pattern',
+        matcher: '\\.innerHTML\\s*=',
+        severity: 'warning',
+        category: 'security',
+    },
+    {
+        name: 'hardcoded-secret',
+        description: 'Potential hardcoded secret or API key',
+        type: 'anti-pattern',
+        matcher: '(password|secret|api_key|apikey|token)\\s*[=:]\\s*["\'][^"\']+["\']',
+        severity: 'error',
+        category: 'security',
+    },
+    {
+        name: 'sql-injection-risk',
+        description: 'String concatenation in SQL query (potential injection)',
+        type: 'anti-pattern',
+        matcher: '(query|execute)\\s*\\(\\s*[`"\'].*\\$\\{',
+        severity: 'error',
+        category: 'security',
+    },
+    // Performance patterns
+    {
+        name: 'console-log',
+        description: 'console.log left in code (should be removed in production)',
+        type: 'smell',
+        matcher: '\\bconsole\\.(log|debug|info)\\s*\\(',
+        severity: 'info',
+        category: 'performance',
+    },
+    {
+        name: 'sync-fs-operations',
+        description: 'Synchronous file system operations block the event loop',
+        type: 'anti-pattern',
+        matcher: '\\b(readFileSync|writeFileSync|existsSync|statSync|readdirSync)\\s*\\(',
+        severity: 'warning',
+        category: 'performance',
+    },
+    {
+        name: 'nested-loops',
+        description: 'Deeply nested loops may indicate O(n²) or worse complexity',
+        type: 'smell',
+        matcher: 'for\\s*\\([^)]+\\)\\s*\\{[^}]*for\\s*\\([^)]+\\)\\s*\\{[^}]*for\\s*\\(',
+        severity: 'warning',
+        category: 'performance',
+    },
+    {
+        name: 'await-in-loop',
+        description: 'await inside loop may cause sequential execution instead of parallel',
+        type: 'smell',
+        matcher: '(for|while)\\s*\\([^)]*\\)\\s*\\{[^}]*await\\b',
+        severity: 'info',
+        category: 'performance',
+    },
+    // Maintainability patterns
+    {
+        name: 'magic-number',
+        description: 'Magic numbers should be named constants',
+        type: 'smell',
+        matcher: '(?<!\\.)\\b(?!(0|1|2|10|100|1000)\\b)\\d{2,}\\b(?!\\.)',
+        severity: 'info',
+        category: 'maintainability',
+    },
+    {
+        name: 'todo-fixme',
+        description: 'TODO or FIXME comment indicating incomplete work',
+        type: 'smell',
+        matcher: '(TODO|FIXME|HACK|XXX)\\s*:?',
+        severity: 'info',
+        category: 'maintainability',
+    },
+    {
+        name: 'any-type',
+        description: 'Use of "any" type defeats TypeScript type checking',
+        type: 'smell',
+        matcher: ':\\s*any\\b',
+        severity: 'warning',
+        category: 'maintainability',
+    },
+    {
+        name: 'ts-ignore',
+        description: '@ts-ignore suppresses TypeScript errors',
+        type: 'smell',
+        matcher: '@ts-ignore',
+        severity: 'warning',
+        category: 'maintainability',
+    },
+    {
+        name: 'eslint-disable',
+        description: 'eslint-disable suppresses linting rules',
+        type: 'smell',
+        matcher: 'eslint-disable(?!-next-line)',
+        severity: 'info',
+        category: 'maintainability',
+    },
+    {
+        name: 'long-function',
+        description: 'Function body exceeds recommended length',
+        type: 'smell',
+        matcher: 'AST:long-function',
+        severity: 'warning',
+        category: 'maintainability',
+    },
+    {
+        name: 'many-parameters',
+        description: 'Function has too many parameters (consider using options object)',
+        type: 'smell',
+        matcher: 'AST:many-parameters',
+        severity: 'info',
+        category: 'maintainability',
+    },
+];
+/**
+ * findPatterns tool
+ */
+export const findPatternsTool = defineTool({
+    name: 'find_patterns',
+    description: TOOL_DESCRIPTION,
+    inputSchema: TOOL_INPUT_SCHEMA,
+    execute: executeFindPatterns,
+});
+/**
+ * Execute the findPatterns tool
+ */
+async function executeFindPatterns(input) {
+    const { path: inputPath, patterns, categories = ['all'], 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('findPatterns requires a directory path');
+        }
+        // Determine which patterns to use
+        const patternsToUse = patterns ?? getBuiltinPatterns(categories);
+        // Collect files
+        const files = [];
+        await collectFiles(resolvedPath, files, maxFiles);
+        // Find matches
+        const allMatches = [];
+        const byPattern = {};
+        let errorCount = 0;
+        let warningCount = 0;
+        let infoCount = 0;
+        for (const file of files) {
+            const fileMatches = await analyzeFileForPatterns(file, patternsToUse);
+            allMatches.push(...fileMatches);
+        }
+        // Count by pattern and severity
+        for (const match of allMatches) {
+            byPattern[match.pattern] = (byPattern[match.pattern] ?? 0) + 1;
+            if (match.severity === 'error')
+                errorCount++;
+            else if (match.severity === 'warning')
+                warningCount++;
+            else
+                infoCount++;
+        }
+        // Sort by severity (errors first)
+        allMatches.sort((a, b) => {
+            const severityOrder = { error: 0, warning: 1, info: 2 };
+            return severityOrder[a.severity] - severityOrder[b.severity];
+        });
+        // Limit results
+        const limitedMatches = allMatches.slice(0, 100);
+        const result = {
+            path: resolvedPath,
+            matches: limitedMatches,
+            stats: {
+                filesAnalyzed: files.length,
+                totalMatches: allMatches.length,
+                byPattern,
+                bySeverity: {
+                    error: errorCount,
+                    warning: warningCount,
+                    info: infoCount,
+                },
+            },
+        };
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        return createErrorResult(`Failed to find patterns: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Get built-in patterns filtered by category
+ */
+function getBuiltinPatterns(categories) {
+    if (categories.includes('all')) {
+        return BUILTIN_PATTERNS;
+    }
+    return BUILTIN_PATTERNS.filter((p) => categories.includes(p.category));
+}
+/**
+ * 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
+    }
+}
+/**
+ * Analyze a file for patterns
+ */
+async function analyzeFileForPatterns(filePath, patterns) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const matches = [];
+        // Separate regex patterns from AST patterns
+        const regexPatterns = patterns.filter((p) => !p.matcher.startsWith('AST:'));
+        const astPatterns = patterns.filter((p) => p.matcher.startsWith('AST:'));
+        // Check regex patterns line by line
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            for (const pattern of regexPatterns) {
+                try {
+                    const regex = new RegExp(pattern.matcher, 'gi');
+                    if (regex.test(line)) {
+                        matches.push({
+                            pattern: pattern.name,
+                            description: pattern.description,
+                            severity: pattern.severity,
+                            path: filePath,
+                            line: i + 1,
+                            snippet: line.trim().slice(0, 100),
+                            suggestion: getSuggestion(pattern.name),
+                        });
+                    }
+                }
+                catch {
+                    // Invalid regex, skip
+                }
+            }
+        }
+        // Check AST patterns
+        if (astPatterns.length > 0) {
+            const astMatches = analyzeFileForAstPatterns(filePath, content, astPatterns);
+            matches.push(...astMatches);
+        }
+        return matches;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Analyze file for AST-based patterns
+ */
+function analyzeFileForAstPatterns(filePath, content, patterns) {
+    const detection = detectLanguage(filePath);
+    if (!detection.language || !isLanguageSupported(detection.language)) {
+        return [];
+    }
+    const matches = [];
+    try {
+        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, filePath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+        const checkLongFunction = patterns.some((p) => p.matcher === 'AST:long-function');
+        const checkManyParameters = patterns.some((p) => p.matcher === 'AST:many-parameters');
+        const visit = (node) => {
+            // Check long functions (>50 lines)
+            if (checkLongFunction) {
+                if (ts.isFunctionDeclaration(node) ||
+                    ts.isMethodDeclaration(node) ||
+                    ts.isArrowFunction(node) ||
+                    ts.isFunctionExpression(node)) {
+                    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+                    const lines = endLine - startLine;
+                    if (lines > 50) {
+                        let name = '<anonymous>';
+                        if (ts.isFunctionDeclaration(node) && node.name) {
+                            name = node.name.text;
+                        }
+                        else if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) {
+                            name = node.name.text;
+                        }
+                        matches.push({
+                            pattern: 'long-function',
+                            description: `Function "${name}" has ${String(lines)} lines (recommended: <50)`,
+                            severity: 'warning',
+                            path: filePath,
+                            line: startLine + 1,
+                            snippet: `function ${name}(...) { /* ${String(lines)} lines */ }`,
+                            suggestion: 'Consider breaking this function into smaller functions',
+                        });
+                    }
+                }
+            }
+            // Check many parameters (>5)
+            if (checkManyParameters) {
+                if (ts.isFunctionDeclaration(node) ||
+                    ts.isMethodDeclaration(node) ||
+                    ts.isArrowFunction(node) ||
+                    ts.isFunctionExpression(node)) {
+                    const paramCount = node.parameters.length;
+                    if (paramCount > 5) {
+                        const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                        let name = '<anonymous>';
+                        if (ts.isFunctionDeclaration(node) && node.name) {
+                            name = node.name.text;
+                        }
+                        else if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) {
+                            name = node.name.text;
+                        }
+                        matches.push({
+                            pattern: 'many-parameters',
+                            description: `Function "${name}" has ${String(paramCount)} parameters (recommended: <5)`,
+                            severity: 'info',
+                            path: filePath,
+                            line: line + 1,
+                            snippet: `function ${name}(${String(paramCount)} params...)`,
+                            suggestion: 'Consider using an options object instead of many parameters',
+                        });
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return matches;
+}
+/**
+ * Get suggestion for a pattern
+ */
+function getSuggestion(patternName) {
+    const suggestions = {
+        'eval-usage': 'Use safer alternatives like JSON.parse() or Function constructor',
+        'innerHTML-usage': 'Use textContent or sanitize HTML before insertion',
+        'hardcoded-secret': 'Use environment variables or a secrets manager',
+        'sql-injection-risk': 'Use parameterized queries or an ORM',
+        'console-log': 'Remove or replace with proper logging',
+        'sync-fs-operations': 'Use async versions like readFile, writeFile',
+        'any-type': 'Use a specific type or unknown if type is truly unknown',
+        'ts-ignore': 'Fix the underlying type issue instead of suppressing',
+    };
+    return suggestions[patternName];
+}
+/**
+ * Create customizable findPatterns tool
+ */
+export function createFindPatternsTool(options) {
+    return defineTool({
+        name: options?.name ?? 'find_patterns',
+        description: options?.description ?? TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            const modifiedInput = {
+                ...input,
+                maxFiles: input.maxFiles ?? options?.defaultMaxFiles,
+                patterns: input.patterns ?? [...BUILTIN_PATTERNS, ...(options?.additionalPatterns ?? [])],
+            };
+            return executeFindPatterns(modifiedInput);
+        },
+    });
+}

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

@@ -0,0 +1,23 @@
+/**
+ * findReferences Tool
+ *
+ * Find all usages of a symbol across the codebase.
+ * Uses TypeScript Compiler API for accurate AST analysis.
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { FindReferencesInput } from './types.js';
+/**
+ * findReferences tool - Find all usages of a symbol
+ */
+export declare const findReferencesTool: Tool<FindReferencesInput>;
+/**
+ * Factory function to create a customized findReferences tool
+ */
+export declare function createFindReferencesTool(options?: {
+    /** Default limit */
+    defaultLimit?: number;
+    /** Default groupByFile */
+    defaultGroupByFile?: boolean;
+    /** Default includeDefinition */
+    defaultIncludeDefinition?: boolean;
+}): Tool<FindReferencesInput>;