agentpool 2.1.9__py3-none-any.whl

agentpool_server/acp_server/commands/docs_commands/get_schema.py

@@ -0,0 +1,176 @@
+"""Get Python code from Pydantic model schema."""
+
+from __future__ import annotations
+
+import asyncio
+import uuid
+
+from pydantic_ai import UserPromptPart
+from schemez import jsonschema_to_code, openapi_to_code
+from slashed import CommandContext  # noqa: TC002
+
+from agentpool.log import get_logger
+from agentpool.messaging.context import NodeContext  # noqa: TC001
+from agentpool_commands.base import NodeCommand
+from agentpool_server.acp_server.session import ACPSession  # noqa: TC001
+
+from .helpers import SCHEMA_EXTRACTION_SCRIPT
+
+
+logger = get_logger(__name__)
+
+
+class GetSchemaCommand(NodeCommand):
+    """Get Python code from Pydantic model schema.
+
+    Supports both dot notation paths to BaseModel classes and URLs to OpenAPI schemas.
+    Uses datamodel-codegen to generate clean Python code from schemas.
+    """
+
+    name = "get-schema"
+    category = "docs"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext[ACPSession]],
+        input_path: str,
+        *,
+        class_name: str | None = None,
+        cwd: str | None = None,
+    ) -> None:
+        """Get Python code from Pydantic model schema.
+
+        Args:
+            ctx: Command context with ACP session
+            input_path: Dot notation path to BaseModel or URL to OpenAPI schema
+            class_name: Optional custom class name for generated code
+            cwd: Working directory to run in (defaults to session cwd)
+        """
+        session = ctx.context.data
+        assert session
+
+        # Generate tool call ID
+        tool_call_id = f"get-schema-{uuid.uuid4().hex[:8]}"
+
+        try:
+            # Check if we have terminal access
+            if not (
+                session.client_capabilities
+                and session.client_capabilities.terminal
+                and session.acp_agent.terminal_access
+            ):
+                await session.notifications.send_agent_text(
+                    "❌ **Terminal access not available for schema generation**"
+                )
+                return
+
+            # Determine if input is URL or dot path
+            is_url = input_path.startswith(("http://", "https://"))
+
+            # Start tool call
+            display_title = (
+                f"Generating schema from URL: {input_path}"
+                if is_url
+                else f"Generating schema from model: {input_path}"
+            )
+            await session.notifications.tool_call_start(
+                tool_call_id=tool_call_id,
+                title=display_title,
+                kind="read",
+            )
+
+            if is_url:
+                # Direct URL approach - use OpenAPIParser directly
+                try:
+                    generated_code = await asyncio.to_thread(
+                        openapi_to_code, input_path=input_path, class_name=class_name
+                    )
+                except Exception as e:  # noqa: BLE001
+                    await session.notifications.tool_call_progress(
+                        tool_call_id=tool_call_id,
+                        status="failed",
+                        title=f"Failed to generate from URL: {e!s}",
+                    )
+                    return
+
+                generated_code = generated_code.strip()
+
+            else:
+                # Dot path approach - client-side schema extraction
+                # Step 1: CLIENT-SIDE - Extract schema via inline script
+                schema_script = SCHEMA_EXTRACTION_SCRIPT.format(input_path=input_path)
+
+                # Run schema extraction client-side using uv run python -c
+                output, exit_code = await session.requests.run_command(
+                    command="uv",
+                    args=["run", "python", "-c", schema_script],
+                    cwd=cwd or session.cwd,
+                )
+
+                if exit_code != 0:
+                    error_msg = output.strip() or f"Exit code: {exit_code}"
+                    await session.notifications.tool_call_progress(
+                        tool_call_id=tool_call_id,
+                        status="failed",
+                        title=f"Failed to extract schema: {error_msg}",
+                    )
+                    return
+
+                schema_json = output.strip()
+                if not schema_json:
+                    await session.notifications.tool_call_progress(
+                        tool_call_id=tool_call_id,
+                        status="failed",
+                        title="No schema extracted from model",
+                    )
+                    return
+
+                # Step 2: SERVER-SIDE - Generate code from schema
+
+                try:
+                    generated_code = await asyncio.to_thread(
+                        jsonschema_to_code,
+                        schema_json=schema_json,
+                        class_name=class_name,
+                        input_path=input_path,
+                    )
+                except Exception as e:  # noqa: BLE001
+                    await session.notifications.tool_call_progress(
+                        tool_call_id=tool_call_id,
+                        status="failed",
+                        title=f"Failed to generate code: {e!s}",
+                    )
+                    return
+
+                generated_code = generated_code.strip()
+
+            if not generated_code:
+                await session.notifications.tool_call_progress(
+                    tool_call_id=tool_call_id,
+                    status="completed",
+                    title="No code generated from schema",
+                )
+                return
+
+            # Stage the generated code for use in agent context
+            staged_part = UserPromptPart(
+                content=f"Generated Python code from {input_path}:\n\n{generated_code}"
+            )
+            session.staged_content.add([staged_part])
+
+            # Send successful result - wrap in code block for proper display
+            staged_count = len(session.staged_content)
+            await session.notifications.tool_call_progress(
+                tool_call_id=tool_call_id,
+                status="completed",
+                title=f"Schema code generated and staged ({staged_count} total parts)",
+                content=[f"```python\n{generated_code}\n```"],
+            )
+
+        except Exception as e:
+            logger.exception("Unexpected error generating schema code", input_path=input_path)
+            await session.notifications.tool_call_progress(
+                tool_call_id=tool_call_id,
+                status="failed",
+                title=f"Error: {e}",
+            )

