agentpool 2.1.9__py3-none-any.whl

agentpool_server/acp_server/session_manager.py

@@ -0,0 +1,313 @@
+"""ACP Session Manager - delegates to pool's SessionManager."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, Any, Self
+
+from acp.schema import ClientCapabilities
+from agentpool.log import get_logger
+from agentpool.sessions import SessionData
+from agentpool_server.acp_server.session import ACPSession
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from types import TracebackType
+
+    from acp import Client
+    from acp.schema import Implementation, McpServer
+    from agentpool import AgentPool
+    from agentpool.sessions import SessionManager
+    from agentpool_server.acp_server.acp_agent import AgentPoolACPAgent
+
+
+logger = get_logger(__name__)
+
+
+class ACPSessionManager:
+    """Manages ACP sessions, delegating persistence to pool's SessionManager.
+
+    This is a thin coordinator that:
+    - Creates and tracks active ACP sessions
+    - Delegates session persistence to pool.sessions (SessionManager)
+    - Handles ACP-specific session initialization
+    """
+
+    def __init__(self, pool: AgentPool[Any]) -> None:
+        """Initialize ACP session manager.
+
+        Args:
+            pool: Agent pool containing SessionManager for persistence
+        """
+        self._pool = pool
+        self._active: dict[str, ACPSession] = {}
+        self._lock = asyncio.Lock()
+        self._command_update_task: asyncio.Task[None] | None = None
+        logger.info("Initialized ACP session manager")
+
+    @property
+    def session_manager(self) -> SessionManager:
+        """Get the pool's session manager for persistence."""
+        return self._pool.sessions
+
+    async def create_session(
+        self,
+        default_agent_name: str,
+        cwd: str,
+        client: Client,
+        acp_agent: AgentPoolACPAgent,
+        mcp_servers: Sequence[McpServer] | None = None,
+        session_id: str | None = None,
+        client_capabilities: ClientCapabilities | None = None,
+        client_info: Implementation | None = None,
+    ) -> str:
+        """Create a new ACP session.
+
+        Args:
+            default_agent_name: Name of the default agent to start with
+            cwd: Working directory for the session
+            client: ACP client connection
+            acp_agent: ACP agent instance
+            mcp_servers: Optional MCP server configurations
+            session_id: Optional specific session ID (generated if None)
+            client_capabilities: Client capabilities for tool registration
+            client_info: Client implementation info (name, version)
+
+        Returns:
+            Session ID for the created session
+        """
+        async with self._lock:
+            # Generate session ID if not provided
+            if session_id is None:
+                session_id = self.session_manager.generate_session_id()
+
+            # Check for existing session
+            if session_id in self._active:
+                logger.warning("Session ID already exists", session_id=session_id)
+                msg = f"Session {session_id} already exists"
+                raise ValueError(msg)
+
+            # Create and persist session data via pool's SessionManager
+            data = SessionData(
+                session_id=session_id,
+                agent_name=default_agent_name,
+                conversation_id=f"conv_{session_id}",
+                cwd=cwd,
+                metadata={
+                    "protocol": "acp",
+                    "mcp_server_count": len(mcp_servers) if mcp_servers else 0,
+                },
+            )
+            await self.session_manager.save(data)
+
+            # Create the ACP-specific runtime session
+            session = ACPSession(
+                session_id=session_id,
+                agent_pool=self._pool,
+                current_agent_name=default_agent_name,
+                cwd=cwd,
+                client=client,
+                mcp_servers=mcp_servers,
+                acp_agent=acp_agent,
+                client_capabilities=client_capabilities or ClientCapabilities(),
+                client_info=client_info,
+                manager=self,
+            )
+            session.register_update_callback(self._on_commands_updated)
+
+            # Initialize async resources
+            await session.initialize()
+
+            # Initialize MCP servers if any are provided
+            await session.initialize_mcp_servers()
+
+            self._active[session_id] = session
+            logger.info("Created ACP session", session_id=session_id, agent=default_agent_name)
+            return session_id
+
+    def get_session(self, session_id: str) -> ACPSession | None:
+        """Get an active session by ID.
+
+        Args:
+            session_id: Session identifier
+
+        Returns:
+            ACPSession instance or None if not found
+        """
+        return self._active.get(session_id)
+
+    async def resume_session(
+        self,
+        session_id: str,
+        client: Client,
+        acp_agent: AgentPoolACPAgent,
+        client_capabilities: ClientCapabilities | None = None,
+        client_info: Implementation | None = None,
+    ) -> ACPSession | None:
+        """Resume a session from storage.
+
+        Args:
+            session_id: Session identifier
+            client: ACP client connection
+            acp_agent: ACP agent instance
+            client_capabilities: Client capabilities
+            client_info: Client implementation info (name, version)
+
+        Returns:
+            Resumed ACPSession if found, None otherwise
+        """
+        async with self._lock:
+            # Check if already active
+            if session_id in self._active:
+                return self._active[session_id]
+
+            # Try to load from pool's session store
+            data = await self.session_manager.store.load(session_id)
+            if data is None:
+                logger.warning("Session not found in store", session_id=session_id)
+                return None
+
+            # Validate agent still exists
+            if data.agent_name not in self._pool.all_agents:
+                logger.warning(
+                    "Session agent no longer exists",
+                    session_id=session_id,
+                    agent=data.agent_name,
+                )
+                return None
+
+            # Reconstruct ACP session
+            session = ACPSession(
+                session_id=session_id,
+                agent_pool=self._pool,
+                current_agent_name=data.agent_name,
+                cwd=data.cwd or "",
+                client=client,
+                mcp_servers=None,  # MCP servers would need to be re-provided
+                acp_agent=acp_agent,
+                client_capabilities=client_capabilities or ClientCapabilities(),
+                client_info=client_info,
+                manager=self,
+            )
+            session.register_update_callback(self._on_commands_updated)
+
+            # Initialize async resources
+            await session.initialize()
+
+            self._active[session_id] = session
+            logger.info("Resumed ACP session", session_id=session_id)
+            return session
+
+    async def close_session(self, session_id: str, *, delete: bool = False) -> None:
+        """Close and optionally delete a session.
+
+        Args:
+            session_id: Session identifier to close
+            delete: Whether to also delete from persistent storage
+        """
+        async with self._lock:
+            session = self._active.pop(session_id, None)
+
+        if session:
+            await session.close()
+            logger.info("Closed ACP session", session_id=session_id)
+
+        if delete:
+            await self.session_manager.store.delete(session_id)
+            logger.info("Deleted session from store", session_id=session_id)
+
+    async def update_session_agent(self, session_id: str, agent_name: str) -> None:
+        """Update the agent for a session and persist.
+
+        Args:
+            session_id: Session identifier
+            agent_name: New agent name
+        """
+        session = self._active.get(session_id)
+        if not session:
+            return
+
+        # Load, update, and save session data
+        data = await self.session_manager.store.load(session_id)
+        if data:
+            updated = data.with_agent(agent_name)
+            await self.session_manager.save(updated)
+
+    async def list_sessions(self, *, active_only: bool = False) -> list[str]:
+        """List session IDs.
+
+        Args:
+            active_only: Only return currently active sessions
+
+        Returns:
+            List of session IDs
+        """
+        if active_only:
+            return list(self._active.keys())
+
+        return await self.session_manager.store.list_sessions()
+
+    async def close_all_sessions(self) -> int:
+        """Close all active sessions.
+
+        This is used during pool hot-switching to cleanly shut down
+        all sessions before swapping the pool.
+
+        Returns:
+            Number of sessions that were closed
+        """
+        async with self._lock:
+            sessions = list(self._active.values())
+            self._active.clear()
+
+        closed_count = 0
+        for session in sessions:
+            try:
+                await session.close()
+                closed_count += 1
+            except Exception:
+                logger.exception(
+                    "Error closing session during pool swap", session=session.session_id
+                )
+
+        logger.info("Closed all sessions for pool swap", count=closed_count)
+        return closed_count
+
+    async def __aenter__(self) -> Self:
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Async context manager exit - close all active sessions."""
+        async with self._lock:
+            sessions = list(self._active.values())
+            self._active.clear()
+
+        for session in sessions:
+            try:
+                await session.close()
+            except Exception:
+                logger.exception("Error closing session", session=session.session_id)
+
+        logger.info("Closed all %d ACP sessions", len(sessions))
+
+    def _on_commands_updated(self) -> None:
+        """Handle command updates by notifying all active sessions."""
+        task = asyncio.create_task(self._update_all_sessions_commands())
+        self._command_update_task = task
+
+    async def _update_all_sessions_commands(self) -> None:
+        """Update available commands for all active sessions."""
+        async with self._lock:
+            for session in self._active.values():
+                try:
+                    await session.send_available_commands_update()
+                except Exception:
+                    msg = "Failed to update commands"
+                    logger.exception(msg, session_id=session.session_id)

agentpool_server/acp_server/syntax_detection.py

@@ -0,0 +1,250 @@
+"""Syntax highlighting utilities for file content display."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+dot_file_map = {
+    ".bashrc": "bash",
+    ".bash_profile": "bash",
+    ".bash_logout": "bash",
+    ".zshrc": "bash",
+    ".zsh_profile": "bash",
+    ".profile": "bash",
+    ".vimrc": "vim",
+    ".gvimrc": "vim",
+    ".tmux.conf": "tmux",
+    ".gitignore": "gitignore",
+    ".gitconfig": "gitconfig",
+    ".editorconfig": "editorconfig",
+    ".eslintrc": "json",
+    ".prettierrc": "json",
+    ".babelrc": "json",
+}
+
+lang_map = {
+    # Python
+    ".py": "python",
+    ".pyx": "python",
+    ".pyi": "python",
+    # JavaScript/TypeScript
+    ".js": "javascript",
+    ".mjs": "javascript",
+    ".jsx": "javascript",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".mts": "typescript",
+    # JVM Languages
+    ".java": "java",
+    ".kt": "kotlin",
+    ".scala": "scala",
+    ".groovy": "groovy",
+    # C/C++
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".hpp": "cpp",
+    ".hxx": "cpp",
+    # Rust
+    ".rs": "rust",
+    # Go
+    ".go": "go",
+    # Web
+    ".html": "html",
+    ".htm": "html",
+    ".xml": "xml",
+    ".xhtml": "html",
+    ".css": "css",
+    ".scss": "scss",
+    ".sass": "sass",
+    ".less": "less",
+    # Data formats
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".csv": "csv",
+    # Shell/Scripts
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "bash",
+    ".fish": "fish",
+    ".ps1": "powershell",
+    ".psm1": "powershell",
+    ".bat": "batch",
+    ".cmd": "batch",
+    # Other languages
+    ".rb": "ruby",
+    ".php": "php",
+    ".sql": "sql",
+    ".r": "r",
+    ".swift": "swift",
+    ".dart": "dart",
+    ".lua": "lua",
+    ".pl": "perl",
+    ".pm": "perl",
+    ".vim": "vim",
+    ".tex": "latex",
+    ".cls": "latex",
+    ".sty": "latex",
+    # Config/Other
+    ".ini": "ini",
+    ".cfg": "ini",
+    ".conf": "conf",
+    ".log": "log",
+    ".md": "markdown",
+    ".markdown": "markdown",
+    ".mdown": "markdown",
+    ".mkd": "markdown",
+    ".rst": "rst",
+    ".txt": "text",
+    # Docker
+    ".dockerfile": "dockerfile",
+    # Makefiles
+    ".mk": "makefile",
+    # Nginx
+    ".nginx": "nginx",
+    # Apache
+    ".htaccess": "apache",
+    # Git
+    ".gitignore": "gitignore",
+    ".gitconfig": "gitconfig",
+}
+
+
+def get_language_from_path(path: str | Path) -> str:  # noqa: PLR0911
+    """Get syntax highlighting language identifier from file path.
+
+    Args:
+        path: File path to analyze
+
+    Returns:
+        Language identifier for syntax highlighting, or empty string if unknown
+
+    Examples:
+        >>> get_language_from_path("src/main.py")
+        'python'
+        >>> get_language_from_path("config.json")
+        'json'
+        >>> get_language_from_path("Dockerfile")
+        'dockerfile'
+        >>> get_language_from_path("unknown.xyz")
+        ''
+    """
+    path_str = str(path)
+    _, ext = os.path.splitext(path_str.lower())  # noqa: PTH122
+
+    # Special cases for files without extensions or specific names
+    filename = os.path.basename(path_str.lower())  # noqa: PTH119
+
+    # Docker files
+    if filename in ("dockerfile", "dockerfile.dev", "dockerfile.prod"):
+        return "dockerfile"
+
+    # Build files
+    if filename in ("makefile", "rakefile", "justfile"):
+        return "makefile"
+
+    if filename in (".rules", ".cursorrules"):
+        return "markdown"
+
+    # Config files starting with dot
+
+    if filename in dot_file_map:
+        return dot_file_map[filename]
+
+    # License files
+    if filename in ("license", "licence", "copying", "contributing"):
+        return "text"
+
+    # README files
+    if filename.startswith("readme") and "." not in filename:
+        return "text"
+
+    # Package files
+    if filename == "yarn.lock":
+        return "yaml"
+
+    return lang_map.get(ext, "")
+
+
+def format_code_block(content: str, language: str = "") -> str:
+    r"""Format content as a markdown code block with optional language.
+
+    Args:
+        content: The code/text content
+        language: Optional language identifier for syntax highlighting
+
+    Returns:
+        Formatted markdown code block
+
+    Examples:
+        >>> format_code_block('print("hello")', 'python')
+        '```python\\nprint("hello")\\n```'
+        >>> format_code_block('some text')
+        '```\\nsome text\\n```'
+    """
+    return f"```{language}\n{content}\n```"
+
+
+def format_file_content(content: str, file_path: str | Path) -> str:
+    r"""Format file content as a syntax-highlighted code block.
+
+    Args:
+        content: The file content
+        file_path: Path to the file (used to determine language)
+
+    Returns:
+        Formatted markdown code block with appropriate syntax highlighting
+
+    Examples:
+        >>> format_file_content('def hello(): pass', 'main.py')
+        '```python\\ndef hello(): pass\\n```'
+    """
+    language = get_language_from_path(file_path)
+    return format_code_block(content, language)
+
+
+def format_zed_code_block(
+    content: str,
+    file_path: str | Path,
+    start_line: int | None = None,
+    end_line: int | None = None,
+) -> str:
+    r"""Format content as a Zed-compatible code block with path and optional line numbers.
+
+    Args:
+        content: The code/text content
+        file_path: Path to the file (used in code block header)
+        start_line: Optional starting line number (1-based)
+        end_line: Optional ending line number (1-based)
+
+    Returns:
+        Formatted Zed-compatible code block
+
+    Examples:
+        >>> format_zed_code_block('def hello(): pass', 'src/main.py')
+        '```src/main.py\\ndef hello(): pass\\n```'
+        >>> format_zed_code_block('def hello(): pass', 'src/main.py', 10)
+        '```src/main.py#L10\\ndef hello(): pass\\n```'
+        >>> format_zed_code_block('def hello(): pass', 'src/main.py', 10, 15)
+        '```src/main.py#L10-15\\ndef hello(): pass\\n```'
+    """
+    path_str = str(file_path)
+
+    # Build line number suffix if provided
+    line_suffix = ""
+    if start_line is not None:
+        if end_line is not None and end_line != start_line:
+            line_suffix = f"#L{start_line}-{end_line}"
+        else:
+            line_suffix = f"#L{start_line}"
+
+    return f"```{path_str}{line_suffix}\n{content}\n```"

