agentpool 2.1.9__py3-none-any.whl

agentpool_toolsets/config_creation.py

@@ -0,0 +1,192 @@
+"""Config creation toolset with schema validation."""
+
+from __future__ import annotations
+
+import json
+import tomllib
+from typing import TYPE_CHECKING, Any, Literal
+
+import anyenv
+from schemez.helpers import json_schema_to_pydantic_code
+from upathtools import is_directory_sync, to_upath
+from upathtools.filesystems.file_filesystems import JsonSchemaFileSystem
+
+from agentpool.resource_providers import StaticResourceProvider
+
+
+if TYPE_CHECKING:
+    import jsonschema
+    from upathtools import JoinablePathLike
+
+
+MarkupType = Literal["yaml", "json", "toml"]
+
+
+def _parse_content(content: str, markup: MarkupType) -> dict[str, Any]:
+    """Parse content based on markup type."""
+    import yamling
+
+    match markup:
+        case "yaml":
+            return yamling.load_yaml(content, verify_type=dict)
+        case "json":
+            return anyenv.load_json(content, return_type=dict)
+        case "toml":
+            return tomllib.loads(content)
+
+
+def _format_validation_error(error: jsonschema.ValidationError) -> str:
+    """Format a validation error for user-friendly display."""
+    path = " -> ".join(str(p) for p in error.absolute_path) if error.absolute_path else "root"
+    return f"At '{path}': {error.message}"
+
+
+class ConfigCreationTools(StaticResourceProvider):
+    """Provider for config creation and validation tools."""
+
+    def __init__(
+        self,
+        schema_path: JoinablePathLike,
+        markup: MarkupType = "yaml",
+        name: str = "config_creation",
+    ) -> None:
+        """Initialize the config creation toolset.
+
+        Args:
+            schema_path: Path to the JSON schema file
+            markup: Markup language for configs (yaml, json, toml)
+            name: Namespace for the tools
+        """
+        super().__init__(name=name)
+        self._schema_path = to_upath(schema_path)
+        self._markup: MarkupType = markup
+        self._schema: dict[str, Any] | None = None
+
+        self.add_tool(
+            self.create_tool(
+                self.create_config,
+                category="edit",
+                read_only=False,
+                idempotent=True,
+                description_override=(
+                    f"Create and validate a {markup.upper()} configuration. "
+                    "Returns validation result and any errors."
+                ),
+            )
+        )
+        self.add_tool(
+            self.create_tool(
+                self.show_schema_as_code, category="read", read_only=True, idempotent=True
+            )
+        )
+        self.add_tool(
+            self.create_tool(self.list_schema, category="read", read_only=True, idempotent=True)
+        )
+        self.add_tool(
+            self.create_tool(
+                self.read_schema_node, category="read", read_only=True, idempotent=True
+            )
+        )
+
+    def _load_schema(self) -> dict[str, Any]:
+        """Load and cache the JSON schema."""
+        if self._schema is None:
+            content = self._schema_path.read_text()
+            self._schema = anyenv.load_json(content, return_type=dict)
+        return self._schema
+
+    def _get_schema_fs(self) -> JsonSchemaFileSystem:
+        """Get or create the JSON schema filesystem."""
+        return JsonSchemaFileSystem(schema_url=str(self._schema_path))
+
+    async def create_config(self, content: str) -> str:
+        """Create and validate a configuration.
+
+        Args:
+            content: The configuration content in the configured markup format
+
+        Returns:
+            Validation result message
+        """
+        import jsonschema
+
+        schema = self._load_schema()
+        try:
+            data = _parse_content(content, self._markup)
+        except Exception as e:  # noqa: BLE001
+            return f"Failed to parse {self._markup.upper()}: {e}"
+
+        validator = jsonschema.Draft202012Validator(schema)
+        if errors := [_format_validation_error(e) for e in validator.iter_errors(data)]:
+            error_list = "\n".join(f"- {e}" for e in errors[:10])
+            suffix = f"\n... and {len(errors) - 10} more errors" if len(errors) > 10 else ""  # noqa: PLR2004
+            return f"Validation failed with {len(errors)} error(s):\n{error_list}{suffix}"
+
+        return "Configuration is valid! Successfully validated against schema."
+
+    async def show_schema_as_code(self) -> str:
+        """Show the JSON schema as Python Pydantic code.
+
+        Returns:
+            Python code representation of the schema
+        """
+        schema = self._load_schema()
+        return json_schema_to_pydantic_code(schema, class_name="Config")
+
+    async def list_schema(self, path: str = "/") -> str:
+        """List contents at a path in the JSON schema.
+
+        Args:
+            path: Path to list (e.g. '/', '/$defs', '/$defs/AgentConfig/properties')
+
+        Returns:
+            Formatted listing of schema contents at the path
+        """
+        fs = self._get_schema_fs()
+        try:
+            items = fs.ls(path, detail=True)
+        except FileNotFoundError:
+            return f"Path not found: {path}"
+
+        if not items:
+            return f"No contents at: {path}"
+
+        lines = [f"Contents of {path}:\n"]
+        for item in items:
+            name = item["name"]
+            fs = self._get_schema_fs()
+            full_path = f"{path.rstrip('/')}/{name}" if path != "/" else f"/{name}"
+            is_dir = is_directory_sync(fs, full_path, entry_type=item.get("type"))
+            icon = "📁" if is_dir else "📄"
+            parts = [f"{icon} {name}"]
+            if schema_type := item.get("schema_type"):
+                parts.append(f"[{schema_type}]")
+            if item.get("required"):
+                parts.append("(required)")
+            if desc := item.get("description"):
+                # Truncate long descriptions
+                desc_short = desc[:60] + "..." if len(desc) > 60 else desc  # noqa: PLR2004
+                parts.append(f"- {desc_short}")
+            lines.append("  " + " ".join(parts))
+
+        return "\n".join(lines)
+
+    async def read_schema_node(self, path: str) -> str:
+        """Read the JSON schema at a specific path.
+
+        Args:
+            path: Path to read (e.g. '/$defs/AgentConfig', '/properties/agents')
+
+        Returns:
+            JSON schema content at the path
+        """
+        fs = self._get_schema_fs()
+        try:
+            content = fs.cat(path)
+            # Parse and re-format for readability
+            schema_data = json.loads(content)
+            return json.dumps(schema_data, indent=2)
+        except FileNotFoundError:
+            return f"Path not found: {path}"
+        except json.JSONDecodeError as e:
+            return f"Failed to parse schema at {path}: {e}"

