universal-mcp-applications 0.1.33__tar.gz → 0.1.36rc3__tar.gz

{universal_mcp_applications-0.1.33 → universal_mcp_applications-0.1.36rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-applications
-Version: 0.1.33
+Version: 0.1.36rc3
 Summary: A Universal MCP Application: universal_mcp_applications
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications
@@ -35,7 +35,7 @@ Requires-Dist: replicate>=1.0.6
 Requires-Dist: requests>=2.31.0
 Requires-Dist: resend>=2.10.0
 Requires-Dist: twilio>=9.8.0
-Requires-Dist: universal-mcp>=0.1.24rc26
+Requires-Dist: universal-mcp>=0.1.24rc29
 Requires-Dist: yfinance>=0.2.66
 Requires-Dist: youtube-transcript-api==1.2.2
 Provides-Extra: dev

{universal_mcp_applications-0.1.33 → universal_mcp_applications-0.1.36rc3}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp-applications"
-version = "0.1.33"
+version = "0.1.36-rc3"
 description = "A Universal MCP Application: universal_mcp_applications"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -43,7 +43,7 @@ dependencies = [
     "requests>=2.31.0",
     "resend>=2.10.0",
     "twilio>=9.8.0",
-    "universal-mcp>=0.1.24rc26",
+    "universal-mcp>=0.1.24rc29",
     "yfinance>=0.2.66",
     "youtube-transcript-api==1.2.2",
 ]

universal_mcp_applications-0.1.36rc3/src/scripts/check_internal_calls.py

@@ -0,0 +1,195 @@
+import ast
+import os
+
+# List of applications to be checked for internal calls
+APPS = [
+    "ahrefs",
+    "airtable",
+    "apollo",
+    "asana",
+    "aws_s3",
+    "bill",  # not seeded
+    "box",
+    "braze",
+    # "cal_com_v2",   # not seeded
+    "calendly",
+    "canva",
+    "clickup",
+    "coda",
+    "confluence",  # not seeded
+    "contentful",  # not seeded
+    "crustdata",
+    "dialpad",  # not seeded
+    "digitalocean",
+    "domain_checker",
+    "e2b",
+    "elevenlabs",
+    "exa",
+    "falai",
+    "figma",
+    "file_system",
+    "firecrawl",
+    "fireflies",
+    "fpl",
+    "ghost_content",
+    "github",
+    "gong",
+    "google_calendar",
+    "google_docs",
+    "google_drive",
+    "google_gemini",
+    "google_mail",
+    "google_searchconsole",
+    "google_sheet",
+    "hashnode",
+    "heygen",
+    "http_tools",
+    "hubspot",
+    "jira",
+    "klaviyo",
+    "linkedin",
+    "mailchimp",
+    "markitdown",
+    "miro",
+    "ms_teams",
+    "neon",
+    "notion",
+    "onedrive",
+    "openai",
+    "outlook",
+    "perplexity",
+    "pipedrive",  # not seeded
+    "posthog",
+    "reddit",
+    "resend",
+    "retell",
+    "rocketlane",
+    "scraper",
+    "semanticscholar",
+    "semrush",  # not seeded
+    "sendgrid",
+    "sentry",
+    "serpapi",
+    "sharepoint",
+    "shopify",
+    "shortcut",
+    "slack",
+    "spotify",  # not seeded
+    "supabase",
+    "tavily",
+    "trello",
+    "twilio",
+    "twitter",
+    "whatsapp",
+    "whatsapp_business",
+    "wrike",  # not seeded
+    "yahoo_finance",
+    "youtube",
+    "zenquotes",
+]
+
+
+class InternalCallFinder(ast.NodeVisitor):
+    """
+    An AST visitor that finds calls to tool functions from within other tool functions.
+    """
+
+    def __init__(self, tool_functions):
+        self.tool_functions = set(tool_functions)
+        self.current_function = None
+        self.internal_calls = []
+
+    def visit_FunctionDef(self, node):
+        if node.name in self.tool_functions:
+            self.current_function = node.name
+            self.generic_visit(node)
+            self.current_function = None
+        else:
+            self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node):
+        if node.name in self.tool_functions:
+            self.current_function = node.name
+            self.generic_visit(node)
+            self.current_function = None
+        else:
+            self.generic_visit(node)
+
+    def visit_Call(self, node):
+        if self.current_function:
+            if isinstance(node.func, ast.Attribute) and isinstance(node.func.value, ast.Name) and node.func.value.id == "self":
+                called_func_name = node.func.attr
+                if called_func_name in self.tool_functions and called_func_name != self.current_function:
+                    self.internal_calls.append({"caller": self.current_function, "callee": called_func_name})
+        self.generic_visit(node)
+
+
+def get_tool_function_names(tree):
+    """
+    Extracts the names of the tool functions from the 'list_tools' method in the AST.
+    """
+    tool_functions = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            for item in node.body:
+                if isinstance(item, ast.FunctionDef) and item.name == "list_tools":
+                    for statement in item.body:
+                        if isinstance(statement, ast.Return):
+                            if isinstance(statement.value, (ast.List, ast.Tuple)):
+                                for elt in statement.value.elts:
+                                    if isinstance(elt, ast.Attribute):
+                                        tool_functions.add(elt.attr)
+    return list(tool_functions)
+
+
+def process_file(file_path):
+    """
+    Reads and processes a single app.py file to find internal calls.
+    """
+    with open(file_path, "r") as f:
+        source = f.read()
+    try:
+        tree = ast.parse(source)
+    except SyntaxError as e:
+        print(f"Error parsing {file_path}: {e}")
+        return []
+
+    tool_functions = get_tool_function_names(tree)
+    if not tool_functions:
+        return []
+
+    finder = InternalCallFinder(tool_functions)
+    finder.visit(tree)
+    return finder.internal_calls
+
+
+def main():
+    """
+    Main function to iterate through specified applications and check for internal calls.
+    """
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "universal_mcp", "applications"))
+
+    apps_with_internal_calls = {}
+
+    for app in APPS:
+        app_path = os.path.join(base_path, app, "app.py")
+        if os.path.exists(app_path):
+            internal_calls = process_file(app_path)
+            if internal_calls:
+                apps_with_internal_calls[app] = internal_calls
+        else:
+            print(f"Could not find {app_path} for application {app}")
+
+    if apps_with_internal_calls:
+        print("Applications with internal tool function calls:")
+        for app, calls in apps_with_internal_calls.items():
+            print(f"- {app}:")
+            unique_calls = {(call["caller"], call["callee"]) for call in calls}
+            for caller, callee in sorted(list(unique_calls)):
+                print(f"  - '{caller}' calls '{callee}'")
+    else:
+        print("No applications with internal tool function calls found in the specified APPS list.")
+
+
+if __name__ == "__main__":
+    main()

