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

package/dist/tools/find-symbol.js

@@ -4,21 +4,21 @@
  * Find the definition location of a symbol across the codebase.
  * Uses TypeScript Compiler API for accurate AST analysis.
  */
-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";
 // Supported file extensions for searching
 const SUPPORTED_EXTENSIONS = new Set([
-    '.ts',
-    '.tsx',
-    '.js',
-    '.jsx',
-    '.mts',
-    '.mjs',
-    '.cts',
-    '.cjs',
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mts",
+    ".mjs",
+    ".cts",
+    ".cjs",
 ]);
 // Helper to check for a specific modifier kind
 function hasModifierKind(modifiers, kind) {
@@ -30,50 +30,50 @@ Returns structured JSON with file path, line number, symbol kind, and other meta
 Use this to locate where functions, classes, variables, types, etc. are defined.`;
 // Tool input schema
 const TOOL_INPUT_SCHEMA = {
-    type: 'object',
+    type: "object",
     properties: {
         symbol: {
-            type: 'string',
-            description: 'Symbol name to find',
+            type: "string",
+            description: "Symbol name to find",
         },
         scope: {
-            type: 'string',
-            description: 'Scope the search to a specific file or directory',
+            type: "string",
+            description: "Scope the search to a specific file or directory",
         },
         kind: {
-            type: 'string',
+            type: "string",
             enum: [
-                'function',
-                'class',
-                'variable',
-                'type',
-                'interface',
-                'enum',
-                'method',
-                'property',
-                'any',
+                "function",
+                "class",
+                "variable",
+                "type",
+                "interface",
+                "enum",
+                "method",
+                "property",
+                "any",
             ],
-            description: 'Filter by symbol kind (default: any)',
-            default: 'any',
+            description: "Filter by symbol kind (default: any)",
+            default: "any",
         },
         limit: {
-            type: 'number',
-            description: 'Maximum results to return (default: 10)',
+            type: "number",
+            description: "Maximum results to return (default: 10)",
             default: 10,
         },
         includeNodeModules: {
-            type: 'boolean',
-            description: 'Include symbols from node_modules (default: false)',
+            type: "boolean",
+            description: "Include symbols from node_modules (default: false)",
             default: false,
         },
     },
-    required: ['symbol'],
+    required: ["symbol"],
 };
 /**
  * findSymbol tool - Find symbol definitions
  */
 export const findSymbolTool = defineTool({
-    name: 'find_symbol',
+    name: "find_symbol",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeFindSymbol,
@@ -82,10 +82,10 @@ export const findSymbolTool = defineTool({
  * Execute the findSymbol tool
  */
 async function executeFindSymbol(input) {
-    const { symbol, scope, kind = 'any', limit = 10, includeNodeModules = false } = input;
+    const { symbol, scope, kind = "any", limit = 10, includeNodeModules = false, } = input;
     // Validate input
     if (!symbol || symbol.trim().length === 0) {
-        return createErrorResult('Symbol name is required');
+        return createErrorResult("Symbol name is required");
     }
     const startTime = Date.now();
     const definitions = [];
@@ -152,14 +152,14 @@ async function collectFiles(dir, includeNodeModules) {
             const fullPath = path.join(currentDir, entry.name);
             if (entry.isDirectory()) {
                 // Skip node_modules unless explicitly included
-                if (entry.name === 'node_modules' && !includeNodeModules) {
+                if (entry.name === "node_modules" && !includeNodeModules) {
                     continue;
                 }
                 // Skip common non-source directories
-                if (entry.name.startsWith('.') ||
-                    entry.name === 'dist' ||
-                    entry.name === 'build' ||
-                    entry.name === 'coverage') {
+                if (entry.name.startsWith(".") ||
+                    entry.name === "dist" ||
+                    entry.name === "build" ||
+                    entry.name === "coverage") {
                     continue;
                 }
                 await walk(fullPath);
@@ -181,7 +181,7 @@ async function collectFiles(dir, includeNodeModules) {
 async function searchFileForSymbol(filePath, symbolName, kindFilter) {
     const definitions = [];
     try {
-        const sourceCode = await fs.readFile(filePath, 'utf-8');
+        const sourceCode = await fs.readFile(filePath, "utf-8");
         const scriptKind = getScriptKind(filePath);
         const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true, scriptKind);
         // Search for symbols
@@ -196,21 +196,21 @@ async function searchFileForSymbol(filePath, symbolName, kindFilter) {
  * Get TypeScript script kind from file extension
  */
 function getScriptKind(filePath) {
-    const ext = filePath.toLowerCase().split('.').pop();
+    const ext = filePath.toLowerCase().split(".").pop();
     switch (ext) {
-        case 'ts':
+        case "ts":
             return ts.ScriptKind.TS;
-        case 'tsx':
+        case "tsx":
             return ts.ScriptKind.TSX;
-        case 'js':
+        case "js":
             return ts.ScriptKind.JS;
-        case 'jsx':
+        case "jsx":
             return ts.ScriptKind.JSX;
-        case 'mts':
-        case 'cts':
+        case "mts":
+        case "cts":
             return ts.ScriptKind.TS;
-        case 'mjs':
-        case 'cjs':
+        case "mjs":
+        case "cjs":
             return ts.ScriptKind.JS;
         default:
             return ts.ScriptKind.TS;
@@ -244,40 +244,42 @@ function extractSymbolDefinition(node, sourceFile, symbolName, kindFilter, fileP
     let exported = false;
     let signature;
     let docSummary;
-    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+    const modifiers = ts.canHaveModifiers(node)
+        ? ts.getModifiers(node)
+        : undefined;
     exported = hasModifierKind(modifiers, ts.SyntaxKind.ExportKeyword);
     // Function declarations
     if (ts.isFunctionDeclaration(node) && node.name) {
         name = node.name.text;
-        kind = 'function';
+        kind = "function";
         signature = buildFunctionSignature(node);
         docSummary = getJsDocSummary(node, sourceFile);
     }
     // Class declarations
     else if (ts.isClassDeclaration(node) && node.name) {
         name = node.name.text;
-        kind = 'class';
+        kind = "class";
         signature = `class ${name}`;
         docSummary = getJsDocSummary(node, sourceFile);
     }
     // Interface declarations
     else if (ts.isInterfaceDeclaration(node)) {
         name = node.name.text;
-        kind = 'interface';
+        kind = "interface";
         signature = `interface ${name}`;
         docSummary = getJsDocSummary(node, sourceFile);
     }
     // Type alias declarations
     else if (ts.isTypeAliasDeclaration(node)) {
         name = node.name.text;
-        kind = 'type';
+        kind = "type";
         signature = `type ${name}`;
         docSummary = getJsDocSummary(node, sourceFile);
     }
     // Enum declarations
     else if (ts.isEnumDeclaration(node)) {
         name = node.name.text;
-        kind = 'enum';
+        kind = "enum";
         signature = `enum ${name}`;
         docSummary = getJsDocSummary(node, sourceFile);
     }
@@ -285,39 +287,42 @@ function extractSymbolDefinition(node, sourceFile, symbolName, kindFilter, fileP
     else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
         // Skip if this is a function (arrow function or function expression)
         if (node.initializer &&
-            (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+            (ts.isArrowFunction(node.initializer) ||
+                ts.isFunctionExpression(node.initializer))) {
             name = node.name.text;
-            kind = 'function';
+            kind = "function";
             signature = buildArrowFunctionSignature(node);
         }
         else {
             name = node.name.text;
-            kind = 'variable';
+            kind = "variable";
             signature = `${getVariableKind(node)} ${name}`;
         }
         // Check parent for export status
         const parent = node.parent.parent;
         if (ts.isVariableStatement(parent)) {
-            const parentMods = ts.canHaveModifiers(parent) ? ts.getModifiers(parent) : undefined;
+            const parentMods = ts.canHaveModifiers(parent)
+                ? ts.getModifiers(parent)
+                : undefined;
             exported = hasModifierKind(parentMods, ts.SyntaxKind.ExportKeyword);
             docSummary = getJsDocSummary(parent, sourceFile);
         }
     }
     // Method declarations (inside classes)
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- node.name can be undefined for computed properties
-    else if (ts.isMethodDeclaration(node) && node.name && ts.isIdentifier(node.name)) {
+    else if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) {
         name = node.name.text;
-        kind = 'method';
+        kind = "method";
         signature = buildMethodSignature(node);
         docSummary = getJsDocSummary(node, sourceFile);
         // Methods are exported if their containing class is exported
     }
     // Property declarations (inside classes)
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- node.name can be undefined for computed properties
-    else if (ts.isPropertyDeclaration(node) && node.name && ts.isIdentifier(node.name)) {
+    else if (ts.isPropertyDeclaration(node) && ts.isIdentifier(node.name)) {
         name = node.name.text;
-        kind = 'property';
-        const typeAnnotation = node.type ? `: ${node.type.getText(sourceFile)}` : '';
+        kind = "property";
+        const typeAnnotation = node.type
+            ? `: ${node.type.getText(sourceFile)}`
+            : "";
         signature = `${name}${typeAnnotation}`;
         docSummary = getJsDocSummary(node, sourceFile);
     }
@@ -329,9 +334,9 @@ function extractSymbolDefinition(node, sourceFile, symbolName, kindFilter, fileP
         return null;
     }
     // Apply kind filter
-    if (kindFilter !== 'any' && kind !== kindFilter) {
+    if (kindFilter !== "any" && kind !== kindFilter) {
         // Handle type filter matching both 'type' and 'interface'
-        if (kindFilter === 'type' && kind === 'interface') {
+        if (kindFilter === "type" && kind === "interface") {
             // Allow interface to match type filter
         }
         else {
@@ -360,64 +365,69 @@ function getVariableKind(node) {
     const parent = node.parent;
     if (ts.isVariableDeclarationList(parent)) {
         if (parent.flags & ts.NodeFlags.Const)
-            return 'const';
+            return "const";
         if (parent.flags & ts.NodeFlags.Let)
-            return 'let';
+            return "let";
     }
-    return 'var';
+    return "var";
 }
 /**
  * Build a function signature string
  */
 function buildFunctionSignature(node) {
-    const name = node.name?.text ?? 'anonymous';
+    const name = node.name?.text ?? "anonymous";
     const params = node.parameters
         .map((p) => {
-        const paramName = ts.isIdentifier(p.name) ? p.name.text : 'param';
-        const paramType = p.type ? p.type.getText() : '';
+        const paramName = ts.isIdentifier(p.name) ? p.name.text : "param";
+        const paramType = p.type ? p.type.getText() : "";
         return paramType ? `${paramName}: ${paramType}` : paramName;
     })
-        .join(', ');
-    const returnType = node.type ? `: ${node.type.getText()}` : '';
+        .join(", ");
+    const returnType = node.type ? `: ${node.type.getText()}` : "";
     const asyncPrefix = hasModifierKind(ts.getModifiers(node), ts.SyntaxKind.AsyncKeyword)
-        ? 'async '
-        : '';
+        ? "async "
+        : "";
     return `${asyncPrefix}function ${name}(${params})${returnType}`;
 }
 /**
  * Build a method signature string
  */
 function buildMethodSignature(node) {
-    const name = ts.isIdentifier(node.name) ? node.name.text : 'method';
+    const name = ts.isIdentifier(node.name) ? node.name.text : "method";
     const params = node.parameters
         .map((p) => {
-        const paramName = ts.isIdentifier(p.name) ? p.name.text : 'param';
-        const paramType = p.type ? p.type.getText() : '';
+        const paramName = ts.isIdentifier(p.name) ? p.name.text : "param";
+        const paramType = p.type ? p.type.getText() : "";
         return paramType ? `${paramName}: ${paramType}` : paramName;
     })
-        .join(', ');
-    const returnType = node.type ? `: ${node.type.getText()}` : '';
+        .join(", ");
+    const returnType = node.type ? `: ${node.type.getText()}` : "";
     const modifiers = ts.getModifiers(node);
-    const asyncPrefix = hasModifierKind(modifiers, ts.SyntaxKind.AsyncKeyword) ? 'async ' : '';
-    const staticPrefix = hasModifierKind(modifiers, ts.SyntaxKind.StaticKeyword) ? 'static ' : '';
+    const asyncPrefix = hasModifierKind(modifiers, ts.SyntaxKind.AsyncKeyword)
+        ? "async "
+        : "";
+    const staticPrefix = hasModifierKind(modifiers, ts.SyntaxKind.StaticKeyword)
+        ? "static "
+        : "";
     return `${staticPrefix}${asyncPrefix}${name}(${params})${returnType}`;
 }
 /**
  * Build an arrow function signature string from variable declaration
  */
 function buildArrowFunctionSignature(node) {
-    const name = ts.isIdentifier(node.name) ? node.name.text : 'anonymous';
+    const name = ts.isIdentifier(node.name) ? node.name.text : "anonymous";
     if (node.initializer &&
-        (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+        (ts.isArrowFunction(node.initializer) ||
+            ts.isFunctionExpression(node.initializer))) {
         const func = node.initializer;
         const params = func.parameters
             .map((p) => {
-            const paramName = ts.isIdentifier(p.name) ? p.name.text : 'param';
-            const paramType = p.type ? p.type.getText() : '';
+            const paramName = ts.isIdentifier(p.name) ? p.name.text : "param";
+            const paramType = p.type ? p.type.getText() : "";
             return paramType ? `${paramName}: ${paramType}` : paramName;
         })
-            .join(', ');
-        const returnType = func.type ? `: ${func.type.getText()}` : '';
+            .join(", ");
+        const returnType = func.type ? `: ${func.type.getText()}` : "";
         return `const ${name} = (${params})${returnType}`;
     }
     return `const ${name}`;
@@ -444,7 +454,7 @@ function getJsDocSummary(node, sourceFile) {
 export function createFindSymbolTool(options) {
     const { defaultLimit = 10, defaultIncludeNodeModules = false } = options ?? {};
     return defineTool({
-        name: 'find_symbol',
+        name: "find_symbol",
         description: TOOL_DESCRIPTION,
         inputSchema: TOOL_INPUT_SCHEMA,
         execute: async (input) => {

package/dist/tools/get-call-graph.d.ts

@@ -4,8 +4,8 @@
  * Analyze function call relationships using TypeScript Compiler API.
  * Returns a call graph showing what functions call what.
  */
-import type { Tool } from '@compilr-dev/agents';
-import type { GetCallGraphInput, CallGraphDirection } from './types.js';
+import type { Tool } from "@compilr-dev/agents";
+import type { GetCallGraphInput, CallGraphDirection } from "./types.js";
 /**
  * getCallGraph tool - Analyze function call relationships
  */

package/dist/tools/get-call-graph.js

@@ -4,54 +4,54 @@
  * Analyze function call relationships using TypeScript Compiler API.
  * Returns a call graph showing what functions call what.
  */
-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 = `Analyze function call relationships in source code.
 Returns a call graph showing which functions call which other functions.
 Use this to understand code flow, dependencies, and refactoring impact.`;
 // Tool input schema
 const TOOL_INPUT_SCHEMA = {
-    type: 'object',
+    type: "object",
     properties: {
         path: {
-            type: 'string',
-            description: 'File to analyze',
+            type: "string",
+            description: "File to analyze",
         },
         functionName: {
-            type: 'string',
-            description: 'Specific function to analyze (optional)',
+            type: "string",
+            description: "Specific function to analyze (optional)",
         },
         direction: {
-            type: 'string',
-            enum: ['callers', 'callees', 'both'],
+            type: "string",
+            enum: ["callers", "callees", "both"],
             description: "Direction: 'callers' | 'callees' | 'both' (default: 'both')",
         },
         maxDepth: {
-            type: 'number',
-            description: 'Maximum depth to traverse (default: 2)',
+            type: "number",
+            description: "Maximum depth to traverse (default: 2)",
             default: 2,
         },
         includeExternal: {
-            type: 'boolean',
-            description: 'Include external package calls (default: false)',
+            type: "boolean",
+            description: "Include external package calls (default: false)",
             default: false,
         },
         scope: {
-            type: 'string',
+            type: "string",
             description: "Scope directory for finding callers (default: file's directory)",
         },
     },
-    required: ['path'],
+    required: ["path"],
 };
 /**
  * getCallGraph tool - Analyze function call relationships
  */
 export const getCallGraphTool = defineTool({
-    name: 'get_call_graph',
+    name: "get_call_graph",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeGetCallGraph,
@@ -60,10 +60,10 @@ export const getCallGraphTool = defineTool({
  * Execute the getCallGraph tool
  */
 async function executeGetCallGraph(input) {
-    const { path: inputPath, functionName, direction = 'both', maxDepth = 2, includeExternal = false, scope, } = input;
+    const { path: inputPath, functionName, direction = "both", maxDepth = 2, includeExternal = false, scope, } = input;
     // Validate input
     if (!inputPath || inputPath.trim().length === 0) {
-        return createErrorResult('Path is required');
+        return createErrorResult("Path is required");
     }
     try {
         // Check if path exists
@@ -96,7 +96,7 @@ async function executeGetCallGraph(input) {
  * Analyze call graph for a file
  */
 async function analyzeCallGraph(filePath, functionName, direction, maxDepth, includeExternal, _scopeDir) {
-    const sourceCode = await fs.readFile(filePath, 'utf-8');
+    const sourceCode = await fs.readFile(filePath, "utf-8");
     const scriptKind = getScriptKind(filePath);
     const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true, scriptKind);
     // Find all functions in the file
@@ -122,7 +122,7 @@ async function analyzeCallGraph(filePath, functionName, direction, maxDepth, inc
         rootNode = targetFunc.node;
     }
     // Analyze callees (what each function calls)
-    if (direction === 'callees' || direction === 'both') {
+    if (direction === "callees" || direction === "both") {
         const functionsToAnalyze = functionName
             ? functions.filter((f) => f.node.name === functionName)
             : functions;
@@ -140,12 +140,12 @@ async function analyzeCallGraph(filePath, functionName, direction, maxDepth, inc
             graphNode.calls = callees;
             // Count external calls
             if (includeExternal) {
-                externalCallCount += callees.filter((c) => c.function.path === 'external').length;
+                externalCallCount += callees.filter((c) => c.function.path === "external").length;
             }
         }
     }
     // Analyze callers (what calls each function)
-    if (direction === 'callers' || direction === 'both') {
+    if (direction === "callers" || direction === "both") {
         const functionsToAnalyze = functionName
             ? functions.filter((f) => f.node.name === functionName)
             : functions;
@@ -208,7 +208,8 @@ function extractFunctions(sourceFile, filePath) {
             const decls = node.declarationList.declarations;
             for (const decl of decls) {
                 if (ts.isIdentifier(decl.name) && decl.initializer) {
-                    if (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) {
+                    if (ts.isArrowFunction(decl.initializer) ||
+                        ts.isFunctionExpression(decl.initializer)) {
                         const { line, character } = sourceFile.getLineAndCharacterOfPosition(decl.getStart(sourceFile));
                         const isExported = hasExportModifier(node);
                         const isAsync = hasAsyncModifier(decl.initializer);
@@ -295,7 +296,7 @@ function extractCallees(sourceFile, func, allFunctions, includeExternal) {
 function extractCallInfo(node, sourceFile, allFunctions, includeExternal) {
     const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
     let funcName;
-    let callType = 'direct';
+    let callType = "direct";
     let className;
     // Simple function call: funcName()
     if (ts.isIdentifier(node.expression)) {
@@ -306,14 +307,14 @@ function extractCallInfo(node, sourceFile, allFunctions, includeExternal) {
         funcName = node.expression.name.text;
         const propName = node.expression.name.text;
         // Check for promise chain
-        if (propName === 'then' || propName === 'catch' || propName === 'finally') {
-            callType = 'promise';
+        if (propName === "then" || propName === "catch" || propName === "finally") {
+            callType = "promise";
         }
         else {
-            callType = 'method';
+            callType = "method";
             if (ts.isIdentifier(node.expression.expression)) {
                 const objName = node.expression.expression.text;
-                if (objName !== 'this') {
+                if (objName !== "this") {
                     // Could be instance.method or ClassName.staticMethod
                     className = objName;
                 }
@@ -339,7 +340,7 @@ function extractCallInfo(node, sourceFile, allFunctions, includeExternal) {
         return {
             function: {
                 name: funcName,
-                path: 'external',
+                path: "external",
                 line: 0,
                 column: 0,
                 className,
@@ -403,7 +404,7 @@ function findCallersInFile(sourceFile, targetFuncName, allFunctions, _filePath)
                 function: func.node,
                 callLine,
                 callColumn,
-                type: 'direct',
+                type: "direct",
                 count: callCount,
             });
         }
@@ -414,35 +415,39 @@ function findCallersInFile(sourceFile, targetFuncName, allFunctions, _filePath)
  * Check if a node has export modifier
  */
 function hasExportModifier(node) {
-    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
-    return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+    const modifiers = ts.canHaveModifiers(node)
+        ? ts.getModifiers(node)
+        : undefined;
+    return (modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
 }
 /**
  * Check if a node has async modifier
  */
 function hasAsyncModifier(node) {
-    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+    const modifiers = ts.canHaveModifiers(node)
+        ? ts.getModifiers(node)
+        : undefined;
     return modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
 }
 /**
  * Get TypeScript script kind from file extension
  */
 function getScriptKind(filePath) {
-    const ext = filePath.toLowerCase().split('.').pop();
+    const ext = filePath.toLowerCase().split(".").pop();
     switch (ext) {
-        case 'ts':
+        case "ts":
             return ts.ScriptKind.TS;
-        case 'tsx':
+        case "tsx":
             return ts.ScriptKind.TSX;
-        case 'js':
+        case "js":
             return ts.ScriptKind.JS;
-        case 'jsx':
+        case "jsx":
             return ts.ScriptKind.JSX;
-        case 'mts':
-        case 'cts':
+        case "mts":
+        case "cts":
             return ts.ScriptKind.TS;
-        case 'mjs':
-        case 'cjs':
+        case "mjs":
+        case "cjs":
             return ts.ScriptKind.JS;
         default:
             return ts.ScriptKind.TS;
@@ -452,9 +457,9 @@ function getScriptKind(filePath) {
  * Factory function to create a customized getCallGraph tool
  */
 export function createGetCallGraphTool(options) {
-    const { defaultDirection = 'both', defaultMaxDepth = 2, defaultIncludeExternal = false, } = options ?? {};
+    const { defaultDirection = "both", defaultMaxDepth = 2, defaultIncludeExternal = false, } = options ?? {};
     return defineTool({
-        name: 'get_call_graph',
+        name: "get_call_graph",
         description: TOOL_DESCRIPTION,
         inputSchema: TOOL_INPUT_SCHEMA,
         execute: async (input) => {

package/dist/tools/get-complexity.d.ts

@@ -4,8 +4,8 @@
  * Calculate code complexity metrics including cyclomatic complexity,
  * cognitive complexity, nesting depth, and identify complexity hotspots.
  */
-import type { Tool } from '@compilr-dev/agents';
-import type { GetComplexityInput } from './types.js';
+import type { Tool } from "@compilr-dev/agents";
+import type { GetComplexityInput } from "./types.js";
 /**
  * getComplexity tool
  */