v0.100.9

cecli/coders/__init__.py

@@ -1,42 +1,57 @@
-from .agent_coder import AgentCoder
-from .architect_coder import ArchitectCoder
-from .ask_coder import AskCoder
-from .base_coder import Coder
-from .context_coder import ContextCoder
-from .copypaste_coder import CopyPasteCoder
-from .editblock_coder import EditBlockCoder
-from .editblock_fenced_coder import EditBlockFencedCoder
-from .editor_diff_fenced_coder import EditorDiffFencedCoder
-from .editor_editblock_coder import EditorEditBlockCoder
-from .editor_whole_coder import EditorWholeFileCoder
-from .hashline_coder import HashLineCoder
-from .help_coder import HelpCoder
-from .patch_coder import PatchCoder
-from .sub_agent_coder import SubAgentCoder
-from .udiff_coder import UnifiedDiffCoder
-from .udiff_simple import UnifiedDiffSimpleCoder
-from .wholefile_coder import WholeFileCoder
-
-# from .single_wholefile_func_coder import SingleWholeFileFunctionCoder
+"""Coder module with lazy imports to reduce startup memory."""
 
 __all__ = [
-    HelpCoder,
-    AskCoder,
-    Coder,
-    EditBlockCoder,
-    EditBlockFencedCoder,
-    WholeFileCoder,
-    PatchCoder,
-    UnifiedDiffCoder,
-    UnifiedDiffSimpleCoder,
-    #    SingleWholeFileFunctionCoder,
-    ArchitectCoder,
-    EditorEditBlockCoder,
-    EditorWholeFileCoder,
-    EditorDiffFencedCoder,
-    ContextCoder,
-    AgentCoder,
-    CopyPasteCoder,
-    HashLineCoder,
-    SubAgentCoder,
+    "HelpCoder",
+    "AskCoder",
+    "Coder",
+    "EditBlockCoder",
+    "EditBlockFencedCoder",
+    "WholeFileCoder",
+    "PatchCoder",
+    "UnifiedDiffCoder",
+    "UnifiedDiffSimpleCoder",
+    "ArchitectCoder",
+    "EditorEditBlockCoder",
+    "EditorWholeFileCoder",
+    "EditorDiffFencedCoder",
+    "ContextCoder",
+    "AgentCoder",
+    "CopyPasteCoder",
+    "HashLineCoder",
+    "SubAgentCoder",
 ]
+
+# Module name mapping (snake_case to class name)
+_MODULE_MAP = {
+    "HelpCoder": ".help_coder",
+    "AskCoder": ".ask_coder",
+    "Coder": ".base_coder",
+    "EditBlockCoder": ".editblock_coder",
+    "EditBlockFencedCoder": ".editblock_fenced_coder",
+    "WholeFileCoder": ".wholefile_coder",
+    "PatchCoder": ".patch_coder",
+    "UnifiedDiffCoder": ".udiff_coder",
+    "UnifiedDiffSimpleCoder": ".udiff_simple",
+    "ArchitectCoder": ".architect_coder",
+    "EditorEditBlockCoder": ".editor_editblock_coder",
+    "EditorWholeFileCoder": ".editor_whole_coder",
+    "EditorDiffFencedCoder": ".editor_diff_fenced_coder",
+    "ContextCoder": ".context_coder",
+    "AgentCoder": ".agent_coder",
+    "CopyPasteCoder": ".copypaste_coder",
+    "HashLineCoder": ".hashline_coder",
+    "SubAgentCoder": ".sub_agent_coder",
+}
+
+
+def __getattr__(name):
+    if name in _MODULE_MAP:
+        import importlib
+
+        mod = importlib.import_module(_MODULE_MAP[name], __package__)
+        return getattr(mod, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__():
+    return __all__

cecli/coders/agent_coder.py

@@ -194,6 +194,7 @@ def _get_agent_config(self):
                     "todo_list",
                     "sub_agents",
                     "skills",
+                    "servers",
                 },
             )
         )
@@ -357,6 +358,7 @@ def _calculate_context_block_tokens(self, force=False):
                 "git_status",
                 "symbol_outline",
                 "skills",
+                "servers",
                 "sub_agents",
                 "loaded_skills",
             ]
@@ -391,6 +393,8 @@ def _generate_context_block(self, block_name):
             content = self.get_todo_list()
         elif block_name == "skills":
             content = self.get_skills_context()