{universal_mcp_applications-0.1.33 → universal_mcp_applications-0.1.36rc3}/src/scripts/docgen.py

@@ -28,9 +28,7 @@ from src.scripts.prompts import SYSTEM_PROMPT_TEMPLATE, USER_PROMPT_TEMPLATE
 class DescriptionOutput(BaseModel):
     """Structure for the generated description output."""
 
-    description: str = Field(
-        description="A clear, detailed description of what the function does"
-    )
+    description: str = Field(description="A clear, detailed description of what the function does")
     # suggested_name: Optional[str] = Field(None, description="A better name for the function, if applicable")
 
 
@@ -42,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."""
@@ -181,11 +177,7 @@ def parse_existing_docstring(docstring: str | None) -> tuple[str, str]:
 
     for i, line in enumerate(lines):
         stripped_line = line.strip()
-        if (
-            not summary_done
-            and stripped_line
-            and not stripped_line.startswith(section_markers)
-        ):
+        if not summary_done and stripped_line and not stripped_line.startswith(section_markers):
             summary_lines.append(line.strip())
         elif not summary_done and not stripped_line and summary_lines:
             # This blank line marks the end of the summary
@@ -208,9 +200,7 @@ def parse_existing_docstring(docstring: str | None) -> tuple[str, str]:
     return summary, rest_of_docstring
 
 
-def generate_description(
-    function_code: str, file_content: str, model: str = "perplexity/sonar"
-) -> DescriptionOutput:
+def generate_description(function_code: str, file_content: str, model: str = "perplexity/sonar") -> DescriptionOutput:
     """
     Generate a high-quality description and suggest a name for a Python function.
 
