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

agentpool_server/acp_server/commands/acp_commands.py

@@ -14,11 +14,6 @@ from agentpool_server.acp_server.session import ACPSession  # noqa: TC001
 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
@@ -71,14 +66,15 @@ class ListSessionsCommand(NodeCommand):
             output_lines = ["## 📋 ACP Sessions\n"]
 
             # Collect all sessions to paginate
-            all_sessions: list[tuple[str, str, dict[str, str | None]]] = []  # (id, type, info)
+            # (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:
                 active_sessions = session.manager._active
                 for session_id, sess in active_sessions.items():
                     session_data = await session.manager.session_manager.store.load(session_id)
-                    title = session_data.title if session_data else None
+                    conv_id = session_data.conversation_id if session_data else None
                     is_current = session_id == session.session_id
                     all_sessions.append((
                         session_id,
@@ -86,7 +82,7 @@ class ListSessionsCommand(NodeCommand):
                         {
                             "agent_name": sess.current_agent_name,
                             "cwd": sess.cwd or "unknown",
-                            "title": title,
+                            "conversation_id": conv_id,
                             "is_current": "yes" if is_current else None,
                             "last_active": None,
                         },
@@ -111,7 +107,7 @@ class ListSessionsCommand(NodeCommand):
                                 {
                                     "agent_name": session_data.agent_name,
                                     "cwd": session_data.cwd or "unknown",
-                                    "title": session_data.title,
+                                    "conversation_id": session_data.conversation_id,
                                     "is_current": None,
                                     "last_active": session_data.last_active.strftime(
                                         "%Y-%m-%d %H:%M"
@@ -121,7 +117,28 @@ class ListSessionsCommand(NodeCommand):
                 except Exception as e:  # noqa: BLE001
                     output_lines.append(f"*Error loading stored sessions: {e}*\n")
 
-            # Calculate pagination
+            # 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)
@@ -159,15 +176,22 @@ class ListSessionsCommand(NodeCommand):
                     output_lines.append("")
             else:
                 # Compact table view (default)
-                output_lines.append("| Title | Agent | Last Active |")
-                output_lines.append("|-------|-------|-------------|")
+                # 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 session_id[:16]
+                    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 "-"
-                    output_lines.append(f"| {title} | {agent} | {last_active} |")
+                    # 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
@@ -190,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
@@ -253,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}`",
@@ -328,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:
@@ -466,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
@@ -645,107 +578,6 @@ class SetPoolCommand(NodeCommand):
             await ctx.output.print(f"❌ **Error switching pool:** {e}")
 
 
-class CompactCommand(NodeCommand):
-    """Compact the conversation history to reduce context size.
-
-    Uses the configured compaction pipeline from the agent pool manifest,
-    or falls back to a default summarizing pipeline.
-
-    This will:
-    - Apply configured compaction steps (filter, truncate, summarize)
-    - Reduce the message history while preserving important context
-    - Report the reduction in message count
-
-    Options:
-      --preset <name>   Use a specific preset (minimal, balanced, summarizing)
-
-    Examples:
-      /compact
-      /compact --preset=minimal
-    """
-
-    name = "compact"
-    category = "acp"
-
-    async def execute_command(
-        self,
-        ctx: CommandContext[NodeContext[ACPSession]],
-        *,
-        preset: str | None = None,
-    ) -> None:
-        """Compact the conversation history.
-
-        Args:
-            ctx: Command context with ACP session
-            preset: Optional preset name (minimal, balanced, summarizing)
-        """
-        session = ctx.context.data
-        if not session:
-            raise RuntimeError("Session not available in command context")
-
-        agent = session.agent
-
-        # Check if there's any history to compact
-        if not agent.conversation.get_history():
-            await ctx.output.print("📭 **No message history to compact**")
-            return
-
-        try:
-            # Get compaction pipeline
-            from agentpool.messaging.compaction import (
-                balanced_context,
-                minimal_context,
-                summarizing_context,
-            )
-
-            pipeline = None
-
-            # Check for preset override
-            if preset:
-                match preset.lower():
-                    case "minimal":
-                        pipeline = minimal_context()
-                    case "balanced":
-                        pipeline = balanced_context()
-                    case "summarizing":
-                        pipeline = summarizing_context()
-                    case _:
-                        await ctx.output.print(
-                            f"⚠️ **Unknown preset:** `{preset}`\n"
-                            "Available: minimal, balanced, summarizing"
-                        )
-                        return
-
-            # Fall back to pool's configured pipeline
-            if pipeline is None:
-                pipeline = session.agent_pool.compaction_pipeline
-
-            # Fall back to default summarizing pipeline
-            if pipeline is None:
-                pipeline = summarizing_context()
-
-            await ctx.output.print("🔄 **Compacting conversation history...**")
-
-            # Apply the pipeline using shared helper
-            from agentpool.messaging.compaction import compact_conversation
-
-            original_count, compacted_count = await compact_conversation(
-                pipeline, agent.conversation
-            )
-            reduction = original_count - compacted_count
-
-            await ctx.output.print(
-                f"✅ **Compaction complete**\n"
-                f"- Messages: {original_count} → {compacted_count} ({reduction} removed)\n"
-                f"- Reduction: {reduction / original_count * 100:.1f}%"
-                if original_count > 0
-                else "✅ **Compaction complete** (no messages)"
-            )
-
-        except Exception as e:  # noqa: BLE001
-            await ctx.output.print(f"❌ **Error compacting history:** {e}")
-
-
 def get_acp_commands() -> list[type[NodeCommand]]:
     """Get all ACP-specific slash commands."""
     return [
@@ -753,7 +585,5 @@ def get_acp_commands() -> list[type[NodeCommand]]:
         LoadSessionCommand,
         SaveSessionCommand,
         DeleteSessionCommand,
-        ListPoolsCommand,
         SetPoolCommand,
-        CompactCommand,
     ]

agentpool_server/acp_server/commands/docs_commands/fetch_repo.py

@@ -75,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:
@@ -120,16 +122,15 @@ 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)