@compilr-dev/agents-coding-ts 0.1.3 → 0.1.5

package/dist/tools/find-duplicates.js

@@ -4,52 +4,52 @@
  * 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';
+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',
+    type: "object",
     properties: {
         path: {
-            type: 'string',
-            description: 'Directory to analyze',
+            type: "string",
+            description: "Directory to analyze",
         },
         minLines: {
-            type: 'number',
-            description: 'Minimum lines for a duplicate (default: 6)',
+            type: "number",
+            description: "Minimum lines for a duplicate (default: 6)",
             default: 6,
         },
         minTokens: {
-            type: 'number',
-            description: 'Minimum tokens for a duplicate (default: 50)',
+            type: "number",
+            description: "Minimum tokens for a duplicate (default: 50)",
             default: 50,
         },
         ignoreIdenticalFiles: {
-            type: 'boolean',
-            description: 'Ignore identical files (default: true)',
+            type: "boolean",
+            description: "Ignore identical files (default: true)",
             default: true,
         },
         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"];
 /**
  * findDuplicates tool
  */
 export const findDuplicatesTool = defineTool({
-    name: 'find_duplicates',
+    name: "find_duplicates",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeFindDuplicates,
@@ -70,7 +70,7 @@ async function executeFindDuplicates(input) {
         }
         const stats = await fs.stat(resolvedPath);
         if (!stats.isDirectory()) {
-            return createErrorResult('findDuplicates requires a directory path');
+            return createErrorResult("findDuplicates requires a directory path");
         }
         // Collect files
         const files = [];
@@ -79,8 +79,8 @@ async function executeFindDuplicates(input) {
         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 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);
@@ -93,8 +93,8 @@ async function executeFindDuplicates(input) {
             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;
+            const content = await fs.readFile(file, "utf-8");
+            totalLines += content.split("\n").length;
         }
         // Group by hash
         const hashGroups = new Map();
@@ -133,7 +133,9 @@ async function executeFindDuplicates(input) {
         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 percentageDuplicate = totalLines > 0
+            ? Math.round((totalDuplicateLines / totalLines) * 10000) / 100
+            : 0;
         const result = {
             path: resolvedPath,
             duplicates: limitedGroups,
@@ -169,7 +171,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);
                 }
             }
@@ -184,15 +187,15 @@ async function collectFiles(dirPath, files, maxFiles, currentDepth = 0) {
  */
 async function extractCodeBlocks(filePath, minLines, minTokens) {
     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 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');
+                const blockContent = blockLines.join("\n");
                 // Normalize content for comparison
                 const normalized = normalizeCode(blockContent);
                 // Count tokens (simplified: split on whitespace and punctuation)
@@ -200,10 +203,10 @@ async function extractCodeBlocks(filePath, minLines, minTokens) {
                 if (tokens < minTokens)
                     continue;
                 // Skip if mostly empty/comments
-                const significantLines = blockLines.filter((l) => l.trim() && !l.trim().startsWith('//') && !l.trim().startsWith('*'));
+                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');
+                const hash = crypto.createHash("md5").update(normalized).digest("hex");
                 blocks.push({
                     hash,
                     path: filePath,
@@ -226,16 +229,16 @@ async function extractCodeBlocks(filePath, minLines, minTokens) {
 function normalizeCode(code) {
     return (code
         // Remove comments
-        .replace(/\/\/.*$/gm, '')
-        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/\/\/.*$/gm, "")
+        .replace(/\/\*[\s\S]*?\*\//g, "")
         // Normalize whitespace
-        .replace(/\s+/g, ' ')
+        .replace(/\s+/g, " ")
         // Remove string literals (replace with placeholder)
         .replace(/"[^"]*"/g, '""')
         .replace(/'[^']*'/g, "''")
-        .replace(/`[^`]*`/g, '``')
+        .replace(/`[^`]*`/g, "``")
         // Normalize numbers
-        .replace(/\b\d+\b/g, '0')
+        .replace(/\b\d+\b/g, "0")
         .trim());
 }
 /**
@@ -249,17 +252,17 @@ function countTokens(code) {
  * Truncate sample to first N lines
  */
 function truncateSample(content, maxLines) {
-    const lines = content.split('\n');
+    const lines = content.split("\n");
     if (lines.length <= maxLines)
         return content;
-    return lines.slice(0, maxLines).join('\n') + '\n...';
+    return lines.slice(0, maxLines).join("\n") + "\n...";
 }
 /**
  * Create customizable findDuplicates tool
  */
 export function createFindDuplicatesTool(options) {
     return defineTool({
-        name: options?.name ?? 'find_duplicates',
+        name: options?.name ?? "find_duplicates",
         description: options?.description ?? TOOL_DESCRIPTION,
         inputSchema: TOOL_INPUT_SCHEMA,
         execute: async (input) => {

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

@@ -4,8 +4,8 @@
  * 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';
+import type { Tool } from "@compilr-dev/agents";
+import type { FindImplementationsInput } from "./types.js";
 /**
  * findImplementations tool - Find implementations of interfaces/abstract classes
  */

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
  */