universal-mcp 0.1.15rc5__py3-none-any.whl → 0.1.16__py3-none-any.whl

universal_mcp/utils/installation.py

@@ -7,19 +7,30 @@ from loguru import logger
 from rich import print
 
 
-def get_uvx_path() -> str:
+def get_uvx_path() -> Path:
     """Get the full path to the uv executable."""
     uvx_path = shutil.which("uvx")
-    if not uvx_path:
-        logger.error(
-            "uvx executable not found in PATH, falling back to 'uvx'. "
-            "Please ensure uvx is installed and in your PATH"
-        )
-        return "uvx"  # Fall back to just "uvx" if not found
-    return uvx_path
-
-
-def create_file_if_not_exists(path: Path) -> None:
+    if uvx_path:
+        return Path(uvx_path)
+
+    # Check if
+    common_uv_paths = [
+        Path.home() / ".local/bin/uvx",  # Linux/macOS
+        Path.home() / ".cargo/bin/uvx",  # Linux/macOS
+        Path.home() / "AppData/Local/Programs/uvx/uvx.exe",  # Windows
+        Path.home() / "AppData/Roaming/uvx/uvx.exe",  # Windows
+    ]
+    for path in common_uv_paths:
+        logger.info(f"Checking {path}")
+        if path.exists():
+            return path
+    logger.error(
+        "uvx executable not found in PATH, falling back to 'uvx'. Please ensure uvx is installed and in your PATH"
+    )
+    return None  # Fall back to just "uvx" if not found
+
+
+def _create_file_if_not_exists(path: Path) -> None:
     """Create a file if it doesn't exist"""
     if not path.exists():
         print(f"[yellow]Creating config file at {path}[/yellow]")
@@ -27,6 +38,34 @@ def create_file_if_not_exists(path: Path) -> None:
             json.dump({}, f)
 
 
+def _generate_mcp_config(api_key: str) -> None:
+    uvx_path = get_uvx_path()
+    if not uvx_path:
+        raise ValueError("uvx executable not found in PATH")
+    return {
+        "command": str(uvx_path),
+        "args": ["universal_mcp@latest", "run"],
+        "env": {
+            "AGENTR_API_KEY": api_key,
+            "PATH": str(uvx_path.parent),
+        },
+    }
+
+
+def _install_config(config_path: Path, mcp_config: dict):
+    _create_file_if_not_exists(config_path)
+    try:
+        config = json.loads(config_path.read_text())
+    except json.JSONDecodeError:
+        print("[yellow]Config file was empty or invalid, creating new configuration[/yellow]")
+        config = {}
+    if "mcpServers" not in config:
+        config["mcpServers"] = {}
+    config["mcpServers"]["universal_mcp"] = mcp_config
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=4)
+
+
 def get_supported_apps() -> list[str]:
     """Get list of supported apps"""
     return ["claude", "cursor", "cline", "continue", "goose", "windsurf", "zed"]
@@ -37,35 +76,17 @@ def install_claude(api_key: str) -> None:
     print("[bold blue]Installing Claude configuration...[/bold blue]")
     # Determine platform-specific config path
     if sys.platform == "darwin":  # macOS
-        config_path = (
-            Path.home()
-            / "Library/Application Support/Claude/claude_desktop_config.json"
-        )
+        config_path = Path.home() / "Library/Application Support/Claude/claude_desktop_config.json"
     elif sys.platform == "win32":  # Windows
         config_path = Path.home() / "AppData/Roaming/Claude/claude_desktop_config.json"
     else:
         raise ValueError(
             "Unsupported platform. Only macOS and Windows are currently supported.",
         )