agentpool_server/acp_server/commands/docs_commands/get_source.py

@@ -0,0 +1,110 @@
+"""Get Python source code using dot notation."""
+
+from __future__ import annotations
+
+import uuid
+
+from pydantic_ai import UserPromptPart
+from slashed import CommandContext  # noqa: TC002
+
+from agentpool.log import get_logger
+from agentpool.messaging.context import NodeContext  # noqa: TC001
+import agentpool.utils.importing
+from agentpool_commands.base import NodeCommand
+from agentpool_server.acp_server.session import ACPSession  # noqa: TC001
+
+
+logger = get_logger(__name__)
+
+
+class GetSourceCommand(NodeCommand):
+    """Get Python source code using dot notation.
+
+    Uses the AgentPool importing.py utility to fetch source code
+    for any Python object accessible via dot notation.
+    """
+
+    name = "get-source"
+    category = "docs"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext[ACPSession]],
+        dot_path: str,
+        *,
+        cwd: str | None = None,
+    ) -> None:
+        """Get Python source code for an object.
+
+        Args:
+            ctx: Command context with ACP session
+            dot_path: Dot notation path to Python object (e.g., 'requests.Session.get')
+            cwd: Working directory to run in (defaults to session cwd)
+        """
+        session = ctx.context.data
+        assert session
+
+        # Generate tool call ID
+        tool_call_id = f"get-source-{uuid.uuid4().hex[:8]}"
+
+        try:
+            # Check if we have terminal access
+            if not (
+                session.client_capabilities
+                and session.client_capabilities.terminal
+                and session.acp_agent.terminal_access
+            ):
+                msg = "❌ **Terminal access not available for source code fetching**"
+                await session.notifications.send_agent_text(msg)
+                return
+
+            importing_py_path = agentpool.utils.importing.__file__
+            assert isinstance(importing_py_path, str)
+            await session.notifications.tool_call_start(
+                tool_call_id=tool_call_id,
+                title=f"Getting source: {dot_path}",
+                kind="read",
+            )
+            # Run importing.py as script
+            output, exit_code = await session.requests.run_command(
+                command="uv",
+                args=["run", importing_py_path, dot_path],
+                cwd=cwd or session.cwd,
+            )
+            # Check if command succeeded
+            if exit_code != 0:
+                error_msg = output.strip() or f"Exit code: {exit_code}"
+                await session.notifications.tool_call_progress(
+                    tool_call_id=tool_call_id,
+                    status="failed",
+                    title=f"Failed to get source for {dot_path}: {error_msg}",
+                )
+                return
+            source_content = output.strip()
+            if not source_content:
+                await session.notifications.tool_call_progress(
+                    tool_call_id=tool_call_id,
+                    status="completed",
+                    title="No source code found",
+                )
+                return
+            # Stage the source content for use in agent context
+            content = f"Python source code for {dot_path}:\n\n{source_content}"
+            staged_part = UserPromptPart(content=content)
+            session.staged_content.add([staged_part])
+            # Send successful result - wrap in code block for proper display
+            staged_count = len(session.staged_content)
+            await session.notifications.tool_call_progress(
+                tool_call_id=tool_call_id,
+                status="completed",
+                title=f"Source code fetched and staged ({staged_count} total parts)",
+                content=[f"```python\n{source_content}\n```"],
+            )
+
+        except Exception as e:
+            logger.exception("Unexpected error fetching source code", dot_path=dot_path)
+            await session.notifications.tool_call_progress(
+                tool_call_id=tool_call_id,
+                status="failed",
+                title=f"Error: {e}",
+            )

