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

package/dist/tools/get-signature.js

@@ -4,49 +4,49 @@
  * Get detailed signature information for a function, method, class, or type.
  * Includes parameters, return types, generics, and documentation.
  */
-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 = `Get detailed signature information for a function, method, class, interface, or type.
 Returns parameters with types, return type, generics, and extracted documentation (JSDoc/TSDoc).
 Useful for understanding API contracts without reading full source code.`;
 // Tool input schema
 const TOOL_INPUT_SCHEMA = {
-    type: 'object',
+    type: "object",
     properties: {
         path: {
-            type: 'string',
-            description: 'File containing the symbol',
+            type: "string",
+            description: "File containing the symbol",
         },
         name: {
-            type: 'string',
-            description: 'Symbol name to get signature for',
+            type: "string",
+            description: "Symbol name to get signature for",
         },
         line: {
-            type: 'number',
-            description: 'Line number for disambiguation (optional)',
+            type: "number",
+            description: "Line number for disambiguation (optional)",
         },
         includeDoc: {
-            type: 'boolean',
-            description: 'Include full documentation (default: true)',
+            type: "boolean",
+            description: "Include full documentation (default: true)",
             default: true,
         },
         expandTypes: {
-            type: 'boolean',
-            description: 'Expand type aliases (default: false)',
+            type: "boolean",
+            description: "Expand type aliases (default: false)",
             default: false,
         },
     },
-    required: ['path', 'name'],
+    required: ["path", "name"],
 };
 /**
  * getSignature tool
  */
 export const getSignatureTool = defineTool({
-    name: 'get_signature',
+    name: "get_signature",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeGetSignature,
@@ -55,7 +55,7 @@ export const getSignatureTool = defineTool({
  * Execute the getSignature tool
  */
 async function executeGetSignature(input) {
-    const { path: inputPath, name, line, includeDoc = true, expandTypes = false } = input;
+    const { path: inputPath, name, line, includeDoc = true, expandTypes = false, } = input;
     try {
         const resolvedPath = path.resolve(inputPath);
         // Check if file exists
@@ -70,8 +70,8 @@ async function executeGetSignature(input) {
         if (!detection.language || !isLanguageSupported(detection.language)) {
             return createErrorResult(`Unsupported language for file: ${resolvedPath}`);
         }
-        const content = await fs.readFile(resolvedPath, 'utf-8');
-        const sourceFile = ts.createSourceFile(resolvedPath, content, ts.ScriptTarget.Latest, true, resolvedPath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+        const content = await fs.readFile(resolvedPath, "utf-8");
+        const sourceFile = ts.createSourceFile(resolvedPath, content, ts.ScriptTarget.Latest, true, resolvedPath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
         // Find the symbol
         const result = findSymbolSignature(sourceFile, name, line, includeDoc, expandTypes);
         if (!result) {
@@ -108,48 +108,49 @@ function findSymbolSignature(sourceFile, symbolName, targetLine, includeDoc, _ex
         // Function declarations
         if (ts.isFunctionDeclaration(node) && node.name?.text === symbolName) {
             found.node = node;
-            found.kind = 'function';
+            found.kind = "function";
         }
         // Variable declarations (arrow functions, const functions)
         else if (ts.isVariableDeclaration(node) &&
             ts.isIdentifier(node.name) &&
             node.name.text === symbolName) {
             if (node.initializer &&
-                (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+                (ts.isArrowFunction(node.initializer) ||
+                    ts.isFunctionExpression(node.initializer))) {
                 found.node = node;
-                found.kind = 'function';
+                found.kind = "function";
             }
             else {
                 found.node = node;
-                found.kind = 'variable';
+                found.kind = "variable";
             }
         }
         // Class declarations
         else if (ts.isClassDeclaration(node) && node.name?.text === symbolName) {
             found.node = node;
-            found.kind = 'class';
+            found.kind = "class";
         }
         // Interface declarations
         else if (ts.isInterfaceDeclaration(node) && node.name.text === symbolName) {
             found.node = node;
-            found.kind = 'interface';
+            found.kind = "interface";
         }
         // Type alias declarations
         else if (ts.isTypeAliasDeclaration(node) && node.name.text === symbolName) {
             found.node = node;
-            found.kind = 'type';
+            found.kind = "type";
         }
         // Enum declarations
         else if (ts.isEnumDeclaration(node) && node.name.text === symbolName) {
             found.node = node;
-            found.kind = 'enum';
+            found.kind = "enum";
         }
         // Method declarations (inside classes)
         else if (ts.isMethodDeclaration(node) &&
             ts.isIdentifier(node.name) &&
             node.name.text === symbolName) {
             found.node = node;
-            found.kind = 'method';
+            found.kind = "method";
         }
         ts.forEachChild(node, visit);
     };
@@ -166,21 +167,23 @@ function extractSignature(node, kind, sourceFile, includeDoc) {
     const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
     const exported = isExported(node);
     const name = getNodeName(node);
-    const documentation = includeDoc ? extractDocumentation(node, sourceFile) : undefined;
+    const documentation = includeDoc
+        ? extractDocumentation(node, sourceFile)
+        : undefined;
     switch (kind) {
-        case 'function':
+        case "function":
             return extractFunctionSignature(node, sourceFile, name, line + 1, exported, documentation);
-        case 'method':
+        case "method":
             return extractMethodSignature(node, sourceFile, name, line + 1, exported, documentation);
-        case 'class':
+        case "class":
             return extractClassSignature(node, sourceFile, name, line + 1, exported, documentation);
-        case 'interface':
+        case "interface":
             return extractInterfaceSignature(node, sourceFile, name, line + 1, exported, documentation);
-        case 'type':
+        case "type":
             return extractTypeSignature(node, sourceFile, name, line + 1, exported, documentation);
-        case 'enum':
+        case "enum":
             return extractEnumSignature(node, sourceFile, name, line + 1, exported, documentation);
-        case 'variable':
+        case "variable":
             return extractVariableSignature(node, sourceFile, name, line + 1, exported, documentation);
         default:
             return {
@@ -208,7 +211,7 @@ function extractFunctionSignature(node, sourceFile, name, line, exported, docume
     else {
         return {
             name,
-            kind: 'function',
+            kind: "function",
             line,
             signature: node.getText(sourceFile),
             formattedSignature: node.getText(sourceFile),
@@ -219,17 +222,20 @@ function extractFunctionSignature(node, sourceFile, name, line, exported, docume
     const parameters = extractParameters(funcNode.parameters, sourceFile, documentation);
     const returnType = extractReturnType(funcNode, sourceFile);
     const generics = extractGenerics(funcNode.typeParameters, sourceFile);
-    const isAsync = funcNode.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+    const isAsync = funcNode.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ??
+        false;
     // Build signature string
-    const asyncPrefix = isAsync ? 'async ' : '';
-    const genericsStr = generics.length > 0 ? `<${generics.map((g) => formatGeneric(g)).join(', ')}>` : '';
-    const paramsStr = parameters.map((p) => formatParameter(p)).join(', ');
-    const returnStr = returnType ? `: ${returnType.type}` : '';
+    const asyncPrefix = isAsync ? "async " : "";
+    const genericsStr = generics.length > 0
+        ? `<${generics.map((g) => formatGeneric(g)).join(", ")}>`
+        : "";
+    const paramsStr = parameters.map((p) => formatParameter(p)).join(", ");
+    const returnStr = returnType ? `: ${returnType.type}` : "";
     const signature = `${asyncPrefix}function ${name}${genericsStr}(${paramsStr})${returnStr}`;
     const formattedSignature = formatMultilineSignature(asyncPrefix, name, genericsStr, parameters, returnType);
     return {
         name,
-        kind: 'function',
+        kind: "function",
         line,
         signature,
         formattedSignature,
@@ -248,17 +254,20 @@ function extractMethodSignature(node, sourceFile, name, line, exported, document
     const returnType = extractReturnType(node, sourceFile);
     const generics = extractGenerics(node.typeParameters, sourceFile);
     const isAsync = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-    const isStatic = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword) ?? false;
-    const asyncPrefix = isAsync ? 'async ' : '';
-    const staticPrefix = isStatic ? 'static ' : '';
-    const genericsStr = generics.length > 0 ? `<${generics.map((g) => formatGeneric(g)).join(', ')}>` : '';
-    const paramsStr = parameters.map((p) => formatParameter(p)).join(', ');
-    const returnStr = returnType ? `: ${returnType.type}` : '';
+    const isStatic = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword) ??
+        false;
+    const asyncPrefix = isAsync ? "async " : "";
+    const staticPrefix = isStatic ? "static " : "";
+    const genericsStr = generics.length > 0
+        ? `<${generics.map((g) => formatGeneric(g)).join(", ")}>`
+        : "";
+    const paramsStr = parameters.map((p) => formatParameter(p)).join(", ");
+    const returnStr = returnType ? `: ${returnType.type}` : "";
     const signature = `${staticPrefix}${asyncPrefix}${name}${genericsStr}(${paramsStr})${returnStr}`;
     const formattedSignature = signature;
     return {
         name,
-        kind: 'method',
+        kind: "method",
         line,
         signature,
         formattedSignature,
@@ -280,29 +289,32 @@ function extractClassSignature(node, sourceFile, name, line, exported, documenta
     let constructorSignature;
     if (constructor) {
         const params = extractParameters(constructor.parameters, sourceFile, undefined);
-        constructorSignature = `constructor(${params.map((p) => formatParameter(p)).join(', ')})`;
+        constructorSignature = `constructor(${params.map((p) => formatParameter(p)).join(", ")})`;
     }
     // Build extends/implements
-    let heritage = '';
+    let heritage = "";
     if (node.heritageClauses) {
         for (const clause of node.heritageClauses) {
             const tokenKind = clause.token;
             if (tokenKind === ts.SyntaxKind.ExtendsKeyword) {
-                heritage += ` extends ${clause.types.map((t) => t.getText(sourceFile)).join(', ')}`;
+                heritage += ` extends ${clause.types.map((t) => t.getText(sourceFile)).join(", ")}`;
             }
             else if (tokenKind === ts.SyntaxKind.ImplementsKeyword) {
-                heritage += ` implements ${clause.types.map((t) => t.getText(sourceFile)).join(', ')}`;
+                heritage += ` implements ${clause.types.map((t) => t.getText(sourceFile)).join(", ")}`;
             }
         }
     }
-    const isAbstract = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword) ?? false;
-    const abstractPrefix = isAbstract ? 'abstract ' : '';
-    const genericsStr = generics.length > 0 ? `<${generics.map((g) => formatGeneric(g)).join(', ')}>` : '';
+    const isAbstract = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword) ??
+        false;
+    const abstractPrefix = isAbstract ? "abstract " : "";
+    const genericsStr = generics.length > 0
+        ? `<${generics.map((g) => formatGeneric(g)).join(", ")}>`
+        : "";
     const signature = `${abstractPrefix}class ${name}${genericsStr}${heritage}`;
     const formattedSignature = signature;
     return {
         name,
-        kind: 'class',
+        kind: "class",
         line,
         signature,
         formattedSignature,
@@ -320,18 +332,20 @@ function extractInterfaceSignature(node, sourceFile, name, line, exported, docum
     const generics = extractGenerics(node.typeParameters, sourceFile);
     const members = extractInterfaceMembers(node, sourceFile);
     // Build extends
-    let heritage = '';
+    let heritage = "";
     if (node.heritageClauses) {
         for (const clause of node.heritageClauses) {
-            heritage += ` extends ${clause.types.map((t) => t.getText(sourceFile)).join(', ')}`;
+            heritage += ` extends ${clause.types.map((t) => t.getText(sourceFile)).join(", ")}`;
         }
     }
-    const genericsStr = generics.length > 0 ? `<${generics.map((g) => formatGeneric(g)).join(', ')}>` : '';
+    const genericsStr = generics.length > 0
+        ? `<${generics.map((g) => formatGeneric(g)).join(", ")}>`
+        : "";
     const signature = `interface ${name}${genericsStr}${heritage}`;
     const formattedSignature = signature;
     return {
         name,
-        kind: 'interface',
+        kind: "interface",
         line,
         signature,
         formattedSignature,
@@ -347,15 +361,17 @@ function extractInterfaceSignature(node, sourceFile, name, line, exported, docum
 function extractTypeSignature(node, sourceFile, name, line, exported, documentation) {
     const generics = extractGenerics(node.typeParameters, sourceFile);
     const typeText = node.type.getText(sourceFile);
-    const genericsStr = generics.length > 0 ? `<${generics.map((g) => formatGeneric(g)).join(', ')}>` : '';
+    const genericsStr = generics.length > 0
+        ? `<${generics.map((g) => formatGeneric(g)).join(", ")}>`
+        : "";
     const signature = `type ${name}${genericsStr} = ${typeText}`;
     // Format multi-line for complex types
     const formattedSignature = typeText.length > 60
-        ? `type ${name}${genericsStr} = \n  ${typeText.replace(/\n/g, '\n  ')}`
+        ? `type ${name}${genericsStr} = \n  ${typeText.replace(/\n/g, "\n  ")}`
         : signature;
     return {
         name,
-        kind: 'type',
+        kind: "type",
         line,
         signature,
         formattedSignature,
@@ -370,7 +386,7 @@ function extractTypeSignature(node, sourceFile, name, line, exported, documentat
 function extractEnumSignature(node, sourceFile, name, line, exported, documentation) {
     const members = node.members.map((member) => ({
         name: member.name.getText(sourceFile),
-        kind: 'property',
+        kind: "property",
         signature: member.initializer
             ? `${member.name.getText(sourceFile)} = ${member.initializer.getText(sourceFile)}`
             : member.name.getText(sourceFile),
@@ -378,11 +394,11 @@ function extractEnumSignature(node, sourceFile, name, line, exported, documentat
         readonly: true,
     }));
     const isConst = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ConstKeyword) ?? false;
-    const constPrefix = isConst ? 'const ' : '';
+    const constPrefix = isConst ? "const " : "";
     const signature = `${constPrefix}enum ${name}`;
     return {
         name,
-        kind: 'enum',
+        kind: "enum",
         line,
         signature,
         formattedSignature: signature,
@@ -399,25 +415,29 @@ function extractVariableSignature(node, sourceFile, name, line, exported, docume
     const typeText = typeNode ? typeNode.getText(sourceFile) : undefined;
     // Determine const/let/var
     const parent = node.parent;
-    let declKind = 'const';
+    let declKind = "const";
     if (ts.isVariableDeclarationList(parent)) {
         if (parent.flags & ts.NodeFlags.Let)
-            declKind = 'let';
+            declKind = "let";
         else if (parent.flags & ts.NodeFlags.Const)
-            declKind = 'const';
+            declKind = "const";
         else
-            declKind = 'var';
+            declKind = "var";
     }
-    const signature = typeText ? `${declKind} ${name}: ${typeText}` : `${declKind} ${name}`;
+    const signature = typeText
+        ? `${declKind} ${name}: ${typeText}`
+        : `${declKind} ${name}`;
     return {
         name,
-        kind: 'variable',
+        kind: "variable",
         line,
         signature,
         formattedSignature: signature,
         exported,
         documentation,
-        returnType: typeText ? { type: typeText, isPromise: false, nullable: false } : undefined,
+        returnType: typeText
+            ? { type: typeText, isPromise: false, nullable: false }
+            : undefined,
     };
 }
 /**
@@ -426,10 +446,12 @@ function extractVariableSignature(node, sourceFile, name, line, exported, docume
 function extractParameters(params, sourceFile, documentation) {
     return params.map((param) => {
         const paramName = param.name.getText(sourceFile);
-        const type = param.type ? param.type.getText(sourceFile) : 'any';
+        const type = param.type ? param.type.getText(sourceFile) : "any";
         const optional = param.questionToken !== undefined || param.initializer !== undefined;
         const rest = param.dotDotDotToken !== undefined;
-        const defaultValue = param.initializer ? param.initializer.getText(sourceFile) : undefined;
+        const defaultValue = param.initializer
+            ? param.initializer.getText(sourceFile)
+            : undefined;
         const description = documentation?.params?.[paramName];
         return {
             name: paramName,
@@ -448,8 +470,8 @@ function extractReturnType(node, sourceFile) {
     if (!node.type)
         return undefined;
     const typeText = node.type.getText(sourceFile);
-    const isPromise = typeText.startsWith('Promise<') || typeText.startsWith('Promise ');
-    const nullable = typeText.includes('| null') || typeText.includes('| undefined');
+    const isPromise = typeText.startsWith("Promise<") || typeText.startsWith("Promise ");
+    const nullable = typeText.includes("| null") || typeText.includes("| undefined");
     return {
         type: typeText,
         isPromise,
@@ -464,7 +486,9 @@ function extractGenerics(typeParams, sourceFile) {
         return [];
     return typeParams.map((param) => ({
         name: param.name.getText(sourceFile),
-        constraint: param.constraint ? param.constraint.getText(sourceFile) : undefined,
+        constraint: param.constraint
+            ? param.constraint.getText(sourceFile)
+            : undefined,
         default: param.default ? param.default.getText(sourceFile) : undefined,
     }));
 }
@@ -479,14 +503,16 @@ function extractClassMembers(node, sourceFile) {
         // Handle property declarations
         if (ts.isPropertyDeclaration(member)) {
             const memberName = member.name.getText(sourceFile);
-            const mods = ts.canHaveModifiers(member) ? ts.getModifiers(member) : undefined;
+            const mods = ts.canHaveModifiers(member)
+                ? ts.getModifiers(member)
+                : undefined;
             const isStatic = mods?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword) ?? false;
             const isReadonly = mods?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false;
             const visibility = getVisibility(member);
-            const type = member.type ? member.type.getText(sourceFile) : 'any';
+            const type = member.type ? member.type.getText(sourceFile) : "any";
             members.push({
                 name: memberName,
-                kind: 'property',
+                kind: "property",
                 signature: `${memberName}: ${type}`,
                 optional: member.questionToken !== undefined,
                 readonly: isReadonly,
@@ -497,14 +523,20 @@ function extractClassMembers(node, sourceFile) {
         // Handle method declarations
         else if (ts.isMethodDeclaration(member)) {
             const memberName = member.name.getText(sourceFile);
-            const mods = ts.canHaveModifiers(member) ? ts.getModifiers(member) : undefined;
+            const mods = ts.canHaveModifiers(member)
+                ? ts.getModifiers(member)
+                : undefined;
             const isStatic = mods?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword) ?? false;
             const visibility = getVisibility(member);
-            const params = member.parameters.map((p) => p.getText(sourceFile)).join(', ');
-            const returnType = member.type ? `: ${member.type.getText(sourceFile)}` : '';
+            const params = member.parameters
+                .map((p) => p.getText(sourceFile))
+                .join(", ");
+            const returnType = member.type
+                ? `: ${member.type.getText(sourceFile)}`
+                : "";
             members.push({
                 name: memberName,
-                kind: 'method',
+                kind: "method",
                 signature: `${memberName}(${params})${returnType}`,
                 optional: member.questionToken !== undefined,
                 readonly: false,
@@ -515,13 +547,17 @@ function extractClassMembers(node, sourceFile) {
         // Handle getter accessors
         else if (ts.isGetAccessor(member)) {
             const memberName = member.name.getText(sourceFile);
-            const mods = ts.canHaveModifiers(member) ? ts.getModifiers(member) : undefined;
+            const mods = ts.canHaveModifiers(member)
+                ? ts.getModifiers(member)
+                : undefined;
             const isStatic = mods?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword) ?? false;
             const visibility = getVisibility(member);
-            const returnType = member.type ? `: ${member.type.getText(sourceFile)}` : '';
+            const returnType = member.type
+                ? `: ${member.type.getText(sourceFile)}`
+                : "";
             members.push({
                 name: memberName,
-                kind: 'getter',
+                kind: "getter",
                 signature: `get ${memberName}()${returnType}`,
                 optional: false,
                 readonly: true,
@@ -532,14 +568,16 @@ function extractClassMembers(node, sourceFile) {
         // Handle setter accessors
         else if (ts.isSetAccessor(member)) {
             const memberName = member.name.getText(sourceFile);
-            const mods = ts.canHaveModifiers(member) ? ts.getModifiers(member) : undefined;
+            const mods = ts.canHaveModifiers(member)
+                ? ts.getModifiers(member)
+                : undefined;
             const isStatic = mods?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword) ?? false;
             const visibility = getVisibility(member);
             const param = member.parameters[0];
             const paramStr = param.getText(sourceFile);
             members.push({
                 name: memberName,
-                kind: 'setter',
+                kind: "setter",
                 signature: `set ${memberName}(${paramStr})`,
                 optional: false,
                 readonly: false,
@@ -558,11 +596,11 @@ function extractInterfaceMembers(node, sourceFile) {
     for (const member of node.members) {
         if (ts.isPropertySignature(member)) {
             const memberName = member.name.getText(sourceFile);
-            const type = member.type ? member.type.getText(sourceFile) : 'any';
+            const type = member.type ? member.type.getText(sourceFile) : "any";
             const isReadonly = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false;
             members.push({
                 name: memberName,
-                kind: 'property',
+                kind: "property",
                 signature: `${memberName}: ${type}`,
                 optional: member.questionToken !== undefined,
                 readonly: isReadonly,
@@ -570,11 +608,15 @@ function extractInterfaceMembers(node, sourceFile) {
         }
         else if (ts.isMethodSignature(member)) {
             const memberName = member.name.getText(sourceFile);
-            const params = member.parameters.map((p) => p.getText(sourceFile)).join(', ');
-            const returnType = member.type ? `: ${member.type.getText(sourceFile)}` : '';
+            const params = member.parameters
+                .map((p) => p.getText(sourceFile))
+                .join(", ");
+            const returnType = member.type
+                ? `: ${member.type.getText(sourceFile)}`
+                : "";
             members.push({
                 name: memberName,
-                kind: 'method',
+                kind: "method",
                 signature: `${memberName}(${params})${returnType}`,
                 optional: member.questionToken !== undefined,
                 readonly: false,
@@ -592,16 +634,16 @@ function extractDocumentation(node, sourceFile) {
     if (!jsDocComments?.length && !jsDocTags.length)
         return undefined;
     const doc = {
-        summary: '',
+        summary: "",
     };
     // Get comment text
     if (jsDocComments?.length) {
         const firstDoc = jsDocComments[0];
-        if (typeof firstDoc.comment === 'string') {
-            const lines = firstDoc.comment.split('\n');
+        if (typeof firstDoc.comment === "string") {
+            const lines = firstDoc.comment.split("\n");
             doc.summary = lines[0].trim();
             if (lines.length > 1) {
-                doc.description = lines.slice(1).join('\n').trim();
+                doc.description = lines.slice(1).join("\n").trim();
             }
         }
     }
@@ -612,27 +654,27 @@ function extractDocumentation(node, sourceFile) {
     const see = [];
     for (const tag of jsDocTags) {
         const tagName = tag.tagName.text;
-        const tagComment = typeof tag.comment === 'string' ? tag.comment : '';
-        if (tagName === 'param' && ts.isJSDocParameterTag(tag)) {
+        const tagComment = typeof tag.comment === "string" ? tag.comment : "";
+        if (tagName === "param" && ts.isJSDocParameterTag(tag)) {
             const paramName = tag.name.getText(sourceFile);
             params[paramName] = tagComment;
         }
-        else if (tagName === 'returns' || tagName === 'return') {
+        else if (tagName === "returns" || tagName === "return") {
             doc.returns = tagComment;
         }
-        else if (tagName === 'throws' || tagName === 'exception') {
+        else if (tagName === "throws" || tagName === "exception") {
             throws.push(tagComment);
         }
-        else if (tagName === 'example') {
+        else if (tagName === "example") {
             examples.push(tagComment);
         }
-        else if (tagName === 'see') {
+        else if (tagName === "see") {
             see.push(tagComment);
         }
         else if (ts.isJSDocDeprecatedTag(tag)) {
-            doc.deprecatedMessage = tagComment || 'This API is deprecated';
+            doc.deprecatedMessage = tagComment || "This API is deprecated";
         }
-        else if (tagName === 'since') {
+        else if (tagName === "since") {
             doc.since = tagComment;
         }
     }
@@ -667,7 +709,7 @@ function getNodeName(node) {
         return node.name.text;
     if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name))
         return node.name.text;
-    return '<anonymous>';
+    return "<anonymous>";
 }
 /**
  * Check if node is exported
@@ -680,27 +722,27 @@ function isExported(node) {
         const varStatement = varDeclList.parent;
         if (ts.canHaveModifiers(varStatement)) {
             const modifiers = ts.getModifiers(varStatement);
-            return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+            return (modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
         }
         return false;
     }
     if (!ts.canHaveModifiers(node))
         return false;
     const modifiers = ts.getModifiers(node);
-    return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+    return (modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
 }
 /**
  * Get visibility modifier
  */
 function getVisibility(node) {
     if (!ts.canHaveModifiers(node))
-        return 'public';
+        return "public";
     const modifiers = ts.getModifiers(node);
     if (modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword))
-        return 'private';
+        return "private";
     if (modifiers?.some((m) => m.kind === ts.SyntaxKind.ProtectedKeyword))
-        return 'protected';
-    return 'public';
+        return "protected";
+    return "public";
 }
 /**
  * Format a generic parameter
@@ -719,7 +761,7 @@ function formatGeneric(g) {
 function formatParameter(p) {
     let result = p.rest ? `...${p.name}` : p.name;
     if (p.optional && !p.defaultValue)
-        result += '?';
+        result += "?";
     result += `: ${p.type}`;
     if (p.defaultValue)
         result += ` = ${p.defaultValue}`;
@@ -730,13 +772,15 @@ function formatParameter(p) {
  */
 function formatMultilineSignature(asyncPrefix, name, genericsStr, parameters, returnType) {
     if (parameters.length <= 2) {
-        const paramsStr = parameters.map((p) => formatParameter(p)).join(', ');
-        const returnStr = returnType ? `: ${returnType.type}` : '';
+        const paramsStr = parameters.map((p) => formatParameter(p)).join(", ");
+        const returnStr = returnType ? `: ${returnType.type}` : "";
         return `${asyncPrefix}function ${name}${genericsStr}(${paramsStr})${returnStr}`;
     }
     // Multi-line for many parameters
-    const paramsLines = parameters.map((p) => `  ${formatParameter(p)}`).join(',\n');
-    const returnStr = returnType ? `: ${returnType.type}` : '';
+    const paramsLines = parameters
+        .map((p) => `  ${formatParameter(p)}`)
+        .join(",\n");
+    const returnStr = returnType ? `: ${returnType.type}` : "";
     return `${asyncPrefix}function ${name}${genericsStr}(\n${paramsLines}\n)${returnStr}`;
 }
 /**
@@ -744,7 +788,7 @@ function formatMultilineSignature(asyncPrefix, name, genericsStr, parameters, re
  */
 export function createGetSignatureTool(options) {
     return defineTool({
-        name: options?.name ?? 'get_signature',
+        name: options?.name ?? "get_signature",
         description: options?.description ?? TOOL_DESCRIPTION,
         inputSchema: TOOL_INPUT_SCHEMA,
         execute: async (input) => {