mnehmos.trace.mcp 1.0.0

package/dist/languages/python-ast/parser.js

@@ -0,0 +1,1205 @@
+/**
+ * Python AST Parser
+ * Parses Python source code to extract endpoints, tools, and models
+ *
+ * Uses regex-based parsing as a fallback when tree-sitter is not available.
+ * The parser detects:
+ * - FastAPI endpoints (@app.get, @app.post, @router.get, etc.)
+ * - Flask routes (@app.route, @blueprint.route)
+ * - MCP tools (@mcp.tool, @server.tool)
+ * - Pydantic BaseModel classes
+ * - Typed functions (for type annotation testing)
+ */
+import { TypeResolver } from './type-resolver.js';
+import { detectAllHttpCalls } from '../../patterns/python/index.js';
+/**
+ * Python AST Parser implementation
+ */
+export class PythonASTParser {
+    name = 'python';
+    filePatterns = ['**/*.py', '**/*.pyi'];
+    typeResolver;
+    routers = new Map();
+    blueprints = new Map();
+    servers = new Map(); // variable name -> server name
+    enums = new Map();
+    initialized = false;
+    constructor() {
+        this.typeResolver = new TypeResolver();
+    }
+    /**
+     * Initialize the parser
+     */
+    async initialize() {
+        this.initialized = true;
+        return true;
+    }
+    /**
+     * Extract producer schemas from Python source
+     */
+    async extractSchemas(options) {
+        const content = options.content;
+        if (!content) {
+            return [];
+        }
+        // Reset state for new parsing
+        this.routers.clear();
+        this.blueprints.clear();
+        this.servers.clear();
+        this.enums.clear();
+        this.typeResolver = new TypeResolver();
+        const schemas = [];
+        const lines = content.split('\n');
+        try {
+            // First pass: collect routers, blueprints, servers, enums, and models
+            this.collectDefinitions(content, lines);
+            // Second pass: extract endpoints and tools
+            const endpoints = this.extractEndpoints(content, lines);
+            schemas.push(...endpoints);
+            // Extract Pydantic models
+            const models = this.extractPydanticModels(content, lines);
+            schemas.push(...models);
+            // Extract typed functions (for type annotation testing)
+            // These are functions with type annotations but without decorators
+            const typedFunctions = this.extractTypedFunctions(content, lines);
+            schemas.push(...typedFunctions);
+        }
+        catch (error) {
+            // Silently handle parse errors - return what we have
+            if (process.env.DEBUG_TRACE_MCP) {
+                console.error('[PythonASTParser] Parse error:', error);
+            }
+        }
+        return schemas;
+    }
+    /**
+     * Trace consumer usage - detects HTTP client calls (requests, httpx, aiohttp)
+     *
+     * @param options - TraceOptions containing content to analyze
+     * @returns ConsumerSchema[] representing HTTP client calls found
+     */
+    async traceUsage(options) {
+        const content = options.content;
+        if (!content) {
+            return [];
+        }
+        // Detect HTTP client calls from all supported libraries
+        const httpCalls = detectAllHttpCalls(content);
+        // Convert HTTP calls to ConsumerSchema format
+        return httpCalls.map(call => this.httpCallToConsumerSchema(call));
+    }
+    /**
+     * Convert a Python HTTP call to ConsumerSchema format
+     */
+    httpCallToConsumerSchema(call) {
+        // Build toolName as "METHOD URL" format
+        const url = call.url || '<dynamic>';
+        const toolName = `${call.method} ${url}`;
+        // Build arguments provided
+        const argumentsProvided = {
+            library: call.library,
+            method: call.method,
+            url: call.url,
+            isAsync: call.isAsync
+        };
+        // Add session/client flags
+        if (call.isSession) {
+            argumentsProvided.isSession = true;
+        }
+        if (call.isClient) {
+            argumentsProvided.isClient = true;
+        }
+        if (call.isAsyncClient) {
+            argumentsProvided.isAsyncClient = true;
+        }
+        // Add URL-related flags
+        if (call.isDynamicUrl) {
+            argumentsProvided.isDynamicUrl = true;
+        }
+        if (call.hasQueryParams) {
+            argumentsProvided.hasQueryParams = true;
+        }
+        // Add additional info if available
+        if (call.hasHeaders) {
+            argumentsProvided.hasHeaders = true;
+        }
+        if (call.hasBody) {
+            argumentsProvided.hasBody = true;
+        }
+        if (call.responseVariable) {
+            argumentsProvided.responseVariable = call.responseVariable;
+        }
+        if (call.pathParams && call.pathParams.length > 0) {
+            argumentsProvided.pathParams = call.pathParams;
+        }
+        // Build expected properties from response property access
+        const expectedProperties = call.responseProperties || [];
+        return {
+            toolName,
+            argumentsProvided,
+            expectedProperties,
+            callSite: {
+                file: '',
+                line: call.line,
+                column: 0
+            }
+        };
+    }
+    /**
+     * Collect router, blueprint, server, enum, and model definitions
+     */
+    collectDefinitions(content, lines) {
+        // Find APIRouter definitions: router = APIRouter(prefix="/api/v1")
+        const routerPattern = /(\w+)\s*=\s*APIRouter\s*\(([^)]*)\)/g;
+        let match;
+        while ((match = routerPattern.exec(content)) !== null) {
+            const varName = match[1];
+            const args = match[2];
+            const prefixMatch = args.match(/prefix\s*=\s*["']([^"']+)["']/);
+            const prefix = prefixMatch ? prefixMatch[1] : '';
+            this.routers.set(varName, { variableName: varName, prefix });
+        }
+        // Find Blueprint definitions: bp = Blueprint("name", __name__, url_prefix="/api")
+        const blueprintPattern = /(\w+)\s*=\s*Blueprint\s*\(\s*["'][^"']+["']\s*,\s*[^,]+(?:,\s*url_prefix\s*=\s*["']([^"']+)["'])?\s*\)/g;
+        while ((match = blueprintPattern.exec(content)) !== null) {
+            const varName = match[1];
+            const prefix = match[2] || '';
+            this.blueprints.set(varName, { variableName: varName, prefix });
+        }
+        // Find Server definitions: mcp = Server("name") or server = Server("name")
+        const serverPattern = /(\w+)\s*=\s*Server\s*\(\s*["']([^"']+)["']\s*\)/g;
+        while ((match = serverPattern.exec(content)) !== null) {
+            const varName = match[1];
+            const serverName = match[2];
+            this.servers.set(varName, serverName);
+        }
+        // Find include_router patterns: router.include_router(sub_router)
+        const includePattern = /(\w+)\.include_router\s*\(\s*(\w+)\s*\)/g;
+        while ((match = includePattern.exec(content)) !== null) {
+            const parentRouter = match[1];
+            const childRouter = match[2];
+            const parentDef = this.routers.get(parentRouter);
+            const childDef = this.routers.get(childRouter);
+            if (parentDef && childDef) {
+                // Update child router's prefix to include parent's prefix
+                childDef.prefix = parentDef.prefix + childDef.prefix;
+            }
+        }
+        // Find Enum definitions
+        this.extractEnums(content, lines);
+        // Pre-register Pydantic models for type resolution
+        this.preRegisterModels(content, lines);
+    }
+    /**
+     * Extract enum definitions
+     */
+    extractEnums(content, _lines) {
+        // Match class Name(Enum): or class Name(IntEnum): or class Name(str, Enum):
+        // Use non-greedy [^)]*? so (?:Enum|IntEnum) can actually match
+        // Use \r?\n to handle both Unix and Windows line endings
+        // Use [ \t]+ instead of \s+ to avoid matching across blank lines
+        const enumPattern = /class\s+(\w+)\s*\([^)]*?(?:Enum|IntEnum)[^)]*\)\s*:((?:\r?\n[ \t]+.+)+)/g;
+        let match;
+        while ((match = enumPattern.exec(content)) !== null) {
+            const enumName = match[1];
+            const body = match[2];
+            const isIntEnum = match[0].includes('IntEnum');
+            const values = [];
+            // Pattern for enum values: NAME = "value" or NAME = 123
+            // Capture quoted strings or integers, skip method definitions
+            const valuePattern = /^\s+([A-Z_][A-Z0-9_]*)\s*=\s*(?:["']([^"']+)["']|(\d+))/gm;
+            let valueMatch;
+            while ((valueMatch = valuePattern.exec(body)) !== null) {
+                const name = valueMatch[1];
+                // Parse value - use captured string or integer
+                let value;
+                if (valueMatch[3] !== undefined) {
+                    // Integer value
+                    value = parseInt(valueMatch[3], 10);
+                }
+                else if (valueMatch[2] !== undefined) {
+                    // String value
+                    value = valueMatch[2];
+                }
+                else {
+                    continue; // Skip if neither matched
+                }
+                values.push({ name, value });
+            }
+            if (values.length > 0) {
+                this.enums.set(enumName, { name: enumName, values, isIntEnum });
+                this.typeResolver.registerEnum({ name: enumName, values, isIntEnum });
+            }
+        }
+    }
+    /**
+     * Pre-register Pydantic models for type resolution
+     */
+    preRegisterModels(content, lines) {
+        const modelPattern = /class\s+(\w+)\s*\(\s*(?:.*?BaseModel.*?|(\w+))\s*\)\s*:/g;
+        let match;
+        while ((match = modelPattern.exec(content)) !== null) {
+            const className = match[1];
+            const lineNum = this.getLineNumber(content, match.index);
+            // Check if it extends BaseModel (directly or indirectly)
+            const bases = this.extractBases(match[0]);
+            // Simple check - register all classes for now, we'll filter later
+            this.typeResolver.registerModel({
+                name: className,
+                fields: [],
+                bases,
+                location: { file: '', line: lineNum, column: 0 }
+            });
+        }
+    }
+    /**
+     * Extract base classes from class definition
+     */
+    extractBases(classLine) {
+        const match = classLine.match(/class\s+\w+\s*\(([^)]+)\)/);
+        if (!match)
+            return [];
+        return match[1].split(',').map(b => b.trim()).filter(b => b && !b.includes('='));
+    }
+    /**
+     * Extract FastAPI and Flask endpoints
+     */
+    extractEndpoints(content, lines) {
+        const schemas = [];
+        // Pattern for decorated functions
+        // Matches: @something.method("/path") or @something.method("/path", ...)
+        // followed by async def or def
+        const decoratedFuncPattern = /@(\w+)\.(\w+)\s*\(([^)]*)\)[\s\S]*?(?=@\w+\.|class\s|def\s|async\s+def\s)/g;
+        // More specific approach: find all decorators and their associated functions
+        const funcBlocks = this.extractDecoratedFunctions(content, lines);
+        for (const block of funcBlocks) {
+            const endpoints = this.processDecoratedFunction(block, lines);
+            if (endpoints) {
+                // Handle both single schema and array of schemas (for multi-method Flask routes)
+                if (Array.isArray(endpoints)) {
+                    schemas.push(...endpoints);
+                }
+                else {
+                    schemas.push(endpoints);
+                }
+            }
+        }
+        return schemas;
+    }
+    /**
+     * Extract all decorated function blocks
+     */
+    extractDecoratedFunctions(content, lines) {
+        const blocks = [];
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i];
+            // Check if this line starts a decorator
+            if (line.trim().startsWith('@')) {
+                const decorators = [];
+                const startLine = i + 1;
+                // Collect all decorators
+                while (i < lines.length && lines[i].trim().startsWith('@')) {
+                    // Handle multi-line decorators
+                    let decorator = lines[i].trim();
+                    while (!decorator.includes(')') && !decorator.endsWith(':')) {
+                        i++;
+                        if (i < lines.length) {
+                            decorator += ' ' + lines[i].trim();
+                        }
+                    }
+                    decorators.push(decorator);
+                    i++;
+                }
+                // Now we should be at the function definition
+                if (i < lines.length) {
+                    const funcLine = lines[i];
+                    if (funcLine.trim().startsWith('def ') || funcLine.trim().startsWith('async def ')) {
+                        // Collect function definition (may span multiple lines)
+                        let funcDef = funcLine;
+                        while (!funcDef.includes(':') || (funcDef.split('(').length > funcDef.split(')').length)) {
+                            i++;
+                            if (i < lines.length) {
+                                funcDef += '\n' + lines[i];
+                            }
+                        }
+                        // Get the function body (for docstring)
+                        const bodyStart = i + 1;
+                        let bodyEnd = bodyStart;
+                        const baseIndent = this.getIndent(funcLine);
+                        while (bodyEnd < lines.length) {
+                            const bodyLine = lines[bodyEnd];
+                            // Empty lines are ok
+                            if (bodyLine.trim() === '') {
+                                bodyEnd++;
+                                continue;
+                            }
+                            // Check indentation
+                            const lineIndent = this.getIndent(bodyLine);
+                            if (lineIndent <= baseIndent && bodyLine.trim() !== '') {
+                                break;
+                            }
+                            bodyEnd++;
+                        }
+                        // Capture more lines for detailed docstrings (up to 30 lines)
+                        const funcBody = lines.slice(bodyStart, Math.min(bodyStart + 30, bodyEnd)).join('\n');
+                        blocks.push({
+                            decorators,
+                            funcDef,
+                            funcBody,
+                            startLine,
+                            endLine: bodyEnd
+                        });
+                    }
+                }
+            }
+            i++;
+        }
+        return blocks;
+    }
+    /**
+     * Get indentation level of a line
+     */
+    getIndent(line) {
+        const match = line.match(/^(\s*)/);
+        return match ? match[1].length : 0;
+    }
+    /**
+     * Process a decorated function block into a schema (or array of schemas for multi-method routes)
+     */
+    processDecoratedFunction(block, _lines) {
+        // Parse decorators
+        for (const decorator of block.decorators) {
+            // FastAPI pattern: @app.get("/path") or @router.post("/path")
+            const fastapiMatch = decorator.match(/@(\w+)\.(get|post|put|patch|delete|options|head)\s*\(([^)]*)\)/i);
+            if (fastapiMatch) {
+                return this.processFastAPIEndpoint(fastapiMatch, block, decorator);
+            }
+            // Flask pattern: @app.route("/path") or @bp.route("/path", methods=["GET"])
+            const flaskMatch = decorator.match(/@(\w+)\.route\s*\(([^)]*)\)/);
+            if (flaskMatch) {
+                return this.processFlaskRoute(flaskMatch, block, decorator);
+            }
+            // MCP pattern: @mcp.tool() or @server.tool()
+            const mcpMatch = decorator.match(/@(\w+)\.tool\s*\(\s*\)/);
+            if (mcpMatch) {
+                return this.processMCPTool(mcpMatch, block);
+            }
+        }
+        return null;
+    }
+    /**
+     * Process FastAPI endpoint
+     */
+    processFastAPIEndpoint(match, block, decorator) {
+        const routerVar = match[1];
+        const method = match[2].toUpperCase();
+        const args = match[3];
+        // Extract path from first argument - handle empty string paths
+        const pathMatch = args.match(/["']([^"']*)["']/);
+        let path = pathMatch !== null ? pathMatch[1] : '/';
+        // Add router prefix if applicable
+        const routerDef = this.routers.get(routerVar);
+        if (routerDef && routerDef.prefix) {
+            // Normalize prefix first
+            let prefix = routerDef.prefix.replace(/\/+$/, '');
+            // When path is empty, just use the prefix
+            if (path === '' || path === '/') {
+                path = prefix;
+            }
+            else {
+                // Ensure path starts with / if not empty
+                if (!path.startsWith('/')) {
+                    path = '/' + path;
+                }
+                path = prefix + path;
+            }
+        }
+        // Normalize path - remove trailing slashes aggressively
+        path = path.trim().replace(/[\r\n\t]/g, '');
+        if (!path.startsWith('/'))
+            path = '/' + path;
+        // Remove ALL trailing slashes
+        path = path.replace(/\/+$/g, '') || '/';
+        // Parse function definition
+        const funcInfo = this.parseFunctionDef(block.funcDef);
+        // Extract status_code from decorator
+        const statusMatch = decorator.match(/status_code\s*=\s*(\d+)/);
+        const statusCode = statusMatch ? parseInt(statusMatch[1], 10) : undefined;
+        // Extract response_model
+        const responseModelMatch = decorator.match(/response_model\s*=\s*(\w+)/);
+        const responseModel = responseModelMatch ? responseModelMatch[1] : undefined;
+        // Extract parameters
+        const parameters = this.extractParameters(funcInfo.params, path);
+        // Build input schema
+        const inputSchema = this.buildInputSchema(parameters);
+        // Build output schema
+        const outputSchema = responseModel
+            ? this.typeResolver.resolve(responseModel)
+            : funcInfo.returnType
+                ? this.typeResolver.resolve(funcInfo.returnType)
+                : {};
+        // Extract docstring
+        const docstring = this.extractDocstring(block.funcBody);
+        // Final path normalization to ensure no trailing slashes
+        // Apply double normalization for extra safety
+        let normalizedPath = this.normalizePath(path);
+        // One more explicit check
+        if (normalizedPath.length > 1 && normalizedPath.endsWith('/')) {
+            normalizedPath = normalizedPath.slice(0, -1);
+        }
+        // Final aggressive trailing slash removal
+        const finalPath = normalizedPath.replace(/\/+$/, '') || '/';
+        return {
+            id: funcInfo.name,
+            toolName: funcInfo.name,
+            method,
+            path: finalPath,
+            async: funcInfo.isAsync,
+            statusCode,
+            type: 'endpoint',
+            inputSchema,
+            outputSchema,
+            description: docstring,
+            location: { file: '', line: block.startLine, column: 0 }
+        };
+    }
+    /**
+     * Process Flask route - returns array of schemas for multi-method routes
+     */
+    processFlaskRoute(match, block, decorator) {
+        const routerVar = match[1];
+        const args = match[2];
+        // Extract path
+        const pathMatch = args.match(/["']([^"']+)["']/);
+        let path = pathMatch ? pathMatch[1] : '/';
+        // Add blueprint prefix if applicable
+        const blueprintDef = this.blueprints.get(routerVar);
+        if (blueprintDef) {
+            path = blueprintDef.prefix + path;
+        }
+        // Convert Flask path parameters to OpenAPI style
+        // <int:user_id> -> {user_id}
+        const pathParams = this.extractFlaskPathParams(path);
+        path = path.replace(/<(\w+:)?(\w+)>/g, '{$2}');
+        // Extract methods
+        const methodsMatch = args.match(/methods\s*=\s*\[([^\]]+)\]/);
+        let methods = ['GET'];
+        if (methodsMatch) {
+            methods = methodsMatch[1]
+                .split(',')
+                .map(m => m.trim().replace(/["']/g, '').toUpperCase());
+        }
+        // Parse function definition
+        const funcInfo = this.parseFunctionDef(block.funcDef);
+        // Extract parameters
+        const parameters = this.extractParameters(funcInfo.params, path, pathParams);
+        // Build input schema
+        const inputSchema = this.buildInputSchema(parameters);
+        // Extract docstring
+        const docstring = this.extractDocstring(block.funcBody);
+        // For multiple methods, create separate schemas for each
+        if (methods.length > 1) {
+            return methods.map(method => ({
+                id: `${funcInfo.name}_${method}`,
+                toolName: funcInfo.name,
+                method: method,
+                path,
+                async: funcInfo.isAsync,
+                type: 'endpoint',
+                inputSchema,
+                outputSchema: {},
+                description: docstring,
+                location: { file: '', line: block.startLine, column: 0 }
+            }));
+        }
+        // Single method
+        const method = methods[0];
+        return {
+            id: `${funcInfo.name}_${method}`,
+            toolName: funcInfo.name,
+            method,
+            path,
+            async: funcInfo.isAsync,
+            type: 'endpoint',
+            inputSchema,
+            outputSchema: {},
+            description: docstring,
+            location: { file: '', line: block.startLine, column: 0 }
+        };
+    }
+    /**
+     * Extract Flask path parameters with their types
+     */
+    extractFlaskPathParams(path) {
+        const params = new Map();
+        const pattern = /<(\w+):(\w+)>/g;
+        let match;
+        while ((match = pattern.exec(path)) !== null) {
+            const converter = match[1];
+            const paramName = match[2];
+            params.set(paramName, converter);
+        }
+        // Also match simple <param> without converter
+        const simplePattern = /<(\w+)>/g;
+        while ((match = simplePattern.exec(path)) !== null) {
+            if (!match[0].includes(':')) {
+                params.set(match[1], 'string');
+            }
+        }
+        return params;
+    }
+    /**
+     * Process MCP tool
+     */
+    processMCPTool(match, block) {
+        const serverVar = match[1];
+        const serverName = this.servers.get(serverVar);
+        // Parse function definition
+        const funcInfo = this.parseFunctionDef(block.funcDef);
+        // Extract parameters
+        const parameters = this.extractParameters(funcInfo.params, '');
+        // Build input schema
+        const inputSchema = this.buildInputSchema(parameters);
+        // Build output schema
+        const outputSchema = funcInfo.returnType
+            ? this.typeResolver.resolve(funcInfo.returnType)
+            : {};
+        // Extract docstring
+        const docstring = this.extractDocstring(block.funcBody);
+        // Extract parameter descriptions from docstring
+        const paramDescriptions = this.extractParamDescriptions(block.funcBody);
+        for (const [paramName, description] of paramDescriptions) {
+            if (inputSchema.properties?.[paramName]) {
+                inputSchema.properties[paramName].description = description;
+            }
+        }
+        return {
+            id: funcInfo.name,
+            toolName: funcInfo.name,
+            async: funcInfo.isAsync,
+            type: 'tool',
+            inputSchema,
+            outputSchema,
+            description: docstring,
+            location: { file: '', line: block.startLine, column: 0 }
+        };
+    }
+    /**
+     * Parse function definition
+     */
+    parseFunctionDef(funcDef) {
+        const isAsync = funcDef.trim().startsWith('async ');
+        // Extract function name
+        const nameMatch = funcDef.match(/def\s+(\w+)\s*\(/);
+        const name = nameMatch ? nameMatch[1] : 'unknown';
+        // Extract parameters - handle nested parentheses
+        const paramsStr = this.extractParamsFromFuncDef(funcDef);
+        const params = this.parseParams(paramsStr);
+        // Extract return type
+        const returnMatch = funcDef.match(/->\s*([^:]+):/);
+        const returnType = returnMatch ? returnMatch[1].trim() : undefined;
+        return { name, isAsync, params, returnType };
+    }
+    /**
+     * Extract parameters from function definition, handling nested parentheses
+     */
+    extractParamsFromFuncDef(funcDef) {
+        const startIdx = funcDef.indexOf('(');
+        if (startIdx === -1)
+            return '';
+        let depth = 0;
+        let endIdx = -1;
+        for (let i = startIdx; i < funcDef.length; i++) {
+            const char = funcDef[i];
+            if (char === '(') {
+                depth++;
+            }
+            else if (char === ')') {
+                depth--;
+                if (depth === 0) {
+                    endIdx = i;
+                    break;
+                }
+            }
+        }
+        if (endIdx === -1)
+            return '';
+        return funcDef.slice(startIdx + 1, endIdx);
+    }
+    /**
+     * Parse function parameters
+     */
+    parseParams(paramsStr) {
+        const params = [];
+        if (!paramsStr.trim())
+            return params;
+        // Split by comma, but respect nested brackets
+        const parts = this.splitParams(paramsStr);
+        for (const part of parts) {
+            const trimmed = part.trim();
+            if (!trimmed || trimmed === 'self' || trimmed === 'cls')
+                continue;
+            // Parse parameter: name: Type = default
+            const param = this.parseParam(trimmed);
+            if (param) {
+                params.push(param);
+            }
+        }
+        return params;
+    }
+    /**
+     * Split parameters respecting nested brackets
+     */
+    splitParams(paramsStr) {
+        const parts = [];
+        let current = '';
+        let depth = 0;
+        for (const char of paramsStr) {
+            if (char === '[' || char === '(' || char === '{') {
+                depth++;
+                current += char;
+            }
+            else if (char === ']' || char === ')' || char === '}') {
+                depth--;
+                current += char;
+            }
+            else if (char === ',' && depth === 0) {
+                parts.push(current);
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current.trim()) {
+            parts.push(current);
+        }
+        return parts;
+    }
+    /**
+     * Parse a single parameter
+     */
+    parseParam(paramStr) {
+        // Handle *args, **kwargs
+        if (paramStr.startsWith('*'))
+            return null;
+        // Split by = for default value
+        const eqIndex = paramStr.indexOf('=');
+        let nameType = paramStr;
+        let defaultValue;
+        if (eqIndex > 0) {
+            nameType = paramStr.slice(0, eqIndex).trim();
+            defaultValue = paramStr.slice(eqIndex + 1).trim();
+        }
+        // Split by : for type annotation
+        const colonIndex = nameType.indexOf(':');
+        let name = nameType;
+        let type;
+        if (colonIndex > 0) {
+            name = nameType.slice(0, colonIndex).trim();
+            type = nameType.slice(colonIndex + 1).trim();
+        }
+        return { name, type, default: defaultValue };
+    }
+    /**
+     * Extract parameters with source detection
+     */
+    extractParameters(params, path, flaskPathParams) {
+        const result = [];
+        // Extract path parameters from path
+        const pathParams = new Set();
+        const pathParamPattern = /\{(\w+)\}/g;
+        let match;
+        while ((match = pathParamPattern.exec(path)) !== null) {
+            pathParams.add(match[1]);
+        }
+        for (const param of params) {
+            let source = 'unknown';
+            let typeSchema = this.typeResolver.resolve(param.type);
+            let converter;
+            // Check if it's a path parameter
+            if (pathParams.has(param.name)) {
+                source = 'path';
+                // For Flask, check if there's a converter
+                if (flaskPathParams?.has(param.name)) {
+                    converter = flaskPathParams.get(param.name);
+                    typeSchema = this.flaskConverterToSchema(converter);
+                }
+            }
+            // Check if it's a FastAPI dependency pattern
+            else if (param.default?.includes('Query(')) {
+                source = 'query';
+            }
+            else if (param.default?.includes('Body(')) {
+                source = 'body';
+            }
+            else if (param.default?.includes('Header(')) {
+                source = 'header';
+                // Convert parameter name from snake_case to header format
+            }
+            else if (param.default?.includes('Depends(')) {
+                source = 'depends';
+            }
+            else if (param.default?.includes('Path(')) {
+                source = 'path';
+            }
+            // Default to query for primitive types, body for complex
+            else if (!pathParams.has(param.name)) {
+                const isPrimitive = ['str', 'int', 'float', 'bool'].some(t => param.type?.includes(t) || !param.type);
+                source = isPrimitive ? 'query' : 'body';
+            }
+            // Extract default value
+            let defaultValue;
+            if (param.default) {
+                defaultValue = this.parseDefaultValue(param.default);
+            }
+            result.push({
+                name: param.name,
+                type: param.type,
+                typeSchema,
+                required: param.default === undefined,
+                default: defaultValue,
+                source,
+                converter
+            });
+        }
+        return result;
+    }
+    /**
+     * Convert Flask URL converter to JSON Schema
+     */
+    flaskConverterToSchema(converter) {
+        switch (converter) {
+            case 'int':
+                return { type: 'integer' };
+            case 'float':
+                return { type: 'number' };
+            case 'path':
+                return { type: 'string' };
+            case 'uuid':
+                return { type: 'string', format: 'uuid' };
+            case 'string':
+            default:
+                return { type: 'string' };
+        }
+    }
+    /**
+     * Parse default value
+     */
+    parseDefaultValue(defaultStr) {
+        const trimmed = defaultStr.trim();
+        // None
+        if (trimmed === 'None')
+            return undefined;
+        // Boolean
+        if (trimmed === 'True')
+            return true;
+        if (trimmed === 'False')
+            return false;
+        // Number
+        if (/^-?\d+$/.test(trimmed))
+            return parseInt(trimmed, 10);
+        if (/^-?\d+\.\d+$/.test(trimmed))
+            return parseFloat(trimmed);
+        // String
+        if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+            (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+            return trimmed.slice(1, -1);
+        }
+        // Empty list/dict
+        if (trimmed === '[]')
+            return [];
+        if (trimmed === '{}')
+            return {};
+        // FastAPI Query/Body/etc - extract default from inside
+        const fastapiMatch = trimmed.match(/(?:Query|Body|Path|Header)\s*\(([^)]*)\)/);
+        if (fastapiMatch) {
+            const inner = fastapiMatch[1];
+            // First positional arg is the default
+            if (inner.startsWith('...'))
+                return undefined; // Required
+            const firstArg = inner.split(',')[0].trim();
+            return this.parseDefaultValue(firstArg);
+        }
+        return undefined;
+    }
+    /**
+     * Build input schema from parameters
+     */
+    buildInputSchema(params) {
+        const properties = {};
+        const required = [];
+        for (const param of params) {
+            if (param.source === 'depends')
+                continue; // Skip dependencies
+            properties[param.name] = {
+                ...param.typeSchema,
+                ...(param.default !== undefined && { default: param.default }),
+                ...(param.description && { description: param.description })
+            };
+            if (param.required) {
+                required.push(param.name);
+            }
+        }
+        return {
+            type: 'object',
+            properties,
+            required // Always include required array (empty or with values)
+        };
+    }
+    /**
+     * Extract docstring from function body
+     */
+    extractDocstring(body) {
+        const match = body.match(/^\s*(?:"""([\s\S]*?)"""|'''([\s\S]*?)''')/);
+        if (match) {
+            const docstring = (match[1] || match[2]).trim();
+            // Return first line or first sentence for short description
+            const firstLine = docstring.split('\n')[0].trim();
+            if (firstLine.includes('.')) {
+                return firstLine.split('.')[0].trim() + '.';
+            }
+            return firstLine;
+        }
+        return undefined;
+    }
+    /**
+     * Extract parameter descriptions from docstring Args section
+     */
+    extractParamDescriptions(body) {
+        const descriptions = new Map();
+        const match = body.match(/Args:\s*([\s\S]*?)(?:Returns:|Raises:|Example:|$)/);
+        if (match) {
+            const argsSection = match[1];
+            const paramPattern = /(\w+):\s*(.+?)(?=\n\s+\w+:|$)/gs;
+            let paramMatch;
+            while ((paramMatch = paramPattern.exec(argsSection)) !== null) {
+                const paramName = paramMatch[1];
+                const description = paramMatch[2].replace(/\n\s+/g, ' ').trim();
+                descriptions.set(paramName, description);
+            }
+        }
+        return descriptions;
+    }
+    /**
+     * Extract Pydantic models - uses two-pass approach for proper inheritance
+     */
+    extractPydanticModels(content, lines) {
+        // First pass: collect all model info with their own fields (but not inherited)
+        const modelInfos = [];
+        // Find class definitions that extend BaseModel
+        const classPattern = /class\s+(\w+)\s*\(([^)]+)\)\s*:/g;
+        let match;
+        while ((match = classPattern.exec(content)) !== null) {
+            const className = match[1];
+            const bases = match[2].split(',').map(b => b.trim());
+            // Check if it extends BaseModel (directly or indirectly)
+            const isBaseModel = bases.some(b => b === 'BaseModel' ||
+                b.includes('BaseModel') ||
+                this.isSubclassOfBaseModel(b));
+            if (!isBaseModel)
+                continue;
+            const lineNum = this.getLineNumber(content, match.index);
+            const classBody = this.extractClassBody(content, match.index + match[0].length, lines, lineNum);
+            // Parse fields (own fields only, not inherited)
+            const fields = this.extractPydanticFields(classBody, bases);
+            // Extract docstring
+            const docstring = this.extractDocstring(classBody);
+            // Register model with its own fields for type resolution and inheritance
+            // Keep full bases list (including 'BaseModel') for isSubclassOfBaseModel to work
+            const model = {
+                name: className,
+                fields,
+                bases, // Keep all bases for inheritance checking
+                docstring,
+                location: { file: '', line: lineNum, column: 0 }
+            };
+            this.typeResolver.registerModel(model);
+            modelInfos.push({ className, bases, fields, docstring, lineNum });
+        }
+        // Second pass: build schemas with inheritance resolved
+        const schemas = [];
+        for (const info of modelInfos) {
+            const properties = {};
+            const required = [];
+            // Collect inherited fields recursively
+            const collectInheritedFields = (bases) => {
+                for (const base of bases) {
+                    if (base === 'BaseModel')
+                        continue;
+                    const baseModel = this.typeResolver.getModel(base);
+                    if (baseModel) {
+                        // First collect from parent's bases (grandparents)
+                        collectInheritedFields(baseModel.bases);
+                        // Then add parent's own fields
+                        for (const field of baseModel.fields) {
+                            properties[field.name] = field.typeSchema;
+                            if (field.required && !required.includes(field.name)) {
+                                required.push(field.name);
+                            }
+                        }
+                    }
+                }
+            };
+            // Collect inherited fields
+            collectInheritedFields(info.bases);
+            // Add own fields (may override inherited)
+            for (const field of info.fields) {
+                properties[field.name] = {
+                    ...field.typeSchema,
+                    ...(field.default !== undefined && { default: field.default }),
+                    ...(field.description && { description: field.description }),
+                    ...(field.constraints?.minLength !== undefined && { minLength: field.constraints.minLength }),
+                    ...(field.constraints?.maxLength !== undefined && { maxLength: field.constraints.maxLength }),
+                    ...(field.constraints?.minimum !== undefined && { minimum: field.constraints.minimum }),
+                    ...(field.constraints?.maximum !== undefined && { maximum: field.constraints.maximum }),
+                    ...(field.constraints?.pattern && { pattern: field.constraints.pattern }),
+                };
+                if (field.required && !required.includes(field.name)) {
+                    required.push(field.name);
+                }
+            }
+            schemas.push({
+                id: info.className,
+                toolName: info.className,
+                type: 'model',
+                properties,
+                required,
+                inputSchema: { type: 'object', properties, required: required.length > 0 ? required : undefined },
+                outputSchema: {},
+                description: info.docstring,
+                location: { file: '', line: info.lineNum, column: 0 }
+            });
+        }
+        return schemas;
+    }
+    /**
+     * Check if a class is a subclass of BaseModel
+     */
+    isSubclassOfBaseModel(className) {
+        const model = this.typeResolver.getModel(className);
+        if (!model)
+            return false;
+        return model.bases.some(b => b === 'BaseModel' || this.isSubclassOfBaseModel(b));
+    }
+    /**
+     * Extract class body
+     */
+    extractClassBody(content, startOffset, lines, startLineNum) {
+        // Find the indentation of the class body
+        const contentAfter = content.slice(startOffset);
+        const bodyMatch = contentAfter.match(/^[^\n]*\n([\s\S]*?)(?=\nclass\s|\n[^\s]|$)/);
+        if (bodyMatch) {
+            return bodyMatch[1];
+        }
+        return '';
+    }
+    /**
+     * Extract Pydantic field definitions
+     */
+    extractPydanticFields(classBody, bases) {
+        const fields = [];
+        // Pattern for field definitions: name: Type = default
+        const fieldPattern = /^\s+(\w+)\s*:\s*([^=\n]+)(?:\s*=\s*(.+))?$/gm;
+        let match;
+        while ((match = fieldPattern.exec(classBody)) !== null) {
+            const name = match[1];
+            const typeStr = match[2].trim();
+            const defaultStr = match[3]?.trim();
+            // Skip methods and private fields
+            if (name.startsWith('_') || name === 'Config')
+                continue;
+            // Parse type
+            const typeSchema = this.typeResolver.resolve(typeStr);
+            // Determine if required
+            let required = true;
+            let defaultValue;
+            let constraints;
+            let description;
+            if (defaultStr) {
+                required = false;
+                // Check for Field() with constraints
+                if (defaultStr.startsWith('Field(')) {
+                    const fieldInfo = this.parseFieldCall(defaultStr);
+                    required = fieldInfo.required;
+                    defaultValue = fieldInfo.default;
+                    constraints = fieldInfo.constraints;
+                    description = fieldInfo.description;
+                }
+                else {
+                    defaultValue = this.parseDefaultValue(defaultStr);
+                    // If default is None and type is Optional, it's not required
+                    if (defaultStr === 'None') {
+                        required = false;
+                    }
+                }
+            }
+            // Check if type is Optional - then not required
+            if (typeStr.startsWith('Optional[') || typeStr.includes(' | None')) {
+                required = false;
+            }
+            fields.push({
+                name,
+                type: typeStr,
+                typeSchema,
+                required,
+                default: defaultValue,
+                description,
+                constraints
+            });
+        }
+        return fields;
+    }
+    /**
+     * Parse Field() call for constraints
+     */
+    parseFieldCall(fieldStr) {
+        const result = { required: true };
+        // Extract arguments
+        const argsMatch = fieldStr.match(/Field\s*\(([^)]*)\)/s);
+        if (!argsMatch)
+            return result;
+        const args = argsMatch[1];
+        // Check for ... (required marker)
+        if (args.trim().startsWith('...')) {
+            result.required = true;
+        }
+        else {
+            // First positional arg is default
+            const firstArg = args.split(',')[0].trim();
+            if (firstArg && firstArg !== '...' && !firstArg.includes('=')) {
+                result.default = this.parseDefaultValue(firstArg);
+                result.required = false;
+            }
+        }
+        // Parse keyword arguments
+        const constraints = {};
+        const minLengthMatch = args.match(/min_length\s*=\s*(\d+)/);
+        if (minLengthMatch)
+            constraints.minLength = parseInt(minLengthMatch[1]);
+        const maxLengthMatch = args.match(/max_length\s*=\s*(\d+)/);
+        if (maxLengthMatch)
+            constraints.maxLength = parseInt(maxLengthMatch[1]);
+        const geMatch = args.match(/ge\s*=\s*(-?\d+(?:\.\d+)?)/);
+        if (geMatch)
+            constraints.minimum = parseFloat(geMatch[1]);
+        const leMatch = args.match(/le\s*=\s*(-?\d+(?:\.\d+)?)/);
+        if (leMatch)
+            constraints.maximum = parseFloat(leMatch[1]);
+        const patternMatch = args.match(/pattern\s*=\s*["']([^"']+)["']/);
+        if (patternMatch)
+            constraints.pattern = patternMatch[1];
+        const minItemsMatch = args.match(/min_items\s*=\s*(\d+)/);
+        if (minItemsMatch)
+            constraints.minItems = parseInt(minItemsMatch[1]);
+        const maxItemsMatch = args.match(/max_items\s*=\s*(\d+)/);
+        if (maxItemsMatch)
+            constraints.maxItems = parseInt(maxItemsMatch[1]);
+        if (Object.keys(constraints).length > 0) {
+            result.constraints = constraints;
+        }
+        // Description
+        const descMatch = args.match(/description\s*=\s*["']([^"']+)["']/);
+        if (descMatch) {
+            result.description = descMatch[1];
+        }
+        return result;
+    }
+    /**
+     * Get line number for a character offset
+     */
+    getLineNumber(content, offset) {
+        const beforeOffset = content.slice(0, offset);
+        return (beforeOffset.match(/\n/g) || []).length + 1;
+    }
+    /**
+     * Extract typed functions (for type annotation testing)
+     * This extracts functions that have type annotations but are NOT decorated
+     */
+    extractTypedFunctions(content, lines) {
+        const schemas = [];
+        // Pattern to match undecorated function definitions with type hints
+        // def func_name(param: type, ...) -> return_type:
+        const funcPattern = /^(async\s+)?def\s+(\w+)\s*\(([^)]*)\)\s*(?:->\s*([^:]+))?\s*:/gm;
+        let match;
+        while ((match = funcPattern.exec(content)) !== null) {
+            const isAsync = !!match[1];
+            const funcName = match[2];
+            const paramsStr = match[3];
+            const returnType = match[4]?.trim();
+            const lineNum = this.getLineNumber(content, match.index);
+            // Check if this function is decorated (look at previous line)
+            const prevLineIdx = lineNum - 2;
+            if (prevLineIdx >= 0 && lines[prevLineIdx]?.trim().startsWith('@')) {
+                // Skip decorated functions - they're handled elsewhere
+                continue;
+            }
+            // Skip dunder methods
+            if (funcName.startsWith('__') && funcName.endsWith('__')) {
+                continue;
+            }
+            // Skip methods inside classes (check indentation)
+            const funcLine = lines[lineNum - 1];
+            if (funcLine && this.getIndent(funcLine) > 0) {
+                continue;
+            }
+            // Parse parameters
+            const params = this.parseParams(paramsStr);
+            // Skip functions without type hints
+            const hasTypeHints = params.some(p => p.type) || returnType;
+            if (!hasTypeHints)
+                continue;
+            // Build input schema from parameters
+            const properties = {};
+            const required = [];
+            for (const param of params) {
+                if (param.type) {
+                    const typeSchema = this.typeResolver.resolve(param.type);
+                    properties[param.name] = typeSchema;
+                    if (param.default === undefined) {
+                        required.push(param.name);
+                    }
+                }
+            }
+            // Build output schema from return type
+            const outputSchema = returnType ? this.typeResolver.resolve(returnType) : {};
+            schemas.push({
+                id: funcName,
+                toolName: funcName,
+                async: isAsync,
+                type: 'function',
+                inputSchema: {
+                    type: 'object',
+                    properties,
+                    ...(required.length > 0 && { required })
+                },
+                outputSchema,
+                location: { file: '', line: lineNum, column: 0 }
+            });
+        }
+        return schemas;
+    }
+    /**
+     * Normalize a path by ensuring leading slash and removing trailing slashes
+     */
+    normalizePath(path) {
+        // Handle empty/falsy path
+        if (!path || path.trim() === '') {
+            return '/';
+        }
+        // Trim whitespace, CRLF, and any hidden characters
+        path = path.trim().replace(/[\r\n\t]/g, '');
+        // Ensure leading slash
+        if (!path.startsWith('/')) {
+            path = '/' + path;
+        }
+        // Remove ALL trailing slashes and whitespace (but keep root "/" as is)
+        // Use a more aggressive approach
+        while (path.length > 1 && (path.endsWith('/') || path.endsWith(' ') || path.charCodeAt(path.length - 1) < 32)) {
+            path = path.slice(0, -1);
+        }
+        return path || '/';
+    }
+}
+//# sourceMappingURL=parser.js.map