onetool-mcp 1.0.0b1__py3-none-any.whl

ot/executor/fence_processor.py

@@ -0,0 +1,83 @@
+"""Fence processing for command execution.
+
+Handles stripping of:
+- Execution trigger prefixes (__ot, __onetool, mcp__onetool__run)
+- Markdown code fences (triple backticks with/without language)
+- Inline backticks (single and double)
+
+Used by the runner to clean commands before execution.
+"""
+
+from __future__ import annotations
+
+import re
+
+
+def strip_fences(command: str) -> tuple[str, bool]:
+    """Strip execution prefixes, markdown code fences, and inline backticks.
+
+    Execution trigger prefixes (stripped first):
+        __ot                 - short name, default tool
+        __ot__run            - short name, explicit tool call
+        __onetool            - full name, default tool
+        __onetool__run       - full name, explicit tool call
+        mcp__onetool__run    - explicit MCP call
+
+    Each prefix supports three invocation styles:
+        <prefix> func(arg="value")     - simple call
+        <prefix> `code`                - inline backticks
+        <prefix> + code fence          - multi-line code fence
+
+    Note: mcp__ot__run is NOT a valid prefix.
+
+    Markdown fences (stripped after prefix):
+        ```python
+        code here
+        ```
+
+        `code here`
+
+        `` `code here` ``
+
+    Args:
+        command: Raw command string that may contain prefixes and fences
+
+    Returns:
+        Tuple of (stripped command, whether anything was stripped)
+    """
+    stripped = command.strip()
+    anything_stripped = False
+
+    # Strip execution trigger prefixes:
+    # - __ot, __ot__run (short name)
+    # - __onetool, __onetool__run (full name)
+    # - mcp__onetool__run (explicit MCP call)
+    # Note: mcp__ot__run is NOT valid
+    prefix_pattern = r"^(?:mcp__onetool__run|__onetool(?:__run)?|__ot(?:__run)?)\s*"
+    match = re.match(prefix_pattern, stripped)
+    if match:
+        stripped = stripped[match.end() :].strip()
+        anything_stripped = True
+
+    # Handle triple backtick fenced blocks
+    if stripped.startswith("```"):
+        first_newline = stripped.find("\n")
+        if first_newline != -1 and stripped.endswith("```"):
+            content = stripped[first_newline + 1 : -3].strip()
+            return content, True
+
+    # Handle double backtick fenced blocks: `` `code` ``
+    if stripped.startswith("`` `") and stripped.endswith("` ``"):
+        content = stripped[4:-4].strip()
+        return content, True
+
+    if stripped.startswith("``") and stripped.endswith("``"):
+        content = stripped[2:-2].strip()
+        return content, True
+
+    # Handle inline single backticks: `code`
+    if stripped.startswith("`") and stripped.endswith("`") and stripped.count("`") == 2:
+        content = stripped[1:-1].strip()
+        return content, True
+
+    return stripped, anything_stripped

ot/executor/linter.py

