@compilr-dev/agents-coding-python 0.1.0

package/dist/tools/get-signature.js

@@ -0,0 +1,800 @@
+/**
+ * getSignature Tool
+ *
+ * Get detailed signature information for a function, method, or class in Python code.
+ * Includes parameters, type hints, decorators, and docstrings.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { defineTool, createSuccessResult, createErrorResult, } from "@compilr-dev/agents";
+import { parseFile, parseFunction, parseClass, } from "../parser/python-parser.js";
+// Tool description
+const TOOL_DESCRIPTION = `Get detailed signature information for a function, method, or class in Python.
+Returns parameters with type hints, return type, decorators, and extracted docstring documentation.
+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,
+        },
+    },
+    required: ["path", "name"],
+};
+/**
+ * getSignature tool
+ */
+export const getSignatureTool = defineTool({
+    name: "get_signature_python",
+    description: TOOL_DESCRIPTION,
+    inputSchema: TOOL_INPUT_SCHEMA,
+    execute: executeGetSignature,
+});
+/**
+ * Execute the getSignature tool
+ */
+async function executeGetSignature(input) {
+    const { path: inputPath, name, line, includeDoc = true } = input;
+    // Validate input
+    if (!inputPath || inputPath.trim().length === 0) {
+        return createErrorResult("Path is required");
+    }
+    if (!name || name.trim().length === 0) {
+        return createErrorResult("Symbol name is required");
+    }
+    try {
+        const resolvedPath = path.resolve(inputPath);
+        // Check if file exists
+        try {
+            await fs.access(resolvedPath);
+        }
+        catch {
+            return createErrorResult(`File not found: ${resolvedPath}`);
+        }
+        // Check if Python file
+        if (!resolvedPath.endsWith(".py")) {
+            return createErrorResult("File must be a Python file (.py)");
+        }
+        // Parse the file
+        const parseResult = await parseFile(resolvedPath);
+        const { tree, source } = parseResult;
+        // Find the symbol
+        const result = findSymbolSignature(tree.rootNode, source, name, line, includeDoc);
+        if (!result) {
+            return createErrorResult(`Symbol "${name}" not found in ${resolvedPath}`);
+        }
+        return createSuccessResult({
+            ...result,
+            path: resolvedPath,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createErrorResult(`Failed to get signature: ${message}`);
+    }
+}
+/**
+ * Find a symbol and extract its signature
+ */
+function findSymbolSignature(rootNode, source, symbolName, targetLine, includeDoc) {
+    let foundNode = null;
+    let foundKind = null;
+    function visit(node, className) {
+        if (foundNode && !targetLine)
+            return; // Already found, stop if no line disambiguation
+        const nodeLine = node.startPosition.row + 1;
+        // Skip if we have a target line and this isn't it
+        if (targetLine && nodeLine !== targetLine) {
+            for (const child of node.children) {
+                visit(child, className);
+            }
+            return;
+        }
+        // Function definitions
+        if (node.type === "function_definition") {
+            const nameNode = node.childForFieldName("name");
+            if (nameNode?.text === symbolName) {
+                foundNode = node;
+                foundKind = className ? "method" : "function";
+            }
+        }
+        // Async function definitions
+        else if (node.type === "async_function_definition") {
+            const funcDef = node.children.find((c) => c.type === "function_definition");
+            const nameNode = funcDef?.childForFieldName("name");
+            if (nameNode?.text === symbolName) {
+                foundNode = node;
+                foundKind = className ? "method" : "async_function";
+            }
+        }
+        // Class definitions
+        else if (node.type === "class_definition") {
+            const nameNode = node.childForFieldName("name");
+            if (nameNode?.text === symbolName) {
+                foundNode = node;
+                foundKind = "class";
+            }
+            else {
+                // Search inside class for methods
+                const body = node.childForFieldName("body");
+                if (body) {
+                    for (const member of body.children) {
+                        visit(member, nameNode?.text);
+                    }
+                }
+            }
+        }
+        // Decorated definitions
+        else if (node.type === "decorated_definition") {
+            const definition = node.children.find((c) => c.type === "function_definition" ||
+                c.type === "async_function_definition" ||
+                c.type === "class_definition");
+            if (definition) {
+                if (definition.type === "class_definition") {
+                    const nameNode = definition.childForFieldName("name");
+                    if (nameNode?.text === symbolName) {
+                        foundNode = node;
+                        foundKind = "class";
+                    }
+                }
+                else {
+                    const funcDef = definition.type === "async_function_definition"
+                        ? definition.children.find((c) => c.type === "function_definition")
+                        : definition;
+                    const nameNode = funcDef?.childForFieldName("name");
+                    if (nameNode?.text === symbolName) {
+                        foundNode = node;
+                        foundKind =
+                            definition.type === "async_function_definition"
+                                ? "async_function"
+                                : className
+                                    ? "method"
+                                    : "function";
+                    }
+                }
+            }
+        }
+        // Variable assignments (module-level)
+        else if (node.type === "assignment" && !className) {
+            const left = node.childForFieldName("left");
+            if (left?.type === "identifier" && left.text === symbolName) {
+                foundNode = node;
+                foundKind = "variable";
+            }
+        }
+        // Recurse into children
+        if (!foundNode) {
+            for (const child of node.children) {
+                if (child.type !== "class_definition") {
+                    visit(child, className);
+                }
+            }
+        }
+    }
+    visit(rootNode);
+    if (!foundNode || !foundKind) {
+        return null;
+    }
+    return extractSignature(foundNode, foundKind, source, includeDoc);
+}
+/**
+ * Extract signature from a node
+ */
+function extractSignature(node, kind, source, includeDoc) {
+    const line = node.startPosition.row + 1;
+    switch (kind) {
+        case "function":
+        case "async_function":
+        case "method":
+            return extractFunctionSignature(node, source, kind, line, includeDoc);
+        case "class":
+            return extractClassSignature(node, source, line, includeDoc);
+        case "variable":
+            return extractVariableSignature(node, source, line);
+        default:
+            return {
+                name: "<unknown>",
+                kind,
+                line,
+                signature: node.text.split("\n")[0],
+                formattedSignature: node.text.split("\n")[0],
+            };
+    }
+}
+/**
+ * Extract function/method signature
+ */
+function extractFunctionSignature(node, source, kind, line, includeDoc) {
+    // Handle decorated definitions
+    let funcNode;
+    const decorators = [];
+    const isAsync = kind === "async_function";
+    if (node.type === "decorated_definition") {
+        // Extract decorators
+        for (const child of node.children) {
+            if (child.type === "decorator") {
+                decorators.push(child.text.trim());
+            }
+        }
+        const definition = node.children.find((c) => c.type === "function_definition" ||
+            c.type === "async_function_definition");
+        if (definition?.type === "async_function_definition") {
+            funcNode =
+                definition.children.find((c) => c.type === "function_definition") ??
+                    definition;
+        }
+        else {
+            funcNode = definition ?? node;
+        }
+    }
+    else if (node.type === "async_function_definition") {
+        funcNode =
+            node.children.find((c) => c.type === "function_definition") ?? node;
+    }
+    else {
+        funcNode = node;
+    }
+    const funcInfo = parseFunction(funcNode, source);
+    const name = funcInfo.name;
+    // Extract parameters
+    const parameters = extractParameters(funcNode, source);
+    // Extract return type
+    const returnAnnotation = funcNode.childForFieldName("return_type");
+    let returnType;
+    if (returnAnnotation) {
+        const typeText = returnAnnotation.text;
+        returnType = {
+            type: typeText,
+            isCoroutine: isAsync,
+            nullable: typeText.includes("None") ||
+                typeText.startsWith("Optional[") ||
+                typeText.includes(" | None"),
+        };
+    }
+    // Extract docstring
+    let documentation;
+    if (includeDoc) {
+        const body = funcNode.childForFieldName("body");
+        if (body) {
+            documentation = extractDocstring(body, source);
+        }
+    }
+    // Build signature string
+    const asyncPrefix = isAsync ? "async " : "";
+    const paramsStr = parameters.map((p) => formatParameter(p)).join(", ");
+    const returnStr = returnType ? ` -> ${returnType.type}` : "";
+    const signature = `${asyncPrefix}def ${name}(${paramsStr})${returnStr}`;
+    // Formatted signature with decorators
+    const decoratorLines = decorators.length > 0 ? decorators.join("\n") + "\n" : "";
+    const formattedSignature = parameters.length > 3
+        ? `${decoratorLines}${asyncPrefix}def ${name}(\n${parameters.map((p) => `    ${formatParameter(p)}`).join(",\n")}\n)${returnStr}`
+        : `${decoratorLines}${signature}`;
+    return {
+        name,
+        kind,
+        line,
+        signature,
+        formattedSignature,
+        parameters,
+        returnType,
+        decorators: decorators.length > 0 ? decorators : undefined,
+        documentation,
+        async: isAsync,
+    };
+}
+/**
+ * Extract class signature
+ */
+function extractClassSignature(node, source, line, includeDoc) {
+    // Handle decorated definitions
+    let classNode;
+    const decorators = [];
+    if (node.type === "decorated_definition") {
+        for (const child of node.children) {
+            if (child.type === "decorator") {
+                decorators.push(child.text.trim());
+            }
+        }
+        classNode =
+            node.children.find((c) => c.type === "class_definition") ?? node;
+    }
+    else {
+        classNode = node;
+    }
+    const classInfo = parseClass(classNode, source);
+    const name = classInfo.name;
+    const bases = classInfo.bases;
+    // Extract docstring
+    let documentation;
+    if (includeDoc) {
+        const body = classNode.childForFieldName("body");
+        if (body) {
+            documentation = extractDocstring(body, source);
+        }
+    }
+    // Extract members
+    const members = extractClassMembers(classNode, source);
+    // Build signature
+    const basesStr = bases.length > 0 ? `(${bases.join(", ")})` : "";
+    const signature = `class ${name}${basesStr}`;
+    // Formatted signature with decorators
+    const decoratorLines = decorators.length > 0 ? decorators.join("\n") + "\n" : "";
+    const formattedSignature = `${decoratorLines}${signature}`;
+    return {
+        name,
+        kind: "class",
+        line,
+        signature,
+        formattedSignature,
+        decorators: decorators.length > 0 ? decorators : undefined,
+        documentation,
+        bases: bases.length > 0 ? bases : undefined,
+        members: members.length > 0 ? members : undefined,
+    };
+}
+/**
+ * Extract variable signature
+ */
+function extractVariableSignature(node, source, line) {
+    const left = node.childForFieldName("left");
+    const name = left?.text ?? "<unknown>";
+    // Check for type annotation
+    const annotationNode = node.children.find((c) => c.type === "type");
+    const annotation = annotationNode?.text;
+    const signature = annotation ? `${name}: ${annotation}` : name;
+    return {
+        name,
+        kind: "variable",
+        line,
+        signature,
+        formattedSignature: signature,
+        returnType: annotation
+            ? {
+                type: annotation,
+                nullable: annotation.includes("None") ||
+                    annotation.startsWith("Optional[") ||
+                    annotation.includes(" | None"),
+            }
+            : undefined,
+    };
+}
+/**
+ * Extract parameters from function node
+ */
+function extractParameters(funcNode, _source) {
+    const parameters = [];
+    const paramsNode = funcNode.childForFieldName("parameters");
+    if (!paramsNode)
+        return parameters;
+    let seenKwOnly = false;
+    let seenPosOnly = false;
+    for (const child of paramsNode.children) {
+        // Skip punctuation
+        if (child.type === "," || child.type === "(" || child.type === ")")
+            continue;
+        // Position-only marker (/)
+        if (child.type === "positional_separator") {
+            seenPosOnly = true;
+            continue;
+        }
+        // Keyword-only marker (*)
+        if (child.type === "keyword_separator") {
+            seenKwOnly = true;
+            continue;
+        }
+        // Regular parameter
+        if (child.type === "identifier") {
+            parameters.push({
+                name: child.text,
+                optional: false,
+                isPosOnly: seenPosOnly,
+                isKwOnly: seenKwOnly,
+            });
+            continue;
+        }
+        // Typed parameter
+        if (child.type === "typed_parameter") {
+            const nameNode = child.children.find((c) => c.type === "identifier");
+            const typeNode = child.childForFieldName("type");
+            parameters.push({
+                name: nameNode?.text ?? "<unknown>",
+                type: typeNode?.text,
+                optional: false,
+                isPosOnly: !seenKwOnly && seenPosOnly,
+                isKwOnly: seenKwOnly,
+            });
+            continue;
+        }
+        // Default parameter
+        if (child.type === "default_parameter") {
+            const nameNode = child.childForFieldName("name");
+            const valueNode = child.childForFieldName("value");
+            parameters.push({
+                name: nameNode?.text ?? "<unknown>",
+                optional: true,
+                defaultValue: valueNode?.text,
+                isPosOnly: !seenKwOnly && seenPosOnly,
+                isKwOnly: seenKwOnly,
+            });
+            continue;
+        }
+        // Typed default parameter
+        if (child.type === "typed_default_parameter") {
+            const nameNode = child.childForFieldName("name");
+            const typeNode = child.childForFieldName("type");
+            const valueNode = child.childForFieldName("value");
+            parameters.push({
+                name: nameNode?.text ?? "<unknown>",
+                type: typeNode?.text,
+                optional: true,
+                defaultValue: valueNode?.text,
+                isPosOnly: !seenKwOnly && seenPosOnly,
+                isKwOnly: seenKwOnly,
+            });
+            continue;
+        }
+        // *args
+        if (child.type === "list_splat_pattern") {
+            const nameNode = child.children.find((c) => c.type === "identifier");
+            parameters.push({
+                name: nameNode?.text ?? "args",
+                optional: true,
+                isVarArgs: true,
+            });
+            seenKwOnly = true; // After *args, all are keyword-only
+            continue;
+        }
+        // **kwargs
+        if (child.type === "dictionary_splat_pattern") {
+            const nameNode = child.children.find((c) => c.type === "identifier");
+            parameters.push({
+                name: nameNode?.text ?? "kwargs",
+                optional: true,
+                isKwArgs: true,
+            });
+            continue;
+        }
+    }
+    return parameters;
+}
+/**
+ * Extract class members
+ */
+function extractClassMembers(classNode, source) {
+    const members = [];
+    const body = classNode.childForFieldName("body");
+    if (!body)
+        return members;
+    for (const member of body.children) {
+        // Method definitions
+        if (member.type === "function_definition") {
+            const funcInfo = parseFunction(member, source);
+            const paramsNode = member.childForFieldName("parameters");
+            const paramsText = paramsNode?.text ?? "()";
+            const returnNode = member.childForFieldName("return_type");
+            const returnText = returnNode ? ` -> ${returnNode.text}` : "";
+            members.push({
+                name: funcInfo.name,
+                kind: "method",
+                signature: `def ${funcInfo.name}${paramsText}${returnText}`,
+                async: false,
+            });
+        }
+        // Async method definitions
+        else if (member.type === "async_function_definition") {
+            const funcDef = member.children.find((c) => c.type === "function_definition");
+            if (funcDef) {
+                const funcInfo = parseFunction(funcDef, source);
+                const paramsNode = funcDef.childForFieldName("parameters");
+                const paramsText = paramsNode?.text ?? "()";
+                const returnNode = funcDef.childForFieldName("return_type");
+                const returnText = returnNode ? ` -> ${returnNode.text}` : "";
+                members.push({
+                    name: funcInfo.name,
+                    kind: "method",
+                    signature: `async def ${funcInfo.name}${paramsText}${returnText}`,
+                    async: true,
+                });
+            }
+        }
+        // Decorated methods
+        else if (member.type === "decorated_definition") {
+            const decorators = [];
+            for (const child of member.children) {
+                if (child.type === "decorator") {
+                    decorators.push(child.text.trim());
+                }
+            }
+            const definition = member.children.find((c) => c.type === "function_definition" ||
+                c.type === "async_function_definition");
+            if (definition) {
+                const funcDef = definition.type === "async_function_definition"
+                    ? (definition.children.find((c) => c.type === "function_definition") ?? definition)
+                    : definition;
+                const funcInfo = parseFunction(funcDef, source);
+                const paramsNode = funcDef.childForFieldName("parameters");
+                const paramsText = paramsNode?.text ?? "()";
+                const returnNode = funcDef.childForFieldName("return_type");
+                const returnText = returnNode ? ` -> ${returnNode.text}` : "";
+                const isAsync = definition.type === "async_function_definition";
+                const asyncPrefix = isAsync ? "async " : "";
+                const isStaticMethod = decorators.some((d) => d === "@staticmethod" || d.includes("staticmethod"));
+                const isClassMethod = decorators.some((d) => d === "@classmethod" || d.includes("classmethod"));
+                const isProperty = decorators.some((d) => d === "@property" || d.includes("property"));
+                members.push({
+                    name: funcInfo.name,
+                    kind: isProperty ? "property" : "method",
+                    signature: `${asyncPrefix}def ${funcInfo.name}${paramsText}${returnText}`,
+                    async: isAsync,
+                    static: isStaticMethod,
+                    classmethod: isClassMethod,
+                    decorators,
+                });
+            }
+        }
+        // Class variable assignments
+        else if (member.type === "assignment") {
+            const left = member.childForFieldName("left");
+            if (left?.type === "identifier") {
+                members.push({
+                    name: left.text,
+                    kind: "class_variable",
+                    signature: member.text.split("\n")[0],
+                });
+            }
+        }
+        // Annotated assignments
+        else if (member.type === "expression_statement") {
+            const expr = member.children[0];
+            if (expr?.type === "assignment") {
+                const left = expr.childForFieldName("left");
+                if (left?.type === "identifier") {
+                    members.push({
+                        name: left.text,
+                        kind: "class_variable",
+                        signature: expr.text.split("\n")[0],
+                    });
+                }
+            }
+        }
+    }
+    return members;
+}
+/**
+ * Extract docstring from a body node
+ */
+function extractDocstring(bodyNode, _source) {
+    // Look for the first expression_statement containing a string
+    for (const child of bodyNode.children) {
+        if (child.type === "expression_statement") {
+            const string = child.children.find((c) => c.type === "string" || c.type === "concatenated_string");
+            if (string) {
+                return parseDocstring(string.text);
+            }
+        }
+        // Stop looking after non-expression-statement
+        if (child.type !== "expression_statement" && child.type !== "comment") {
+            break;
+        }
+    }
+    return undefined;
+}
+/**
+ * Parse a docstring into structured documentation
+ */
+function parseDocstring(docstring) {
+    // Remove quotes
+    let content = docstring.trim();
+    if (content.startsWith('"""') && content.endsWith('"""')) {
+        content = content.slice(3, -3);
+    }
+    else if (content.startsWith("'''") && content.endsWith("'''")) {
+        content = content.slice(3, -3);
+    }
+    else if (content.startsWith('"') && content.endsWith('"')) {
+        content = content.slice(1, -1);
+    }
+    else if (content.startsWith("'") && content.endsWith("'")) {
+        content = content.slice(1, -1);
+    }
+    content = content.trim();
+    const lines = content.split("\n");
+    const doc = {
+        summary: "",
+    };
+    // First non-empty line is summary
+    const summaryLines = [];
+    let inSection = null;
+    const params = {};
+    const raises = [];
+    const examples = [];
+    let returns;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Check for section headers (Google-style, NumPy-style, or reST-style)
+        if (trimmed === "Args:" ||
+            trimmed === "Arguments:" ||
+            trimmed === "Parameters:" ||
+            trimmed === "Parameters" ||
+            trimmed.startsWith(":param ")) {
+            if (inSection === null &&
+                summaryLines.length === 0 &&
+                !trimmed.startsWith(":")) {
+                continue; // Skip empty leading lines
+            }
+            if (inSection === null && summaryLines.length > 0) {
+                doc.summary = summaryLines.join(" ").trim();
+            }
+            inSection = "params";
+            if (trimmed.startsWith(":param ")) {
+                // reST style: :param name: description
+                const match = trimmed.match(/:param\s+(\w+):\s*(.*)/);
+                if (match) {
+                    params[match[1]] = match[2];
+                }
+            }
+            continue;
+        }
+        if (trimmed === "Returns:" ||
+            trimmed === "Return:" ||
+            trimmed.startsWith(":returns:") ||
+            trimmed.startsWith(":return:")) {
+            if (inSection === null && summaryLines.length > 0) {
+                doc.summary = summaryLines.join(" ").trim();
+            }
+            inSection = "returns";
+            if (trimmed.startsWith(":return")) {
+                const match = trimmed.match(/:returns?:\s*(.*)/);
+                if (match) {
+                    returns = match[1];
+                }
+            }
+            continue;
+        }
+        if (trimmed === "Raises:" ||
+            trimmed === "Raise:" ||
+            trimmed === "Exceptions:" ||
+            trimmed.startsWith(":raises:")) {
+            if (inSection === null && summaryLines.length > 0) {
+                doc.summary = summaryLines.join(" ").trim();
+            }
+            inSection = "raises";
+            continue;
+        }
+        if (trimmed === "Examples:" || trimmed === "Example:") {
+            if (inSection === null && summaryLines.length > 0) {
+                doc.summary = summaryLines.join(" ").trim();
+            }
+            inSection = "examples";
+            continue;
+        }
+        if (trimmed === "Notes:" ||
+            trimmed === "Note:" ||
+            trimmed.startsWith(".. note::")) {
+            if (inSection === null && summaryLines.length > 0) {
+                doc.summary = summaryLines.join(" ").trim();
+            }
+            inSection = "notes";
+            continue;
+        }
+        if (trimmed.startsWith(".. deprecated::") || trimmed === "Deprecated:") {
+            if (inSection === null && summaryLines.length > 0) {
+                doc.summary = summaryLines.join(" ").trim();
+            }
+            inSection = "deprecated";
+            continue;
+        }
+        // Process content based on current section
+        if (inSection === null) {
+            if (trimmed || summaryLines.length > 0) {
+                summaryLines.push(trimmed);
+            }
+        }
+        else if (inSection === "params") {
+            // Google-style: name (type): description or name: description
+            const paramMatch = trimmed.match(/^(\w+)\s*(?:\([^)]+\))?\s*:\s*(.*)$/);
+            if (paramMatch) {
+                params[paramMatch[1]] = paramMatch[2];
+            }
+            else if (trimmed && Object.keys(params).length > 0) {
+                // Continuation of previous param description
+                const lastParam = Object.keys(params).pop();
+                if (lastParam) {
+                    params[lastParam] += " " + trimmed;
+                }
+            }
+        }
+        else if (inSection === "returns") {
+            if (trimmed) {
+                returns = returns ? returns + " " + trimmed : trimmed;
+            }
+        }
+        else if (inSection === "raises") {
+            if (trimmed) {
+                raises.push(trimmed);
+            }
+        }
+        else if (inSection === "examples") {
+            examples.push(line); // Keep indentation for examples
+        }
+        else if (inSection === "notes") {
+            doc.notes = doc.notes ? doc.notes + " " + trimmed : trimmed;
+        }
+        else if (inSection === "deprecated") {
+            doc.deprecated = doc.deprecated
+                ? doc.deprecated + " " + trimmed
+                : trimmed;
+        }
+    }
+    // Handle case where summary wasn't separated
+    if (!doc.summary && summaryLines.length > 0) {
+        doc.summary = summaryLines.join(" ").trim();
+    }
+    // Add collected data
+    if (Object.keys(params).length > 0)
+        doc.params = params;
+    if (returns)
+        doc.returns = returns;
+    if (raises.length > 0)
+        doc.raises = raises;
+    if (examples.length > 0)
+        doc.examples = examples;
+    return doc;
+}
+/**
+ * Format a parameter for signature string
+ */
+function formatParameter(p) {
+    let result = "";
+    // Handle *args and **kwargs
+    if (p.isVarArgs) {
+        result = `*${p.name}`;
+    }
+    else if (p.isKwArgs) {
+        result = `**${p.name}`;
+    }
+    else {
+        result = p.name;
+    }
+    // Add type annotation
+    if (p.type) {
+        result += `: ${p.type}`;
+    }
+    // Add default value
+    if (p.defaultValue !== undefined) {
+        result += ` = ${p.defaultValue}`;
+    }
+    return result;
+}
+/**
+ * Factory function to create a customized getSignature tool
+ */
+export function createGetSignatureTool(options) {
+    return defineTool({
+        name: "get_signature_python",
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            return executeGetSignature({
+                ...input,
+                includeDoc: input.includeDoc ?? options?.defaultIncludeDoc ?? true,
+            });
+        },
+    });
+}