agentpool 2.1.9__py3-none-any.whl → 2.5.0__py3-none-any.whl

agentpool_server/acp_server/commands/acp_commands.py

@@ -2,8 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
+from pydantic_ai import ModelRequest, ModelResponse  # noqa: TC002
 from slashed import CommandContext  # noqa: TC002
 
 from agentpool.messaging.context import NodeContext  # noqa: TC001
@@ -12,32 +11,29 @@ from agentpool_config.session import SessionQuery
 from agentpool_server.acp_server.session import ACPSession  # noqa: TC001
 
 
-if TYPE_CHECKING:
-    from pydantic_ai import ModelRequest, ModelResponse
-
-
 class ListSessionsCommand(NodeCommand):
     """List all available ACP sessions.
 
-    Shows:
-    - Session ID and status (active/stored)
-    - Agent name and working directory
-    - Creation time and last activity
-
     Options:
       --active    Show only active sessions
       --stored    Show only stored sessions
+      --detail    Show detailed view (default: compact table)
+      --page      Page number (1-based, default: 1)
+      --per-page  Items per page (default: 20)
     """
 
     name = "list-sessions"
     category = "acp"
 
-    async def execute_command(
+    async def execute_command(  # noqa: PLR0915
         self,
         ctx: CommandContext[NodeContext[ACPSession]],
         *,
         active: bool = False,
         stored: bool = False,
+        detail: bool = False,
+        page: int = 1,
+        per_page: int = 20,
     ) -> None:
         """List available ACP sessions.
 
@@ -45,6 +41,9 @@ class ListSessionsCommand(NodeCommand):
             ctx: Command context with ACP session
             active: Show only active sessions
             stored: Show only stored sessions
+            detail: Show detailed view instead of compact table
+            page: Page number (1-based)
+            per_page: Number of items per page
         """
         session = ctx.context.data
         if not session:
@@ -54,6 +53,11 @@ class ListSessionsCommand(NodeCommand):
             await ctx.output.print("❌ **Session manager not available**")
             return
 
+        # Validate pagination params
+        page = max(page, 1)
+        if per_page < 1:
+            per_page = 20
+
         # If no filter specified, show both
         if not active and not stored:
             active = stored = True
@@ -61,63 +65,146 @@ class ListSessionsCommand(NodeCommand):
         try:
             output_lines = ["## 📋 ACP Sessions\n"]
 
-            # Show active sessions
+            # Collect all sessions to paginate
+            # (id, type, info) where info includes conversation_id for message counting
+            all_sessions: list[tuple[str, str, dict[str, str | None]]] = []
+
+            # Collect active sessions
             if active:
-                output_lines.append("### 🟢 Active Sessions")
                 active_sessions = session.manager._active
-
-                if not active_sessions:
-                    output_lines.append("*No active sessions*\n")
-                else:
-                    for session_id, sess in active_sessions.items():
-                        agent_name = sess.current_agent_name
-                        cwd = sess.cwd or "unknown"
-                        is_current = session_id == session.session_id
-
-                        # Get title from SessionData
-                        session_data = await session.manager.session_manager.store.load(session_id)
-                        title = session_data.title if session_data else None
-
-                        status = " *(current)*" if is_current else ""
-                        title_text = f": {title}" if title else ""
-                        output_lines.append(f"- **{session_id}**{status}{title_text}")
-                        output_lines.append(f"  - Agent: `{agent_name}`")
-                        output_lines.append(f"  - Directory: `{cwd}`")
-                    output_lines.append("")
-
-            # Show stored sessions
+                for session_id, sess in active_sessions.items():
+                    session_data = await session.manager.session_manager.store.load(session_id)
+                    conv_id = session_data.conversation_id if session_data else None
+                    is_current = session_id == session.session_id
+                    all_sessions.append((
+                        session_id,
+                        "active",
+                        {
+                            "agent_name": sess.current_agent_name,
+                            "cwd": sess.cwd or "unknown",
+                            "conversation_id": conv_id,
+                            "is_current": "yes" if is_current else None,
+                            "last_active": None,
+                        },
+                    ))
+
+            # Collect stored sessions
             if stored:
-                output_lines.append("### 💾 Stored Sessions")
-
                 try:
                     stored_session_ids = await session.manager.session_manager.store.list_sessions()
-                    # Filter out active ones if we already showed them
+                    # Filter out active ones if we already collected them
                     if active:
                         stored_session_ids = [
                             sid for sid in stored_session_ids if sid not in session.manager._active
                         ]
 
-                    if not stored_session_ids:
-                        output_lines.append("*No stored sessions*\n")
-                    else:
-                        for session_id in stored_session_ids:
-                            session_data = await session.manager.session_manager.store.load(
-                                session_id
-                            )
-                            if session_data:
-                                title_text = f": {session_data.title}" if session_data.title else ""
-                                output_lines.append(f"- **{session_id}**{title_text}")
-                                output_lines.append(f"  - Agent: `{session_data.agent_name}`")
-                                output_lines.append(
-                                    f"  - Directory: `{session_data.cwd or 'unknown'}`"
-                                )
-                                output_lines.append(
-                                    f"  - Last active: {session_data.last_active.strftime('%Y-%m-%d %H:%M')}"  # noqa: E501
-                                )
-                        output_lines.append("")
+                    for session_id in stored_session_ids:
+                        session_data = await session.manager.session_manager.store.load(session_id)
+                        if session_data:
+                            all_sessions.append((
+                                session_id,
+                                "stored",
+                                {
+                                    "agent_name": session_data.agent_name,
+                                    "cwd": session_data.cwd or "unknown",
+                                    "conversation_id": session_data.conversation_id,
+                                    "is_current": None,
+                                    "last_active": session_data.last_active.strftime(
+                                        "%Y-%m-%d %H:%M"
+                                    ),
+                                },
+                            ))
                 except Exception as e:  # noqa: BLE001
                     output_lines.append(f"*Error loading stored sessions: {e}*\n")
 
+            # Get message counts and titles from storage
+            all_conv_ids = [
+                conv_id for _, _, info in all_sessions if (conv_id := info.get("conversation_id"))
+            ]
+            storage = session.agent_pool.storage
+            msg_counts = await storage.get_message_counts(all_conv_ids) if storage else {}
+            titles = await storage.get_conversation_titles(all_conv_ids) if storage else {}
+
+            # Add titles to session info
+            for _, _, info in all_sessions:
+                if conv_id := info.get("conversation_id"):
+                    info["title"] = titles.get(conv_id)
+
+            # Filter out sessions with 0 messages (unless showing detail view)
+            if not detail:
+                all_sessions = [
+                    (sid, stype, info)
+                    for sid, stype, info in all_sessions
+                    if msg_counts.get(info.get("conversation_id") or "", 0) > 0
+                ]
+
+            # Calculate pagination AFTER filtering
+            total_count = len(all_sessions)
+            total_pages = (total_count + per_page - 1) // per_page if total_count > 0 else 1
+            page = min(page, total_pages)
+
+            start_idx = (page - 1) * per_page
+            end_idx = start_idx + per_page
+            page_sessions = all_sessions[start_idx:end_idx]
+
+            if not page_sessions:
+                output_lines.append("*No sessions found*\n")
+            elif detail:
+                # Detailed view (original format)
+                active_in_page = [(s, i) for s, t, i in page_sessions if t == "active"]
+                stored_in_page = [(s, i) for s, t, i in page_sessions if t == "stored"]
+
+                if active_in_page:
+                    output_lines.append("### 🟢 Active Sessions")
+                    for session_id, info in active_in_page:
+                        status = " *(current)*" if info["is_current"] else ""
+                        title_text = f": {info['title']}" if info["title"] else ""
+                        output_lines.append(f"- **{session_id}**{status}{title_text}")
+                        output_lines.append(f"  - Agent: `{info['agent_name']}`")
+                        output_lines.append(f"  - Directory: `{info['cwd']}`")
+                    output_lines.append("")
+
+                if stored_in_page:
+                    output_lines.append("### 💾 Stored Sessions")
+                    for session_id, info in stored_in_page:
+                        title_text = f": {info['title']}" if info["title"] else ""
+                        output_lines.append(f"- **{session_id}**{title_text}")
+                        output_lines.append(f"  - Agent: `{info['agent_name']}`")
+                        output_lines.append(f"  - Directory: `{info['cwd']}`")
+                        if info["last_active"]:
+                            output_lines.append(f"  - Last active: {info['last_active']}")
+                    output_lines.append("")
+            else:
+                # Compact table view (default)
+                # Table with multi-line session cell (title + ID using <br>)
+                output_lines.append("| Session | Agent | Msgs | Last Active |")
+                output_lines.append("|---------|-------|------|-------------|")
+                for session_id, _session_type, info in page_sessions:
+                    title = info["title"] or "(untitled)"
+                    if info["is_current"]:
+                        title = f"▶️ {title}"
+                    agent = info["agent_name"]
+                    conv_id = info.get("conversation_id") or ""
+                    msg_count = msg_counts.get(conv_id, 0)
+                    last_active = info["last_active"] or "-"
+                    # Two lines in session cell: title and ID
+                    session_cell = f"{title} `{session_id}`"
+                    output_lines.append(
+                        f"| {session_cell} | {agent} | {msg_count} | {last_active} |"
+                    )
+                output_lines.append("")
+
+            # Add pagination info
+            output_lines.append(f"---\n*Page {page}/{total_pages} ({total_count} total sessions)*")
+            if total_pages > 1:
+                nav_hints = []
+                if page > 1:
+                    nav_hints.append(f"`/list-sessions --page {page - 1}` for previous")
+                if page < total_pages:
+                    nav_hints.append(f"`/list-sessions --page {page + 1}` for next")
+                if nav_hints:
+                    output_lines.append(f"*{', '.join(nav_hints)}*")
+
             await ctx.output.print("\n".join(output_lines))
 
         except Exception as e:  # noqa: BLE001
@@ -127,11 +214,6 @@ class ListSessionsCommand(NodeCommand):
 class LoadSessionCommand(NodeCommand):
     """Load a previous ACP session with conversation replay.
 
-    This command will:
-    1. Look up the session by ID
-    2. Replay the conversation history via ACP notifications
-    3. Restore the session context (agent, working directory)
-
     Options:
       --preview     Show session info without loading
       --no-replay   Load session without replaying conversation
@@ -190,8 +272,14 @@ class LoadSessionCommand(NodeCommand):
                     f"## 📋 Session Preview: `{session_id}`\n",
                 ]
 
-                if session_data.title:
-                    preview_lines.append(f"**Title:** {session_data.title}")
+                # Fetch title from storage
+                title = (
+                    await storage.get_conversation_title(session_data.conversation_id)
+                    if storage
+                    else None
+                )
+                if title:
+                    preview_lines.append(f"**Title:** {title}")
 
                 preview_lines.extend([
                     f"**Agent:** `{session_data.agent_name}`",
@@ -265,11 +353,6 @@ class LoadSessionCommand(NodeCommand):
 class SaveSessionCommand(NodeCommand):
     """Save the current ACP session to persistent storage.
 
-    This will save:
-    - Current agent configuration
-    - Working directory
-    - Session metadata
-
     Note: Conversation history is automatically saved if storage is enabled.
 
     Options:
@@ -403,96 +486,9 @@ class DeleteSessionCommand(NodeCommand):
             await ctx.output.print(f"❌ **Error deleting session:** {e}")
 
 
-class ListPoolsCommand(NodeCommand):
-    """List available agent pool configurations.
-
-    Shows:
-    - Stored configurations from ConfigStore (name -> path mapping)
-    - Currently active pool configuration
-    - Available agents in the current pool
-
-    Examples:
-      /list-pools
-    """
-
-    name = "list-pools"
-    category = "acp"
-
-    async def execute_command(
-        self,
-        ctx: CommandContext[NodeContext[ACPSession]],
-    ) -> None:
-        """List available pool configurations.
-
-        Args:
-            ctx: Command context with ACP session
-        """
-        from agentpool_cli import agent_store
-
-        session = ctx.context.data
-        if not session:
-            raise RuntimeError("Session not available in command context")
-
-        try:
-            output_lines = ["## 🏊 Agent Pool Configurations\n"]
-
-            # Show current pool info
-            output_lines.append("### 📍 Current Pool")
-            current_config = (
-                session.acp_agent.server.config_path if session.acp_agent.server else None
-            )
-            if current_config:
-                output_lines.append(f"**Config:** `{current_config}`")
-            else:
-                output_lines.append("**Config:** *(default/built-in)*")
-
-            # Show agents in current pool
-            agent_names = list(session.agent_pool.all_agents.keys())
-            output_lines.append(f"**Agents:** {', '.join(f'`{n}`' for n in agent_names)}")
-            output_lines.append(f"**Active agent:** `{session.current_agent_name}`")
-            output_lines.append("")
-
-            # Show stored configurations
-            output_lines.append("### 💾 Stored Configurations")
-            stored_configs = agent_store.list_configs()
-            active_config = agent_store.get_active()
-
-            if not stored_configs:
-                output_lines.append("*No stored configurations*")
-                output_lines.append("")
-                output_lines.append("Use `agentpool add <name> <path>` to add configurations.")
-            else:
-                # Build markdown table
-                output_lines.append("| Name | Path |")
-                output_lines.append("|------|------|")
-                for name, path in stored_configs:
-                    is_active = active_config and active_config.name == name
-                    is_current = current_config and path == current_config
-                    markers = []
-                    if is_active:
-                        markers.append("default")
-                    if is_current:
-                        markers.append("current")
-                    name_col = f"{name} ({', '.join(markers)})" if markers else name
-                    output_lines.append(f"| {name_col} | `{path}` |")
-
-            output_lines.append("")
-            output_lines.append("*Use `/set-pool <name>` or `/set-pool <path>` to switch pools.*")
-
-            await ctx.output.print("\n".join(output_lines))
-
-        except Exception as e:  # noqa: BLE001
-            await ctx.output.print(f"❌ **Error listing pools:** {e}")
-
-
 class SetPoolCommand(NodeCommand):
     """Switch to a different agent pool configuration.
 
-    This command will:
-    1. Close all active sessions
-    2. Load the new pool configuration
-    3. Initialize the new pool with all agents
-
     The configuration can be specified as:
     - A stored config name (from `agentpool add`)
     - A direct path to a configuration file
@@ -589,6 +585,5 @@ def get_acp_commands() -> list[type[NodeCommand]]:
         LoadSessionCommand,
         SaveSessionCommand,
         DeleteSessionCommand,
-        ListPoolsCommand,
         SetPoolCommand,
     ]

agentpool_server/acp_server/commands/docs_commands/fetch_repo.py

@@ -66,10 +66,7 @@ class FetchRepoCommand(NodeCommand):
         """
         session = ctx.context.data
         assert session
-
-        # Generate tool call ID
-        tool_call_id = f"fetch-repo-{uuid.uuid4().hex[:8]}"
-
+        tc_id = f"fetch-repo-{uuid.uuid4().hex[:8]}"
         try:
             # Build URL
             base_url = f"https://uithub.com/{repo}"
@@ -78,12 +75,14 @@ class FetchRepoCommand(NodeCommand):
             if path:
                 base_url += f"/{path}"
 
-            # Build parameters
-            params = {}
+            # Build headers with Bearer token
+            headers = {"accept": "text/markdown"}
             api_key = os.getenv("UITHUB_API_KEY")
             if api_key:
-                params["apiKey"] = api_key
+                headers["Authorization"] = f"Bearer {api_key}"
 
+            # Build parameters
+            params = {}
             if include_dirs:
                 params["dir"] = ",".join(include_dirs)
             if disable_genignore:
@@ -113,7 +112,7 @@ class FetchRepoCommand(NodeCommand):
                 display_path += f":{path}"
 
             await session.notifications.tool_call_start(
-                tool_call_id=tool_call_id,
+                tool_call_id=tc_id,
                 title=f"Fetching repository: {display_path}",
                 kind="fetch",
             )
@@ -123,22 +122,20 @@ class FetchRepoCommand(NodeCommand):
                 response = await client.get(
                     base_url,
                     params=params,
-                    headers={"accept": "text/markdown"},
+                    headers=headers,
                     timeout=30.0,
                 )
                 response.raise_for_status()
                 content = response.text
 
             # Stage the content for use in agent context
-            staged_part = UserPromptPart(
-                content=f"Repository contents from {display_path}:\n\n{content}"
-            )
+            part_content = f"Repository contents from {display_path}:\n\n{content}"
+            staged_part = UserPromptPart(content=part_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,
+                tool_call_id=tc_id,
                 status="completed",
                 title=f"Repository {display_path} fetched and staged ({staged_count} total parts)",
                 content=[f"```\n{content}\n```"],
@@ -149,21 +146,25 @@ class FetchRepoCommand(NodeCommand):
                 "HTTP error fetching repository", repo=repo, status=e.response.status_code
             )
             await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
+                tool_call_id=tc_id,
                 status="failed",
                 title=f"HTTP {e.response.status_code}: Failed to fetch {repo}",
             )
         except httpx.RequestError as e:
             logger.exception("Request error fetching repository", repo=repo)
             await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
+                tool_call_id=tc_id,
                 status="failed",
                 title=f"Network error: {e}",
             )
         except Exception as e:
             logger.exception("Unexpected error fetching repository", repo=repo)
             await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
+                tool_call_id=tc_id,
                 status="failed",
                 title=f"Error: {e}",
             )
+
+
+if __name__ == "__main__":
+    cmd = FetchRepoCommand()