@@ -0,0 +1,142 @@
+"""Optional Ruff linting integration for OneTool.
+
+Provides style warnings (non-blocking) using Ruff linter if installed.
+Falls back gracefully if Ruff is not available.
+
+Example:
+    result = lint_code(code)
+    if result.available:
+        for warning in result.warnings:
+            print(f"Style warning: {warning}")
+"""
+
+from __future__ import annotations
+
+import contextlib
+import subprocess
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from loguru import logger
+
+
+@dataclass
+class LintResult:
+    """Result of linting operation."""
+
+    available: bool = False  # Whether Ruff is available
+    warnings: list[str] = field(default_factory=list)
+    error: str | None = None  # Error message if linting failed
+
+
+def _check_ruff_available() -> bool:
+    """Check if Ruff is available on the system."""
+    try:
+        result = subprocess.run(
+            ["ruff", "--version"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return False
+
+
+# Cache Ruff availability check
+_ruff_available: bool | None = None
+
+
+def is_ruff_available() -> bool:
+    """Check if Ruff linter is available (cached)."""
+    global _ruff_available
+    if _ruff_available is None:
+        _ruff_available = _check_ruff_available()
+    return _ruff_available
+
+
+def lint_code(
+    code: str,
+    select: list[str] | None = None,
+    ignore: list[str] | None = None,
+) -> LintResult:
+    """Lint Python code using Ruff.
+
+    Args:
+        code: Python code to lint
+        select: Rule codes to enable (e.g., ["E", "F", "W"])
+        ignore: Rule codes to ignore (e.g., ["E501"])
+
+    Returns:
+        LintResult with warnings if Ruff is available
+    """
+    result = LintResult()
+
+    if not is_ruff_available():
+        result.available = False
+        return result
+
+    result.available = True
+
+    # Write code to temp file for Ruff
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            suffix=".py",
+            delete=False,
+        ) as f:
+            f.write(code)
+            temp_path = Path(f.name)
+
+        # Build Ruff command
+        cmd = ["ruff", "check", str(temp_path), "--output-format=text"]
+
+        if select:
+            cmd.extend(["--select", ",".join(select)])
+        if ignore:
+            cmd.extend(["--ignore", ",".join(ignore)])
+
+        # Run Ruff
+        proc = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        # Parse output - each line is a warning
+        if proc.stdout:
+            for line in proc.stdout.strip().split("\n"):
+                if line.strip():
+                    # Remove temp file path from output
+                    warning = line.replace(str(temp_path), "<code>")
+                    result.warnings.append(warning)
+
+    except subprocess.TimeoutExpired:
+        result.error = "Ruff linting timed out"
+        logger.warning("Ruff linting timed out")
+    except OSError as e:
+        result.error = f"Failed to run Ruff: {e}"
+        logger.warning(f"Failed to run Ruff: {e}")
+    finally:
+        # Clean up temp file
+        with contextlib.suppress(NameError, OSError):
+            temp_path.unlink()
+
+    return result
+
+
+def lint_code_quick(code: str) -> list[str]:
+    """Quick lint that returns just the warnings list.
+
+    Convenience function for simple use cases.
+
+    Args:
+        code: Python code to lint
+
+    Returns:
+        List of warning strings (empty if Ruff unavailable)
+    """
+    result = lint_code(code)
+    return result.warnings

ot/executor/pack_proxy.py

@@ -0,0 +1,260 @@
+"""Pack proxy creation for dot notation access.
+
+Creates proxy objects that allow:
+- brave.web_search(query="test") - pack access to tool functions
+- context7.resolve_library_id() - MCP proxy access
+- proxy.list_servers() - introspection of MCP servers
+
+Used by the runner to build the execution namespace.
+"""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from functools import wraps
+from typing import TYPE_CHECKING, Any
+
+from ot.executor.param_resolver import (
+    get_mcp_tool_param_names,
+    get_tool_param_names,
+    resolve_kwargs,
+)
+from ot.stats import timed_tool_call
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from ot.executor.tool_loader import LoadedTools
+
+
+def _wrap_with_stats(
+    pack_name: str, func_name: str, func: Callable[..., Any]
+) -> Callable[..., Any]:
+    """Wrap a function to record execution-level stats, track calls, and resolve param prefixes."""
+    tool_name = f"{pack_name}.{func_name}"
+
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        # Resolve abbreviated parameter names (cached lookup)
+        if kwargs:
+            param_names = get_tool_param_names(tool_name)
+            if param_names:
+                kwargs = resolve_kwargs(kwargs, param_names)
+
+        with timed_tool_call(tool_name):
+            return func(*args, **kwargs)
+
+    return wrapper
+
+
+def _create_pack_proxy(pack_name: str, pack_funcs: dict[str, Any]) -> Any:
+    """Create a pack proxy instance for dot notation access.
+
+    Returns an object that allows pack.func() syntax where func is looked up
+    from pack_funcs dict. Each function call is tracked for execution-level stats.
+    """
+
+    class PackProxy:
+        """Proxy object that provides dot notation access to pack functions."""
+
+        def __init__(self) -> None:
+            # Cache wrapped functions to avoid recreating on each access
+            self._function_cache: dict[str, Callable[..., Any]] = {}
+
+        def __getattr__(self, name: str) -> Any:
+            if name.startswith("_"):
+                raise AttributeError(f"Cannot access private attribute '{name}'")
+
+            if name in pack_funcs:
+                # Return cached wrapper or create and cache new one
+                if name not in self._function_cache:
+                    self._function_cache[name] = _wrap_with_stats(
+                        pack_name, name, pack_funcs[name]
+                    )
+                return self._function_cache[name]
+
+            available = ", ".join(sorted(pack_funcs.keys()))
+            raise AttributeError(
+                f"Function '{name}' not found in pack '{pack_name}'. "
+                f"Available: {available}"
+            )
+
+    return PackProxy()
+
+
+def _create_mcp_proxy_pack(server_name: str) -> Any:
+    """Create a pack proxy for an MCP server.
+
+    Allows calling proxied MCP tools using dot notation:
+    - context7.resolve_library_id(library_name="next.js")
+
+    Each call is tracked for execution-level stats.
+
+    Args:
+        server_name: Name of the MCP server.
+
+    Returns:
+        Object with __getattr__ that routes to proxy manager.
+    """
+    from ot.proxy import get_proxy_manager
+
+    class McpProxyPack:
+        """Proxy object that routes tool calls to an MCP server."""
+
+        def __init__(self) -> None:
+            # Cache callable proxies to avoid recreating on each access
+            self._function_cache: dict[str, Callable[..., str]] = {}
+
+        def __getattr__(self, tool_name: str) -> Any:
+            if tool_name.startswith("_"):
+                raise AttributeError(f"Cannot access private attribute '{tool_name}'")
+
+            if tool_name in self._function_cache:
+                return self._function_cache[tool_name]
+
+            def call_proxy_tool(**kwargs: Any) -> str:
+                tool_full_name = f"{server_name}.{tool_name}"
+
+                # Resolve abbreviated parameter names (cached lookup)
+                if kwargs:
+                    param_names = get_mcp_tool_param_names(server_name, tool_name)
+                    if param_names:
+                        kwargs = resolve_kwargs(kwargs, param_names)
+
+                with timed_tool_call(tool_full_name):
+                    proxy = get_proxy_manager()
+                    return proxy.call_tool_sync(server_name, tool_name, kwargs)
+
+            self._function_cache[tool_name] = call_proxy_tool
+            return call_proxy_tool
+
+    return McpProxyPack()
+
+
+def _create_proxy_introspection_pack() -> Any:
+    """Create the 'proxy' pack for introspection.
+
+    Provides:
+    - proxy.list_servers() - List all configured MCP servers with status
+    - proxy.list_tools(server="name") - List tools available on a server
+
+    Returns:
+        Object with introspection methods.
+    """
+    from ot.proxy import get_proxy_manager
+
+    class ProxyIntrospectionPack:
+        """Provides introspection methods for proxied MCP servers."""
+
+        def list_servers(self) -> list[dict[str, Any]]:
+            """List all configured MCP servers with connection status.
+
+            Returns:
+                List of dicts with server name, type, enabled, and connected status.
+            """
+            from ot.config import get_config
+
+            config = get_config()
+            proxy = get_proxy_manager()
+
+            servers = []
+            for name, cfg in (config.servers or {}).items():
+                servers.append(
+                    {
+                        "name": name,
+                        "type": cfg.type,
+                        "enabled": cfg.enabled,
+                        "connected": name in proxy.servers,
+                    }
+                )
+            return servers
+
+        def list_tools(self, server: str) -> list[dict[str, str]]:
+            """List tools available on a proxied MCP server.
+
+            Args:
+                server: Name of the MCP server.
+
+            Returns:
+                List of dicts with tool name and description.
+
+            Raises:
+                ValueError: If server is not connected.
+            """
+            proxy = get_proxy_manager()
+
+            if server not in proxy.servers:
+                available = ", ".join(proxy.servers) or "none"
+                raise ValueError(
+                    f"Server '{server}' not connected. Available: {available}"
+                )
+
+            tools = proxy.list_tools(server)
+            return [{"name": t.name, "description": t.description} for t in tools]
+
+    return ProxyIntrospectionPack()
+
+
+# Cache for execution namespace: key=(registry_id, frozenset of proxy servers)
+# Uses OrderedDict for proper LRU eviction
+_NAMESPACE_CACHE_MAXSIZE = 10
+_namespace_cache: OrderedDict[tuple[int, frozenset[str]], dict[str, Any]] = (
+    OrderedDict()
+)
+
+
+def build_execution_namespace(
+    registry: LoadedTools,
+) -> dict[str, Any]:
+    """Build execution namespace with pack proxies for dot notation access.
+
+    Results are cached based on registry identity and proxy server configuration.
+    Cache is invalidated when registry changes or proxy servers are added/removed.
+
+    Provides dot notation access to tools:
+    - brave.web_search(query="test")  # pack access
+    - context7.resolve_library_id()   # MCP proxy access
+
+    Args:
+        registry: LoadedTools registry with functions and packs
+
+    Returns:
+        Dict suitable for use as exec() globals
+    """
+    from ot.executor.worker_proxy import WorkerPackProxy
+    from ot.proxy import get_proxy_manager
+
+    # Check cache - key is registry identity + current proxy servers
+    proxy_mgr = get_proxy_manager()
+    cache_key = (id(registry), frozenset(proxy_mgr.servers))
+
+    if cache_key in _namespace_cache:
+        # LRU: move to end on access
+        _namespace_cache.move_to_end(cache_key)
+        return _namespace_cache[cache_key]
+
+    namespace: dict[str, Any] = {}
+
+    # Add pack proxies for dot notation
+    for pack_name, pack_funcs in registry.packs.items():
+        if isinstance(pack_funcs, WorkerPackProxy):
+            # Extension tools already have a proxy - use directly
+            namespace[pack_name] = pack_funcs
+        else:
+            namespace[pack_name] = _create_pack_proxy(pack_name, pack_funcs)
+
+    # Add MCP proxy packs (only if not already defined locally)
+    for server_name in proxy_mgr.servers:
+        if server_name not in namespace:
+            namespace[server_name] = _create_mcp_proxy_pack(server_name)
+
+    # Add proxy introspection pack (always available)
+    if "proxy" not in namespace:
+        namespace["proxy"] = _create_proxy_introspection_pack()
+
+    # Cache result with LRU eviction
+    _namespace_cache[cache_key] = namespace
+    while len(_namespace_cache) > _NAMESPACE_CACHE_MAXSIZE:
+        _namespace_cache.popitem(last=False)
+
+    return namespace

ot/executor/param_resolver.py

@@ -0,0 +1,140 @@
+"""Parameter name prefix matching for tool calls.
+
+Resolves abbreviated parameter names to full parameter names using prefix matching.
+For example: q= -> query=, c= -> count=
+"""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from collections.abc import Sequence
+from functools import lru_cache
+
+
+@lru_cache(maxsize=256)
+def get_tool_param_names(tool_name: str) -> tuple[str, ...]:
+    """Get parameter names for a tool from the registry (cached).
+
+    Args:
+        tool_name: Full tool name (e.g., "brave.web_search").
+
+    Returns:
+        Tuple of parameter names in signature order, or empty tuple if not found.
+    """
+    from ot.registry import get_registry
+
+    registry = get_registry()
+    tool_info = registry.get_tool(tool_name)
+    if tool_info:
+        return tuple(arg.name for arg in tool_info.args)
+    return ()
+
+
+# Cache for MCP tool param names: (server_name, tool_name) -> param_names
+# Uses OrderedDict for LRU eviction with bounded size
+_MCP_PARAM_CACHE_MAXSIZE = 256
+_mcp_param_cache: OrderedDict[tuple[str, str], tuple[str, ...]] = OrderedDict()
+
+
+def get_mcp_tool_param_names(server_name: str, tool_name: str) -> tuple[str, ...]:
+    """Get parameter names for an MCP tool from its input schema (cached).
+
+    Args:
+        server_name: Name of the MCP server.
+        tool_name: Name of the tool.
+
+    Returns:
+        Tuple of parameter names, or empty tuple if not found.
+    """
+    cache_key = (server_name, tool_name)
+    if cache_key in _mcp_param_cache:
+        _mcp_param_cache.move_to_end(cache_key)
+        return _mcp_param_cache[cache_key]
+
+    from ot.proxy import get_proxy_manager
+
+    proxy = get_proxy_manager()
+    tools = proxy.list_tools(server_name)
+    result: tuple[str, ...] = ()
+    for tool in tools:
+        if tool.name == tool_name:
+            result = tuple(get_param_names_from_schema(tool.input_schema))
+            break
+
+    _mcp_param_cache[cache_key] = result
+    while len(_mcp_param_cache) > _MCP_PARAM_CACHE_MAXSIZE:
+        _mcp_param_cache.popitem(last=False)
+    return result
+
+
+def resolve_kwargs(
+    kwargs: dict[str, object], param_names: Sequence[str]
+) -> dict[str, object]:
+    """Resolve abbreviated parameter names to full parameter names.
+
+    Matching rules:
+    1. Exact match wins - if param name matches exactly, use it
+    2. Prefix match - find all params that start with the abbreviated name
+    3. First match wins - if multiple params match, use first in param_names order
+
+    Args:
+        kwargs: Dictionary of parameter names to values.
+        param_names: Sequence of valid parameter names in signature order.
+
+    Returns:
+        New dictionary with resolved parameter names.
+
+    Examples:
+        >>> resolve_kwargs({"q": "test"}, ["query", "count"])
+        {"query": "test"}
+
+        >>> resolve_kwargs({"query": "test"}, ["query", "count"])
+        {"query": "test"}  # exact match
+
+        >>> resolve_kwargs({"q": "x"}, ["query_info", "query", "quality"])
+        {"query_info": "x"}  # first prefix match
+
+        >>> resolve_kwargs({"xyz": "test"}, ["query"])
+        {"xyz": "test"}  # no match, passthrough
+    """
+    if not kwargs or not param_names:
+        return kwargs
+
+    param_set = set(param_names)
+    resolved: dict[str, object] = {}
+
+    for key, value in kwargs.items():
+        # Exact match - use as-is
+        if key in param_set:
+            resolved[key] = value
+            continue
+
+        # Find prefix matches (preserve signature order)
+        matches = [p for p in param_names if p.startswith(key)]
+
+        if len(matches) == 1:
+            # Single match - use it
+            resolved[matches[0]] = value
+        elif len(matches) > 1:
+            # Multiple matches - use first in signature order
+            resolved[matches[0]] = value
+        else:
+            # No match - passthrough (let function raise its own error)
+            resolved[key] = value
+
+    return resolved
+
+
+def get_param_names_from_schema(input_schema: dict[str, object]) -> list[str]:
+    """Extract parameter names from a JSON schema.
+
+    Args:
+        input_schema: JSON schema dict with "properties" key.
+
+    Returns:
+        List of parameter names in schema order.
+    """
+    properties = input_schema.get("properties", {})
+    if isinstance(properties, dict):
+        return list(properties.keys())
+    return []