agentpool_toolsets/entry_points.py

@@ -0,0 +1,47 @@
+"""Entry point based toolset implementation."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from epregistry import EntryPointRegistry
+
+from agentpool.log import get_logger
+from agentpool.resource_providers import ResourceProvider
+
+
+if TYPE_CHECKING:
+    from agentpool.tools.base import Tool
+
+
+logger = get_logger(__name__)
+
+
+class EntryPointTools(ResourceProvider):
+    """Provider for entry point based tools."""
+
+    def __init__(self, module: str) -> None:
+        super().__init__(name=module)
+        self.module = module
+        self._tools: list[Tool] | None = None
+        self.registry = EntryPointRegistry[Callable[..., Any]]("agentpool")
+
+    async def get_tools(self) -> list[Tool]:
+        """Get tools from entry points."""
+        # Return cached tools if available
+        if self._tools is not None:
+            return self._tools
+
+        self._tools = []
+        entry_point = self.registry.get("tools")
+        if not entry_point:
+            msg = f"No tools entry point found for {self.module}"
+            raise ValueError(msg)
+
+        get_tools = entry_point.load()
+        for item in get_tools():
+            meta = {"module": self.module}
+            tool = self.create_tool(item, metadata=meta)
+            self._tools.append(tool)
+        return self._tools

agentpool_toolsets/fsspec_toolset/__init__.py

@@ -0,0 +1,7 @@
+"""FSSpec Toolset."""
+
+from __future__ import annotations
+
+from agentpool_toolsets.fsspec_toolset.toolset import FSSpecTools
+
+__all__ = ["FSSpecTools"]

agentpool_toolsets/fsspec_toolset/diagnostics.py

@@ -0,0 +1,115 @@
+"""LSP diagnostics manager for file operations."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from anyenv.lsp_servers import DiagnosticRunner
+from anyenv.os_commands import get_os_command_provider
+
+
+if TYPE_CHECKING:
+    from anyenv.lsp_servers import Diagnostic, LSPServerInfo
+    from exxec import ExecutionEnvironment
+
+
+class DiagnosticsManager:
+    """Manages LSP diagnostics for file operations.
+
+    Lazily checks server availability and caches results.
+    """
+
+    def __init__(self, env: ExecutionEnvironment | None = None) -> None:
+        """Initialize diagnostics manager.
+
+        Args:
+            env: Execution environment for running diagnostic commands.
+                 If None, diagnostics will be disabled.
+        """
+        self._env = env
+        self._runner: DiagnosticRunner | None = None
+        self._server_availability: dict[str, bool] = {}
+
+    @property
+    def enabled(self) -> bool:
+        """Check if diagnostics are enabled (have an execution environment)."""
+        return self._env is not None
+
+    def _get_runner(self) -> DiagnosticRunner:
+        """Get or create the diagnostic runner."""
+        if self._runner is None:
+            executor = self._env.execute_command if self._env else None
+            self._runner = DiagnosticRunner(executor=executor)
+            self._runner.register_defaults()
+        return self._runner
+
+    async def _is_server_available(self, server: LSPServerInfo) -> bool:
+        """Check if a server's CLI command is available (cached).
+
+        Args:
+            server: The LSP server info to check
+
+        Returns:
+            True if the server's command is available
+        """
+        if not self._env or not server.cli_diagnostics:
+            return False
+
+        if server.id not in self._server_availability:
+            provider = get_os_command_provider(self._env.os_type)
+            which_cmd = provider.get_command("which")
+            cmd = which_cmd.create_command(server.cli_diagnostics.command)
+            result = await self._env.execute_command(cmd)
+            is_available = (
+                which_cmd.parse_command(result.stdout or "", result.exit_code or 0) is not None
+            )
+            self._server_availability[server.id] = is_available
+
+        return self._server_availability[server.id]
+
+    async def run_for_file(self, path: str) -> list[Diagnostic]:
+        """Run all applicable diagnostics on a file.
+
+        Args:
+            path: File path to check
+
+        Returns:
+            List of diagnostics from all available servers
+        """
+        if not self.enabled:
+            return []
+
+        runner = self._get_runner()
+        all_diagnostics: list[Diagnostic] = []
+
+        for server in runner.get_servers_for_file(path):
+            if await self._is_server_available(server):
+                result = await runner.run(server, [path])
+                all_diagnostics.extend(result.diagnostics)
+
+        return all_diagnostics
+
+    def format_diagnostics(self, diagnostics: list[Diagnostic]) -> str:
+        """Format diagnostics as a Markdown table.
+
+        Args:
+            diagnostics: List of diagnostics to format
+
+        Returns:
+            Markdown table with Severity, Location, Code, Description columns
+        """
+        if not diagnostics:
+            return ""
+
+        lines: list[str] = [
+            "| Severity | Location | Code | Description |",
+            "|----------|----------|------|-------------|",
+        ]
+        for d in diagnostics:
+            loc = f"{d.file}:{d.line}:{d.column}"
+            code = d.code or ""
+            # Escape pipe characters in message
+            msg = d.message.replace("|", "\\|")
+            lines.append(f"| {d.severity.upper()} | {loc} | {code} | {msg} |")
+
+        return "\n".join(lines)