universal-mcp 0.1.7rc1__py3-none-any.whl → 0.1.8__py3-none-any.whl

universal_mcp/utils/docstring_parser.py

@@ -0,0 +1,179 @@
+import re
+from typing import Any
+
+
+def parse_docstring(docstring: str | None) -> dict[str, Any]:
+    """
+    Parses a standard Python docstring into summary, args, returns, raises, and tags.
+
+    Args:
+        docstring: The docstring to parse.
+
+    Returns:
+        A dictionary with keys 'summary', 'args', 'returns', 'raises', 'tags'.
+        'args' is a dict mapping arg names to descriptions.
+        'raises' is a dict mapping exception type names to descriptions.
+        'tags' is a list of strings extracted from the 'Tags:' section, comma-separated.
+    """
+    if not docstring:
+        return {"summary": "", "args": {}, "returns": "", "raises": {}, "tags": []}
+
+    lines = docstring.strip().splitlines()
+    if not lines:
+        return {"summary": "", "args": {}, "returns": "", "raises": {}, "tags": []}
+
+    summary = lines[0].strip()
+    args = {}
+    returns = ""
+    raises = {}
+    tags: list[str] = []  # Final list of parsed tags
+    current_section = None
+    current_key = None
+    current_desc_lines = []  # Accumulator for multi-line descriptions/tag content
+    key_pattern = re.compile(r"^\s*([\w\.]+)\s*(?:\(.*\))?:\s*(.*)")
+
+    def finalize_current_item():
+        """Helper function to finalize the currently parsed item."""
+        nonlocal returns, tags  # Allow modification of outer scope variables
+        desc = " ".join(current_desc_lines).strip()
+        if current_section == "args" and current_key:
+            args[current_key] = desc
+        elif current_section == "raises" and current_key:
+            raises[current_key] = desc
+        elif current_section == "returns":
+            returns = desc
+        # SIM102 applied: Combine nested if
+        elif current_section == "tags" and desc:  # Only process if there's content
+            tags = [tag.strip() for tag in desc.split(",") if tag.strip()]
+
+    # B007 applied: Rename unused loop variable i to _
+    for _, line in enumerate(lines[1:]):
+        stripped_line = line.strip()
+        original_indentation = len(line) - len(line.lstrip(" "))
+
+        section_line = stripped_line.lower()
+        is_new_section_header = False
+        new_section_type = None
+        header_content = ""
+
+        if section_line in ("args:", "arguments:", "parameters:"):
+            new_section_type = "args"
+            is_new_section_header = True
+        elif section_line in ("returns:", "yields:"):
+            new_section_type = "returns"
+            is_new_section_header = True
+        elif section_line.startswith(("raises ", "raises:", "errors:", "exceptions:")):
+            new_section_type = "raises"
+            is_new_section_header = True
+        elif section_line.startswith(
+            ("tags:", "tags")
+        ):  # Match "Tags:" or "Tags" potentially followed by content
+            new_section_type = "tags"
+            is_new_section_header = True
+            if ":" in stripped_line:
+                header_content = stripped_line.split(":", 1)[1].strip()
+        elif section_line.endswith(":") and section_line[:-1] in (
+            "attributes",
+            "see also",
+            "example",
+            "examples",
+            "notes",
+        ):
+            new_section_type = "other"
+            is_new_section_header = True
+
+        finalize_previous = False
+        if is_new_section_header:
+            finalize_previous = True
+        elif current_section in ["args", "raises"] and current_key:
+            if key_pattern.match(line) or (original_indentation == 0 and stripped_line):
+                finalize_previous = True
+        elif current_section in ["returns", "tags"] and current_desc_lines:
+            if original_indentation == 0 and stripped_line:
+                finalize_previous = True
+        # SIM102 applied: Combine nested if/elif
+        elif (
+            not stripped_line
+            and current_desc_lines
+            and current_section in ["args", "raises", "returns", "tags"]
+            and (current_section not in ["args", "raises"] or current_key)
+        ):
+            finalize_previous = True
+
+        if finalize_previous:
+            finalize_current_item()
+            current_key = None
+            current_desc_lines = []
+            if not is_new_section_header or new_section_type == "other":
+                current_section = None
+
+        if is_new_section_header and new_section_type != "other":
+            current_section = new_section_type
+            # If Tags header had content, start accumulating it
+            if new_section_type == "tags" and header_content:
+                current_desc_lines.append(header_content)
+            # Don't process the header line itself further
+            continue
+
+        if not stripped_line:
+            continue
+
+        if current_section == "args" or current_section == "raises":
+            match = key_pattern.match(line)
+            if match:
+                current_key = match.group(1)
+                current_desc_lines = [match.group(2).strip()]  # Start new description
+            elif (
+                current_key and original_indentation > 0
+            ):  # Check for indentation for continuation
+                current_desc_lines.append(stripped_line)
+
+        elif current_section == "returns":
+            if not current_desc_lines or original_indentation > 0:
+                current_desc_lines.append(stripped_line)
+
+        elif current_section == "tags":
+            if (
+                original_indentation > 0 or not current_desc_lines
+            ):  # Indented or first line
+                current_desc_lines.append(stripped_line)
+
+    finalize_current_item()
+    return {
+        "summary": summary,
+        "args": args,
+        "returns": returns,
+        "raises": raises,
+        "tags": tags,
+    }
+
+
+docstring_example = """
+    Starts a crawl job for a given URL using Firecrawl. Returns the job ID immediately.
+
+    Args:
+        url: The starting URL for the crawl.
+                It can be a very long url that spans multiple lines if needed.
+        params: Optional dictionary of parameters to customize the crawl.
+                See API docs for details.
+        idempotency_key: Optional unique key to prevent duplicate jobs.
+
+    Returns:
+        A dictionary containing the job initiation response on success,
+        or a string containing an error message on failure. This description
+        can also span multiple lines.
+
+    Raises:
+        ValueError: If the URL is invalid.
+        requests.exceptions.ConnectionError: If connection fails.
+
+    Tags:
+        crawl, async_job, start, api,  long_tag_example , another
+        , final_tag
+"""
+
+if __name__ == "__main__":
+    parsed = parse_docstring(docstring_example)
+    import json
+
+    print(json.dumps(parsed, indent=4))

