mcp-proxy-adapter 2.1.0__py3-none-any.whl → 2.1.2__py3-none-any.whl

mcp_proxy_adapter/schema.py

@@ -0,0 +1,257 @@
+"""
+Module for optimizing OpenAPI schema for MCP Proxy.
+"""
+from typing import Dict, Any, List, Optional
+
+class SchemaOptimizer:
+    """
+    OpenAPI schema optimizer for use with MCP Proxy.
+    
+    This class transforms a standard OpenAPI schema into a format
+    more suitable for use with MCP Proxy and AI models.
+    """
+    
+    def optimize(
+        self, 
+        schema: Dict[str, Any], 
+        cmd_endpoint: str,
+        commands_info: Dict[str, Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """
+        Optimizes OpenAPI schema for MCP Proxy.
+        
+        Args:
+            schema: Original OpenAPI schema
+            cmd_endpoint: Path for universal JSON-RPC endpoint
+            commands_info: Information about registered commands
+            
+        Returns:
+            Dict[str, Any]: Optimized schema
+        """
+        # Create a new schema in a format compatible with the proxy
+        optimized = {
+            "openapi": "3.0.2",
+            "info": {
+                "title": "Command Registry API",
+                "description": "API for executing commands through MCPProxy",
+                "version": "1.0.0"
+            },
+            "paths": {
+                cmd_endpoint: {
+                    "post": {
+                        "summary": "Execute command",
+                        "description": "Universal endpoint for executing various commands",
+                        "operationId": "execute_command",
+                        "requestBody": {
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/CommandRequest"
+                                    },
+                                    "examples": {}
+                                }
+                            },
+                            "required": True
+                        },
+                        "responses": {
+                            "200": {
+                                "description": "Command executed successfully",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "$ref": "#/components/schemas/CommandResponse"
+                                        }
+                                    }
+                                }
+                            },
+                            "400": {
+                                "description": "Error in request or during command execution",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "type": "object",
+                                            "properties": {
+                                                "detail": {
+                                                    "type": "string",
+                                                    "description": "Error description"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            "components": {
+                "schemas": {
+                    "CommandRequest": {
+                        "title": "CommandRequest",
+                        "description": "Command execution request",
+                        "type": "object",
+                        "required": ["command"],
+                        "properties": {
+                            "command": {
+                                "title": "Command",
+                                "description": "Command to execute",
+                                "type": "string",
+                                "enum": list(commands_info.keys())
+                            },
+                            "params": {
+                                "title": "Parameters",
+                                "description": "Command parameters, depend on command type",
+                                "oneOf": []
+                            }
+                        }
+                    },
+                    "CommandResponse": {
+                        "title": "CommandResponse",
+                        "description": "Command execution response",
+                        "type": "object",
+                        "required": ["result"],
+                        "properties": {
+                            "result": {
+                                "title": "Result",
+                                "description": "Command execution result"
+                            }
+                        }
+                    }
+                },
+                "examples": {}
+            }
+        }
+        
+        # Add parameter schemas and examples for each command
+        for cmd_name, cmd_info in commands_info.items():
+            param_schema_name = f"{cmd_name.capitalize()}Params"
+            params = cmd_info.get("params", {})
+            has_params = bool(params)
+
+            # Define parameter schema (даже если params пустой, схема будет пустым объектом)
+            param_schema = {
+                "title": param_schema_name,
+                "description": f"Parameters for command {cmd_name}",
+                "type": "object",
+                "properties": {},
+            }
+            required_params = []
+            example_params = {}
+
+            for param_name, param_info in params.items():
+                param_property = {
+                    "title": param_name.capitalize(),
+                    "type": param_info.get("type", "string"),
+                    "description": param_info.get("description", "")
+                }
+                if "default" in param_info:
+                    param_property["default"] = param_info["default"]
+                if "enum" in param_info:
+                    param_property["enum"] = param_info["enum"]
+                param_schema["properties"][param_name] = param_property
+                if param_info.get("required", False):
+                    required_params.append(param_name)
+                if "example" in param_info:
+                    example_params[param_name] = param_info["example"]
+                elif "default" in param_info:
+                    example_params[param_name] = param_info["default"]
+                elif param_info.get("type") == "string":
+                    example_params[param_name] = "example_value"
+                elif param_info.get("type") == "integer":
+                    example_params[param_name] = 1
+                elif param_info.get("type") == "boolean":
+                    example_params[param_name] = False
+
+            if required_params:
+                param_schema["required"] = required_params
+
+            # Добавляем схему параметров всегда, даже если она пустая
+            optimized["components"]["schemas"][param_schema_name] = param_schema
+
+            # Добавляем $ref на схему параметров в oneOf всегда
+            optimized["components"]["schemas"]["CommandRequest"]["properties"]["params"]["oneOf"].append({
+                "$ref": f"#/components/schemas/{param_schema_name}"
+            })
+
+            # Пример использования команды
+            example_id = f"{cmd_name}_example"
+            example = {
+                "summary": f"Example of using command {cmd_name}",
+                "value": {
+                    "command": cmd_name
+                }
+            }
+            if has_params:
+                example["value"]["params"] = example_params
+            optimized["components"]["examples"][example_id] = example
+            optimized["paths"][cmd_endpoint]["post"]["requestBody"]["content"]["application/json"]["examples"][example_id] = {
+                "$ref": f"#/components/examples/{example_id}"
+            }
+
+        # Для команд без параметров добавляем type: null в oneOf
+        optimized_oneof = optimized["components"]["schemas"]["CommandRequest"]["properties"]["params"]["oneOf"]
+        optimized_oneof.append({"type": "null"})
+
+        # Add tool descriptions to schema for AI models
+        self._add_tool_descriptions(optimized, commands_info)
+        return optimized
+    
+    def _add_tool_descriptions(
+        self, 
+        schema: Dict[str, Any],
+        commands_info: Dict[str, Dict[str, Any]]
+    ) -> None:
+        """
+        Adds AI tool descriptions to the schema.
+        
+        This method enhances the OpenAPI schema with special descriptions
+        for better integration with AI models and MCPProxy.
+        
+        Args:
+            schema: OpenAPI schema to enhance
+            commands_info: Information about registered commands
+        """
+        # Add AI tool descriptions to x-mcp-tools
+        schema["x-mcp-tools"] = []
+        
+        for cmd_name, cmd_info in commands_info.items():
+            # Create tool description
+            tool = {
+                "name": f"mcp_{cmd_name}",  # Add mcp_ prefix to command name
+                "description": cmd_info.get("description", "") or cmd_info.get("summary", ""),
+                "parameters": {
+                    "type": "object",
+                    "properties": {},
+                    "required": []
+                }
+            }
+            
+            # Add parameters
+            for param_name, param_info in cmd_info.get("params", {}).items():
+                # Convert parameter to JSON Schema format
+                param_schema = {}
+                
+                # Parameter type
+                param_schema["type"] = param_info.get("type", "string")
+                
+                # Description
+                if "description" in param_info:
+                    param_schema["description"] = param_info["description"]
+                
+                # Default value
+                if "default" in param_info:
+                    param_schema["default"] = param_info["default"]
+                
+                # Possible values
+                if "enum" in param_info:
+                    param_schema["enum"] = param_info["enum"]
+                
+                # Add parameter to schema
+                tool["parameters"]["properties"][param_name] = param_schema
+                
+                # If parameter is required, add to required list
+                if param_info.get("required", False):
+                    tool["parameters"]["required"].append(param_name)
+            
+            # Add tool to list
+            schema["x-mcp-tools"].append(tool) 

{mcp_proxy_adapter-2.1.0.dist-info → mcp_proxy_adapter-2.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 2.1.0
+Version: 2.1.2
 Summary: Adapter for exposing Command Registry commands as tools for AI models via MCP Proxy.
 Home-page: https://github.com/vasilyvz/mcp-proxy-adapter
 Author: Vasiliy VZ
@@ -21,7 +21,7 @@ Requires-Python: >=3.9, <4
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fastapi<1.0.0,>=0.95.0
-Requires-Dist: pydantic<2.0.0,>=1.10.0
+Requires-Dist: pydantic>=2.0.0
 Requires-Dist: uvicorn<1.0.0,>=0.22.0
 Requires-Dist: docstring-parser<1.0.0,>=0.15
 Requires-Dist: typing-extensions<5.0.0,>=4.5.0

mcp_proxy_adapter-2.1.2.dist-info/RECORD

@@ -0,0 +1,61 @@
+docs/README.md,sha256=XpZqqKcf7GZ_uqtaadmIZc4dE9oyKv7biKj41kDtQo4,4633
+docs/README_ru.md,sha256=Ln8oDVOurhBVurQaEFDweVvq_bZZbdFSSTvWTrpBgMs,6326
+docs/architecture.md,sha256=wF5-RMQI-QssY4jA2lSKjjq6iHunda-n2PqI5ELAj84,10430
+docs/architecture_ru.md,sha256=Ato3CoAmhNBukMO6uje12e5-OlpDYVrwGIcN1CKqTsw,15529
+docs/command_development.md,sha256=-CKfEtLO-4tB2WKZNbIT1Ao4juiKFBcKS7As4_1ja74,6645
+docs/command_development_ru.md,sha256=kzvYpnEfsXfZxZY1wswwDChzBtMtEY9l74M7XkWxtHk,19968
+docs/deployment.md,sha256=eOOCq8V6Gz_SDo9hReXKXXNtaS8WmrxR-KXjJjUE1pw,4988
+docs/deployment_ru.md,sha256=0eNxKqiqc-sIht4brdZVEcxZkbrUP4y95PhfpD_0Qyg,40107
+docs/examples.md,sha256=85kfd73rgqJ2DUD3PrRfjViCXgv5bM_9Uqizm_ET7NE,6348
+docs/examples_ru.md,sha256=mxQqwKXMX6OcY6tyfuRgmYqAQXYnrzTGOJS_u5ECUcs,11866
+docs/mcp_proxy_adapter.md,sha256=Y-dcFKwYbYJe5_zDrvlDPuSz-S1czL7Gh848EzclS7k,8210
+docs/mcp_proxy_adapter_ru.md,sha256=aJ1KAyoyzcRPSn7YGralpUGO-zmUQMtDKoQ2zrOUVTc,17489
+docs/quickstart.md,sha256=YH0KspJcbe59ynpRf9kne-QsLGcUo4kKtNiEZ48nrus,5419
+docs/quickstart_ru.md,sha256=biipkQ4_XGVzqxLeGptzfWxyr6J9TN1ggdhCf2pDWKA,11884
+docs/testing.md,sha256=Z1hdqairo14QMoPxeBX1_YAbbS3Uedy4uaxfvu8aG5k,7572
+docs/testing_ru.md,sha256=z2-zGIXuFx8GpLYwydP9Oe3N8l_zVzheLBYvxgI-f6k,18219
+docs/validation_ru.md,sha256=iYtM3ZoFGe3_EaCG0738LkGJ5FPayrEr2z_KPhNcs0Q,15886
+examples/analyze_config.py,sha256=vog7TNHDw5ZoYhQLbAvZvEoufmQwH54KJzQBJrSq5w4,4283
+examples/basic_integration.py,sha256=w_oA777YiQt36gzI113KPQ6k45caXbMCqW9hD8sy8zo,4657
+examples/docstring_and_schema_example.py,sha256=c96L4KF_7yWzffmvd4hyeQuXSdYyYkv7Uvuy0QxgMcQ,1929
+examples/extension_example.py,sha256=vnatnFdNTapMpPcQ79Ugitk92ZiUfpLTs7Dvsodf1og,2277
+examples/help_best_practices.py,sha256=wUtZRnAktnpfAc9vAvqSxUquHEr5ewaPDPyc6BoCqdQ,2637
+examples/help_usage.py,sha256=UOd3HJeYlQpQkAyceGNm66jXX_h-T05pjIGD-b7-Pfg,2568
+examples/mcp_proxy_client.py,sha256=z4IzFlGigVTQSb8TpcrQ_a0migsmC58LnNwc8wZmTfw,3811
+examples/mcp_proxy_config.json,sha256=39aeV7NNEZstX9RAOdsr5tUZnvCuo7bR38Xc1sGGCJI,3655
+examples/openapi_server.py,sha256=hueoG9KcimOc4W27euWksMYjjG8Jz-li9hEKi3ZCDBk,12515
+examples/project_structure_example.py,sha256=sswTo6FZb1F5juHa0FYG3cgvrh3wfgGfJu2bBy5tCm4,1460
+examples/testing_example.py,sha256=AB13c4C1bjs1145O-yriwyreeVXtMOlQLzs2BCGmprk,1719
+mcp_proxy_adapter/__init__.py,sha256=_6D-TfANWp9zc550M5LUeGPvioFqG1bAl3tZj-gNmJU,463
+mcp_proxy_adapter/adapter.py,sha256=76dkVeDuqLsJ5AhuftzLlwy2M6yr_PfNbmNfo9dXVhc,28844
+mcp_proxy_adapter/models.py,sha256=acqVQBYAojHXeJ1MJyvpMyT6-J6aMxWuZMszn_-RsOU,2338
+mcp_proxy_adapter/registry.py,sha256=jgC4TKaPbMbAsoxvGp2ToaOE4drD-VfZug7WJbm4IW4,15853
+mcp_proxy_adapter/schema.py,sha256=HZM0TTQTSi8ha1TEeVevdCyGZOUPoT1soB7Nex0hV50,10947
+mcp_proxy_adapter/analyzers/__init__.py,sha256=2rcYZDP-bXq078MQpxP32lAwYYyRhOwAQGBcefBfBzY,368
+mcp_proxy_adapter/analyzers/docstring_analyzer.py,sha256=T3FLJEo_uChShfiEKRl8GpVoHvh5HiudZkxnj4KixfA,7541
+mcp_proxy_adapter/analyzers/type_analyzer.py,sha256=6Wac7osKwF03waFSwQ8ZM0Wqn_zAP2D-I4WMEpR0hQM,5230
+mcp_proxy_adapter/dispatchers/__init__.py,sha256=FWgimgInGphIjCEnvA3-ZExiapUzYAVis2H9C5IWivU,365
+mcp_proxy_adapter/dispatchers/base_dispatcher.py,sha256=S5_Xri058jAmOWeit1tedB_GMZQ9RLcNcYabA83ZF6k,2288
+mcp_proxy_adapter/dispatchers/json_rpc_dispatcher.py,sha256=ffu1M32E1AdC7IB44mlbV2L56eJQMsp-7fYi_r4rmHc,6331
+mcp_proxy_adapter/validators/docstring_validator.py,sha256=Onpq2iNJ1qF4ejkJJIlBkLROuSNIVALHVmXIgkCpaFI,2934
+mcp_proxy_adapter/validators/metadata_validator.py,sha256=uCrn38-VYYn89l6f5CC_GoTAHAweaOW2Z6Esro1rtGw,3155
+mcp_proxy_adapter-2.1.2.dist-info/licenses/LICENSE,sha256=OkApFEwdgMCt_mbvUI-eIwKMSTe38K3XnU2DT5ub-wI,1072
+scripts/publish.py,sha256=MMKksSAzWoZOlxxHOm9-o6juEJYj5AMS4OG5pDIeChw,2627
+scripts/code_analyzer/code_analyzer.py,sha256=FmWctoxttImvIPJoyNMLyUt7pEg3mQihqt6T9vMBKVQ,12766
+scripts/code_analyzer/register_commands.py,sha256=GpQxdFsA0BWHONZpDjl18zkoqlbV6pmkabLMwIR_1JE,20545
+tests/conftest.py,sha256=gkusSolrEp6-AHLjMKDUVxEcmfboa2P5SbeyiMugP-E,495
+tests/test_adapter.py,sha256=ohLX1wGFmHnv5DXJx2segjT2EEg9-3ZU9FKwS74D7KI,18247
+tests/test_adapter_coverage.py,sha256=k5oCvT9EQy_8JYam4Os88Npnn-Hgr0pm_ChHyRwk4Vc,8813
+tests/test_basic_dispatcher.py,sha256=wB30AM3UPI_EklAMrGIwQHDTqbfY80I5spi6arpdxCc,5472
+tests/test_command_registry.py,sha256=Ze4qwi2fV-EOuJ0su2l-jclLRCB9ZdZNUY54GFtde9E,12000
+tests/test_examples.py,sha256=dYiRgV3Z74MiOJq4I1soPE4xmJNSM8L-IqxdV4vXCWI,1615
+tests/test_mcp_proxy_adapter.py,sha256=WDYkLpz9Kd4OW0XbfhSanmhca7m7DIGZNC1L6CAoNpA,24890
+tests/test_mcp_proxy_adapter_basic.py,sha256=gKIcqYzZVEdJcp3PKKJPKNxtJ05l80Wj4ig1Vd2dagM,10624
+tests/test_part1.py,sha256=gb7lQ-lKjqYMMLGMt_7aSuScXSqy80tP8vBq2TBSiTs,14191
+tests/test_part2.py,sha256=842aTEHCwqS6UBs3sE0DRbXRdeiZ8n0w4rJTAWschnY,18220
+tests/test_schema.py,sha256=-X_323kncA0l3o1GKIKYf9OjhIj1hOJBPCH71682pk8,13704
+tests/test_simple_adapter.py,sha256=IFLbVphiRMl1w5LoT1AihYOt0b66GNnt8uDafwokVCI,8374
+mcp_proxy_adapter-2.1.2.dist-info/METADATA,sha256=RWCuMTdFD78eQjOZ_r33iBT8ChwqBJcKu_0T4MDQr6E,8150
+mcp_proxy_adapter-2.1.2.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+mcp_proxy_adapter-2.1.2.dist-info/top_level.txt,sha256=FkpPEr9rFZcEWxGfy6kRIUkCiLMxHpTD3--73ThTnPo,46
+mcp_proxy_adapter-2.1.2.dist-info/RECORD,,

mcp_proxy_adapter-2.1.2.dist-info/top_level.txt

@@ -0,0 +1,5 @@
+docs
+examples
+mcp_proxy_adapter
+scripts
+tests

scripts/code_analyzer/code_analyzer.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+"""
+Code Analyzer Tool
+
+This script performs three main functions:
+1. Lists Python files with more than 350 lines of code
+2. Creates a call graph showing which function calls which other function
+3. Creates an index of all functions with their file paths
+"""
+
+import os
+import ast
+import sys
+from pathlib import Path
+import networkx as nx
+import matplotlib.pyplot as plt
+from collections import defaultdict
+
+# Директории, которые следует исключить из анализа
+EXCLUDED_DIRS = [
+    '.venv', 
+    'site-packages', 
+    'dist-packages',
+    '__pycache__',
+    'node_modules',
+    '.git'
+]
+
+def should_skip_dir(path):
+    """Проверяет, нужно ли пропустить директорию"""
+    for excluded in EXCLUDED_DIRS:
+        if excluded in path:
+            return True
+    return False
+
+class FunctionCallVisitor(ast.NodeVisitor):
+    """AST visitor to collect function calls within each function definition"""
+    
+    def __init__(self):
+        self.current_function = None
+        self.call_graph = defaultdict(set)
+        self.functions = {}  # Map function names to their full names with class if applicable
+        self.current_class = None
+    
+    def visit_ClassDef(self, node):
+        old_class = self.current_class
+        self.current_class = node.name
+        # Visit all children in the class
+        self.generic_visit(node)
+        self.current_class = old_class
+    
+    def visit_FunctionDef(self, node):
+        # Save the current function
+        old_function = self.current_function
+        
+        # Create fully qualified function name
+        if self.current_class:
+            self.current_function = f"{self.current_class}.{node.name}"
+        else:
+            self.current_function = node.name
+        
+        # Map the simple name to the fully qualified name
+        self.functions[node.name] = self.current_function
+        
+        # Visit all children in the function
+        self.generic_visit(node)
+        
+        # Restore the parent function
+        self.current_function = old_function
+    
+    def visit_AsyncFunctionDef(self, node):
+        # Handle async functions just like regular functions
+        self.visit_FunctionDef(node)
+    
+    def visit_Call(self, node):
+        # Check if we're inside a function
+        if self.current_function:
+            func_name = None
+            
+            # Get the name of the called function
+            if isinstance(node.func, ast.Name):
+                # Direct function call like "foo()"
+                func_name = node.func.id
+            elif isinstance(node.func, ast.Attribute):
+                # Method call like "obj.foo()"
+                func_name = node.func.attr
+            
+            if func_name:
+                # Add to the call graph
+                self.call_graph[self.current_function].add(func_name)
+        
+        # Continue visiting children
+        self.generic_visit(node)
+
+def count_lines(file_path):
+    """Count the number of non-empty, non-comment lines in a file"""
+    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+        lines = f.readlines()
+    
+    # Count non-empty, non-comment lines
+    count = 0
+    for line in lines:
+        line = line.strip()
+        if line and not line.startswith('#'):
+            count += 1
+    
+    return count
+
+def find_large_files(root_dir, min_lines=350):
+    """Find Python files with more than min_lines lines of code"""
+    large_files = []
+    
+    for root, dirs, files in os.walk(root_dir):
+        # Пропускаем исключенные директории
+        dirs[:] = [d for d in dirs if not should_skip_dir(os.path.join(root, d))]
+        
+        for file in files:
+            if file.endswith('.py'):
+                file_path = os.path.join(root, file)
+                
+                # Пропускаем файлы в исключенных директориях
+                if should_skip_dir(file_path):
+                    continue
+                    
+                line_count = count_lines(file_path)
+                
+                if line_count > min_lines:
+                    relative_path = os.path.relpath(file_path, root_dir)
+                    large_files.append((relative_path, line_count))
+    
+    return large_files
+
+def create_function_index(root_dir, output_file='function_index.txt'):
+    """Create an index of all functions with their file paths"""
+    function_index = []
+    modules_analyzed = 0
+    
+    # Process each Python file
+    for root, dirs, files in os.walk(root_dir):
+        # Пропускаем исключенные директории
+        dirs[:] = [d for d in dirs if not should_skip_dir(os.path.join(root, d))]
+        
+        for file in files:
+            if file.endswith('.py'):
+                file_path = os.path.join(root, file)
+                
+                # Пропускаем файлы в исключенных директориях
+                if should_skip_dir(file_path):
+                    continue
+                
+                try:
+                    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                        module_content = f.read()
+                    
+                    # Parse the file
+                    module = ast.parse(module_content, filename=file_path)
+                    
+                    # Extract the module name from the file path
+                    rel_path = os.path.relpath(file_path, root_dir)
+                    module_name = os.path.splitext(rel_path)[0].replace(os.path.sep, '.')
+                    
+                    # Find functions and classes
+                    for node in ast.walk(module):
+                        if isinstance(node, ast.FunctionDef) or isinstance(node, ast.AsyncFunctionDef):
+                            function_name = node.name
+                            function_index.append((function_name, rel_path))
+                        elif isinstance(node, ast.ClassDef):
+                            class_name = node.name
+                            function_index.append((f"class {class_name}", rel_path))
+                            # Find methods in the class
+                            for class_node in node.body:
+                                if isinstance(class_node, ast.FunctionDef) or isinstance(class_node, ast.AsyncFunctionDef):
+                                    method_name = class_node.name
+                                    function_index.append((f"{class_name}.{method_name}", rel_path))
+                    
+                    modules_analyzed += 1
+                    
+                except (SyntaxError, UnicodeDecodeError) as e:
+                    print(f"Error analyzing {file_path}: {e}")
+    
+    # Save function index to file
+    with open(output_file, 'w', encoding='utf-8') as f:
+        f.write(f"# Function Index (analyzed {modules_analyzed} modules)\n\n")
+        
+        for function_name, file_path in sorted(function_index, key=lambda x: x[0].lower()):
+            f.write(f"{function_name}: {file_path}\n")
+    
+    print(f"Function index saved to {output_file}")
+    
+    return function_index
+
+def create_call_graph(root_dir, output_file='call_graph.txt'):
+    """Create a graph of function calls and save it to a file"""
+    call_graph = defaultdict(set)
+    modules_analyzed = 0
+    
+    # Process each Python file
+    for root, dirs, files in os.walk(root_dir):
+        # Пропускаем исключенные директории
+        dirs[:] = [d for d in dirs if not should_skip_dir(os.path.join(root, d))]
+        
+        for file in files:
+            if file.endswith('.py'):
+                file_path = os.path.join(root, file)
+                
+                # Пропускаем файлы в исключенных директориях
+                if should_skip_dir(file_path):
+                    continue
+                
+                try:
+                    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                        module_content = f.read()
+                    
+                    # Parse the file
+                    module = ast.parse(module_content, filename=file_path)
+                    
+                    # Extract the module name from the file path
+                    rel_path = os.path.relpath(file_path, root_dir)
+                    module_name = os.path.splitext(rel_path)[0].replace(os.path.sep, '.')
+                    
+                    # Find function calls
+                    visitor = FunctionCallVisitor()
+                    visitor.visit(module)
+                    
+                    # Add to the global call graph with module name prefix
+                    for caller, callees in visitor.call_graph.items():
+                        full_caller = f"{module_name}::{caller}"
+                        for callee in callees:
+                            # Try to get the fully qualified name if available
+                            if callee in visitor.functions:
+                                full_callee = f"{module_name}::{visitor.functions[callee]}"
+                            else:
+                                full_callee = callee
+                            
+                            call_graph[full_caller].add(full_callee)
+                    
+                    modules_analyzed += 1
+                    
+                except (SyntaxError, UnicodeDecodeError) as e:
+                    print(f"Error analyzing {file_path}: {e}")
+    
+    # Save call graph to file
+    with open(output_file, 'w', encoding='utf-8') as f:
+        f.write(f"# Function Call Graph (analyzed {modules_analyzed} modules)\n\n")
+        
+        for caller, callees in sorted(call_graph.items()):
+            f.write(f"{caller}:\n")
+            for callee in sorted(callees):
+                f.write(f"  - {callee}\n")
+            f.write("\n")
+    
+    print(f"Call graph saved to {output_file}")
+    
+    return call_graph
+
+def visualize_call_graph(call_graph, output_file='call_graph.png'):
+    """Create a visual representation of the call graph using NetworkX"""
+    G = nx.DiGraph()
+    
+    # Add nodes and edges
+    for caller, callees in call_graph.items():
+        G.add_node(caller)
+        for callee in callees:
+            G.add_node(callee)
+            G.add_edge(caller, callee)
+    
+    # Check if the graph is too large to visualize effectively
+    if len(G.nodes) > 100:
+        print(f"Warning: Graph is very large ({len(G.nodes)} nodes), visualization may be cluttered")
+        print("Consider filtering the graph or using a specialized tool like pyan for better visualization")
+    
+    try:
+        # Create the plot
+        plt.figure(figsize=(20, 20))
+        pos = nx.spring_layout(G, k=0.3, iterations=50)
+        nx.draw(G, pos, with_labels=True, node_size=100, node_color="skyblue", 
+                font_size=8, font_weight="bold", arrows=True, 
+                connectionstyle='arc3, rad=0.1', arrowsize=10)
+        
+        # Save the figure
+        plt.tight_layout()
+        plt.savefig(output_file, dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        print(f"Call graph visualization saved to {output_file}")
+    except Exception as e:
+        print(f"Error creating visualization: {e}")
+        print("Text-based call graph is still available")
+
+def main():
+    if len(sys.argv) > 1:
+        root_dir = sys.argv[1]
+    else:
+        root_dir = os.getcwd()  # Default to current directory
+    
+    print(f"Analyzing code in {root_dir} (excluding library files)")
+    
+    # Find large files
+    print("\n=== Files with more than 350 lines ===")
+    large_files = find_large_files(root_dir)
+    
+    if large_files:
+        with open('large_files.txt', 'w', encoding='utf-8') as f:
+            f.write("# Files with more than 350 lines of code\n\n")
+            for file_path, line_count in sorted(large_files, key=lambda x: x[1], reverse=True):
+                info = f"{file_path}: {line_count} lines"
+                print(info)
+                f.write(f"{info}\n")
+        print(f"\nList of large files saved to large_files.txt")
+    else:
+        print("No files with more than 350 lines found.")
+    
+    # Create function index
+    print("\n=== Creating function index ===")
+    create_function_index(root_dir)
+    
+    # Create call graph
+    print("\n=== Creating function call graph ===")
+    call_graph = create_call_graph(root_dir)
+    
+    # Try to visualize the graph if matplotlib is available
+    try:
+        visualize_call_graph(call_graph)
+    except Exception as e:
+        print(f"Could not create visual graph: {e}")
+
+if __name__ == "__main__":
+    main()