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

package/dist/skills/refactor-impact.js

@@ -3,15 +3,26 @@
  *
  * Analyze the impact of refactoring a symbol across the codebase.
  */
-import { defineSkill } from '@compilr-dev/agents';
+import { defineSkill } from "@compilr-dev/agents";
 /**
  * Refactor impact skill - Analyze impact of refactoring a symbol
  */
 export const refactorImpactSkill = defineSkill({
-    name: 'refactor-impact',
-    description: 'Analyze the impact of refactoring a symbol across the codebase',
+    name: "refactor-impact",
+    description: "Analyze the impact of refactoring a symbol across the codebase",
     prompt: `You are in REFACTOR IMPACT ANALYSIS mode. Analyze what would be affected by refactoring a symbol.
 
+## When to Use
+- Planning to rename, move, or change a function/class/interface
+- Assessing risk before modifying public API
+- Understanding what files will need updates
+- Creating a refactoring checklist
+
+## When NOT to Use
+- Just want to understand what a symbol does → use code-structure skill
+- Need to find where a symbol is used (not planning to change it) → use find_references directly
+- Checking type hierarchy without planning changes → use type-analysis skill
+
 ## TOOLS TO USE
 
 1. **find_symbol**: Locate the symbol definition
@@ -130,6 +141,6 @@ get_type_hierarchy({
 - Quantify the impact (number of files, usages)
 - Provide actionable checklist
 - Highlight breaking changes for exported/public symbols`,
-    tags: ['refactoring', 'analysis', 'impact', 'planning'],
-    version: '1.0.0',
+    tags: ["refactoring", "analysis", "impact", "planning"],
+    version: "1.0.0",
 });

package/dist/skills/type-analysis.js

@@ -3,15 +3,26 @@
  *
  * Analyze type hierarchies, interfaces, and their implementations.
  */
-import { defineSkill } from '@compilr-dev/agents';
+import { defineSkill } from "@compilr-dev/agents";
 /**
  * Type analysis skill - Analyze type hierarchies and implementations
  */
 export const typeAnalysisSkill = defineSkill({
-    name: 'type-analysis',
-    description: 'Analyze type hierarchies, interfaces, and their implementations',
+    name: "type-analysis",
+    description: "Analyze type hierarchies, interfaces, and their implementations",
     prompt: `You are in TYPE ANALYSIS mode. Analyze type relationships in the codebase.
 
+## When to Use
+- Understanding interface implementations in the codebase
+- Exploring class inheritance hierarchies
+- Finding all concrete implementations of an abstract class
+- Checking which classes implement a specific interface
+
+## When NOT to Use
+- Planning to refactor a type → use refactor-impact skill first
+- Need general file structure → use code-structure skill
+- Looking for a specific symbol definition → use find_symbol directly
+
 ## TOOLS TO USE
 
 1. **get_type_hierarchy**: Analyze inheritance relationships
@@ -145,6 +156,6 @@ TypeName
 - Highlight incomplete implementations
 - Note generic type parameters when present
 - Keep diagrams simple - expand on request`,
-    tags: ['types', 'analysis', 'inheritance', 'interfaces', 'architecture'],
-    version: '1.0.0',
+    tags: ["types", "analysis", "inheritance", "interfaces", "architecture"],
+    version: "1.0.0",
 });

package/dist/tools/find-dead-code.d.ts

@@ -4,8 +4,8 @@
  * Find potentially unused exports, functions, and variables across a codebase.
  * Uses static analysis to identify code that may be dead.
  */
-import type { Tool } from '@compilr-dev/agents';
-import type { FindDeadCodeInput } from './types.js';
+import type { Tool } from "@compilr-dev/agents";
+import type { FindDeadCodeInput } from "./types.js";
 /**
  * findDeadCode tool
  */

package/dist/tools/find-dead-code.js

@@ -4,59 +4,59 @@
  * Find potentially unused exports, functions, and variables across a codebase.
  * Uses static analysis to identify code that may be dead.
  */