agentpool_server/acp_server/commands/docs_commands/git_diff.py

@@ -0,0 +1,111 @@
+"""Fetch git diff for a specific commit."""
+
+from __future__ import annotations
+
+import uuid
+
+from pydantic_ai import UserPromptPart
+from slashed import CommandContext  # noqa: TC002
+
+from agentpool.log import get_logger
+from agentpool.messaging.context import NodeContext  # noqa: TC001
+from agentpool_commands.base import NodeCommand
+from agentpool_server.acp_server.session import ACPSession  # noqa: TC001
+
+
+logger = get_logger(__name__)
+
+
+class GitDiffCommand(NodeCommand):
+    """Fetch git diff for a specific commit.
+
+    Executes git diff client-side to get the complete diff
+    and displays it in a structured format.
+    """
+
+    name = "git-diff"
+    category = "docs"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext[ACPSession]],
+        commit: str,
+        *,
+        base_commit: str | None = None,
+        cwd: str | None = None,
+    ) -> None:
+        """Fetch git diff for a specific commit.
+
+        Args:
+            ctx: Command context with ACP session
+            commit: Commit hash or reference to diff
+            base_commit: Base commit to compare against (defaults to commit~1)
+            cwd: Working directory to run git in (defaults to session cwd)
+        """
+        session = ctx.context.data
+        assert session
+        tool_call_id = f"git-diff-{uuid.uuid4().hex[:8]}"
+        try:
+            caps = session.client_capabilities  # Check if we have terminal access for running git
+            if not (caps and caps.terminal and session.acp_agent.terminal_access):
+                msg = "❌ **Terminal access not available for git operations**"
+                await session.notifications.send_agent_text(msg)
+                return
+
+            # Build git diff command
+            if base_commit:
+                git_command = ["git", "diff", base_commit, commit]
+                display_title = f"Git diff: {base_commit}..{commit}"
+            else:
+                git_command = ["git", "diff", f"{commit}~1", commit]
+                display_title = f"Git diff: {commit}"
+
+            # Start tool call
+            await session.notifications.tool_call_start(
+                tool_call_id=tool_call_id,
+                title=display_title,
+                kind="execute",
+            )
+
+            # Run git diff command
+            output, exit_code = await session.requests.run_command(
+                command=git_command[0],
+                args=git_command[1:],
+                cwd=cwd or session.cwd,
+            )
+
+            # Check if git command succeeded
+            if exit_code != 0:
+                await session.notifications.tool_call_progress(
+                    tool_call_id=tool_call_id,
+                    status="failed",
+                    title=f"Git diff failed (exit code: {exit_code})",
+                )
+                return
+            diff_content = output.strip()
+            if not diff_content:
+                await session.notifications.tool_call_progress(
+                    tool_call_id=tool_call_id,
+                    status="completed",
+                    title="No changes found in diff",
+                )
+                return
+
+            # Stage the diff content for use in agent context
+            staged_part = UserPromptPart(content=f"Git diff for {display_title}:\n\n{diff_content}")
+            session.staged_content.add([staged_part])
+            # Send successful result - wrap in code block for proper display
+            staged_count = len(session.staged_content)
+            await session.notifications.tool_call_progress(
+                tool_call_id=tool_call_id,
+                status="completed",
+                title=f"Git diff fetched and staged ({staged_count} total parts)",
+                content=[f"```diff\n{diff_content}\n```"],
+            )
+        except Exception as e:
+            logger.exception("Unexpected error fetching git diff", commit=commit)
+            await session.notifications.tool_call_progress(
+                tool_call_id=tool_call_id,
+                status="failed",
+                title=f"Error: {e}",
+            )