universal_mcp/utils/dump_app_tools.py

@@ -7,62 +7,72 @@ from universal_mcp.applications import app_from_slug
 def discover_available_app_slugs():
     apps_dir = Path(__file__).resolve().parent.parent / "applications"
     app_slugs = []
-    
+
     for item in apps_dir.iterdir():
-        if not item.is_dir() or item.name.startswith('_'):
+        if not item.is_dir() or item.name.startswith("_"):
             continue
-        
+
         if (item / "app.py").exists():
             slug = item.name.replace("_", "-")
             app_slugs.append(slug)
-    
+
     return app_slugs
 
+
 def extract_app_tools(app_slugs):
     all_apps_tools = []
-    
+
     for slug in app_slugs:
         try:
             print(f"Loading app: {slug}")
             app_class = app_from_slug(slug)
-            
+
             app_instance = app_class(integration=None)
-            
+
             tools = app_instance.list_tools()
-            
+
             for tool in tools:
                 tool_name = tool.__name__
-                description = tool.__doc__.strip().split('\n')[0] if tool.__doc__ else "No description"
-                
-                all_apps_tools.append({
-                    "app_name": slug,
-                    "tool_name": tool_name,
-                    "description": description
-                })
-                
+                description = (
+                    tool.__doc__.strip().split("\n")[0]
+                    if tool.__doc__
+                    else "No description"
+                )
+
+                all_apps_tools.append(
+                    {
+                        "app_name": slug,
+                        "tool_name": tool_name,
+                        "description": description,
+                    }
+                )
+
         except Exception as e:
             print(f"Error loading app {slug}: {e}")
-    
+
     return all_apps_tools
 
+
 def write_to_csv(app_tools, output_file="app_tools.csv"):
     fieldnames = ["app_name", "tool_name", "description"]
-    
-    with open(output_file, 'w', newline='') as csvfile:
+
+    with open(output_file, "w", newline="") as csvfile:
         writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
         writer.writeheader()
         writer.writerows(app_tools)
-    
+
     print(f"CSV file created: {output_file}")
 
+
 def main():
     app_slugs = discover_available_app_slugs()
     print(f"Found {len(app_slugs)} app slugs: {', '.join(app_slugs)}")
-    
+
     app_tools = extract_app_tools(app_slugs)
     print(f"Extracted {len(app_tools)} tools from all apps")
-    
+
     write_to_csv(app_tools)
 
+
 if __name__ == "__main__":
-    main()
+    main()

universal_mcp/utils/installation.py

@@ -29,7 +29,7 @@ def create_file_if_not_exists(path: Path) -> None:
 
 def get_supported_apps() -> list[str]:
     """Get list of supported apps"""