-
-    # Create config directory if it doesn't exist
-    create_file_if_not_exists(config_path)
-    try:
-        config = json.loads(config_path.read_text())
-    except json.JSONDecodeError:
-        print(
-            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
-        )
-        config = {}
-    if "mcpServers" not in config:
-        config["mcpServers"] = {}
-    config["mcpServers"]["universal_mcp"] = {
-        "command": get_uvx_path(),
-        "args": ["universal_mcp@latest", "run"],
-        "env": {"AGENTR_API_KEY": api_key},
-    }
-    with open(config_path, "w") as f:
-        json.dump(config, f, indent=4)
+    mcp_config = _generate_mcp_config(api_key=api_key)
+    logger.info(f"Installing Claude configuration at {config_path}")
+    logger.info(f"Config: {mcp_config}")
+    _install_config(config_path=config_path, mcp_config=mcp_config)
     print("[green]✓[/green] Claude configuration installed successfully")
 
 
@@ -74,28 +95,8 @@ def install_cursor(api_key: str) -> None:
     print("[bold blue]Installing Cursor configuration...[/bold blue]")
     # Set up Cursor config path
     config_path = Path.home() / ".cursor/mcp.json"
-
-    # Create config directory if it doesn't exist
-    create_file_if_not_exists(config_path)
-
-    try:
-        config = json.loads(config_path.read_text())
-    except json.JSONDecodeError:
-        print(
-            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
-        )
-        config = {}
-
-    if "mcpServers" not in config:
-        config["mcpServers"] = {}
-    config["mcpServers"]["universal_mcp"] = {
-        "command": get_uvx_path(),
-        "args": ["universal_mcp@latest", "run"],
-        "env": {"AGENTR_API_KEY": api_key},
-    }
-
-    with open(config_path, "w") as f:
-        json.dump(config, f, indent=4)
+    mcp_config = _generate_mcp_config(api_key=api_key)
+    _install_config(config_path=config_path, mcp_config=mcp_config)
     print("[green]✓[/green] Cursor configuration installed successfully")
 
 
@@ -104,28 +105,8 @@ def install_cline(api_key: str) -> None:
     print("[bold blue]Installing Cline configuration...[/bold blue]")
     # Set up Cline config path
     config_path = Path.home() / ".config/cline/mcp.json"
-
-    # Create config directory if it doesn't exist
-    create_file_if_not_exists(config_path)
-
-    try:
-        config = json.loads(config_path.read_text())
-    except json.JSONDecodeError:
-        print(
-            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
-        )
-        config = {}
-
-    if "mcpServers" not in config:
-        config["mcpServers"] = {}
-    config["mcpServers"]["universal_mcp"] = {
-        "command": get_uvx_path(),
-        "args": ["universal_mcp@latest", "run"],
-        "env": {"AGENTR_API_KEY": api_key},
-    }
-
-    with open(config_path, "w") as f:
-        json.dump(config, f, indent=4)
+    mcp_config = _generate_mcp_config(api_key=api_key)
+    _install_config(config_path=config_path, mcp_config=mcp_config)
     print("[green]✓[/green] Cline configuration installed successfully")
 
 
@@ -140,28 +121,8 @@ def install_continue(api_key: str) -> None:
         config_path = Path.home() / "AppData/Roaming/Continue/mcp.json"
     else:  # Linux and others
         config_path = Path.home() / ".config/continue/mcp.json"
-
-    # Create config directory if it doesn't exist
-    create_file_if_not_exists(config_path)
-
-    try:
-        config = json.loads(config_path.read_text())
-    except json.JSONDecodeError:
-        print(
-            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
-        )
-        config = {}
-
-    if "mcpServers" not in config:
-        config["mcpServers"] = {}
-    config["mcpServers"]["universal_mcp"] = {
-        "command": get_uvx_path(),
-        "args": ["universal_mcp@latest", "run"],
-        "env": {"AGENTR_API_KEY": api_key},
-    }
-
-    with open(config_path, "w") as f:
-        json.dump(config, f, indent=4)
+    mcp_config = _generate_mcp_config(api_key=api_key)
+    _install_config(config_path=config_path, mcp_config=mcp_config)
     print("[green]✓[/green] Continue configuration installed successfully")
 
 
@@ -177,27 +138,8 @@ def install_goose(api_key: str) -> None:
     else:  # Linux and others
         config_path = Path.home() / ".config/goose/mcp-config.json"
 
