cecli-dev 0.95.8__tar.gz → 0.95.9__tar.gz

{cecli_dev-0.95.8 → cecli_dev-0.95.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.95.8
+Version: 0.95.9
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -54,6 +54,7 @@ Requires-Dist: truststore
 Requires-Dist: rustworkx>=0.15.0
 Requires-Dist: scipy>=1.15.3
 Requires-Dist: importlib-metadata>=7.2.1
+Requires-Dist: tomli>=2.3.0; python_version <= "3.10"
 Requires-Dist: tree-sitter==0.23.2; python_version < "3.10"
 Requires-Dist: tree-sitter>=0.25.1; python_version >= "3.10"
 Provides-Extra: dev

{cecli_dev-0.95.8 → cecli_dev-0.95.9}/cecli/__init__.py

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "0.95.8.dev"
+__version__ = "0.95.9.dev"
 safe_version = __version__
 
 try:

{cecli_dev-0.95.8 → cecli_dev-0.95.9}/cecli/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.95.8'
-__version_tuple__ = version_tuple = (0, 95, 8)
+__version__ = version = '0.95.9'
+__version_tuple__ = version_tuple = (0, 95, 9)
 
-__commit_id__ = commit_id = 'g930eeb2cb'
+__commit_id__ = commit_id = 'g38dc66252'

{cecli_dev-0.95.8 → cecli_dev-0.95.9}/cecli/args.py

@@ -757,12 +757,6 @@ def get_parser(default_config_files, git_root):
         help="Show release notes on first run of new version (default: None, ask user)",
         default=None,
     )
-    group.add_argument(
-        "--install-main-branch",
-        action="store_true",
-        help="Install the latest version from the main branch",
-        default=False,
-    )
     group.add_argument(
         "--upgrade",
         "--update",

{cecli_dev-0.95.8 → cecli_dev-0.95.9}/cecli/coders/agent_coder.py

@@ -23,7 +23,7 @@ from cecli.helpers.similarity import (
     normalize_vector,
 )
 from cecli.helpers.skills import SkillsManager
-from cecli.mcp.server import LocalServer
+from cecli.mcp import LocalServer, McpServerManager
 from cecli.repo import ANY_GIT_ERROR
 from cecli.tools.utils.registry import ToolRegistry
 
@@ -209,14 +209,17 @@ class AgentCoder(Coder):
             local_tools = self.get_local_tool_schemas()
             if not local_tools:
                 return
+
             local_server_config = {"name": server_name}
             local_server = LocalServer(local_server_config)
-            if not self.mcp_servers:
-                self.mcp_servers = []
-            if not any(isinstance(s, LocalServer) for s in self.mcp_servers):
-                self.mcp_servers.append(local_server)
+
+            if not self.mcp_manager:
+                self.mcp_manager = McpServerManager()
+            if not self.mcp_manager.get_server(server_name):
+                await self.mcp_manager.add_server(local_server)
             if not self.mcp_tools:
                 self.mcp_tools = []
+
             if server_name not in [name for name, _ in self.mcp_tools]:
                 self.mcp_tools.append((local_server.name, local_tools))
 
@@ -257,9 +260,7 @@ class AgentCoder(Coder):
                             t.get("function", {}).get("name") == norm_tool_name
                             for t in server_tools
                         ):
