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

package/dist/tools/find-implementations.js

@@ -4,48 +4,53 @@
  * 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';
+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',
+    type: "object",
     properties: {
         name: {
-            type: 'string',
-            description: 'Interface or abstract class name to find implementations of',
+            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)',
+            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)',
+            type: "boolean",
+            description: "Include abstract classes that partially implement (default: false)",
             default: false,
         },
         maxFiles: {
-            type: 'number',
-            description: 'Maximum files to search (default: 100)',
+            type: "number",
+            description: "Maximum files to search (default: 100)",
             default: 100,
         },
     },
-    required: ['name'],
+    required: ["name"],
 };
 // Default file patterns
-const DEFAULT_INCLUDE = ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'];
-const DEFAULT_EXCLUDE = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.git/**'];
+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',
+    name: "find_implementations",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeFindImplementations,
@@ -54,11 +59,11 @@ export const findImplementationsTool = defineTool({
  * Execute the findImplementations tool
  */
 async function executeFindImplementations(input) {
-    const { name, scope = '.', includeAbstract = false, maxFiles = 100 } = 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');
+        return createErrorResult("Interface or class name is required");
     }
     try {
         // Resolve scope path
@@ -119,7 +124,7 @@ async function executeFindImplementations(input) {
  */
 async function findTargetDefinition(filePath, targetName) {
     try {
-        const content = await fs.readFile(filePath, 'utf-8');
+        const content = await fs.readFile(filePath, "utf-8");
         const detection = detectLanguage(filePath);
         if (!detection.language) {
             return null;
@@ -127,7 +132,7 @@ async function findTargetDefinition(filePath, targetName) {
         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);
+        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
@@ -207,7 +212,7 @@ function extractClassMethods(node, abstractOnly) {
  */
 async function findImplementationsInFile(filePath, targetName, targetMethods, isInterface, isAbstractClass, includeAbstract) {
     try {
-        const content = await fs.readFile(filePath, 'utf-8');
+        const content = await fs.readFile(filePath, "utf-8");
         const detection = detectLanguage(filePath);
         if (!detection.language) {
             return [];
@@ -215,7 +220,7 @@ async function findImplementationsInFile(filePath, targetName, targetMethods, is
         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 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
@@ -248,7 +253,7 @@ async function findImplementationsInFile(filePath, targetName, targetMethods, is
                                 path: filePath,
                                 line: line + 1,
                                 column: character + 1,
-                                kind: 'object',
+                                kind: "object",
                                 exported: isExported,
                                 implementedMethods: targetMethods,
                                 missingMethods: [],
@@ -277,7 +282,8 @@ function checkClassImplementation(node, sourceFile, filePath, targetName, target
     if (className === targetName)
         return null;
     // Check if it's abstract
-    const classIsAbstract = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword) ?? false;
+    const classIsAbstract = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword) ??
+        false;
     // Skip abstract classes if not including them
     if (classIsAbstract && !includeAbstract)
         return null;
@@ -329,13 +335,14 @@ function checkClassImplementation(node, sourceFile, filePath, targetName, target
     // 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;
+    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',
+        kind: "class",
         isAbstract: classIsAbstract,
         exported: isExported,
         implementedMethods,
@@ -358,13 +365,14 @@ function checkTypeImplementation(node, sourceFile, filePath, targetName) {
     if (!extendsTarget)
         return null;
     const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+    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',
+        kind: "type",
         exported: isExported,
     };
 }
@@ -384,9 +392,9 @@ async function collectFiles(dirPath, include, exclude, maxDepth, maxFiles, curre
             const relativePath = fullPath;
             // Check exclusions
             const isExcluded = exclude.some((pattern) => {
-                if (pattern.includes('**')) {
-                    const simplePattern = pattern.replace(/\*\*/g, '');
-                    return relativePath.includes(simplePattern.replace(/\*/g, ''));
+                if (pattern.includes("**")) {
+                    const simplePattern = pattern.replace(/\*\*/g, "");
+                    return relativePath.includes(simplePattern.replace(/\*/g, ""));
                 }
                 return entry.name === pattern || relativePath.includes(pattern);
             });
@@ -399,8 +407,8 @@ async function collectFiles(dirPath, include, exclude, maxDepth, maxFiles, curre
             else if (entry.isFile()) {
                 // Check if file matches include patterns
                 const isIncluded = include.some((pattern) => {
-                    if (pattern.includes('*')) {
-                        const ext = pattern.replace('**/', '').replace('*', '');
+                    if (pattern.includes("*")) {
+                        const ext = pattern.replace("**/", "").replace("*", "");
                         return entry.name.endsWith(ext);
                     }
                     return entry.name === pattern;
@@ -421,7 +429,7 @@ async function collectFiles(dirPath, include, exclude, maxDepth, maxFiles, curre
  */
 export function createFindImplementationsTool(options) {
     return defineTool({
-        name: options?.name ?? 'find_implementations',
+        name: options?.name ?? "find_implementations",
         description: options?.description ?? TOOL_DESCRIPTION,
         inputSchema: TOOL_INPUT_SCHEMA,
         execute: async (input) => {

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

@@ -4,8 +4,8 @@
  * 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';
+import type { Tool } from "@compilr-dev/agents";
+import type { FindPatternsInput, CodePattern } from "./types.js";
 /**
  * findPatterns tool
  */