-    # Create config directory if it doesn't exist
-    create_file_if_not_exists(config_path)
-
-    try:
-        config = json.loads(config_path.read_text())
-    except json.JSONDecodeError:
-        print(
-            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
-        )
-        config = {}
-
-    if "mcpServers" not in config:
-        config["mcpServers"] = {}
-    config["mcpServers"]["universal_mcp"] = {
-        "command": get_uvx_path(),
-        "args": ["universal_mcp@latest", "run"],
-        "env": {"AGENTR_API_KEY": api_key},
-    }
-
-    with open(config_path, "w") as f:
-        json.dump(config, f, indent=4)
+    mcp_config = _generate_mcp_config(api_key=api_key)
+    _install_config(config_path=config_path, mcp_config=mcp_config)
     print("[green]✓[/green] Goose configuration installed successfully")
 
 
@@ -212,28 +154,8 @@ def install_windsurf(api_key: str) -> None:
         config_path = Path.home() / "AppData/Roaming/Windsurf/mcp.json"
     else:  # Linux and others
         config_path = Path.home() / ".config/windsurf/mcp.json"
-
-    # Create config directory if it doesn't exist
-    create_file_if_not_exists(config_path)
-
-    try:
-        config = json.loads(config_path.read_text())
-    except json.JSONDecodeError:
-        print(
-            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
-        )
-        config = {}
-
-    if "mcpServers" not in config:
-        config["mcpServers"] = {}
-    config["mcpServers"]["universal_mcp"] = {
-        "command": get_uvx_path(),
-        "args": ["universal_mcp@latest", "run"],
-        "env": {"AGENTR_API_KEY": api_key},
-    }
-
-    with open(config_path, "w") as f:
-        json.dump(config, f, indent=4)
+    mcp_config = _generate_mcp_config(api_key=api_key)
+    _install_config(config_path=config_path, mcp_config=mcp_config)
     print("[green]✓[/green] Windsurf configuration installed successfully")
 
 
@@ -244,47 +166,8 @@ def install_zed(api_key: str) -> None:
     # Set up Zed config path
     config_dir = Path.home() / ".config/zed"
     config_path = config_dir / "mcp_servers.json"
-
-    # Create config directory if it doesn't exist
-    create_file_if_not_exists(config_path)
-
-    try:
-        config = json.loads(config_path.read_text())
-    except json.JSONDecodeError:
-        print(
-            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
-        )
-        config = {}
-
-    if not isinstance(config, list):
-        config = []
-
-    # Check if universal_mcp is already in the config
-    existing_config = False
-    for server in config:
-        if server.get("name") == "universal_mcp":
-            existing_config = True
-            server.update(
-                {
-                    "command": get_uvx_path(),
-                    "args": ["universal_mcp@latest", "run"],
-                    "env": {"AGENTR_API_KEY": api_key},
-                }
-            )
-            break
-
-    if not existing_config:
-        config.append(
-            {
-                "name": "universal_mcp",
-                "command": get_uvx_path(),
-                "args": ["universal_mcp@latest", "run"],
-                "env": {"AGENTR_API_KEY": api_key},
-            }
-        )
-
-    with open(config_path, "w") as f:
-        json.dump(config, f, indent=4)
+    mcp_config = _generate_mcp_config(api_key=api_key)
+    _install_config(config_path=config_path, mcp_config=mcp_config)
     print("[green]✓[/green] Zed configuration installed successfully")
 
 

universal_mcp/utils/{api_generator.py → openapi/api_generator.py}

@@ -6,7 +6,7 @@ from pathlib import Path
 
 from loguru import logger
 
-from universal_mcp.utils.openapi import generate_api_client, load_schema
+from universal_mcp.utils.openapi.openapi import generate_api_client, load_schema
 
 
 def echo(message: str, err: bool = False) -> None:
