onetool-mcp 1.0.0b1__py3-none-any.whl → 1.0.0rc2__py3-none-any.whl

ot/executor/__init__.py

@@ -1,35 +1,35 @@
-"""Execution engines for OneTool.
-
-Provides direct host execution via SimpleExecutor.
-The unified runner provides a single entry point for all command execution.
-"""
-
-from ot.executor.base import ExecutionResult
-from ot.executor.fence_processor import strip_fences
-from ot.executor.runner import (
-    CommandResult,
-    PreparedCommand,
-    execute_command,
-    execute_python_code,
-    prepare_command,
-)
-from ot.executor.simple import SimpleExecutor
-from ot.executor.validator import (
-    ValidationResult,
-    validate_for_exec,
-    validate_python_code,
-)
-
-__all__ = [
-    "CommandResult",
-    "ExecutionResult",
-    "PreparedCommand",
-    "SimpleExecutor",
-    "ValidationResult",
-    "execute_command",
-    "execute_python_code",
-    "prepare_command",
-    "strip_fences",
-    "validate_for_exec",
-    "validate_python_code",
-]
+"""Execution engines for OneTool.
+
+Provides direct host execution via SimpleExecutor.
+The unified runner provides a single entry point for all command execution.
+"""
+
+from ot.executor.base import ExecutionResult
+from ot.executor.fence_processor import strip_fences
+from ot.executor.runner import (
+    CommandResult,
+    PreparedCommand,
+    execute_command,
+    execute_python_code,
+    prepare_command,
+)
+from ot.executor.simple import SimpleExecutor
+from ot.executor.validator import (
+    ValidationResult,
+    validate_for_exec,
+    validate_python_code,
+)
+
+__all__ = [
+    "CommandResult",
+    "ExecutionResult",
+    "PreparedCommand",
+    "SimpleExecutor",
+    "ValidationResult",
+    "execute_command",
+    "execute_python_code",
+    "prepare_command",
+    "strip_fences",
+    "validate_for_exec",
+    "validate_python_code",
+]

ot/executor/base.py

@@ -1,16 +1,16 @@
-"""Base types for executor module."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-
-@dataclass
-class ExecutionResult:
-    """Result from executing a tool."""
-
-    success: bool
-    result: str
-    duration_seconds: float = 0.0
-    executor: str = "simple"
-    error_type: str | None = None
+"""Base types for executor module."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ExecutionResult:
+    """Result from executing a tool."""
+
+    success: bool
+    result: str
+    duration_seconds: float = 0.0
+    executor: str = "simple"
+    error_type: str | None = None

ot/executor/fence_processor.py

@@ -1,83 +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
+"""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

@@ -1,142 +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
+"""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