@compilr-dev/agents-coding-ts 0.1.2 → 0.1.4

package/dist/tools/find-patterns.js

@@ -4,186 +4,186 @@
  * 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';
+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',
+    type: "object",
     properties: {
         path: {
-            type: 'string',
-            description: 'Directory to analyze',
+            type: "string",
+            description: "Directory to analyze",
         },
         patterns: {
-            type: 'array',
-            description: 'Custom patterns to search for (uses built-in if not specified)',
+            type: "array",
+            description: "Custom patterns to search for (uses built-in if not specified)",
             items: {
-                type: 'object',
+                type: "object",
                 properties: {
-                    name: { type: 'string' },
-                    description: { type: 'string' },
-                    type: { type: 'string' },
-                    matcher: { type: 'string' },
-                    severity: { type: 'string' },
+                    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)',
+            type: "array",
+            description: "Pattern categories to include (default: all)",
             items: {
-                type: 'string',
-                enum: ['security', 'performance', 'maintainability', 'all'],
+                type: "string",
+                enum: ["security", "performance", "maintainability", "all"],
             },
         },
         maxFiles: {
-            type: 'number',
-            description: 'Maximum files to analyze (default: 100)',
+            type: "number",
+            description: "Maximum files to analyze (default: 100)",
             default: 100,
         },
     },
-    required: ['path'],
+    required: ["path"],
 };
 // Default exclusions
-const DEFAULT_EXCLUDE = ['node_modules', 'dist', 'build', '.git', 'coverage'];
+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: "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: "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: "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',
+        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: "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: "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: "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',
+        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: "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: "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',
+        name: "any-type",
         description: 'Use of "any" type defeats TypeScript type checking',
-        type: 'smell',
-        matcher: ':\\s*any\\b',
-        severity: 'warning',
-        category: 'maintainability',
+        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: "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: "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: "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',
+        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',
+    name: "find_patterns",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeFindPatterns,
@@ -192,7 +192,7 @@ export const findPatternsTool = defineTool({
  * Execute the findPatterns tool
  */
 async function executeFindPatterns(input) {
-    const { path: inputPath, patterns, categories = ['all'], maxFiles = 100 } = input;
+    const { path: inputPath, patterns, categories = ["all"], maxFiles = 100, } = input;
     try {
         const resolvedPath = path.resolve(inputPath);
         // Check if path exists
@@ -204,7 +204,7 @@ async function executeFindPatterns(input) {
         }
         const stats = await fs.stat(resolvedPath);
         if (!stats.isDirectory()) {
-            return createErrorResult('findPatterns requires a directory path');
+            return createErrorResult("findPatterns requires a directory path");
         }
         // Determine which patterns to use
         const patternsToUse = patterns ?? getBuiltinPatterns(categories);
@@ -224,9 +224,9 @@ async function executeFindPatterns(input) {
         // Count by pattern and severity
         for (const match of allMatches) {
             byPattern[match.pattern] = (byPattern[match.pattern] ?? 0) + 1;
-            if (match.severity === 'error')
+            if (match.severity === "error")
                 errorCount++;
-            else if (match.severity === 'warning')
+            else if (match.severity === "warning")
                 warningCount++;
             else
                 infoCount++;
@@ -262,7 +262,7 @@ async function executeFindPatterns(input) {
  * Get built-in patterns filtered by category
  */
 function getBuiltinPatterns(categories) {
-    if (categories.includes('all')) {
+    if (categories.includes("all")) {
         return BUILTIN_PATTERNS;
     }
     return BUILTIN_PATTERNS.filter((p) => categories.includes(p.category));
@@ -286,7 +286,8 @@ async function collectFiles(dirPath, files, maxFiles, currentDepth = 0) {
             }
             else if (entry.isFile()) {
                 // Only include TypeScript/JavaScript files
-                if (/\.(ts|tsx|js|jsx)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
+                if (/\.(ts|tsx|js|jsx)$/.test(entry.name) &&
+                    !entry.name.endsWith(".d.ts")) {
                     files.push(fullPath);
                 }
             }
@@ -301,18 +302,18 @@ async function collectFiles(dirPath, files, maxFiles, currentDepth = 0) {
  */
 async function analyzeFileForPatterns(filePath, patterns) {
     try {
-        const content = await fs.readFile(filePath, 'utf-8');
-        const lines = content.split('\n');
+        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:'));
+        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');
+                    const regex = new RegExp(pattern.matcher, "gi");
                     if (regex.test(line)) {
                         matches.push({
                             pattern: pattern.name,
@@ -351,9 +352,9 @@ function analyzeFileForAstPatterns(filePath, content, patterns) {
     }
     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 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) {
@@ -365,21 +366,22 @@ function analyzeFileForAstPatterns(filePath, content, patterns) {
                     const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
                     const lines = endLine - startLine;
                     if (lines > 50) {
-                        let name = '<anonymous>';
+                        let name = "<anonymous>";
                         if (ts.isFunctionDeclaration(node) && node.name) {
                             name = node.name.text;
                         }
-                        else if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) {
+                        else if (ts.isMethodDeclaration(node) &&
+                            ts.isIdentifier(node.name)) {
                             name = node.name.text;
                         }
                         matches.push({
-                            pattern: 'long-function',
+                            pattern: "long-function",
                             description: `Function "${name}" has ${String(lines)} lines (recommended: <50)`,
-                            severity: 'warning',
+                            severity: "warning",
                             path: filePath,
                             line: startLine + 1,
                             snippet: `function ${name}(...) { /* ${String(lines)} lines */ }`,
-                            suggestion: 'Consider breaking this function into smaller functions',
+                            suggestion: "Consider breaking this function into smaller functions",
                         });
                     }
                 }
@@ -393,21 +395,22 @@ function analyzeFileForAstPatterns(filePath, content, patterns) {
                     const paramCount = node.parameters.length;
                     if (paramCount > 5) {
                         const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-                        let name = '<anonymous>';
+                        let name = "<anonymous>";
                         if (ts.isFunctionDeclaration(node) && node.name) {
                             name = node.name.text;
                         }
-                        else if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) {
+                        else if (ts.isMethodDeclaration(node) &&
+                            ts.isIdentifier(node.name)) {
                             name = node.name.text;
                         }
                         matches.push({
-                            pattern: 'many-parameters',
+                            pattern: "many-parameters",
                             description: `Function "${name}" has ${String(paramCount)} parameters (recommended: <5)`,
-                            severity: 'info',
+                            severity: "info",
                             path: filePath,
                             line: line + 1,
                             snippet: `function ${name}(${String(paramCount)} params...)`,
-                            suggestion: 'Consider using an options object instead of many parameters',
+                            suggestion: "Consider using an options object instead of many parameters",
                         });
                     }
                 }
@@ -426,14 +429,14 @@ function analyzeFileForAstPatterns(filePath, content, patterns) {
  */
 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',
+        "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];
 }
@@ -442,14 +445,17 @@ function getSuggestion(patternName) {
  */
 export function createFindPatternsTool(options) {
     return defineTool({
-        name: options?.name ?? 'find_patterns',
+        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 ?? [])],
+                patterns: input.patterns ?? [
+                    ...BUILTIN_PATTERNS,
+                    ...(options?.additionalPatterns ?? []),
+                ],
             };
             return executeFindPatterns(modifiedInput);
         },

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

@@ -4,8 +4,8 @@
  * 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';
+import type { Tool } from "@compilr-dev/agents";
+import type { FindReferencesInput } from "./types.js";
 /**
  * findReferences tool - Find all usages of a symbol
  */