agentpool_server/acp_server/zed_tools.md

@@ -0,0 +1,90 @@
+File System Operations
+
+### `copy_path`
+Copies a file or directory in the project
+- **source_path** (required): The source path of the file or directory to copy
+- **destination_path** (required): The destination path where the file or directory should be copied to
+
+### `create_directory`
+Creates a new directory at the specified path
+- **path** (required): The path of the new directory
+
+### `delete_path`
+Deletes the file or directory at the specified path
+- **path** (required): The path of the file or directory to delete
+
+### `move_path`
+Moves or renames a file or directory
+- **source_path** (required): The source path of the file or directory to move/rename
+- **destination_path** (required): The destination path where the file or directory should be moved/renamed to
+
+## File Content Operations
+
+### `edit_file`
+Creates a new file or edits an existing file
+- **display_description** (required): A one-line, user-friendly markdown description of the edit
+- **path** (required): The full path of the file to create or modify
+- **mode** (required): The mode of operation - 'edit', 'create', or 'overwrite'
+
+### `read_file`
+Reads the content of a file
+- **path** (required): The relative path of the file to read
+- **start_line** (optional): Line number to start reading on (1-based index)
+- **end_line** (optional): Line number to end reading on (1-based index, inclusive)
+
+## Search and Discovery
+
+### `find_path`
+Fast file path pattern matching with glob patterns
+- **glob** (required): The glob pattern to match against every path in the project
+- **offset** (optional): Starting position for paginated results (default: 0)
+
+### `grep`
+Searches file contents with regular expressions
+- **regex** (required): A regex pattern to search for in the project
+- **include_pattern** (optional): A glob pattern for the paths of files to include in the search
+- **case_sensitive** (optional): Whether the regex is case-sensitive (default: false)
+- **offset** (optional): Starting position for paginated results (default: 0)
+
+### `list_directory`
+Lists files and directories in a given path
+- **path** (required): The fully-qualified path of the directory to list
+
+## Code Quality and Diagnostics
+
+### `diagnostics`
+Get errors and warnings for the project or a specific file
+- **path** (optional): The path to get diagnostics for. If not provided, returns a project-wide summary
+
+## External Resources
+
+### `fetch`
+Fetches a URL and returns the content as Markdown
+- **url** (required): The URL to fetch
+
+### `resolve-library-id`
+Resolves a package/product name to a Context7-compatible library ID
+- **libraryName** (required): Library name to search for and retrieve a Context7-compatible library ID
+
+### `get-library-docs`
+Fetches up-to-date documentation for a library
+- **context7CompatibleLibraryID** (required): Exact Context7-compatible library ID
+- **topic** (optional): Topic to focus documentation on
+- **tokens** (optional): Maximum number of tokens of documentation to retrieve (default: 5000)
+
+## System Operations
+
+### `terminal`
+Executes a shell one-liner and returns the combined output
+- **command** (required): The one-liner command to execute
+- **cd** (required): Working directory for the command (must be one of the root directories)
+
+### `now`
+Returns the current datetime in RFC 3339 format
+- **timezone** (required): The timezone to use - 'utc' or 'local'
+
+## Analysis and Planning
+
+### `thinking`
+A tool for thinking through problems, brainstorming ideas, or planning without executing actions
+- **content** (required): Content to think about or a problem to solve