-    return ["claude", "cursor", "windsurf"]
+    return ["claude", "cursor", "cline", "continue", "goose", "windsurf", "zed"]
 
 
 def install_claude(api_key: str) -> None:
@@ -61,7 +61,7 @@ def install_claude(api_key: str) -> None:
         config["mcpServers"] = {}
     config["mcpServers"]["universal_mcp"] = {
         "command": get_uvx_path(),
-        "args": ["universal_mcp@latest", "run"],
+        "args": ["universal_mcp[all]@latest", "run"],
         "env": {"AGENTR_API_KEY": api_key},
     }
     with open(config_path, "w") as f:
@@ -90,7 +90,7 @@ def install_cursor(api_key: str) -> None:
         config["mcpServers"] = {}
     config["mcpServers"]["universal_mcp"] = {
         "command": get_uvx_path(),
-        "args": ["universal_mcp@latest", "run"],
+        "args": ["universal_mcp[all]@latest", "run"],
         "env": {"AGENTR_API_KEY": api_key},
     }
 
@@ -99,21 +99,212 @@ def install_cursor(api_key: str) -> None:
     print("[green]✓[/green] Cursor configuration installed successfully")
 
 
-def install_windsurf() -> None:
+def install_cline(api_key: str) -> None:
+    """Install Cline"""
+    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[all]@latest", "run"],
+        "env": {"AGENTR_API_KEY": api_key},
+    }
+
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=4)
+    print("[green]✓[/green] Cline configuration installed successfully")
+
+
+def install_continue(api_key: str) -> None:
+    """Install Continue"""
+    print("[bold blue]Installing Continue configuration...[/bold blue]")
+
+    # Determine platform-specific config path
+    if sys.platform == "darwin":  # macOS
+        config_path = Path.home() / "Library/Application Support/Continue/mcp.json"
+    elif sys.platform == "win32":  # Windows
+        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[all]@latest", "run"],
+        "env": {"AGENTR_API_KEY": api_key},
+    }
+
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=4)
+    print("[green]✓[/green] Continue configuration installed successfully")
+
+
+def install_goose(api_key: str) -> None:
+    """Install Goose"""
+    print("[bold blue]Installing Goose configuration...[/bold blue]")
+
+    # Determine platform-specific config path
+    if sys.platform == "darwin":  # macOS
+        config_path = Path.home() / "Library/Application Support/Goose/mcp-config.json"
+    elif sys.platform == "win32":  # Windows
+        config_path = Path.home() / "AppData/Roaming/Goose/mcp-config.json"
+    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[all]@latest", "run"],
+        "env": {"AGENTR_API_KEY": api_key},
+    }
+
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=4)
+    print("[green]✓[/green] Goose configuration installed successfully")
+
+
+def install_windsurf(api_key: str) -> None:
     """Install Windsurf"""
-    print("[yellow]Windsurf installation not yet implemented[/yellow]")
-    pass
+    print("[bold blue]Installing Windsurf configuration...[/bold blue]")
+
+    # Determine platform-specific config path
+    if sys.platform == "darwin":  # macOS
+        config_path = Path.home() / "Library/Application Support/Windsurf/mcp.json"
+    elif sys.platform == "win32":  # Windows
+        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[all]@latest", "run"],
+        "env": {"AGENTR_API_KEY": api_key},
+    }
+
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=4)
+    print("[green]✓[/green] Windsurf configuration installed successfully")
+
+
+def install_zed(api_key: str) -> None:
+    """Install Zed"""
+    print("[bold blue]Installing Zed configuration...[/bold blue]")
+
+    # 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[all]@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[all]@latest", "run"],
+                "env": {"AGENTR_API_KEY": api_key},
+            }
+        )
+
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=4)
+    print("[green]✓[/green] Zed configuration installed successfully")
 
 
-def install_app(app_name: str) -> None:
+def install_app(app_name: str, api_key: str) -> None:
     """Install an app"""
     print(f"[bold]Installing {app_name}...[/bold]")
     if app_name == "claude":
-        install_claude()
+        install_claude(api_key)
     elif app_name == "cursor":
-        install_cursor()
+        install_cursor(api_key)
+    elif app_name == "cline":
+        install_cline(api_key)
+    elif app_name == "continue":
+        install_continue(api_key)
+    elif app_name == "goose":
+        install_goose(api_key)
     elif app_name == "windsurf":
-        install_windsurf()
+        install_windsurf(api_key)
+    elif app_name == "zed":
+        install_zed(api_key)
     else:
         print(f"[red]Error: App '{app_name}' not supported[/red]")
         raise ValueError(f"App '{app_name}' not supported")