-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 potentially unused exports, functions, and variables.
 Analyzes the codebase to identify code that may be dead (never used).
 Useful for cleanup and reducing bundle size.`;
 // 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",
         },
         includeTests: {
-            type: 'boolean',
-            description: 'Include test files in analysis (default: false)',
+            type: "boolean",
+            description: "Include test files in analysis (default: false)",
             default: false,
         },
         checkExports: {
-            type: 'boolean',
-            description: 'Check for unused exports (default: true)',
+            type: "boolean",
+            description: "Check for unused exports (default: true)",
             default: true,
         },
         checkFunctions: {
-            type: 'boolean',
-            description: 'Check for unused functions (default: true)',
+            type: "boolean",
+            description: "Check for unused functions (default: true)",
             default: true,
         },
         checkVariables: {
-            type: 'boolean',
-            description: 'Check for unused variables (default: false)',
+            type: "boolean",
+            description: "Check for unused variables (default: false)",
             default: false,
         },
         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 TEST_PATTERNS = ['.test.', '.spec.', '__tests__', '__mocks__'];
+const DEFAULT_EXCLUDE = ["node_modules", "dist", "build", ".git", "coverage"];
+const TEST_PATTERNS = [".test.", ".spec.", "__tests__", "__mocks__"];
 /**
  * findDeadCode tool
  */
 export const findDeadCodeTool = defineTool({
-    name: 'find_dead_code',
+    name: "find_dead_code",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeFindDeadCode,
@@ -77,7 +77,7 @@ async function executeFindDeadCode(input) {
         }
         const stats = await fs.stat(resolvedPath);
         if (!stats.isDirectory()) {
-            return createErrorResult('findDeadCode requires a directory path');
+            return createErrorResult("findDeadCode requires a directory path");
         }
         // Collect files
         const files = [];
@@ -101,7 +101,7 @@ async function executeFindDeadCode(input) {
         let unusedVariables = 0;
         for (const def of definitions) {
             // Skip index files (re-exports)
-            if (def.path.endsWith('index.ts') || def.path.endsWith('index.js')) {
+            if (def.path.endsWith("index.ts") || def.path.endsWith("index.js")) {
                 continue;
             }
             const isUsed = usages.has(def.name) || importedSymbols.has(def.name);
@@ -117,16 +117,16 @@ async function executeFindDeadCode(input) {
                             name: def.name,
                             path: def.path,
                             line: def.line,
-                            kind: 'export',
+                            kind: "export",
                             exported: true,
-                            confidence: 'medium',
-                            reason: 'Export is not imported anywhere in the codebase',
+                            confidence: "medium",
+                            reason: "Export is not imported anywhere in the codebase",
                         });
                     }
                 }
             }
             // Check functions
-            if (def.kind === 'function' && checkFunctions) {
+            if (def.kind === "function" && checkFunctions) {
                 totalFunctions++;
                 if (!isUsed && !def.exported) {
                     unusedFunctions++;
@@ -134,15 +134,15 @@ async function executeFindDeadCode(input) {
                         name: def.name,
                         path: def.path,
                         line: def.line,
-                        kind: 'function',
+                        kind: "function",
                         exported: false,
-                        confidence: 'high',
-                        reason: 'Function is not called anywhere in the file',
+                        confidence: "high",
+                        reason: "Function is not called anywhere in the file",
                     });
                 }
             }
             // Check variables
-            if (def.kind === 'variable' && checkVariables) {
+            if (def.kind === "variable" && checkVariables) {
                 totalVariables++;
                 if (!isUsed && !def.exported) {
                     unusedVariables++;
@@ -150,10 +150,10 @@ async function executeFindDeadCode(input) {
                         name: def.name,
                         path: def.path,
                         line: def.line,
-                        kind: 'variable',
+                        kind: "variable",
                         exported: false,
-                        confidence: 'medium',
-                        reason: 'Variable is not referenced after declaration',
+                        confidence: "medium",
+                        reason: "Variable is not referenced after declaration",
                     });
                 }
             }
@@ -193,15 +193,17 @@ async function collectFiles(dirPath, files, includeTests, maxFiles, currentDepth
             if (entry.isDirectory()) {
                 if (DEFAULT_EXCLUDE.includes(entry.name))
                     continue;
-                if (!includeTests && entry.name === '__tests__')
+                if (!includeTests && entry.name === "__tests__")
                     continue;
                 await collectFiles(fullPath, files, includeTests, 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')) {
+                if (/\.(ts|tsx|js|jsx)$/.test(entry.name) &&
+                    !entry.name.endsWith(".d.ts")) {
                     // Skip test files if not including tests
-                    if (!includeTests && TEST_PATTERNS.some((p) => fullPath.includes(p))) {
+                    if (!includeTests &&
+                        TEST_PATTERNS.some((p) => fullPath.includes(p))) {
                         continue;
                     }
                     files.push(fullPath);
@@ -218,47 +220,51 @@ async function collectFiles(dirPath, files, includeTests, maxFiles, currentDepth
  */
 async function analyzeFile(filePath, definitions, usages, importedSymbols) {
     try {
-        const content = await fs.readFile(filePath, 'utf-8');
+        const content = await fs.readFile(filePath, "utf-8");
         const detection = detectLanguage(filePath);
         if (!detection.language || !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);
         // Collect definitions
         const visit = (node) => {
             const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
             // Function declarations
             if (ts.isFunctionDeclaration(node) && node.name) {
-                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ??
+                    false;
                 definitions.push({
                     name: node.name.text,
                     path: filePath,
                     line: line + 1,
-                    kind: 'function',
+                    kind: "function",
                     exported: isExported,
                 });
             }
             // Class declarations
             if (ts.isClassDeclaration(node) && node.name) {
-                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ??
+                    false;
                 definitions.push({
                     name: node.name.text,
                     path: filePath,
                     line: line + 1,
-                    kind: 'class',
+                    kind: "class",
                     exported: isExported,
                 });
             }
             // Variable declarations (const, let, var)
             if (ts.isVariableStatement(node)) {
-                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ??
+                    false;
                 for (const decl of node.declarationList.declarations) {
                     if (ts.isIdentifier(decl.name)) {
                         // Check if it's a function expression
                         const kind = decl.initializer &&
-                            (ts.isFunctionExpression(decl.initializer) || ts.isArrowFunction(decl.initializer))
-                            ? 'function'
-                            : 'variable';
+                            (ts.isFunctionExpression(decl.initializer) ||
+                                ts.isArrowFunction(decl.initializer))
+                            ? "function"
+                            : "variable";
                         definitions.push({
                             name: decl.name.text,
                             path: filePath,
@@ -271,41 +277,45 @@ async function analyzeFile(filePath, definitions, usages, importedSymbols) {
             }
             // Interface declarations
             if (ts.isInterfaceDeclaration(node)) {
-                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ??
+                    false;
                 definitions.push({
                     name: node.name.text,
                     path: filePath,
                     line: line + 1,
-                    kind: 'interface',
+                    kind: "interface",
                     exported: isExported,
                 });
             }
             // Type alias declarations
             if (ts.isTypeAliasDeclaration(node)) {
-                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ??
+                    false;
                 definitions.push({
                     name: node.name.text,
                     path: filePath,
                     line: line + 1,
-                    kind: 'type',
+                    kind: "type",
                     exported: isExported,
                 });
             }
             // Enum declarations
             if (ts.isEnumDeclaration(node)) {
-                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ??
+                    false;
                 definitions.push({
                     name: node.name.text,
                     path: filePath,
                     line: line + 1,
-                    kind: 'enum',
+                    kind: "enum",
                     exported: isExported,
                 });
             }
             // Import declarations - track what's imported
             if (ts.isImportDeclaration(node) && node.importClause) {
                 // Named imports
-                if (node.importClause.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
+                if (node.importClause.namedBindings &&
+                    ts.isNamedImports(node.importClause.namedBindings)) {
                     for (const specifier of node.importClause.namedBindings.elements) {
                         importedSymbols.add(specifier.name.text);
                     }
@@ -344,13 +354,27 @@ async function analyzeFile(filePath, definitions, usages, importedSymbols) {
  */
 function isLikelyEntryPoint(filePath, symbolName) {
     // Main entry files
-    const entryPatterns = ['index.ts', 'index.js', 'main.ts', 'main.js', 'app.ts', 'app.js'];
+    const entryPatterns = [
+        "index.ts",
+        "index.js",
+        "main.ts",
+        "main.js",
+        "app.ts",
+        "app.js",
+    ];
     const fileName = path.basename(filePath);
     if (entryPatterns.includes(fileName)) {
         return true;
     }
     // Common exported names that are likely entry points
-    const entrySymbols = ['default', 'main', 'app', 'handler', 'server', 'client'];
+    const entrySymbols = [
+        "default",
+        "main",
+        "app",
+        "handler",
+        "server",
+        "client",
+    ];
     if (entrySymbols.includes(symbolName.toLowerCase())) {
         return true;
     }
@@ -361,7 +385,7 @@ function isLikelyEntryPoint(filePath, symbolName) {
  */
 export function createFindDeadCodeTool(options) {
     return defineTool({
-        name: options?.name ?? 'find_dead_code',
+        name: options?.name ?? "find_dead_code",
         description: options?.description ?? TOOL_DESCRIPTION,
         inputSchema: TOOL_INPUT_SCHEMA,
         execute: async (input) => {

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

@@ -4,8 +4,8 @@
  * Detect duplicate code blocks across the codebase using content hashing.
  * Helps identify opportunities for refactoring and code reuse.
  */
-import type { Tool } from '@compilr-dev/agents';
-import type { FindDuplicatesInput } from './types.js';
+import type { Tool } from "@compilr-dev/agents";
+import type { FindDuplicatesInput } from "./types.js";
 /**
  * findDuplicates tool
  */

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