-                            server = next(
-                                (s for s in self.mcp_servers if s.name == server_name), None
-                            )
+                            server = self.mcp_manager.get_server(server_name)
                             if server:
                                 for params in parsed_args_list:
                                     tasks.append(
@@ -955,7 +956,7 @@ I will proceed based on the current context.""")
         if self.mcp_tools:
             for server_name, server_tools in self.mcp_tools:
                 if any(t.get("function", {}).get("name") == norm_tool_name for t in server_tools):
-                    server = next((s for s in self.mcp_servers if s.name == server_name), None)
+                    server = self.mcp_manager.get_server(server_name)
                     if server:
                         return await self._execute_mcp_tool(server, norm_tool_name, params)
                     else:
@@ -1499,7 +1500,7 @@ Just reply with fixed versions of the {blocks} above that failed to match.
                 if shared_output:
                     self.io.tool_output("Shell command output:\n" + shared_output)
                 if self.auto_test and not self.reflected_message:
-                    test_errors = await self.commands.cmd_test(self.test_cmd)
+                    test_errors = await self.commands.execute("test", self.test_cmd)
                     if test_errors:
                         ok = await self.io.confirm_ask("Attempt to fix test errors?")
                         if ok:

{cecli_dev-0.95.8 → cecli_dev-0.95.9}/cecli/coders/base_coder.py

@@ -44,7 +44,7 @@ from cecli.history import ChatSummary
 from cecli.io import ConfirmGroup, InputOutput
 from cecli.linter import Linter
 from cecli.llm import litellm
-from cecli.mcp.server import LocalServer
+from cecli.mcp import LocalServer
 from cecli.models import RETRY_TIMEOUT
 from cecli.reasoning_tags import (
     REASONING_TAG,
@@ -138,7 +138,7 @@ class Coder:
     chat_language = None
     commit_language = None
     file_watcher = None
-    mcp_servers = None
+    mcp_manager = None
     mcp_tools = None
     run_one_completed = True
     compact_context_completed = True
@@ -249,8 +249,8 @@ class Coder:
 
         if res is not None:
             if from_coder:
-                if from_coder.mcp_servers and kwargs.get("mcp_servers", False):
-                    res.mcp_servers = from_coder.mcp_servers
+                if from_coder.mcp_manager:
+                    res.mcp_manager = from_coder.mcp_manager
                     res.mcp_tools = from_coder.mcp_tools
 
                 # Transfer TUI app weak reference
@@ -316,7 +316,7 @@ class Coder:
         file_watcher=None,
         auto_copy_context=False,
         auto_accept_architect=True,
-        mcp_servers=None,
+        mcp_manager=None,
         enable_context_compaction=False,
         context_compaction_max_tokens=None,
         context_compaction_summary_tokens=8192,
@@ -350,7 +350,7 @@ class Coder:
         self.args = args
 
         self.num_cache_warming_pings = num_cache_warming_pings
-        self.mcp_servers = mcp_servers
+        self.mcp_manager = mcp_manager
         self.enable_context_compaction = enable_context_compaction
 
         self.context_compaction_max_tokens = context_compaction_max_tokens
@@ -1564,7 +1564,7 @@ class Coder:
 
     def copy_context(self):
         if self.auto_copy_context:
-            self.commands.cmd_copy_context()
+            self.commands.execute("copy-context", "")
 
     async def get_input(self):
         inchat_files = self.get_inchat_relative_files()
@@ -1684,7 +1684,7 @@ class Coder:
                     explicit_yes_required=self.args.yes_always_commands,
                 ):
                     inp += "\n\n"
-                    inp += await self.commands.do_run("web", url, return_content=True)
+                    inp += await self.commands.execute("web", url, return_content=True)
                 else:
                     self.rejected_urls.add(url)
 
@@ -2438,7 +2438,7 @@ class Coder:
             ]
 
         if edited and self.auto_test:
-            test_errors = await self.commands.cmd_test(self.test_cmd)
+            test_errors = await self.commands.execute("test", self.test_cmd)
             self.test_outcome = not test_errors
             if test_errors:
                 ok = await self.io.confirm_ask("Attempt to fix test errors?")
@@ -2562,7 +2562,7 @@ class Coder:
                         and tool_name_from_schema.lower() == tool_call.function.name.lower()
                     ):
                         # Find the McpServer instance that will be used for communication
-                        for server in self.mcp_servers:
+                        for server in self.mcp_manager:
                             if server.name == server_name:
                                 if server not in server_tool_calls:
                                     server_tool_calls[server] = []
@@ -2740,6 +2740,7 @@ class Coder:
         Initialize tools from all configured MCP servers. MCP Servers that fail to be
         initialized will not be available to the Coder instance.
         """
+        # TODO(@gopar): refactor here once we have fully moved over to use the mcp manager
         tools = []
 
         async def get_server_tools(server):
@@ -2750,9 +2751,13 @@ class Coder:
                         return (server.name, server_tools)
 
             try:
-                session = await server.connect()
+                did_connect = await self.mcp_manager.connect_server(server.name)
+                if not did_connect:
+                    raise Exception("Failed to load tools")
+
+                server = self.mcp_manager.get_server(server.name)
                 server_tools = await experimental_mcp_client.load_mcp_tools(
-                    session=session, format="openai"
+                    session=server.session, format="openai"
                 )
                 return (server.name, server_tools)
             except Exception as e:
@@ -2761,11 +2766,11 @@ class Coder:
                 return None
 
         async def get_all_server_tools():
-            tasks = [get_server_tools(server) for server in self.mcp_servers]
+            tasks = [get_server_tools(server) for server in self.mcp_manager]
             results = await asyncio.gather(*tasks)
             return [result for result in results if result is not None]
 
-        if self.mcp_servers:
+        if self.mcp_manager:
             # Retry initialization in case of CancelledError
             max_retries = 3
             for i in range(max_retries):
@@ -3852,7 +3857,7 @@ class Coder:
         self.coder_commit_hashes.add(commit_hash)
         self.last_coder_commit_message = commit_message
         if self.show_diffs:
-            self.commands.cmd_diff()
+            self.commands.execute("diff", "")
 
     def show_undo_hint(self):
         if not self.commit_before_message:

{cecli_dev-0.95.8 → cecli_dev-0.95.9}/cecli/commands/core.py

@@ -178,7 +178,7 @@ class Commands:
         commands = [f"/{cmd}" for cmd in registry_commands]
         return sorted(commands)
 
-    async def do_run(self, cmd_name, args, **kwargs):
+    async def execute(self, cmd_name, args, **kwargs):
         command_class = CommandRegistry.get_command(cmd_name)
         if not command_class:
             self.io.tool_output(f"Error: Command {cmd_name} not found.")
@@ -224,17 +224,17 @@ class Commands:
 
     async def run(self, inp):
         if inp.startswith("!"):
-            return await self.do_run("run", inp[1:])
+            return await self.execute("run", inp[1:])
         res = self.matching_commands(inp)
         if res is None:
             return
         matching_commands, first_word, rest_inp = res
         if len(matching_commands) == 1:
             command = matching_commands[0][1:]
-            return await self.do_run(command, rest_inp)
+            return await self.execute(command, rest_inp)
         elif first_word in matching_commands:
             command = first_word[1:]
-            return await self.do_run(command, rest_inp)
+            return await self.execute(command, rest_inp)
         elif len(matching_commands) > 1:
             self.io.tool_error(f"Ambiguous command: {', '.join(matching_commands)}")
         else:

{cecli_dev-0.95.8 → cecli_dev-0.95.9}/cecli/commands/exit.py

@@ -14,14 +14,6 @@ class ExitCommand(BaseCommand):
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
         """Execute the exit command with given parameters."""
-        for server in coder.mcp_servers:
-            try:
-                await server.exit_stack.aclose()
-            except Exception:
-                pass
-
-        await asyncio.sleep(0)
-
         # Check if running in TUI mode - use graceful exit to restore terminal
         if hasattr(io, "request_exit"):
             io.request_exit()

cecli_dev-0.95.9/cecli/commands/history_search.py

@@ -0,0 +1,112 @@
+import os
+from typing import List
+
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+from cecli.utils import run_fzf
+
+
+class HistorySearchCommand(BaseCommand):
+    NORM_NAME = "history-search"
+    DESCRIPTION = "Fuzzy search in history and paste it in the prompt"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the history-search command with given parameters."""
+        # Get history lines based on whether we're in TUI mode or not
+        if coder.tui and coder.tui():
+            # In TUI mode, parse the history file directly using our custom parser
+            history_lines = cls.parse_input_history_file(io.input_history_file)
+        else:
+            # In non-TUI mode, use the io.get_input_history() method
+            history_lines = io.get_input_history()
+
+        selected_lines = run_fzf(history_lines, coder=coder)
+        if selected_lines:
+            io.set_placeholder("".join(selected_lines))
+
+            if coder.tui and coder.tui():
+                coder.tui().set_input_value("".join(selected_lines))
+            return format_command_result(
+                io, "history-search", "Selected history lines and set placeholder"
+            )
+        else:
+            return format_command_result(io, "history-search", "No history lines selected")
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for history-search command."""
+        return []
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the history-search command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /history-search  # Fuzzy search through command history\n"
+        help_text += (
+            "\nThis command opens a fuzzy finder (FZF) to search through your command history.\n"
+        )
+        help_text += "Selected lines will be pasted into the input prompt for editing.\n"
+        return help_text
+
+    @classmethod
+    def parse_input_history_file(cls, file_path: str) -> List[str]:
+        """Parse the input history file format.
+
+        The file format consists of blocks separated by timestamp lines starting with '#'.
+        Each block has lines starting with '+' for the actual input.
+
+        Args:
+            file_path: Path to the history file
+
+        Returns:
+            List of history entries (strings)
+        """
+        if not file_path or not os.path.exists(file_path):
+            return []
+
+        try:
+            with open(file_path, "r") as f:
+                content = f.read()
+        except (OSError, IOError):
+            return []
+
+        # Parse the file format: blocks separated by timestamp lines starting with '#'
+        # Each block has lines starting with '+' for the actual input
+        history = []
+        current_block = []
+        in_block = False
+
+        for line in content.splitlines():
+            line = line.rstrip("\n")
+
+            if line.startswith("#"):
+                # This is a timestamp line - start a new block
+                if current_block:
+                    # Join the current block lines and add to history
+                    block_text = "\n".join(current_block)
+                    history.append(block_text)
+                    current_block = []
+                in_block = True
+                # Reset in_block if we encounter another timestamp without any + lines
+                # This handles consecutive timestamp lines
+            elif line.startswith("+") and in_block:
+                # This is an input line in the current block
+                # Remove the leading '+' and add to current block
+                # Use [1:] to remove the first character (the '+')
+                # This preserves any leading spaces that might be part of the input
+                current_block.append(line[1:])
+            elif line.strip() == "":
+                # Empty line - ignore
+                continue
+            else:
+                # Unexpected line format - skip it
+                continue
+
+        # Don't forget the last block
+        if current_block:
+            block_text = "\n".join(current_block)
+            history.append(block_text)
+
+        return history