@@ -109,9 +109,7 @@ def generate_api_from_schema(
         f.write(code)
 
     if not test_correct_output(gen_file):
-        logger.error(
-            "Generated code validation failed for '%s'. Aborting generation.", gen_file
-        )
+        logger.error("Generated code validation failed for '%s'. Aborting generation.", gen_file)
         logger.info("Next steps:")
         logger.info(" 1) Review your OpenAPI schema for potential mismatches.")
         logger.info(

universal_mcp/utils/{docgen.py → openapi/docgen.py}

@@ -19,12 +19,8 @@ from pydantic import BaseModel, Field
 class DocstringOutput(BaseModel):
     """Structure for the generated docstring output."""
 
-    summary: str = Field(
-        description="A clear, concise summary of what the function does"
-    )
-    args: dict[str, str] = Field(
-        description="Dictionary mapping parameter names to their descriptions"
-    )
+    summary: str = Field(description="A clear, concise summary of what the function does")
+    args: dict[str, str] = Field(description="Dictionary mapping parameter names to their descriptions")
     returns: str = Field(description="Description of what the function returns")
     raises: dict[str, str] = Field(
         default_factory=dict,
@@ -44,9 +40,7 @@ class FunctionExtractor(ast.NodeVisitor):
 
     def __init__(self, source_code: str):
         self.source_lines = source_code.splitlines(keepends=True)
-        self.functions: list[
-            tuple[str, str]
-        ] = []  # Store tuples of (function_name, function_source)
+        self.functions: list[tuple[str, str]] = []  # Store tuples of (function_name, function_source)
 
     def _get_source_segment(self, node: ast.AST) -> str | None:
         """Safely extracts the source segment for a node using ast.get_source_segment."""
@@ -110,9 +104,7 @@ def extract_functions_from_script(file_path: str) -> list[tuple[str, str]]:
     try:
         tree = ast.parse(source_code, filename=file_path)
     except SyntaxError as e:
-        print(
-            f"Error: Invalid Python syntax in {file_path} at line {e.lineno}, offset {e.offset}: {e.msg}"
-        )
+        print(f"Error: Invalid Python syntax in {file_path} at line {e.lineno}, offset {e.offset}: {e.msg}")
         raise
     except Exception as e:
         print(f"Error parsing {file_path} into AST: {e}")
@@ -175,9 +167,7 @@ def extract_json_from_text(text):
         raise ValueError("Could not extract valid JSON from the response") from e
 
 
-def generate_docstring(
-    function_code: str, model: str = "perplexity/sonar"
-) -> DocstringOutput:
+def generate_docstring(function_code: str, model: str = "perplexity/sonar") -> DocstringOutput:
     """
     Generate a docstring for a Python function using litellm with structured output.
 
@@ -239,9 +229,7 @@ def generate_docstring(
             parsed_data = extract_json_from_text(response_text)
         except ValueError as e:
             print(f"JSON extraction failed: {e}")
-            print(
-                f"Raw response: {response_text[:100]}..."
-            )  # Log first 100 chars for debugging
+            print(f"Raw response: {response_text[:100]}...")  # Log first 100 chars for debugging
             # Return a default structure if extraction fails
             return DocstringOutput(
                 summary="Failed to extract docstring information",
@@ -291,20 +279,14 @@ def format_docstring(docstring: DocstringOutput) -> str:
     if summary:
         parts.append(summary)
 
-    filtered_args = {
-        name: desc
-        for name, desc in docstring.args.items()
-        if name not in ("self", "cls")
-    }
+    filtered_args = {name: desc for name, desc in docstring.args.items() if name not in ("self", "cls")}
     args_lines = []
     if filtered_args:
         args_lines.append("Args:")
         for arg_name, arg_desc in filtered_args.items():
             arg_desc_cleaned = arg_desc.strip()
             args_lines.append(f"    {arg_name}: {arg_desc_cleaned}")
-    elif docstring.args.get(
-        "None"
-    ):  # Include the 'None' placeholder if it was generated
+    elif docstring.args.get("None"):  # Include the 'None' placeholder if it was generated
         args_lines.append("Args:")
         none_desc_cleaned = docstring.args["None"].strip()
         args_lines.append(f"    None: {none_desc_cleaned}")
@@ -321,12 +303,8 @@ def format_docstring(docstring: DocstringOutput) -> str:
         raises_lines.append("Raises:")
         for exception_type, exception_desc in docstring.raises.items():
             exception_desc_cleaned = exception_desc.strip()
-            if (
-                exception_type.strip() and exception_desc_cleaned
-            ):  # Ensure type and desc are not empty
-                raises_lines.append(
-                    f"    {exception_type.strip()}: {exception_desc_cleaned}"
-                )
+            if exception_type.strip() and exception_desc_cleaned:  # Ensure type and desc are not empty
+                raises_lines.append(f"    {exception_type.strip()}: {exception_desc_cleaned}")
     if raises_lines:
         parts.append("\n".join(raises_lines))
 
@@ -363,9 +341,7 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
         lines = function_code.splitlines(keepends=True)
 
         tree = ast.parse(function_code)
-        if not tree.body or not isinstance(
-            tree.body[0], ast.FunctionDef | ast.AsyncFunctionDef
-        ):
+        if not tree.body or not isinstance(tree.body[0], ast.FunctionDef | ast.AsyncFunctionDef):
             print(
                 "Warning: Could not parse function definition from code snippet. Returning original code.",
                 file=sys.stderr,
@@ -399,15 +375,11 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
             if func_node.lineno - 1 < len(lines):  # Ensure def line exists
                 def_line = lines[func_node.lineno - 1]
                 def_line_indent = def_line[: len(def_line) - len(def_line.lstrip())]
-                body_indent = (
-                    def_line_indent + "    "
-                )  # Standard 4 spaces relative indent
+                body_indent = def_line_indent + "    "  # Standard 4 spaces relative indent
 
         # Format the new docstring lines with the calculated indentation
         new_docstring_lines_formatted = [f'{body_indent}"""\n']
-        new_docstring_lines_formatted.extend(
-            [f"{body_indent}{line}\n" for line in docstring.splitlines()]
-        )
+        new_docstring_lines_formatted.extend([f"{body_indent}{line}\n" for line in docstring.splitlines()])
         new_docstring_lines_formatted.append(f'{body_indent}"""\n')
 
         output_lines = []
@@ -425,10 +397,7 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
                 dummy_tree = ast.parse(dummy_code)
                 dummy_body_statements = (
                     dummy_tree.body[0].body
-                    if dummy_tree.body
-                    and isinstance(
-                        dummy_tree.body[0], ast.FunctionDef | ast.AsyncFunctionDef
-                    )
+                    if dummy_tree.body and isinstance(dummy_tree.body[0], ast.FunctionDef | ast.AsyncFunctionDef)
                     else []
                 )
                 cleaned_body_parts = []
@@ -455,13 +424,9 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
 
                     if not is_just_string_stmt:
                         stmt_start_idx = stmt_node.lineno - 1
-                        stmt_end_idx = (
-                            stmt_node.end_lineno - 1
-                        )  # Inclusive end line index
+                        stmt_end_idx = stmt_node.end_lineno - 1  # Inclusive end line index
 
-                        cleaned_body_parts.extend(
-                            lines[stmt_start_idx : stmt_end_idx + 1]
-                        )
+                        cleaned_body_parts.extend(lines[stmt_start_idx : stmt_end_idx + 1])
 
                 if func_node.body:
                     last_stmt_end_idx = func_node.body[-1].end_lineno - 1
@@ -545,9 +510,7 @@ def process_file(file_path: str, model: str = "perplexity/sonar") -> int:
         formatted_docstring = format_docstring(docstring_output)
 
         # Insert docstring into function
-        updated_function = insert_docstring_into_function(
-            function_code, formatted_docstring
-        )
+        updated_function = insert_docstring_into_function(function_code, formatted_docstring)
 
         # Replace the function in the file content
         if updated_function != function_code: