universal-mcp 0.1.23rc2__py3-none-any.whl → 0.1.24rc3__py3-none-any.whl

universal_mcp/applications/sample/app.py

@@ -0,0 +1,245 @@
+import datetime
+
+import httpx
+
+from universal_mcp.applications.application import BaseApplication
+
+
+class SampleToolApp(BaseApplication):
+    """A sample application providing basic utility tools."""
+
+    def __init__(self):
+        """Initializes the SampleToolApp with the name 'sample_tool_app'."""
+        super().__init__(name="sample_tool_app")
+
+    def get_current_time(self):
+        """Get the current system time as a formatted string.
+
+        Returns:
+            str: The current time in the format 'YYYY-MM-DD HH:MM:SS'.
+        """
+        return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    def get_current_date(self):
+        """Get the current system date as a formatted string.
+
+        Returns:
+            str: The current date in the format 'YYYY-MM-DD'.
+        """
+        return datetime.datetime.now().strftime("%Y-%m-%d")
+
+    def calculate(self, expression: str):
+        """Safely evaluate a mathematical expression.
+
+        Args:
+            expression (str): The mathematical expression to evaluate.
+
+        Returns:
+            str: The result of the calculation, or an error message if evaluation fails.
+        """
+        try:
+            # Safe evaluation of mathematical expressions
+            result = eval(expression, {"__builtins__": {}}, {})  # noqa: S102
+            return f"Result: {result}"
+        except Exception as e:
+            return f"Error in calculation: {str(e)}"
+
+    def file_operations(self, operation: str, filename: str, content: str = ""):
+        """Perform file read or write operations.
+
+        Args:
+            operation (str): The operation to perform, either 'read' or 'write'.
+            filename (str): The name of the file to operate on.
+            content (str, optional): The content to write to the file (used only for 'write'). Defaults to "".
+
+        Returns:
+            str: The result of the file operation, or an error message if the operation fails.
+        """
+        try:
+            if operation == "read":
+                with open(filename) as f:
+                    return f"File content:\n{f.read()}"
+            elif operation == "write":
+                with open(filename, "w") as f:
+                    f.write(content)
+                return f"Successfully wrote to {filename}"
+            else:
+                return "Invalid operation. Use 'read' or 'write'"
+        except Exception as e:
+            return f"File operation error: {str(e)}"
+
+    def get_weather(
+        self,
+        latitude: float,
+        longitude: float,
+        current: list[str] | None = None,
+        hourly: list[str] | None = None,
+        daily: list[str] | None = None,
+        timezone: str = "auto",
+        temperature_unit: str = "celsius",
+        wind_speed_unit: str = "kmh",
+        precipitation_unit: str = "mm",
+    ) -> dict:
+        """
+        Get weather data from Open-Meteo API.
+
+        Args:
+            latitude (float): Latitude coordinate
+            longitude (float): Longitude coordinate
+            current (List[str], optional): Current weather parameters to fetch
+            hourly (List[str], optional): Hourly weather parameters to fetch
+            daily (List[str], optional): Daily weather parameters to fetch
+            timezone (str): Timezone (default: "auto")
+            temperature_unit (str): Temperature unit - "celsius" or "fahrenheit"
+            wind_speed_unit (str): Wind speed unit - "kmh", "ms", "mph", "kn"
+            precipitation_unit (str): Precipitation unit - "mm" or "inch"
+
+        Returns:
+            Dict: Weather data from the API
+
+        Raises:
+            httpx.RequestError: If API request fails
+            ValueError: If coordinates are invalid
+        """
+        # Validate coordinates
+        if not (-90 <= latitude <= 90):
+            raise ValueError("Latitude must be between -90 and 90")
+        if not (-180 <= longitude <= 180):
+            raise ValueError("Longitude must be between -180 and 180")
+
+        # Base URL
+        base_url = "https://api.open-meteo.com/v1/forecast"
+
+        # Default parameters if none provided
+        if current is None:
+            current = ["temperature_2m", "relative_humidity_2m", "weather_code", "wind_speed_10m", "wind_direction_10m"]
+
+        if daily is None:
+            daily = ["temperature_2m_max", "temperature_2m_min", "weather_code", "precipitation_sum"]
+
+        # Build parameters
+        params = {
+            "latitude": latitude,
+            "longitude": longitude,
+            "timezone": timezone,
+            "temperature_unit": temperature_unit,
+            "wind_speed_unit": wind_speed_unit,
+            "precipitation_unit": precipitation_unit,
+        }
+
+        # Add weather parameters
+        if current:
+            params["current"] = ",".join(current)
+        if hourly:
+            params["hourly"] = ",".join(hourly)
+        if daily:
+            params["daily"] = ",".join(daily)
+
+        try:
+            # Make API request
+            with httpx.Client(timeout=10) as client:
+                response = client.get(base_url, params=params)
+                response.raise_for_status()
+                return response.json()
+
+        except httpx.TimeoutException as e:
+            raise httpx.RequestError("Request timed out") from e
+        except httpx.ConnectError as e:
+            raise httpx.RequestError("Connection error") from e
+        except httpx.HTTPStatusError as e:
+            raise httpx.RequestError(f"HTTP error: {e}") from e
+        except httpx.RequestError as e:
+            raise httpx.RequestError(f"Request failed: {e}") from e
+
+    def get_simple_weather(self, latitude: float, longitude: float) -> dict:
+        """
+        Get simplified current weather data.
+
+        Args:
+            latitude (float): Latitude coordinate
+            longitude (float): Longitude coordinate
+
+        Returns:
+            Dict: Simplified weather data with current conditions
+        """
+
+        try:
+            weather_data = self.get_weather(
+                latitude=latitude,
+                longitude=longitude,
+                current=[
+                    "temperature_2m",
+                    "relative_humidity_2m",
+                    "weather_code",
+                    "wind_speed_10m",
+                    "wind_direction_10m",
+                    "precipitation",
+                ],
+            )
+
+            # Weather code descriptions (WMO Weather interpretation codes)
+            weather_codes = {
+                0: "Clear sky",
+                1: "Mainly clear",
+                2: "Partly cloudy",
+                3: "Overcast",
+                45: "Fog",
+                48: "Depositing rime fog",
+                51: "Light drizzle",
+                53: "Moderate drizzle",
+                55: "Dense drizzle",
+                61: "Slight rain",
+                63: "Moderate rain",
+                65: "Heavy rain",
+                71: "Slight snow fall",
+                73: "Moderate snow fall",
+                75: "Heavy snow fall",
+                80: "Slight rain showers",
+                81: "Moderate rain showers",
+                82: "Violent rain showers",
+                95: "Thunderstorm",
+                96: "Thunderstorm with slight hail",
+                99: "Thunderstorm with heavy hail",
+            }
+
+            current = weather_data.get("current", {})
+            weather_code = current.get("weather_code", 0)
+
+            simplified = {
+                "location": {
+                    "latitude": weather_data.get("latitude"),
+                    "longitude": weather_data.get("longitude"),
+                    "timezone": weather_data.get("timezone"),
+                },
+                "current": {
+                    "time": current.get("time"),
+                    "temperature": current.get("temperature_2m"),
+                    "temperature_unit": weather_data.get("current_units", {}).get("temperature_2m", "°C"),
+                    "humidity": current.get("relative_humidity_2m"),
+                    "weather_description": weather_codes.get(weather_code, "Unknown"),
+                    "weather_code": weather_code,
+                    "wind_speed": current.get("wind_speed_10m"),
+                    "wind_speed_unit": weather_data.get("current_units", {}).get("wind_speed_10m", "km/h"),
+                    "wind_direction": current.get("wind_direction_10m"),
+                    "precipitation": current.get("precipitation", 0),
+                },
+            }
+
+            return simplified
+
+        except Exception as e:
+            return {"error": str(e)}
+
+    def list_tools(self):
+        """List all available tool methods in this application.
+
+        Returns:
+            list: A list of callable tool methods.
+        """
+        return [
+            self.get_current_time,
+            self.get_current_date,
+            self.calculate,
+            self.file_operations,
+            self.get_simple_weather,
+        ]

universal_mcp/cli.py

@@ -1,113 +1,22 @@
-import re
 from pathlib import Path
 
 import typer
 from rich.console import Console
 from rich.panel import Panel
 
+from universal_mcp.agents.cli import app as client_app
 from universal_mcp.utils.installation import (
     get_supported_apps,
     install_app,
 )
+from universal_mcp.utils.openapi.cli import app as codegen_app
 
 # Setup rich console and logging
 console = Console()
 
-app = typer.Typer()
-
-
-@app.command()
-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)",
-    ),
-    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.
-
-    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/.
-    """
-    # Import here to avoid circular imports
-    from universal_mcp.utils.openapi.api_generator import generate_api_from_schema
-
-    if not schema_path.exists():
-        console.print(f"[red]Error: Schema file {schema_path} does not exist[/red]")
-        raise typer.Exit(1)
-
-    try:
-        app_file_data = generate_api_from_schema(
-            schema_path=schema_path,
-            output_path=output_path,
-            class_name=class_name,
-        )
-        if isinstance(app_file_data, dict) and "code" in app_file_data:
-            console.print("[yellow]No output path specified, printing generated code to console:[/yellow]")
-            console.print(app_file_data["code"])
-        elif isinstance(app_file_data, Path):
-            console.print("[green]API client successfully generated and installed.[/green]")
-            console.print(f"[blue]Application file: {app_file_data}[/blue]")
-        else:
-            # Handle the error case from api_generator if validation fails
-            if isinstance(app_file_data, dict) and "error" in app_file_data:
-                console.print(f"[red]{app_file_data['error']}[/red]")
-                raise typer.Exit(1)
-            else:
-                console.print("[red]Unexpected return value from API generator.[/red]")
-                raise typer.Exit(1)
-
-    except Exception as e:
-        console.print(f"[red]Error generating API client: {e}[/red]")
-        raise typer.Exit(1) from e
-
-
-@app.command()
-def readme(
-    file_path: Path = typer.Argument(..., help="Path to the Python file to process"),
-):
-    """Generate a README.md file for the API client."""
-    from universal_mcp.utils.openapi.readme import generate_readme
-
-    readme_file = generate_readme(file_path)
-    console.print(f"[green]README.md file generated at: {readme_file}[/green]")
-
-
-@app.command()
-def docgen(
-    file_path: Path = typer.Argument(..., help="Path to the Python file to process"),
-    model: str = typer.Option(
-        "perplexity/sonar",
-        "--model",
-        "-m",
-        help="Model to use for generating docstrings",
-    ),
-):
-    """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.openapi.docgen import process_file
-
-    if not file_path.exists():
-        console.print(f"[red]Error: File not found: {file_path}[/red]")
-        raise typer.Exit(1)
-
-    try:
-        processed = process_file(str(file_path), model)
-        console.print(f"[green]Successfully processed {processed} functions[/green]")
-    except Exception as e:
-        console.print(f"[red]Error: {e}[/red]")
-        raise typer.Exit(1) from e
+app = typer.Typer(name="mcp")
+app.add_typer(codegen_app, name="codegen", help="Code generation and manipulation commands")
+app.add_typer(client_app, name="client", help="Client commands")
 
 
 @app.command()
@@ -115,13 +24,20 @@ def run(
     config_path: Path | None = typer.Option(None, "--config", "-c", help="Path to the config file"),
 ):
     """Run the MCP server"""
+    from universal_mcp.agentr.server import AgentrServer
     from universal_mcp.config import ServerConfig
     from universal_mcp.logger import setup_logger
-    from universal_mcp.servers import server_from_config
+    from universal_mcp.servers import LocalServer
 
     config = ServerConfig.model_validate_json(config_path.read_text()) if config_path else ServerConfig()
     setup_logger(level=config.log_level)
-    server = server_from_config(config)
+
+    if config.type == "agentr":
+        server = AgentrServer(config=config, api_key=config.api_key)
+    elif config.type == "local":
+        server = LocalServer(config=config)
+    else:
+        raise ValueError(f"Unsupported server type: {config.type}")
     server.run(transport=config.transport)
 
 
@@ -162,138 +78,5 @@ def install(app_name: str = typer.Argument(..., help="Name of app to install")):
         raise typer.Exit(1) from e
 
 
-@app.command()
-def init(
-    output_dir: Path | None = typer.Option(
-        None,
-        "--output-dir",
-        "-o",
-        help="Output directory for the project (must exist)",
-    ),
-    app_name: str | None = typer.Option(
-        None,
-        "--app-name",
-        "-a",
-        help="App name (letters, numbers, hyphens, underscores only)",
-    ),
-    integration_type: str | None = typer.Option(
-        None,
-        "--integration-type",
-        "-i",
-        help="Integration type (api_key, oauth, agentr, none)",
-        case_sensitive=False,
-        show_choices=True,
-    ),
-):
-    """Initialize a new MCP project using the cookiecutter template."""
-    from cookiecutter.main import cookiecutter
-
-    NAME_PATTERN = r"^[a-zA-Z0-9_-]+$"
-
-    def validate_pattern(value: str, field_name: str) -> None:
-        if not re.match(NAME_PATTERN, value):
-            console.print(
-                f"[red]❌ Invalid {field_name}; only letters, numbers, hyphens, and underscores allowed.[/red]"
-            )
-            raise typer.Exit(code=1)
-
-    # App name
-    if not app_name:
-        app_name = typer.prompt(
-            "Enter the app name",
-            default="app_name",
-            prompt_suffix=" (e.g., reddit, youtube): ",
-        ).strip()
-    validate_pattern(app_name, "app name")
-    app_name = app_name.lower()
-    if not output_dir:
-        path_str = typer.prompt(
-            "Enter the output directory for the project",
-            default=str(Path.cwd()),
-            prompt_suffix=": ",
-        ).strip()
-        output_dir = Path(path_str)
-
-    if not output_dir.exists():
-        try:
-            output_dir.mkdir(parents=True, exist_ok=True)
-            console.print(f"[green]✅ Created output directory at '{output_dir}'[/green]")
-        except Exception as e:
-            console.print(f"[red]❌ Failed to create output directory '{output_dir}': {e}[/red]")
-            raise typer.Exit(code=1) from e
-    elif not output_dir.is_dir():
-        console.print(f"[red]❌ Output path '{output_dir}' exists but is not a directory.[/red]")
-        raise typer.Exit(code=1)
-
-    # Integration type
-    if not integration_type:
-        integration_type = typer.prompt(
-            "Choose the integration type",
-            default="agentr",
-            prompt_suffix=" (api_key, oauth, agentr, none): ",
-        ).lower()
-    if integration_type not in ("api_key", "oauth", "agentr", "none"):
-        console.print("[red]❌ Integration type must be one of: api_key, oauth, agentr, none[/red]")
-        raise typer.Exit(code=1)
-
-    console.print("[blue]🚀 Generating project using cookiecutter...[/blue]")
-    try:
-        cookiecutter(
-            "https://github.com/AgentrDev/universal-mcp-app-template.git",
-            output_dir=str(output_dir),
-            no_input=True,
-            extra_context={
-                "app_name": app_name,
-                "integration_type": integration_type,
-            },
-        )
-    except Exception as exc:
-        console.print(f"❌ Project generation failed: {exc}")
-        raise typer.Exit(code=1) from exc
-
-    project_dir = output_dir / f"{app_name}"
-    console.print(f"✅ Project created at {project_dir}")
-
-
-@app.command()
-def preprocess(
-    schema_path: Path = typer.Option(None, "--schema", "-s", help="Path to the OpenAPI schema file."),
-    output_path: Path = typer.Option(None, "--output", "-o", help="Path to save the processed schema."),
-):
-    from universal_mcp.utils.openapi.preprocessor import run_preprocessing
-
-    """Preprocess an OpenAPI schema using LLM to fill or enhance descriptions."""
-    run_preprocessing(schema_path, output_path)
-
-
-@app.command()
-def split_api(
-    input_app_file: Path = typer.Argument(..., help="Path to the generated app.py file to split"),
-    output_dir: Path = typer.Option(..., "--output-dir", "-o", help="Directory to save the split files"),
-    package_name: str = typer.Option(None, "--package-name", "-p", help="Package name for absolute imports (e.g., 'hubspot')"),
-):
-    """Splits a single generated API client file into multiple files based on path groups."""
-    from universal_mcp.utils.openapi.api_splitter import split_generated_app_file
-
-    if not input_app_file.exists() or not input_app_file.is_file():
-        console.print(f"[red]Error: Input file {input_app_file} does not exist or is not a file.[/red]")
-        raise typer.Exit(1)
-
-    if not output_dir.exists():
-        output_dir.mkdir(parents=True, exist_ok=True)
-        console.print(f"[green]Created output directory: {output_dir}[/green]")
-    elif not output_dir.is_dir():
-        console.print(f"[red]Error: Output path {output_dir} is not a directory.[/red]")
-        raise typer.Exit(1)
-
-    try:
-        split_generated_app_file(input_app_file, output_dir, package_name)
-        console.print(f"[green]Successfully split {input_app_file} into {output_dir}[/green]")
-    except Exception as e:
-        console.print(f"[red]Error splitting API client: {e}[/red]")
-
-        raise typer.Exit(1) from e
-
-
 if __name__ == "__main__":
     app()