@@ -242,9 +232,7 @@ def generate_description(
             try:
                 parsed_data = extract_json_from_text(response_text)
                 return DescriptionOutput(
-                    description=parsed_data.get(
-                        "description", "No description available."
-                    ),
+                    description=parsed_data.get("description", "No description available."),
                     # suggested_name=parsed_data.get("suggested_name"),
                 )
             except ValueError:
@@ -255,16 +243,12 @@ def generate_description(
                 delay = base_delay * (2**attempt)
                 time.sleep(delay)
             else:
-                return DescriptionOutput(
-                    description=f"Error generating description after {max_retries} retries: {e}"
-                )
+                return DescriptionOutput(description=f"Error generating description after {max_retries} retries: {e}")
 
         except Exception as e:
             return DescriptionOutput(description=f"An unexpected error occurred: {e}")
 
-    return DescriptionOutput(
-        description="Failed to generate description after all retries."
-    )
+    return DescriptionOutput(description="Failed to generate description after all retries.")
 
 
 def insert_docstring_into_function(function_code: str, docstring: str) -> str:
@@ -281,9 +265,7 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
     try:
         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)):
             return function_code
 
         func_node = tree.body[0]
@@ -293,9 +275,7 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
         if func_node.body:
             # Use the indentation of the first statement in the body (e.g., the old docstring).
             first_body_line_str = lines[func_node.body[0].lineno - 1]
-            body_indent = first_body_line_str[
-                : len(first_body_line_str) - len(first_body_line_str.lstrip())
-            ]
+            body_indent = first_body_line_str[: len(first_body_line_str) - len(first_body_line_str.lstrip())]
         else:
             # Fallback for empty functions: calculate from the 'def' line.
             def_line = lines[func_node.lineno - 1]
@@ -305,9 +285,7 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
 
         # Format the new docstring with the determined 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')
 
         # Check if the first statement is an existing docstring
@@ -321,9 +299,7 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
             existing_docstring_node = func_node.body[0]
 
         # Splice the code
-        insert_idx = (
-            func_node.body[0].lineno - 1 if func_node.body else func_node.lineno
-        )
+        insert_idx = func_node.body[0].lineno - 1 if func_node.body else func_node.lineno
         pre_insertion_lines = lines[:insert_idx]
 
         if existing_docstring_node:
@@ -331,9 +307,7 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
         else:
             post_insertion_lines = lines[insert_idx:]
 
-        output_lines = (
-            pre_insertion_lines + new_docstring_lines_formatted + post_insertion_lines
-        )
+        output_lines = pre_insertion_lines + new_docstring_lines_formatted + post_insertion_lines
 
         final_code = "".join(output_lines)
         ast.parse(final_code)  # Validate syntax
@@ -360,9 +334,7 @@ def rename_function_in_code(function_code: str, old_name: str, new_name: str) ->
     pattern = r"(async\s+def|def)\s+" + re.escape(old_name) + r"(\s*\()"
     replacement = r"\1 " + new_name + r"\2"
 
-    new_function_code, num_replacements = re.subn(
-        pattern, replacement, function_code, 1
-    )
+    new_function_code, num_replacements = re.subn(pattern, replacement, function_code, 1)
 
     if num_replacements == 0:
         return function_code
@@ -392,9 +364,7 @@ def update_list_tools_method(content: str, old_name: str, new_name: str) -> str:
     replacement = r"\1" + new_name
 
     # First, find the list_tools method definition to narrow the search area
-    list_tools_match = re.search(
-        r"def\s+list_tools\s*\([^)]*\):\s*return\s*\[[^\]]*\]", content, re.DOTALL
-    )
+    list_tools_match = re.search(r"def\s+list_tools\s*\([^)]*\):\s*return\s*\[[^\]]*\]", content, re.DOTALL)
 
     if not list_tools_match:
         return content
@@ -402,9 +372,7 @@ def update_list_tools_method(content: str, old_name: str, new_name: str) -> str:
     list_tools_code = list_tools_match.group(0)
 
     # Perform the replacement only within the found method block
-    updated_list_tools_code, num_replacements = re.subn(
-        pattern, replacement, list_tools_code
-    )
+    updated_list_tools_code, num_replacements = re.subn(pattern, replacement, list_tools_code)
 
     if num_replacements > 0:
         return content.replace(list_tools_code, updated_list_tools_code)
@@ -437,7 +405,6 @@ def process_file(file_path: str, model: str = "perplexity/sonar") -> int:
     count = 0
 
     for function_name, function_code in functions:
-
         try:
             func_tree = ast.parse(function_code)
             func_node = func_tree.body[0]