+        elif block_name == "servers":
+            content = self.get_servers_context()
         elif block_name == "loaded_skills":
             content = self.get_skills_content()
         elif block_name == "sub_agents" and (
@@ -624,8 +628,8 @@ def get_context_summary(self):
                 result += f" ({percentage:.1f}% of limit)"
                 if percentage > 80:
                     result += "\n\n⚠ **Context is getting full!**\n"
-                    result += "- Remove non-essential files via the `ContextManager` tool.\n"
-                    result += "- Keep only essential files in context for best performance"
+                    result += "- Remove non-essential files, skills and tool servers via the `ResourceManager` tool.\n"
+                    result += "- Keep only essential files, skills, and MCP servers in context for best performance"
             result += "\n</context>"
             if not hasattr(self, "context_blocks_cache"):
                 self.context_blocks_cache = {}
@@ -659,7 +663,9 @@ def get_environment_info(self):
                     result += f"- Git repository: {rel_repo_dir} with {num_files:,} files\n"
                 except Exception:
                     result += "- Git repository: active but details unavailable\n"
-            else:
+                if self.mcp_manager and self.mcp_manager.connected_servers:
+                    num_mcp_servers = len(self.mcp_manager.connected_servers)
+                    result += f"- Connected MCP servers: {num_mcp_servers}\n"
                 result += "- Git repository: none\n"
             result += "</context>"
             return result
@@ -806,9 +812,7 @@ async def gather_and_await():
         if self.auto_lint and used_write_tool:
             edited = list(self.files_edited_by_tools)
             lint_coro = self.lint_edited(edited, show_output=False)
-            lint_errors, interrupted = await self.coroutines.interruptible(
-                lint_coro, self.interrupt_event
-            )
+            lint_errors, interrupted = await interruptible(lint_coro, self.interrupt_event)
             if interrupted:
                 raise KeyboardInterrupt("Interrupted during linting")
 
@@ -928,9 +932,7 @@ async def reply_completed(self):
             )
             self.io.tool_output(waiting_msg)
             sleep_coro = asyncio.sleep(command_timeout / 2)
-            _res, interrupted = await self.coroutines.interruptible(
-                sleep_coro, self.interrupt_event
-            )
+            _res, interrupted = await interruptible(sleep_coro, self.interrupt_event)
             if interrupted:
                 raise KeyboardInterrupt("Interrupted while waiting for background commands")
             return True
@@ -1329,7 +1331,7 @@ async def check_for_file_mentions(self, content):
 
         Override parent's method to disable implicit file mention handling in agent mode.
         Files should only be added via explicit tool commands
-        (`ContextManager`).
+        (`ResourceManager`).
         """
         pass
 
@@ -1483,6 +1485,81 @@ def get_skills_content(self):
             self.io.tool_error(f"Error generating skills content context: {str(e)}")
             return None
 
+    def get_servers_context(self):
+        """
+        Generate a context block for available MCP servers.
+
+        Categorizes servers as:
+        - Active: Connected and passing includelist/excludelist filters
+        - Inactive: Connected but filtered out by includelist/excludelist
+        - Available (Disconnected): Managed but not currently connected
+
+        Returns:
+            Formatted context block string or None if no servers available
+        """
+        if not self.use_enhanced_context:
+            return None
+        try:
+            if not self.mcp_manager:
+                return None
+
+            all_servers = self.mcp_manager.servers
+            connected_servers = self.mcp_manager.connected_servers
+            connected_server_names = {s.name for s in connected_servers}
+
+            if not all_servers:
+                return None
+
+            # Apply registered_servers filtering to determine active vs inactive
+            incl = self.registered_servers.get("included", set())
+            excl = self.registered_servers.get("excluded", set())
+
+            active_servers = []
+            inactive_servers = []
+            for server in connected_servers:
+                name = server.name
+                if incl and name not in incl:
+                    inactive_servers.append(name)
+                elif name in excl:
+                    inactive_servers.append(name)
+                else:
+                    active_servers.append(name)
+
+            # Servers managed but not currently connected
+            disconnected_servers = [
+                server.name for server in all_servers if server.name not in connected_server_names
+            ]
+
+            result = '<context name="servers" from="agent">\n'
+            result += "## Connected MCP Servers\n\n"
+
+            if active_servers:
+                result += f"Active ({len(active_servers)}):\n"
+                for name in sorted(active_servers):
+                    result += f"- {name}\n"
+                result += "\n"
+
+            if inactive_servers:
+                result += f"Inactive (Filtered) ({len(inactive_servers)}):\n"
+                for name in sorted(inactive_servers):
+                    result += f"- {name}\n"
+                result += "\n"
+
+            if disconnected_servers:
+                result += f"Available (Disconnected) ({len(disconnected_servers)}):\n"
+                for name in sorted(disconnected_servers):
+                    result += f"- {name}\n"
+                result += "\n"
+
+            if not active_servers and not inactive_servers and not disconnected_servers:
+                result += "No MCP servers currently available.\n\n"
+
+            result += "</context>"
+            return result
+        except Exception as e:
+            self.io.tool_error(f"Error generating servers context: {str(e)}")
+            return None
+
     def get_sub_agents_context(self):
         """
         Generate a context block for registered sub-agents.

cecli/coders/architect_coder.py

@@ -45,7 +45,6 @@ async def reply_completed(self):
         kwargs["args"] = self.args
         kwargs["suggest_shell_commands"] = False
         kwargs["map_tokens"] = 0
-        kwargs["total_cost"] = self.total_cost
         kwargs["cache_prompts"] = False
         kwargs["num_cache_warming_pings"] = 0
         kwargs["summarize_from_coder"] = False