universal-mcp 0.1.1__py3-none-any.whl → 0.1.2rc1__py3-none-any.whl

universal_mcp/cli.py

@@ -1,6 +1,9 @@
-import typer
+import asyncio
+import os
 from pathlib import Path
 
+import typer
+
 from universal_mcp.utils.installation import (
     get_supported_apps,
     install_claude,
@@ -11,29 +14,111 @@ app = typer.Typer()
 
 
 @app.command()
-def generate(schema_path: Path = typer.Option(..., "--schema", "-s")):
-    """Generate API client from OpenAPI schema"""
+def generate(
+    schema_path: Path = typer.Option(..., "--schema", "-s"),
+    output_path: Path = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output file path - should match the API name (e.g., 'twitter.py' for Twitter API)",
+    ),
+    add_docstrings: bool = typer.Option(
+        True, "--docstrings/--no-docstrings", help="Add docstrings to generated code"
+    ),
+):
+    """Generate API client from OpenAPI schema with optional docstring generation.
+
+    The output filename should match the name of the API in the schema (e.g., 'twitter.py' for Twitter API).
+    This name will be used for the folder in applications/ and as a prefix for function names.
+    """
+    # Import here to avoid circular imports
+    from universal_mcp.utils.api_generator import generate_api_from_schema
+
     if not schema_path.exists():
         typer.echo(f"Error: Schema file {schema_path} does not exist", err=True)
         raise typer.Exit(1)
-    from .utils.openapi import generate_api_client, load_schema
 
     try:
-        schema = load_schema(schema_path)
+        # Run the async function in the event loop
+        result = asyncio.run(
+            generate_api_from_schema(
+                schema_path=schema_path,
+                output_path=output_path,
+                add_docstrings=add_docstrings,
+            )
+        )
+
+        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']}")
     except Exception as e:
-        typer.echo(f"Error loading schema: {e}", err=True)
+        typer.echo(f"Error generating API client: {e}", err=True)
+        raise typer.Exit(1) from e
+
+
+@app.command()
+def docgen(
+    file_path: Path = typer.Argument(..., help="Path to the Python file to process"),
+    model: str = typer.Option(
+        "anthropic/claude-3-sonnet-20240229",
+        "--model",
+        "-m",
+        help="Model to use for generating docstrings",
+    ),
+    api_key: str = typer.Option(
+        None,
+        "--api-key",
+        help="Anthropic API key (can also be set via ANTHROPIC_API_KEY environment variable)",
+    ),
+):
+    """Generate docstrings for Python files using LLMs.
+
+    This command uses litellm with structured output to generate high-quality
+    Google-style docstrings for all functions in the specified Python file.
+    """
+    from universal_mcp.utils.docgen import process_file
+
+    if not file_path.exists():
+        typer.echo(f"Error: File not found: {file_path}", err=True)
         raise typer.Exit(1)
-    code = generate_api_client(schema)
-    print(code)
+
+    # Set API key if provided
+    if api_key:
+        os.environ["ANTHROPIC_API_KEY"] = api_key
+
+    try:
+        processed = process_file(str(file_path), model)
+        typer.echo(f"Successfully processed {processed} functions")
+    except Exception as e:
+        typer.echo(f"Error: {e}", err=True)
+        import traceback
+
+        traceback.print_exc()
+        raise typer.Exit(1) from e
 
 
 @app.command()
-def run(transport: str = typer.Option("stdio", "--transport", "-t")):
+def run(
+    config_path: Path | None = typer.Option(
+        None, "--config", "-c", help="Path to the config file"
+    ),
+):
     """Run the MCP server"""
-    from universal_mcp.servers.server import AgentRServer
+    from universal_mcp.config import ServerConfig
+    from universal_mcp.servers import server_from_config
 
-    mcp = AgentRServer(name="AgentR Server", description="AgentR Server", port=8005)
-    mcp.run(transport=transport)
+    if config_path:
+        config = ServerConfig.model_validate_json(config_path.read_text())
+    else:
+        config = ServerConfig()
+    server = server_from_config(config)
+    server.run(transport=config.transport)
 
 
 @app.command()
@@ -73,10 +158,7 @@ def install(app_name: str = typer.Argument(..., help="Name of app to install")):
             typer.echo("App installed successfully")
     except Exception as e:
         typer.echo(f"Error installing app: {e}", err=True)
-        import traceback
-
-        traceback.print_exc()
-        raise typer.Exit(1)
+        raise typer.Exit(1) from e
 
 
 if __name__ == "__main__":

universal_mcp/config.py

@@ -1,15 +1,32 @@
-from pydantic import BaseModel
 from typing import Literal
 
+from pydantic import BaseModel
+
+
 class StoreConfig(BaseModel):
-    type: Literal["memory", "environment"]
+    name: str = "universal_mcp"
+    type: Literal["memory", "environment", "keyring", "agentr"]
+
 
 class IntegrationConfig(BaseModel):
     name: str
-    type: Literal["api_key", "agentr"]
+    type: Literal["api_key", "oauth", "agentr"]
     credentials: dict | None = None
     store: StoreConfig | None = None
 
+
 class AppConfig(BaseModel):
     name: str
     integration: IntegrationConfig | None = None
+    actions: list[str] | None = None
+
+
+class ServerConfig(BaseModel):
+    name: str = "Universal MCP"
+    description: str = "Universal MCP"
+    api_key: str | None = None
+    type: Literal["local", "agentr"] = "agentr"
+    transport: Literal["stdio", "sse", "http"] = "stdio"
+    port: int = 8005
+    apps: list[AppConfig] | None = None
+    store: StoreConfig | None = None

universal_mcp/exceptions.py

@@ -1,8 +1,6 @@
-
-
 class NotAuthorizedError(Exception):
     """Raised when a user is not authorized to access a resource or perform an action."""
+
     def __init__(self, message="Not authorized to perform this action"):
         self.message = message
         super().__init__(self.message)
-

universal_mcp/integrations/__init__.py

@@ -1,4 +1,8 @@
 from universal_mcp.integrations.agentr import AgentRIntegration
-from universal_mcp.integrations.integration import Integration, ApiKeyIntegration, OAuthIntegration
+from universal_mcp.integrations.integration import (
+    ApiKeyIntegration,
+    Integration,
+    OAuthIntegration,
+)
 
-__all__ = ["AgentRIntegration", "Integration", "ApiKeyIntegration", "OAuthIntegration"]
+__all__ = ["AgentRIntegration", "Integration", "ApiKeyIntegration", "OAuthIntegration"]

universal_mcp/integrations/agentr.py

@@ -1,38 +1,44 @@
-from universal_mcp.integrations.integration import Integration
 import os
+
 import httpx
 from loguru import logger
+
 from universal_mcp.exceptions import NotAuthorizedError
+from universal_mcp.integrations.integration import Integration
+
 
 class AgentRIntegration(Integration):
     """Integration class for AgentR API authentication and authorization.
-    
+
     This class handles API key authentication and OAuth authorization flow for AgentR services.
-    
+
     Args:
         name (str): Name of the integration
         api_key (str, optional): AgentR API key. If not provided, will look for AGENTR_API_KEY env var
         **kwargs: Additional keyword arguments passed to parent Integration class
-        
+
     Raises:
         ValueError: If no API key is provided or found in environment variables
     """
+
     def __init__(self, name: str, api_key: str = None, **kwargs):
         super().__init__(name, **kwargs)
         self.api_key = api_key or os.getenv("AGENTR_API_KEY")
         if not self.api_key:
-            logger.error("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.")
+            logger.error(
+                "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 = os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
-    
-    def set_credentials(self, credentials: dict| None = None):
+
+    def set_credentials(self, credentials: dict | None = None):
         """Set credentials for the integration.
-        
+
         This method is not implemented for AgentR integration. Instead it redirects to the authorize flow.
-        
+
         Args:
             credentials (dict | None, optional): Credentials dict (not used). Defaults to None.
-            
+
         Returns:
             str: Authorization URL from authorize() method
         """
@@ -41,22 +47,19 @@ class AgentRIntegration(Integration):
 
     def get_credentials(self):
         """Get credentials for the integration from the AgentR API.
-        
+
         Makes API request to retrieve stored credentials for this integration.
-        
+
         Returns:
             dict: Credentials data from API response
-            
+
         Raises:
             NotAuthorizedError: If credentials are not found (404 response)
             HTTPError: For other API errors
         """
         response = httpx.get(
             f"{self.base_url}/api/{self.name}/credentials/",
-            headers={
-                "accept": "application/json",
-                "X-API-KEY": self.api_key
-            }
+            headers={"accept": "application/json", "X-API-KEY": self.api_key},
         )
         if response.status_code == 404:
             action = self.authorize()
@@ -67,21 +70,20 @@ class AgentRIntegration(Integration):
 
     def authorize(self):
         """Get authorization URL for the integration.
-        
+
         Makes API request to get OAuth authorization URL.
-        
+
         Returns:
             str: Message containing authorization URL
-            
+
         Raises:
             HTTPError: If API request fails
         """
         response = httpx.get(
             f"{self.base_url}/api/{self.name}/authorize/",
-            headers={
-                "X-API-KEY": self.api_key
-            }
+            headers={"X-API-KEY": self.api_key},
         )
         response.raise_for_status()
         url = response.json()
-        return f"Please authorize the application by clicking the link {url}"
+
+        return f"Please ask the user to visit the following url to authorize the application: {url}. Render the url in proper markdown format with a clickable link."

universal_mcp/integrations/integration.py

@@ -1,21 +1,27 @@
 from abc import ABC, abstractmethod
-from universal_mcp.stores.store import Store
+
 import httpx
+from loguru import logger
+
+from universal_mcp.exceptions import NotAuthorizedError
+from universal_mcp.stores.store import Store
+
 
 class Integration(ABC):
     """Abstract base class for handling application integrations and authentication.
-    
+
     This class defines the interface for different types of integrations that handle
     authentication and authorization with external services.
-    
+
     Args:
         name: The name identifier for this integration
         store: Optional Store instance for persisting credentials and other data
-    
+
     Attributes:
         name: The name identifier for this integration
         store: Store instance for persisting credentials and other data
     """
+
     def __init__(self, name: str, store: Store = None):
         self.name = name
         self.store = store
@@ -23,19 +29,19 @@ class Integration(ABC):
     @abstractmethod
     def authorize(self):
         """Authorize the integration.
-        
+
         Returns:
             str: Authorization URL.
         """
         pass
-    
+
     @abstractmethod
     def get_credentials(self):
         """Get credentials for the integration.
-        
+
         Returns:
             dict: Credentials for the integration.
-        
+
         Raises:
             NotAuthorizedError: If credentials are not found.
         """
@@ -44,31 +50,62 @@ class Integration(ABC):
     @abstractmethod
     def set_credentials(self, credentials: dict):
         """Set credentials for the integration.
-        
+
         Args:
             credentials: Credentials for the integration.
         """
         pass
 
 
-
 class ApiKeyIntegration(Integration):
+    """Integration class for API key based authentication.
+
+    This class implements the Integration interface for services that use API key
+    authentication. It handles storing and retrieving API keys using the provided
+    store.
+
+    Args:
+        name: The name identifier for this integration
+        store: Optional Store instance for persisting credentials and other data
+        **kwargs: Additional keyword arguments passed to parent class
+
+    Attributes:
+        name: The name identifier for this integration
+        store: Store instance for persisting credentials and other data
+    """
+
     def __init__(self, name: str, store: Store = None, **kwargs):
         super().__init__(name, store, **kwargs)
+        if not name.endswith("api_key"):
+            self.name = f"{name}_api_key"
+        logger.info(f"Initializing API Key Integration: {name} with store: {store}")
 
     def get_credentials(self):
         credentials = self.store.get(self.name)
+        if credentials is None:
+            action = self.authorize()
+            raise NotAuthorizedError(action)
         return credentials
 
     def set_credentials(self, credentials: dict):
         self.store.set(self.name, credentials)
 
     def authorize(self):
-        return {"text": "Please configure the API Key for {self.name}"}
-    
+        return f"Please ask the user for api key and set the API Key for {self.name} in the store"
+
 
 class OAuthIntegration(Integration):
-    def __init__(self, name: str, store: Store = None, client_id: str = None, client_secret: str = None, auth_url: str = None, token_url: str = None, scope: str = None, **kwargs):
+    def __init__(
+        self,
+        name: str,
+        store: Store = None,
+        client_id: str = None,
+        client_secret: str = None,
+        auth_url: str = None,
+        token_url: str = None,
+        scope: str = None,
+        **kwargs,
+    ):
         super().__init__(name, store, **kwargs)
         self.client_id = client_id
         self.client_secret = client_secret
@@ -81,42 +118,42 @@ class OAuthIntegration(Integration):
         if not credentials:
             return None
         return credentials
-    
+
     def set_credentials(self, credentials: dict):
         if not credentials or not isinstance(credentials, dict):
             raise ValueError("Invalid credentials format")
-        if 'access_token' not in credentials:
+        if "access_token" not in credentials:
             raise ValueError("Credentials must contain access_token")
         self.store.set(self.name, credentials)
 
     def authorize(self):
         if not all([self.client_id, self.client_secret, self.auth_url, self.token_url]):
             raise ValueError("Missing required OAuth configuration")
-        
+
         auth_params = {
-            'client_id': self.client_id,
-            'response_type': 'code',
-            'scope': self.scope,
+            "client_id": self.client_id,
+            "response_type": "code",
+            "scope": self.scope,
         }
-        
+
         return {
             "url": self.auth_url,
             "params": auth_params,
             "client_secret": self.client_secret,
-            "token_url": self.token_url
+            "token_url": self.token_url,
         }
-    
+
     def handle_callback(self, code: str):
         if not all([self.client_id, self.client_secret, self.token_url]):
             raise ValueError("Missing required OAuth configuration")
-        
+
         token_params = {
-            'client_id': self.client_id,
-            'client_secret': self.client_secret,
-            'code': code,
-            'grant_type': 'authorization_code'
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "code": code,
+            "grant_type": "authorization_code",
         }
-        
+
         response = httpx.post(self.token_url, data=token_params)
         response.raise_for_status()
         credentials = response.json()
@@ -126,16 +163,16 @@ class OAuthIntegration(Integration):
     def refresh_token(self):
         if not all([self.client_id, self.client_secret, self.token_url]):
             raise ValueError("Missing required OAuth configuration")
-        
+
         token_params = {
-            'client_id': self.client_id,
-            'client_secret': self.client_secret,
-            'grant_type': 'refresh_token',
-            'refresh_token': self.credentials['refresh_token']
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "grant_type": "refresh_token",
+            "refresh_token": self.credentials["refresh_token"],
         }
-        
+
         response = httpx.post(self.token_url, data=token_params)
         response.raise_for_status()
         credentials = response.json()
         self.store.set(self.name, credentials)
-        return credentials
+        return credentials

universal_mcp/servers/__init__.py

@@ -1,3 +1,23 @@
+from universal_mcp.config import ServerConfig
 from universal_mcp.servers.server import AgentRServer, LocalServer
 
-__all__ = [AgentRServer, LocalServer]
+
+def server_from_config(config: ServerConfig):
+    if config.type == "agentr":
+        return AgentRServer(
+            name=config.name,
+            description=config.description,
+            api_key=config.api_key,
+            port=config.port,
+        )
+    elif config.type == "local":
+        return LocalServer(
+            name=config.name,
+            description=config.description,
+            store=config.store,
+            apps_list=config.apps,
+            port=config.port,
+        )
+
+
+__all__ = [AgentRServer, LocalServer]