@@ -467,15 +434,11 @@ def process_file(file_path: str, model: str = "perplexity/sonar") -> int:
         #     is_renamed = True
 
         # 4. Insert the new docstring back into the (potentially renamed) function code
-        updated_function_block = insert_docstring_into_function(
-            code_to_update, reconstructed_docstring
-        )
+        updated_function_block = insert_docstring_into_function(code_to_update, reconstructed_docstring)
 
         # 5. If any changes were made, update the main content
         if updated_function_block != function_code:
-            updated_content = updated_content.replace(
-                function_code, updated_function_block
-            )
+            updated_content = updated_content.replace(function_code, updated_function_block)
             count += 1
 
             # 6. If the function was renamed, also update the list_tools method

universal_mcp_applications-0.1.36rc3/src/scripts/make_async.py

@@ -0,0 +1,99 @@
+import ast
+import os
+
+# List of applications to be converted to async
+APPS = [
+    "whatsapp",
+    "whatsapp_business",
+    "wrike",  # not seeded
+    "yahoo_finance",
+    "youtube",
+    "zenquotes",
+]
+
+
+class AsyncConverter(ast.NodeTransformer):
+    """
+    An AST transformer that converts specified synchronous functions to asynchronous ones.
+    """
+
+    def __init__(self, tool_functions):
+        self.tool_functions = tool_functions
+
+    def visit_FunctionDef(self, node):
+        """
+        Transforms a synchronous function definition to an asynchronous one
+        if its name is in the list of tool functions.
+        """
+        if node.name in self.tool_functions:
+            # Convert the function to an async function
+            return ast.AsyncFunctionDef(
+                name=node.name,
+                args=node.args,
+                body=node.body,
+                decorator_list=node.decorator_list,
+                returns=node.returns,
+                type_comment=getattr(node, "type_comment", None),
+            )
+        return node
+
+
+def get_tool_function_names(tree):
+    """
+    Extracts the names of the tool functions from the 'list_tools' method in the AST.
+    """
+    tool_functions = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            for item in node.body:
+                if isinstance(item, ast.FunctionDef) and item.name == "list_tools":
+                    for statement in item.body:
+                        if isinstance(statement, ast.Return):
+                            for elt in statement.value.elts:
+                                if isinstance(elt, ast.Attribute):
+                                    tool_functions.add(elt.attr)
+    return list(tool_functions)
+
+
+def process_file(file_path):
+    """
+    Reads, transforms, and writes back the Python source file to make functions async.
+    """
+    with open(file_path, "r") as f:
+        source = f.read()
+
+    tree = ast.parse(source)
+    tool_functions = get_tool_function_names(tree)
+
+    if not tool_functions:
+        print(f"No tool functions found in {file_path}")
+        return
+
+    converter = AsyncConverter(tool_functions)
+    new_tree = converter.visit(tree)
+    ast.fix_missing_locations(new_tree)
+
+    new_source = ast.unparse(new_tree)
+
+    with open(file_path, "w") as f:
+        f.write(new_source)
+    print(f"Successfully converted functions in {file_path} to async.")
+
+
+def main():
+    """
+    Main function to process the applications listed in APPS.
+    """
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "universal_mcp", "applications"))
+
+    for app in APPS:
+        app_path = os.path.join(base_path, app, "app.py")
+        # app_path = "/Users/ankitranjan/Work/applications/src/universal_mcp/applications/hubspot/api_segments/marketing_api.py"
+        if os.path.exists(app_path):
+            process_file(app_path)
+        else:
+            print(f"Could not find {app_path}")
+
+
+if __name__ == "__main__":
+    main()

{universal_mcp_applications-0.1.33 → universal_mcp_applications-0.1.36rc3}/src/scripts/readme.py

@@ -92,9 +92,7 @@ def main():
     """
     Runs the readme generation for a predefined list of applications.
     """
-    base_path = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), "..", "universal_mcp", "applications")
-    )
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "universal_mcp", "applications"))
 
     for app in APPS:
         app_path = os.path.join(base_path, app, "app.py")
@@ -102,9 +100,7 @@ def main():
 
         try:
             # Using 'uv run' to ensure the command is executed in the correct environment
-            subprocess.run(
-                ["uv", "run"] + command, check=True, capture_output=True, text=True
-            )
+            subprocess.run(["uv", "run"] + command, check=True, capture_output=True, text=True)
             # print(result.stdout) # Optional: print stdout for more details
         except subprocess.CalledProcessError:
             pass