universal-mcp 0.1.13rc3__py3-none-any.whl → 0.1.13rc14__py3-none-any.whl

universal_mcp/applications/__init__.py

@@ -1,4 +1,7 @@
 import importlib
+import os
+import subprocess
+import sys
 
 from loguru import logger
 
@@ -7,12 +10,20 @@ from universal_mcp.applications.application import (
     BaseApplication,
     GraphQLApplication,
 )
-import subprocess
+
+UNIVERSAL_MCP_HOME = os.path.join(os.path.expanduser("~"), ".universal-mcp", "packages")
+
+if not os.path.exists(UNIVERSAL_MCP_HOME):
+    os.makedirs(UNIVERSAL_MCP_HOME)
+
+# set python path to include the universal-mcp home directory
+sys.path.append(UNIVERSAL_MCP_HOME)
+
 
 # Name are in the format of "app-name", eg, google-calendar
-# Folder name is "app_name", eg, google_calendar
 # Class name is NameApp, eg, GoogleCalendarApp
 
+
 def _import_class(module_path: str, class_name: str):
     """
     Helper to import a class by name from a module.
@@ -27,23 +38,29 @@ def _import_class(module_path: str, class_name: str):
         return getattr(module, class_name)
     except AttributeError as e:
         logger.error(f"Class '{class_name}' not found in module '{module_path}'")
-        raise ModuleNotFoundError(f"Class '{class_name}' not found in module '{module_path}'") from e
+        raise ModuleNotFoundError(
+            f"Class '{class_name}' not found in module '{module_path}'"
+        ) from e
+
 
 def _install_package(slug_clean: str):
     """
     Helper to install a package via pip from the universal-mcp GitHub repository.
     """
     repo_url = f"git+https://github.com/universal-mcp/{slug_clean}"
-    cmd = ["uv", "pip", "install", repo_url]
+    cmd = ["uv", "pip", "install", repo_url, "--target", UNIVERSAL_MCP_HOME]
     logger.info(f"Installing package '{slug_clean}' with command: {' '.join(cmd)}")
     try:
         subprocess.check_call(cmd)
     except subprocess.CalledProcessError as e:
         logger.error(f"Installation failed for '{slug_clean}': {e}")
-        raise ModuleNotFoundError(f"Installation failed for package '{slug_clean}'") from e
+        raise ModuleNotFoundError(
+            f"Installation failed for package '{slug_clean}'"
+        ) from e
     else:
         logger.info(f"Package '{slug_clean}' installed successfully")
 
+
 def app_from_slug(slug: str):
     """
     Dynamically resolve and return the application class for the given slug.
@@ -54,19 +71,26 @@ def app_from_slug(slug: str):
     package_prefix = f"universal_mcp_{slug_clean.replace('-', '_')}"
     module_path = f"{package_prefix}.app"
 
-    logger.info(f"Resolving app for slug '{slug}' → module '{module_path}', class '{class_name}'")
+    logger.info(
+        f"Resolving app for slug '{slug}' → module '{module_path}', class '{class_name}'"
+    )
     try:
         return _import_class(module_path, class_name)
     except ModuleNotFoundError as orig_err:
-        logger.warning(f"Module '{module_path}' not found locally: {orig_err}. Installing...")
+        logger.warning(
+            f"Module '{module_path}' not found locally: {orig_err}. Installing..."
+        )
         _install_package(slug_clean)
         # Retry import after installation
         try:
             return _import_class(module_path, class_name)
         except ModuleNotFoundError as retry_err:
-            logger.error(f"Still cannot import '{module_path}' after installation: {retry_err}")
+            logger.error(
+                f"Still cannot import '{module_path}' after installation: {retry_err}"
+            )
             raise
 
