@compilr-dev/agents-coding-ts 0.1.0

package/dist/tools/get-signature.js

@@ -0,0 +1,758 @@
+/**
+ * getSignature Tool
+ *
+ * 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';
+// 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',
+    properties: {
+        path: {
+            type: 'string',
+            description: 'File containing the symbol',
+        },
+        name: {
+            type: 'string',
+            description: 'Symbol name to get signature for',
+        },
+        line: {
+            type: 'number',
+            description: 'Line number for disambiguation (optional)',
+        },
+        includeDoc: {
+            type: 'boolean',
+            description: 'Include full documentation (default: true)',
+            default: true,
+        },
+        expandTypes: {
+            type: 'boolean',
+            description: 'Expand type aliases (default: false)',
+            default: false,
+        },
+    },
+    required: ['path', 'name'],
+};
+/**
+ * getSignature tool
+ */
+export const getSignatureTool = defineTool({
+    name: 'get_signature',
+    description: TOOL_DESCRIPTION,
+    inputSchema: TOOL_INPUT_SCHEMA,
+    execute: executeGetSignature,
+});
+/**
+ * Execute the getSignature tool
+ */
+async function executeGetSignature(input) {
+    const { path: inputPath, name, line, includeDoc = true, expandTypes = false } = input;
+    try {
+        const resolvedPath = path.resolve(inputPath);
+        // Check if file exists
+        try {
+            await fs.access(resolvedPath);
+        }
+        catch {
+            return createErrorResult(`File not found: ${resolvedPath}`);
+        }
+        // Check language support
+        const detection = detectLanguage(resolvedPath);
+        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);
+        // Find the symbol
+        const result = findSymbolSignature(sourceFile, name, line, includeDoc, expandTypes);
+        if (!result) {
+            return createErrorResult(`Symbol "${name}" not found in ${resolvedPath}`);
+        }
+        return createSuccessResult({
+            ...result,
+            path: resolvedPath,
+        });
+    }
+    catch (error) {
+        return createErrorResult(`Failed to get signature: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Find a symbol and extract its signature
+ */
+function findSymbolSignature(sourceFile, symbolName, targetLine, includeDoc, _expandTypes) {
+    // Use object to track found values (ESLint tracks object mutations better)
+    const found = {
+        node: null,
+        kind: null,
+    };
+    const visit = (node) => {
+        if (found.node && !targetLine)
+            return; // Already found, stop if no line disambiguation
+        const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+        const nodeLine = line + 1;
+        // Skip if we have a target line and this isn't it
+        if (targetLine && nodeLine !== targetLine) {
+            ts.forEachChild(node, visit);
+            return;
+        }
+        // Function declarations
+        if (ts.isFunctionDeclaration(node) && node.name?.text === symbolName) {
+            found.node = node;
+            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))) {
+                found.node = node;
+                found.kind = 'function';
+            }
+            else {
+                found.node = node;
+                found.kind = 'variable';
+            }
+        }
+        // Class declarations
+        else if (ts.isClassDeclaration(node) && node.name?.text === symbolName) {
+            found.node = node;
+            found.kind = 'class';
+        }
+        // Interface declarations
+        else if (ts.isInterfaceDeclaration(node) && node.name.text === symbolName) {
+            found.node = node;
+            found.kind = 'interface';
+        }
+        // Type alias declarations
+        else if (ts.isTypeAliasDeclaration(node) && node.name.text === symbolName) {
+            found.node = node;
+            found.kind = 'type';
+        }
+        // Enum declarations
+        else if (ts.isEnumDeclaration(node) && node.name.text === symbolName) {
+            found.node = node;
+            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';
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    if (found.node === null || found.kind === null) {
+        return null;
+    }
+    return extractSignature(found.node, found.kind, sourceFile, includeDoc);
+}
+/**
+ * Extract signature from a node
+ */
+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;
+    switch (kind) {
+        case 'function':
+            return extractFunctionSignature(node, sourceFile, name, line + 1, exported, documentation);
+        case 'method':
+            return extractMethodSignature(node, sourceFile, name, line + 1, exported, documentation);
+        case 'class':
+            return extractClassSignature(node, sourceFile, name, line + 1, exported, documentation);
+        case 'interface':
+            return extractInterfaceSignature(node, sourceFile, name, line + 1, exported, documentation);
+        case 'type':
+            return extractTypeSignature(node, sourceFile, name, line + 1, exported, documentation);
+        case 'enum':
+            return extractEnumSignature(node, sourceFile, name, line + 1, exported, documentation);
+        case 'variable':
+            return extractVariableSignature(node, sourceFile, name, line + 1, exported, documentation);
+        default:
+            return {
+                name,
+                kind,
+                line: line + 1,
+                signature: node.getText(sourceFile),
+                formattedSignature: node.getText(sourceFile),
+                exported,
+                documentation,
+            };
+    }
+}
+/**
+ * Extract function signature
+ */
+function extractFunctionSignature(node, sourceFile, name, line, exported, documentation) {
+    let funcNode;
+    if (ts.isFunctionDeclaration(node)) {
+        funcNode = node;
+    }
+    else if (ts.isVariableDeclaration(node) && node.initializer) {
+        funcNode = node.initializer;
+    }
+    else {
+        return {
+            name,
+            kind: 'function',
+            line,
+            signature: node.getText(sourceFile),
+            formattedSignature: node.getText(sourceFile),
+            exported,
+            documentation,
+        };
+    }
+    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;
+    // 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 signature = `${asyncPrefix}function ${name}${genericsStr}(${paramsStr})${returnStr}`;
+    const formattedSignature = formatMultilineSignature(asyncPrefix, name, genericsStr, parameters, returnType);
+    return {
+        name,
+        kind: 'function',
+        line,
+        signature,
+        formattedSignature,
+        exported,
+        parameters,
+        returnType,
+        generics: generics.length > 0 ? generics : undefined,
+        documentation,
+    };
+}
+/**
+ * Extract method signature
+ */
+function extractMethodSignature(node, sourceFile, name, line, exported, documentation) {
+    const parameters = extractParameters(node.parameters, sourceFile, documentation);
+    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 signature = `${staticPrefix}${asyncPrefix}${name}${genericsStr}(${paramsStr})${returnStr}`;
+    const formattedSignature = signature;
+    return {
+        name,
+        kind: 'method',
+        line,
+        signature,
+        formattedSignature,
+        exported,
+        parameters,
+        returnType,
+        generics: generics.length > 0 ? generics : undefined,
+        documentation,
+    };
+}
+/**
+ * Extract class signature
+ */
+function extractClassSignature(node, sourceFile, name, line, exported, documentation) {
+    const generics = extractGenerics(node.typeParameters, sourceFile);
+    const members = extractClassMembers(node, sourceFile);
+    // Find constructor
+    const constructor = node.members.find(ts.isConstructorDeclaration);
+    let constructorSignature;
+    if (constructor) {
+        const params = extractParameters(constructor.parameters, sourceFile, undefined);
+        constructorSignature = `constructor(${params.map((p) => formatParameter(p)).join(', ')})`;
+    }
+    // Build extends/implements
+    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(', ')}`;
+            }
+            else if (tokenKind === ts.SyntaxKind.ImplementsKeyword) {
+                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 signature = `${abstractPrefix}class ${name}${genericsStr}${heritage}`;
+    const formattedSignature = signature;
+    return {
+        name,
+        kind: 'class',
+        line,
+        signature,
+        formattedSignature,
+        exported,
+        generics: generics.length > 0 ? generics : undefined,
+        documentation,
+        constructorSignature,
+        members,
+    };
+}
+/**
+ * Extract interface signature
+ */
+function extractInterfaceSignature(node, sourceFile, name, line, exported, documentation) {
+    const generics = extractGenerics(node.typeParameters, sourceFile);
+    const members = extractInterfaceMembers(node, sourceFile);
+    // Build extends
+    let heritage = '';
+    if (node.heritageClauses) {
+        for (const clause of node.heritageClauses) {
+            heritage += ` extends ${clause.types.map((t) => t.getText(sourceFile)).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',
+        line,
+        signature,
+        formattedSignature,
+        exported,
+        generics: generics.length > 0 ? generics : undefined,
+        documentation,
+        members,
+    };
+}
+/**
+ * Extract type alias signature
+ */
+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 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  ')}`
+        : signature;
+    return {
+        name,
+        kind: 'type',
+        line,
+        signature,
+        formattedSignature,
+        exported,
+        generics: generics.length > 0 ? generics : undefined,
+        documentation,
+    };
+}
+/**
+ * Extract enum signature
+ */
+function extractEnumSignature(node, sourceFile, name, line, exported, documentation) {
+    const members = node.members.map((member) => ({
+        name: member.name.getText(sourceFile),
+        kind: 'property',
+        signature: member.initializer
+            ? `${member.name.getText(sourceFile)} = ${member.initializer.getText(sourceFile)}`
+            : member.name.getText(sourceFile),
+        optional: false,
+        readonly: true,
+    }));
+    const isConst = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ConstKeyword) ?? false;
+    const constPrefix = isConst ? 'const ' : '';
+    const signature = `${constPrefix}enum ${name}`;
+    return {
+        name,
+        kind: 'enum',
+        line,
+        signature,
+        formattedSignature: signature,
+        exported,
+        documentation,
+        members,
+    };
+}
+/**
+ * Extract variable signature
+ */
+function extractVariableSignature(node, sourceFile, name, line, exported, documentation) {
+    const typeNode = node.type;
+    const typeText = typeNode ? typeNode.getText(sourceFile) : undefined;
+    // Determine const/let/var
+    const parent = node.parent;
+    let declKind = 'const';
+    if (ts.isVariableDeclarationList(parent)) {
+        if (parent.flags & ts.NodeFlags.Let)
+            declKind = 'let';
+        else if (parent.flags & ts.NodeFlags.Const)
+            declKind = 'const';
+        else
+            declKind = 'var';
+    }
+    const signature = typeText ? `${declKind} ${name}: ${typeText}` : `${declKind} ${name}`;
+    return {
+        name,
+        kind: 'variable',
+        line,
+        signature,
+        formattedSignature: signature,
+        exported,
+        documentation,
+        returnType: typeText ? { type: typeText, isPromise: false, nullable: false } : undefined,
+    };
+}
+/**
+ * Extract parameters from parameter list
+ */
+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 optional = param.questionToken !== undefined || param.initializer !== undefined;
+        const rest = param.dotDotDotToken !== undefined;
+        const defaultValue = param.initializer ? param.initializer.getText(sourceFile) : undefined;
+        const description = documentation?.params?.[paramName];
+        return {
+            name: paramName,
+            type,
+            optional,
+            rest,
+            defaultValue,
+            description,
+        };
+    });
+}
+/**
+ * Extract return type
+ */
+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');
+    return {
+        type: typeText,
+        isPromise,
+        nullable,
+    };
+}
+/**
+ * Extract generics
+ */
+function extractGenerics(typeParams, sourceFile) {
+    if (!typeParams)
+        return [];
+    return typeParams.map((param) => ({
+        name: param.name.getText(sourceFile),
+        constraint: param.constraint ? param.constraint.getText(sourceFile) : undefined,
+        default: param.default ? param.default.getText(sourceFile) : undefined,
+    }));
+}
+/**
+ * Extract class members
+ */
+function extractClassMembers(node, sourceFile) {
+    const members = [];
+    for (const member of node.members) {
+        if (ts.isConstructorDeclaration(member))
+            continue; // Skip constructor
+        // Handle property declarations
+        if (ts.isPropertyDeclaration(member)) {
+            const memberName = member.name.getText(sourceFile);
+            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';
+            members.push({
+                name: memberName,
+                kind: 'property',
+                signature: `${memberName}: ${type}`,
+                optional: member.questionToken !== undefined,
+                readonly: isReadonly,
+                visibility,
+                static: isStatic,
+            });
+        }
+        // Handle method declarations
+        else if (ts.isMethodDeclaration(member)) {
+            const memberName = member.name.getText(sourceFile);
+            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)}` : '';
+            members.push({
+                name: memberName,
+                kind: 'method',
+                signature: `${memberName}(${params})${returnType}`,
+                optional: member.questionToken !== undefined,
+                readonly: false,
+                visibility,
+                static: isStatic,
+            });
+        }
+        // Handle getter accessors
+        else if (ts.isGetAccessor(member)) {
+            const memberName = member.name.getText(sourceFile);
+            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)}` : '';
+            members.push({
+                name: memberName,
+                kind: 'getter',
+                signature: `get ${memberName}()${returnType}`,
+                optional: false,
+                readonly: true,
+                visibility,
+                static: isStatic,
+            });
+        }
+        // Handle setter accessors
+        else if (ts.isSetAccessor(member)) {
+            const memberName = member.name.getText(sourceFile);
+            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',
+                signature: `set ${memberName}(${paramStr})`,
+                optional: false,
+                readonly: false,
+                visibility,
+                static: isStatic,
+            });
+        }
+    }
+    return members;
+}
+/**
+ * Extract interface members
+ */
+function extractInterfaceMembers(node, sourceFile) {
+    const members = [];
+    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 isReadonly = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false;
+            members.push({
+                name: memberName,
+                kind: 'property',
+                signature: `${memberName}: ${type}`,
+                optional: member.questionToken !== undefined,
+                readonly: isReadonly,
+            });
+        }
+        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)}` : '';
+            members.push({
+                name: memberName,
+                kind: 'method',
+                signature: `${memberName}(${params})${returnType}`,
+                optional: member.questionToken !== undefined,
+                readonly: false,
+            });
+        }
+    }
+    return members;
+}
+/**
+ * Extract JSDoc documentation
+ */
+function extractDocumentation(node, sourceFile) {
+    const jsDocTags = ts.getJSDocTags(node);
+    const jsDocComments = node.jsDoc;
+    if (!jsDocComments?.length && !jsDocTags.length)
+        return undefined;
+    const doc = {
+        summary: '',
+    };
+    // Get comment text
+    if (jsDocComments?.length) {
+        const firstDoc = jsDocComments[0];
+        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();
+            }
+        }
+    }
+    // Process tags
+    const params = {};
+    const throws = [];
+    const examples = [];
+    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 paramName = tag.name.getText(sourceFile);
+            params[paramName] = tagComment;
+        }
+        else if (tagName === 'returns' || tagName === 'return') {
+            doc.returns = tagComment;
+        }
+        else if (tagName === 'throws' || tagName === 'exception') {
+            throws.push(tagComment);
+        }
+        else if (tagName === 'example') {
+            examples.push(tagComment);
+        }
+        else if (tagName === 'see') {
+            see.push(tagComment);
+        }
+        else if (ts.isJSDocDeprecatedTag(tag)) {
+            doc.deprecatedMessage = tagComment || 'This API is deprecated';
+        }
+        else if (tagName === 'since') {
+            doc.since = tagComment;
+        }
+    }
+    if (Object.keys(params).length > 0)
+        doc.params = params;
+    if (throws.length > 0)
+        doc.throws = throws;
+    if (examples.length > 0)
+        doc.examples = examples;
+    if (see.length > 0)
+        doc.see = see;
+    // Return undefined if no useful info
+    if (!doc.summary && !doc.params && !doc.returns)
+        return undefined;
+    return doc;
+}
+/**
+ * Get node name
+ */
+function getNodeName(node) {
+    if (ts.isFunctionDeclaration(node) && node.name)
+        return node.name.text;
+    if (ts.isClassDeclaration(node) && node.name)
+        return node.name.text;
+    if (ts.isInterfaceDeclaration(node))
+        return node.name.text;
+    if (ts.isTypeAliasDeclaration(node))
+        return node.name.text;
+    if (ts.isEnumDeclaration(node))
+        return node.name.text;
+    if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name))
+        return node.name.text;
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name))
+        return node.name.text;
+    return '<anonymous>';
+}
+/**
+ * Check if node is exported
+ */
+function isExported(node) {
+    // For variable declarations, check the parent VariableStatement
+    if (ts.isVariableDeclaration(node)) {
+        // VariableDeclaration -> VariableDeclarationList -> VariableStatement
+        const varDeclList = node.parent;
+        const varStatement = varDeclList.parent;
+        if (ts.canHaveModifiers(varStatement)) {
+            const modifiers = ts.getModifiers(varStatement);
+            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;
+}
+/**
+ * Get visibility modifier
+ */
+function getVisibility(node) {
+    if (!ts.canHaveModifiers(node))
+        return 'public';
+    const modifiers = ts.getModifiers(node);
+    if (modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword))
+        return 'private';
+    if (modifiers?.some((m) => m.kind === ts.SyntaxKind.ProtectedKeyword))
+        return 'protected';
+    return 'public';
+}
+/**
+ * Format a generic parameter
+ */
+function formatGeneric(g) {
+    let result = g.name;
+    if (g.constraint)
+        result += ` extends ${g.constraint}`;
+    if (g.default)
+        result += ` = ${g.default}`;
+    return result;
+}
+/**
+ * Format a parameter
+ */
+function formatParameter(p) {
+    let result = p.rest ? `...${p.name}` : p.name;
+    if (p.optional && !p.defaultValue)
+        result += '?';
+    result += `: ${p.type}`;
+    if (p.defaultValue)
+        result += ` = ${p.defaultValue}`;
+    return result;
+}
+/**
+ * Format multi-line signature
+ */
+function formatMultilineSignature(asyncPrefix, name, genericsStr, parameters, returnType) {
+    if (parameters.length <= 2) {
+        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}` : '';
+    return `${asyncPrefix}function ${name}${genericsStr}(\n${paramsLines}\n)${returnStr}`;
+}
+/**
+ * Create customizable getSignature tool
+ */
+export function createGetSignatureTool(options) {
+    return defineTool({
+        name: options?.name ?? 'get_signature',
+        description: options?.description ?? TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            const modifiedInput = {
+                ...input,
+                includeDoc: input.includeDoc ?? options?.defaultIncludeDoc,
+            };
+            return executeGetSignature(modifiedInput);
+        },
+    });
+}