agentpool_server/acp_server/commands/docs_commands/helpers.py

@@ -0,0 +1,33 @@
+"""Helper functions and constants for documentation commands."""
+
+from __future__ import annotations
+
+
+# Script constants for client-side execution
+SCHEMA_EXTRACTION_SCRIPT = """
+import sys
+import json
+import importlib
+
+def import_callable(path):
+    parts = path.split(".")
+    for i in range(len(parts), 0, -1):
+        try:
+            module_path = ".".join(parts[:i])
+            module = importlib.import_module(module_path)
+            obj = module
+            for part in parts[i:]:
+                obj = getattr(obj, part)
+            return obj
+        except (ImportError, AttributeError):
+            continue
+    raise ImportError(f"Could not import %s" % path)
+
+try:
+    model_class = import_callable("{input_path}")
+    schema = model_class.model_json_schema()
+    print(json.dumps(schema, indent=2))
+except Exception as e:
+    print(f"Error: %s" % e, file=sys.stderr)
+    sys.exit(1)
+"""

agentpool_server/acp_server/commands/docs_commands/url_to_markdown.py

@@ -0,0 +1,90 @@
+"""Convert a webpage to markdown using urltomarkdown.herokuapp.com."""
+
+from __future__ import annotations
+
+import urllib.parse
+import uuid
+
+import anyenv
+from pydantic_ai import UserPromptPart
+from slashed import CommandContext  # noqa: TC002
+
+from agentpool.log import get_logger
+from agentpool.messaging.context import NodeContext  # noqa: TC001
+from agentpool_commands.base import NodeCommand
+from agentpool_server.acp_server.session import ACPSession  # noqa: TC001
+
+
+logger = get_logger(__name__)
+
+
+class UrlToMarkdownCommand(NodeCommand):
+    """Convert a webpage to markdown using urltomarkdown.herokuapp.com.
+
+    Fetches a web page and converts it to markdown format,
+    making it ideal for staging as AI context.
+    """
+
+    name = "url-to-markdown"
+    category = "docs"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext[ACPSession]],
+        url: str,
+        *,
+        title: bool = True,
+        links: bool = True,
+        clean: bool = True,
+    ) -> None:
+        """Convert a webpage to markdown.
+
+        Args:
+            ctx: Command context with ACP session
+            url: URL to convert to markdown
+            title: Include page title as H1 header
+            links: Include links in markdown output
+            clean: Clean/filter content before conversion
+        """
+        session = ctx.context.data
+        assert session
+        tool_call_id = f"url-to-markdown-{uuid.uuid4().hex[:8]}"
+        api_url = "https://urltomarkdown.herokuapp.com/"  # Build API URL and parameters
+        params = {"url": url}
+        if title:
+            params["title"] = "true"
+        if not links:
+            params["links"] = "false"
+        if not clean:
+            params["clean"] = "false"
+        try:
+            await session.notifications.tool_call_start(
+                tool_call_id=tool_call_id,
+                title=f"Converting to markdown: {url}",
+                kind="fetch",
+            )
+            response = await anyenv.get(api_url, params=params, timeout=30.0)
+            markdown_content = await response.text()
+            page_title = ""
+            if "X-Title" in response.headers:
+                page_title = urllib.parse.unquote(response.headers["X-Title"])
+                page_title = f" - {page_title}"
+            # Stage the markdown content for use in agent context
+            content = f"Webpage content from {url}{page_title}:\n\n{markdown_content}"
+            staged_part = UserPromptPart(content=content)
+            session.staged_content.add([staged_part])
+            # Send successful result - wrap in code block for proper display
+            staged_count = len(session.staged_content)
+            await session.notifications.tool_call_progress(
+                tool_call_id=tool_call_id,
+                status="completed",
+                title=f"Webpage converted and staged ({staged_count} total parts)",
+                content=[f"```markdown\n{markdown_content}\n```"],
+            )
+        except Exception as e:
+            logger.exception("Unexpected error converting URL", url=url)
+            await session.notifications.tool_call_progress(
+                tool_call_id=tool_call_id,
+                status="failed",
+                title=f"Error: {e}",
+            )