+
 __all__ = [
     "app_from_slug",
     "BaseApplication",

universal_mcp/cli.py

@@ -1,11 +1,9 @@
-import asyncio
-import os
+import re
 from pathlib import Path
 
 import typer
 from rich import print as rprint
 from rich.panel import Panel
-import re
 
 from universal_mcp.utils.installation import (
     get_supported_apps,
@@ -25,6 +23,12 @@ def generate(
         "-o",
         help="Output file path - should match the API name (e.g., 'twitter.py' for Twitter API)",
     ),
+    class_name: str = typer.Option(
+        None,
+        "--class-name",
+        "-c",
+        help="Class name to use for the API client",
+    ),
 ):
     """Generate API client from OpenAPI schema with optional docstring generation.
 
@@ -40,25 +44,35 @@ def generate(
 
     try:
         # Run the async function in the event loop
-        result = generate_api_from_schema(
-                schema_path=schema_path,
-                output_path=output_path,
-            )
-
-        if not output_path:
-            # Print to stdout if no output path
-            print(result["code"])
-        else:
-            typer.echo("API client successfully generated and installed.")
-            if "app_file" in result:
-                typer.echo(f"Application file: {result['app_file']}")
-            if "readme_file" in result and result["readme_file"]:
-                typer.echo(f"Documentation: {result['readme_file']}")
+        app_file = generate_api_from_schema(
+            schema_path=schema_path,
+            output_path=output_path,
+            class_name=class_name,
+        )
+        typer.echo("API client successfully generated and installed.")
+        typer.echo(f"Application file: {app_file}")
     except Exception as e:
         typer.echo(f"Error generating API client: {e}", err=True)
         raise typer.Exit(1) from e
 
 
+@app.command()
+def readme(
+    file_path: Path = typer.Argument(..., help="Path to the Python file to process"),
+    class_name: str = typer.Option(
+        None,
+        "--class-name",
+        "-c",
+        help="Class name to use for the API client",
+    ),
+):
+    """Generate a README.md file for the API client."""
+    from universal_mcp.utils.readme import generate_readme
+
+    readme_file = generate_readme(file_path, class_name)
+    typer.echo(f"README.md file generated at: {readme_file}")
+
+
 @app.command()
 def docgen(
     file_path: Path = typer.Argument(..., help="Path to the Python file to process"),
@@ -68,7 +82,6 @@ def docgen(
         "-m",
         help="Model to use for generating docstrings",
     ),
-    
 ):
     """Generate docstrings for Python files using LLMs.
 
@@ -154,6 +167,7 @@ def install(app_name: str = typer.Argument(..., help="Name of app to install")):
         typer.echo(f"Error installing app: {e}", err=True)
         raise typer.Exit(1) from e
 
+
 @app.command()
 def init(
     output_dir: Path | None = typer.Option(
@@ -162,13 +176,13 @@ def init(
         "-o",
         help="Output directory for the project (must exist)",
     ),
-    app_name: str|None = typer.Option(
+    app_name: str | None = typer.Option(
         None,
         "--app-name",
         "-a",
         help="App name (letters, numbers, hyphens, underscores only)",
     ),
-    integration_type: str|None = typer.Option(
+    integration_type: str | None = typer.Option(
         None,
         "--integration-type",
         "-i",
@@ -195,7 +209,7 @@ def init(
         app_name = typer.prompt(
             "Enter the app name",
             default="app_name",
-            prompt_suffix=" (e.g., reddit, youtube): "
+            prompt_suffix=" (e.g., reddit, youtube): ",
         ).strip()
     validate_pattern(app_name, "app name")
 
@@ -203,10 +217,10 @@ def init(
         path_str = typer.prompt(
             "Enter the output directory for the project",
             default=str(Path.cwd()),
-            prompt_suffix=": "
+            prompt_suffix=": ",
         ).strip()
         output_dir = Path(path_str)
-    
+
     if not output_dir.exists():
         try:
             output_dir.mkdir(parents=True, exist_ok=True)
@@ -219,7 +233,7 @@ def init(
                 f"❌ Failed to create output directory '{output_dir}': {e}",
                 fg=typer.colors.RED,
             )
-            raise typer.Exit(code=1)
+            raise typer.Exit(code=1) from e
     elif not output_dir.is_dir():
         typer.secho(
             f"❌ Output path '{output_dir}' exists but is not a directory.",
@@ -232,7 +246,7 @@ def init(
         integration_type = typer.prompt(
             "Choose the integration type",
             default="agentr",
-            prompt_suffix=" (api_key, oauth, agentr, none): "
+            prompt_suffix=" (api_key, oauth, agentr, none): ",
         ).lower()
     if integration_type not in ("api_key", "oauth", "agentr", "none"):
         typer.secho(
@@ -240,7 +254,6 @@ def init(
             fg=typer.colors.RED,
         )
         raise typer.Exit(code=1)
-    
 
     typer.secho("🚀 Generating project using cookiecutter...", fg=typer.colors.BLUE)
     try:
@@ -255,10 +268,11 @@ def init(
         )
     except Exception as exc:
         typer.secho(f"❌ Project generation failed: {exc}", fg=typer.colors.RED)
-        raise typer.Exit(code=1)
+        raise typer.Exit(code=1) from exc
 
     project_dir = output_dir / f"universal-mcp-{app_name}"
     typer.secho(f"✅ Project created at {project_dir}", fg=typer.colors.GREEN)
 
+
 if __name__ == "__main__":
     app()

universal_mcp/integrations/__init__.py

@@ -1,9 +1,9 @@
 from universal_mcp.config import IntegrationConfig
 from universal_mcp.integrations.integration import (
+    AgentRIntegration,
     ApiKeyIntegration,
     Integration,
     OAuthIntegration,
-    AgentRIntegration,
 )
 from universal_mcp.stores.store import BaseStore
 

universal_mcp/servers/server.py

@@ -1,8 +1,6 @@
-import os
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 from typing import Any
-from urllib.parse import urlparse
 
 import httpx
 from loguru import logger

universal_mcp/stores/store.py

@@ -11,11 +11,13 @@ class StoreError(Exception):
 
     pass
 
+
 class KeyNotFoundError(StoreError):
     """Exception raised when a key is not found in the store."""
 
     pass
 
+
 class BaseStore(ABC):
     """
     Abstract base class defining the interface for credential stores.

universal_mcp/tools/tools.py

@@ -260,9 +260,7 @@ class ToolManager:
         try:
             available_tool_functions = app.list_tools()
         except TypeError as e:
-            logger.error(
-                f"Error calling list_tools for app '{app.name}'. Error: {e}"
-            )
+            logger.error(f"Error calling list_tools for app '{app.name}'. Error: {e}")
             return
         except Exception as e:
             logger.error(f"Failed to get tool list from app '{app.name}': {e}")

universal_mcp/utils/agentr.py

@@ -1,9 +1,13 @@
-from loguru import logger
 import os
+
 import httpx
+from loguru import logger
+
 from universal_mcp.config import AppConfig
+from universal_mcp.exceptions import NotAuthorizedError
 from universal_mcp.utils.singleton import Singleton
 
+
 class AgentrClient(metaclass=Singleton):
     """Helper class for AgentR API operations.
 
@@ -22,7 +26,9 @@ class AgentrClient(metaclass=Singleton):
                 "API key for AgentR is missing. Please visit https://agentr.dev to create an API key, then set it as AGENTR_API_KEY environment variable."
             )
             raise ValueError("AgentR API key required - get one at https://agentr.dev")
-        self.base_url = (base_url or os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")).rstrip("/")
+        self.base_url = (
+            base_url or os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
+        ).rstrip("/")
 
     def get_credentials(self, integration_name: str) -> dict:
         """Get credentials for an integration from the AgentR API.
@@ -87,4 +93,3 @@ class AgentrClient(metaclass=Singleton):
         response.raise_for_status()
         data = response.json()
         return [AppConfig.model_validate(app) for app in data]
-

universal_mcp/utils/api_generator.py

@@ -1,10 +1,10 @@
+import importlib.util
 import inspect
 import os
+import shutil
 from pathlib import Path
+
 from loguru import logger
-import shutil
-import importlib.util
-from jinja2 import Environment, FileSystemLoader, TemplateError, select_autoescape
 
 from universal_mcp.utils.openapi import generate_api_client, load_schema
 
@@ -26,6 +26,7 @@ def validate_and_load_schema(schema_path: Path) -> dict:
         echo(f"Error loading schema: {e}", err=True)
         raise
 
+
 def get_class_info(module: any) -> tuple[str | None, any]:
     """Find the main class in the generated module."""
     for name, obj in inspect.getmembers(module):
@@ -33,71 +34,6 @@ def get_class_info(module: any) -> tuple[str | None, any]:
             return name, obj
     return None, None
 
-def generate_readme(
-    app_dir: Path, folder_name: str, tools: list
-) -> Path:
-    """Generate README.md with API documentation.
-    
-    Args:
-        app_dir: Directory where the README will be generated
-        folder_name: Name of the application folder
-        tools: List of Function objects from the OpenAPI schema
-        
-    Returns:
-        Path to the generated README file
-        
-    Raises:
-        FileNotFoundError: If the template directory doesn't exist
-        TemplateError: If there's an error rendering the template
-        IOError: If there's an error writing the README file
-    """
-    app = folder_name.replace("_", " ").title()
-    logger.info(f"Generating README for {app} in {app_dir}")
-
-    # Format tools into (name, description) tuples
-    formatted_tools = []
-    for tool in tools:
-        name = tool.__name__
-        description = tool.__doc__.strip().split("\n")[0]
-        formatted_tools.append((name, description))
-
-    # Set up Jinja2 environment
-    template_dir = Path(__file__).parent.parent / "templates"
-    if not template_dir.exists():
-        logger.error(f"Template directory not found: {template_dir}")
-        raise FileNotFoundError(f"Template directory not found: {template_dir}")
-
-    try:
-        env = Environment(
-            loader=FileSystemLoader(template_dir),
-            autoescape=select_autoescape()
-        )
-        template = env.get_template("README.md.j2")
-    except Exception as e:
-        logger.error(f"Error loading template: {e}")
-        raise TemplateError(f"Error loading template: {e}")
-
-    # Render the template
-    try:
-        readme_content = template.render(
-            name=app,
-            tools=formatted_tools
-        )
-    except Exception as e:
-        logger.error(f"Error rendering template: {e}")
-        raise TemplateError(f"Error rendering template: {e}")
-
-    # Write the README file
-    readme_file = app_dir / "README.md"
-    try:
-        with open(readme_file, "w") as f:
-            f.write(readme_content)
-        logger.info(f"Documentation generated at: {readme_file}")
-    except Exception as e:
-        logger.error(f"Error writing README file: {e}")
-        raise IOError(f"Error writing README file: {e}")
-
-    return readme_file
 
 def test_correct_output(gen_file: Path):
     # Check file is non-empty
@@ -122,7 +58,7 @@ def test_correct_output(gen_file: Path):
 def generate_api_from_schema(
     schema_path: Path,
     output_path: Path | None = None,
-    add_docstrings: bool = True,
+    class_name: str | None = None,
 ) -> tuple[Path, Path]:
     """
     Generate API client from OpenAPI schema and write to app.py with a README.
@@ -137,7 +73,6 @@ def generate_api_from_schema(
     """
     # Local imports for logging and file operations
 
-
     logger.info("Starting API generation for schema: %s", schema_path)
 
     # 1. Parse and validate schema
@@ -150,7 +85,7 @@ def generate_api_from_schema(
 
     # 2. Generate client code
     try:
-        code = generate_api_client(schema)
+        code = generate_api_client(schema, class_name)
         logger.info("API client code generated.")
     except Exception as e:
         logger.error("Code generation failed: %s", e)
@@ -174,10 +109,15 @@ 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(" 2) Inspect '%s' for syntax or logic errors in the generated code.", gen_file)
+        logger.info(
+            " 2) Inspect '%s' for syntax or logic errors in the generated code.",
+            gen_file,
+        )
         logger.info(" 3) Correct the issues and re-run the command.")
         return {"error": "Validation failed. See logs above for detailed instructions."}
 
@@ -190,33 +130,6 @@ def generate_api_from_schema(
     shutil.copy(gen_file, app_file)
     logger.info("App file written to: %s", app_file)
 
-    # 6. Collect tools and generate README
-    import importlib.util
-    import sys
-
-    # Load the generated module as "temp_module"
-    spec = importlib.util.spec_from_file_location("temp_module", str(app_file))
-    module = importlib.util.module_from_spec(spec)
-    sys.modules["temp_module"] = module
-    spec.loader.exec_module(module)
-
-    # Retrieve the generated API class
-    class_name, cls = get_class_info(module)
-
-    # Instantiate client and collect its tools
-    tools = []
-    if cls:
-        try:
-            client = cls()
-            tools = client.list_tools()
-        except Exception as e:
-            logger.warning("Failed to instantiate '%s' or list tools: %s", class_name, e)
-    else:
-        logger.warning("No generated class found in module 'temp_module'")
-    readme_file = generate_readme(target_dir, output_path.stem, tools)
-    logger.info("README generated at: %s", readme_file)
-
-
     # Cleanup intermediate file
     try:
         os.remove(gen_file)
@@ -224,4 +137,4 @@ def generate_api_from_schema(
     except Exception as e:
         logger.warning("Could not remove intermediate file %s: %s", gen_file, e)
 
-    return app_file, readme_file
+    return app_file

universal_mcp/utils/docgen.py

@@ -176,7 +176,7 @@ def extract_json_from_text(text):
 
 
 def generate_docstring(
-    function_code: str, model: str = "perplexity/sonar-pro"
+    function_code: str, model: str = "perplexity/sonar"
 ) -> DocstringOutput:
     """
     Generate a docstring for a Python function using litellm with structured output.
@@ -509,7 +509,7 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
         return function_code
 
 
-def process_file(file_path: str, model: str = "perplexity/sonar-pro") -> int:
+def process_file(file_path: str, model: str = "perplexity/sonar") -> int:
     """
     Process a Python file and add docstrings to all functions in it.