cecli-dev 1.3.1__tar.gz → 1.3.2rc2__tar.gz

{cecli_dev-1.3.1 → cecli_dev-1.3.2rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.3.1
+Version: 1.3.2rc2
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -36,6 +36,7 @@ Requires-Dist: cryptography>=42.0.0
 Requires-Dist: xxhash>=3.6.0
 Requires-Dist: beautifulsoup4>=4.13.4
 Requires-Dist: pypandoc>=1.15
+Requires-Dist: chromadb>=1.5.9
 Requires-Dist: diskcache>=5.6.3
 Requires-Dist: json-repair>=0.60.1
 Requires-Dist: jsonschema>=4.25.0
@@ -90,7 +91,7 @@ Requires-Dist: pympler; extra == "dev"
 Requires-Dist: guppy3; extra == "dev"
 Requires-Dist: psutil; extra == "dev"
 Provides-Extra: help
-Requires-Dist: chromadb; extra == "help"
+Requires-Dist: chromadb>=1.5.9; extra == "help"
 Requires-Dist: numpy>=1.26.4; extra == "help"
 Provides-Extra: playwright
 Requires-Dist: playwright; extra == "playwright"

{cecli_dev-1.3.1 → cecli_dev-1.3.2rc2}/cecli/__init__.py

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

{cecli_dev-1.3.1 → cecli_dev-1.3.2rc2}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.3.1'
-__version_tuple__ = version_tuple = (1, 3, 1)
+__version__ = version = '1.3.2rc2'
+__version_tuple__ = version_tuple = (1, 3, 2, 'rc2')
 
-__commit_id__ = commit_id = 'g935c0453d'
+__commit_id__ = commit_id = 'gb52f1a0f8'

{cecli_dev-1.3.1 → cecli_dev-1.3.2rc2}/cecli/args.py

@@ -331,6 +331,12 @@ def get_parser(default_config_files, git_root):
         default=3,
         help="Maximum number of retries a model gets on malformed outputs (default: 3)",
     )
+    group.add_argument(
+        "--max-tool-calls",
+        type=int,
+        default=25,
+        help="Maximum number of tool calls allowed per message (default: 25)",
+    )
     group.add_argument(
         "--cost-limit",
         type=float,

{cecli_dev-1.3.1 → cecli_dev-1.3.2rc2}/cecli/coders/agent_coder.py

@@ -133,6 +133,8 @@ class AgentCoder(Coder):
             self.io.tool_warning(err)
 
         self.start_up_errors = []
+        # Preserve the original 10000 setting now that max tool calls is configurable
+        self.max_tool_calls = self.max_tool_calls * 400
 
     def _setup_agent(self):
         os.makedirs(".cecli/temp", exist_ok=True)
@@ -1221,15 +1223,6 @@ class AgentCoder(Coder):
         for i, tool in enumerate(recent_history, 1):
             context_parts.append(f"{i}. {tool}")
 
-        if not self.edit_allowed:
-            context_parts.append("\n\n")
-            context_parts.append("## File Editing Tools Disabled")
-            context_parts.append(
-                "File editing tools are currently disabled. Use `ReadFile` to determine the"
-                " current content ID prefixes needed to perform an edit and activate them when"
-                " you are ready to edit a file."
-            )
-
         context_parts.append("\n\n")
         repetition_warning = None
 

{cecli_dev-1.3.1 → cecli_dev-1.3.2rc2}/cecli/coders/base_coder.py

@@ -520,6 +520,7 @@ class Coder(metaclass=UsageMeta):
         self.max_compaction_retries = max_compaction_retries
 
         self.max_reflections = nested.getter(self.args, "max_reflections", 3)
+        self.max_tool_calls = nested.getter(self.args, "max_tool_calls", 25)
 
         if not fnames:
             fnames = []

{cecli_dev-1.3.1 → cecli_dev-1.3.2rc2}/cecli/helpers/agents/defaults/memorizer.md

@@ -16,6 +16,8 @@ agent-config:
     - gitremote
     - gitshow
     - gitstatus
+  servers_includelist:
+    - local
   exclude_context_blocks:
     - context_summary
     - directory_structure

{cecli_dev-1.3.1 → cecli_dev-1.3.2rc2}/cecli/helpers/file_system/builders.py

@@ -8,6 +8,7 @@ Construction strategies for FileSystemService.
 import hashlib
 import os
 import subprocess
+import time
 from pathlib import Path
 
 from .ignore import FileIgnoreFilter
@@ -118,6 +119,8 @@ class ScandirBuilder:
         Walk filesystem collecting files relative to root using Breadth-First Search.
         Highly optimized: lazy iteration, single-pass evaluation, and raw string paths.
         """
+        start_time = time.monotonic()
+
         paths = []
 
         # Only use pathlib for initial resolution, then stick to raw strings for speed
@@ -132,6 +135,9 @@ class ScandirBuilder:
         path_count = 0
 
         while dirs_to_scan:
+            if time.monotonic() - start_time > 120:
+                break
+
             next_dirs = []
 
             for current_path, rel_dir, depth in dirs_to_scan:
@@ -159,7 +165,7 @@ class ScandirBuilder:
 
                             # --- Handle Files ---
                             elif entry.is_file(follow_symlinks=False):
-                                # Short-circuit if we hit the 64 file cap (saves ignore_filter overhead)
+                                # Short-circuit if we hit the 256 file cap (saves ignore_filter overhead)
                                 if not is_subfolder_of_user and file_count >= 256:
                                     continue
 
@@ -177,7 +183,7 @@ class ScandirBuilder:
                                 # Global safety hard-stop
                                 if not is_subfolder_of_user and path_count >= max_files:
                                     return sorted(paths)
-                except PermissionError:
+                except (PermissionError, OSError, TimeoutError):
                     continue  # Skip folders we don't have read access to
 
             dirs_to_scan = next_dirs

{cecli_dev-1.3.1 → cecli_dev-1.3.2rc2}/cecli/helpers/hashpos/transformations.py

@@ -10,13 +10,8 @@ and region_resolver.py.
 from __future__ import annotations
 
 import re
-from typing import TYPE_CHECKING
-
-from cecli.helpers.hashpos.hashpos import UNIQUE_HASH_DELIMITER
-
-if TYPE_CHECKING:
-    from cecli.helpers.hashpos.hashpos import HashPos
 
+from cecli.helpers.hashpos.hashpos import UNIQUE_HASH_DELIMITER, HashPos
 
 # ────────────────────────────────────────────────────────────
 # Pattern Matching
@@ -432,9 +427,24 @@ def reposition_indices(
 
 def strip_hashline_prefix(value: str) -> str:
     """Strip the virtual prefix from a ReadFile output line reference."""
-
-    if isinstance(value, str) and value.startswith(UNIQUE_HASH_DELIMITER):
-        return value[len(UNIQUE_HASH_DELIMITER) :].lstrip()
+    if not isinstance(value, str):
+        return value
+
+    # Unique-line delimiter (——): not spatially resolvable, so strip it and match
+    # the remaining content as text.
+    if value.startswith(UNIQUE_HASH_DELIMITER):
+        return value[len(UNIQUE_HASH_DELIMITER) :]
+
+    # Valid canonical duplicate content ID (—XXXX—): keep it intact so that
+    # resolve_content_to_hashline_ids() can target a specific occurrence.
+    if HashPos.HASH_PREFIX_RE.match(value):
+        return value
+
+    # Malformed marker: a short string immediately followed by an em-dash (e.g.
+    # 'о‘星—'). This is not a valid content ID, so strip it.
+    stripped = HashPos._LOOSE_PREFIX_RE.sub("", value, count=1)
+    if stripped != value:
+        return stripped
 
     return value
 

{cecli_dev-1.3.1 → cecli_dev-1.3.2rc2}/cecli/io.py

@@ -1354,6 +1354,13 @@ class InputOutput:
                 while True:
                     try:
                         if self.prompt_session:
+                            if (
+                                getattr(
+                                    getattr(self.prompt_session, "app", None), "_is_running", False
+                                )
+                                is True
+                            ):
+                                return True
                             # Call prompt_async directly instead of using input_task
                             # This allows KeyboardInterrupt to propagate properly
                             res = await self.prompt_session.prompt_async(question)

{cecli_dev-1.3.1 → cecli_dev-1.3.2rc2}/cecli/main.py

@@ -1004,7 +1004,7 @@ async def main_async(
             return await main_async(argv, input, output, right_repo_root, return_coder=return_coder)
 
     if (args.check_update or args.upgrade) and not args.just_check_update and not suppress_pre_init:
-        await check_version(pre_init_io, verbose=args.verbose)
+        await check_version(pre_init_io, verbose=args.verbose, upgrade=args.upgrade)
     elif args.just_check_update:
         update_available = await check_version(pre_init_io, just_check=True, verbose=args.verbose)
         return await graceful_exit(None, 0 if not update_available else 1)

{cecli_dev-1.3.1 → cecli_dev-1.3.2rc2}/cecli/mcp/server.py

@@ -68,7 +68,14 @@ class McpServer:
         # concurrent disconnect on the same loop never blocks the loop thread.
         self._cleanup_lock: threading.Lock = threading.Lock()
         self._disconnecting = False
+        # The session (and its transport context) is owned by a single task so
+        # the AnyIO task group inside the transport is entered and exited on the
+        # same task, no matter which task calls disconnect().
         self.exit_stack = AsyncExitStack()
+        self._cancel_keepalive_on_close = True
+        self._session_task: asyncio.Task | None = None
+        self._session_ready: asyncio.Future | None = None
+        self._shutdown_event: asyncio.Event | None = None
 
     @property
     def is_connected(self) -> bool:
@@ -78,16 +85,21 @@ class McpServer:
     async def connect(self):
         """Connect to the MCP server and return the session.
 
-        If a session is already active, returns the existing session.
-        Otherwise, establishes a new connection and initializes the session.
+        If a session is already active, returns the existing session. Otherwise,
+        establishes a new connection and initializes the session.
+
+        The session is owned by a dedicated task that both opens and closes the
+        transport, so the AnyIO task group inside the transport context is always
+        entered and exited on the same task, regardless of which task later calls
+        disconnect().
 
         Returns:
             ClientSession: The active session if mcp is not disabled
         """
         current_loop = asyncio.get_running_loop()
         if self.session is not None:
-            # Event loop affinity check: streams from stdio_client() are bound
-            # to the loop that created them.  Reconnect if the loop changed.
+            # Event loop affinity check: streams from the transport are bound to
+            # the loop that created them. Reconnect if the loop changed.
             if self._connection_loop is current_loop:
                 if self.verbose and self.io:
                     self.io.tool_output(f"Using existing session for MCP server: {self.name}")
@@ -99,51 +111,57 @@ class McpServer:
         if self.verbose and self.io:
             self.io.tool_output(f"Establishing new connection to MCP server: {self.name}")
 
-        command = self.config["command"]
-
-        env = os.environ.copy()
-        if self.config.get("env"):
-            env.update(self.config["env"])
-
-        server_params = StdioServerParameters(
-            command=command,
-            args=self.config.get("args"),
-            env=env,
-        )
+        self._connection_loop = current_loop
+        self._shutdown_event = asyncio.Event()
+        self._session_ready = current_loop.create_future()
+        self._session_task = asyncio.create_task(self._run_session())
 
         try:
-            os.makedirs(".cecli/logs/", exist_ok=True)
-            with safe_open(".cecli/logs/mcp-errors.log", "w") as err_file:
-                stdio_transport = await self.exit_stack.enter_async_context(
-                    stdio_client(server_params, errlog=err_file)
-                )
-                read, write = stdio_transport
-                session = await self.exit_stack.enter_async_context(ClientSession(read, write))
-                await session.initialize()
-                self.session = session
-                self._connection_loop = current_loop
-                return session
-        except Exception as e:
-            logging.error(f"Error initializing server {self.name}: {e}")
+            session = await self._session_ready
+        except BaseException:
             await self.disconnect()
             raise
 
-    async def disconnect(self):
-        """
-        Disconnect from the MCP server and clean up resources.
+        return session
+
+    async def disconnect(self, cancel_keepalive: bool = True):
+        """Disconnect from the MCP server and clean up resources.
 
         Idempotent and safe to call from any task or thread: only one caller
         performs the teardown; concurrent callers (possibly on another event
         loop) return immediately once the session is marked gone.
+
+        The transport is closed on the session owner task (via a shutdown
+        signal), so the AnyIO task group inside the transport's async context is
+        exited on the same task that entered it.
         """
         with self._cleanup_lock:
             if self._disconnecting:
                 self.session = None
                 return
             self._disconnecting = True
+            self._cancel_keepalive_on_close = cancel_keepalive
 
         try:
-            await self.exit_stack.aclose()
+            task = self._session_task
+            if task is not None and not task.done():
+                # Retire this task as owner before signalling, so an owner task on
+                # another loop won't clear state a newer session has taken over.
+                self._session_task = None
+                if self._shutdown_event is not None:
+                    self._shutdown_event.set()
+
+                try:
+                    await asyncio.wait_for(task, timeout=15)
+                except asyncio.TimeoutError:
+                    task.cancel()
+                except RuntimeError:
+                    # Session task lives on a different loop; it is torn down there.
+                    pass
+
+            elif task is None:
+                await self._close_session(cancel_keepalive)
+                await self.exit_stack.aclose()
         except (asyncio.CancelledError, RuntimeError, GeneratorExit):
             # Expected during shutdown - anyio cancel scopes don't play
             # well with asyncio teardown. Resources are still cleaned up.
@@ -152,6 +170,9 @@ class McpServer:
             logging.error(f"Error during cleanup of server {self.name}: {e}")
         finally:
             self.session = None
+            self._connection_loop = None
+            self._session_ready = None
+            self._shutdown_event = None
             self._disconnecting = False
 
     async def reconnect(self):
@@ -196,6 +217,109 @@ class McpServer:
 
         return False
 
+    async def _open_session(self):
+        """Open the MCP transport and initialize the session.
+
+        All context managers are entered into ``self.exit_stack`` and the active
+        session is stored on ``self.session``. This runs on the session owner
+        task (see ``_run_session``). Subclasses override this for
+        transport-specific setup.
+
+        Returns:
+            ClientSession: The initialized session
+        """
+        command = self.config["command"]
+
+        env = os.environ.copy()
+        if self.config.get("env"):
+            env.update(self.config["env"])
+
+        server_params = StdioServerParameters(
+            command=command,
+            args=self.config.get("args"),
+            env=env,
+        )
+
+        os.makedirs(".cecli/logs/", exist_ok=True)
+        with safe_open(".cecli/logs/mcp-errors.log", "w") as err_file:
+            stdio_transport = await self.exit_stack.enter_async_context(
+                stdio_client(server_params, errlog=err_file)
+            )
+            read, write = stdio_transport
+            session = await self.exit_stack.enter_async_context(ClientSession(read, write))
+            await session.initialize()
+            self.session = session
+
+        return session
+
+    async def _close_session(self, cancel_keepalive: bool = True):
+        """Tear down session-specific resources.
+
+        Always runs on the session owner task, immediately before the transport
+        context is closed. Subclasses override to clean up extra state.
+        """
+        return None
+
+    async def _run_session(self):
+        """Own the transport context for the lifetime of the session.
+
+        Opens the transport and session, then blocks until a shutdown is
+        requested, then closes the transport. Both the open and the close happen
+        in this single task so the AnyIO task group inside the transport context
+        (for example ``stdio_client``) is entered and exited on the same task.
+
+        Even when opening fails partway, any contexts already pushed onto
+        ``self.exit_stack`` are still closed here, so nothing leaks.
+        """
+        # This session owns its own transport stack so an older owner task that
+        # is still winding down can never close a newer session's contexts.
+        exit_stack = AsyncExitStack()
+        self.exit_stack = exit_stack
+
+        try:
+            try:
+                session = await self._open_session()
+            except BaseException as exc:
+                if not self._session_ready.done():
+                    if isinstance(exc, asyncio.CancelledError):
+                        # Deliver cancellation as a future cancellation, not as an
+                        # exception value, so a connect() caller that never awaits
+                        # the future won't trigger a "Future exception was never
+                        # retrieved" warning.
+                        self._session_ready.cancel()
+                    else:
+                        logging.error(f"Error initializing server {self.name}: {exc}")
+                        self._session_ready.set_exception(exc)
+
+                return
+
+            if not self._session_ready.done():
+                self._session_ready.set_result(session)
+
+            await self._shutdown_event.wait()
+        except BaseException:
+            pass
+        finally:
+            try:
+                await self._close_session(self._cancel_keepalive_on_close)
+            except asyncio.CancelledError:
+                pass
+            except Exception as e:
+                logging.error(f"Error during cleanup of server {self.name}: {e}")
+
+            try:
+                await exit_stack.aclose()
+            except (asyncio.CancelledError, RuntimeError, GeneratorExit):
+                pass
+            except Exception as e:
+                logging.error(f"Error during cleanup of server {self.name}: {e}")
+
+            # Only the current owner may clear shared state; if a newer session
+            # has taken over, leave its session/loop fields alone.
+            if self._session_task is asyncio.current_task():
+                self.session = None
+                self._connection_loop = None
+
 
 class HttpBasedMcpServer(McpServer):
     """Base class for HTTP-based MCP servers (HTTP streaming and SSE)."""
@@ -288,66 +412,48 @@ class HttpBasedMcpServer(McpServer):
         """
         raise NotImplementedError("Subclasses must implement _create_transport")
 
-    async def connect(self):
-        current_loop = asyncio.get_running_loop()
-        if self.session is not None:
-            if self._connection_loop is current_loop:
-                if self.verbose and self.io:
-                    self.io.tool_output(f"Using existing session for {self.name}")
-                return self.session
-            if self.verbose and self.io:
-                self.io.tool_output(f"Reconnecting {self.name} (event loop changed)")
-            await self.disconnect()
-
-        if self.verbose and self.io:
-            self.io.tool_output(f"Establishing new connection to {self.name}")
-
-        try:
-            url = self.config.get("url")
-            headers = self.config.get("headers", {})
-
-            oauth_provider = None
-            if not headers:
-                oauth_provider = await self._create_oauth_provider()
-
-            http_client_cls = _get_http_client_module().AsyncClient
-            http_client = await self.exit_stack.enter_async_context(
-                http_client_cls(
-                    auth=oauth_provider,
-                    follow_redirects=True,
-                    headers=headers,
-                    timeout=30,
-                )
+    async def _open_session(self):
+        url = self.config.get("url")
+        headers = self.config.get("headers", {})
+
+        oauth_provider = None
+        if not headers:
+            oauth_provider = await self._create_oauth_provider()
+
+        http_client_cls = _get_http_client_module().AsyncClient
+        http_client = await self.exit_stack.enter_async_context(
+            http_client_cls(
+                auth=oauth_provider,
+                follow_redirects=True,
+                headers=headers,
+                timeout=30,
             )
-            self._http_client = http_client
+        )
+        self._http_client = http_client
 
-            transport = await self.exit_stack.enter_async_context(
-                self._create_transport(url, http_client=http_client)
-            )
+        transport = await self.exit_stack.enter_async_context(
+            self._create_transport(url, http_client=http_client)
+        )
 
-            read, write = _unpack_transport(transport)
+        read, write = _unpack_transport(transport)
 
-            session = await self.exit_stack.enter_async_context(ClientSession(read, write))
-            await session.initialize()
-            self.session = session
-            await self.start_keepalive()
-            self._connection_loop = current_loop
+        session = await self.exit_stack.enter_async_context(ClientSession(read, write))
+        await session.initialize()
+        self.session = session
 
-            if oauth_provider is not None and oauth_provider.context.oauth_metadata:
-                token_endpoint = oauth_provider._get_token_endpoint()
-                server_info = get_mcp_oauth_token(self.name)
-                if "client_info" not in server_info:
-                    server_info["client_info"] = {}
+        await self.start_keepalive()
 
-                server_info["client_info"]["token_endpoint"] = token_endpoint
+        if oauth_provider is not None and oauth_provider.context.oauth_metadata:
+            token_endpoint = oauth_provider._get_token_endpoint()
+            server_info = get_mcp_oauth_token(self.name)
+            if "client_info" not in server_info:
+                server_info["client_info"] = {}
 
-                save_mcp_oauth_token(self.name, server_info)
+            server_info["client_info"]["token_endpoint"] = token_endpoint
 
-            return session
-        except Exception as e:
-            logging.error(f"Error initializing {self.name}: {e}")
-            await self.disconnect()
-            raise
+            save_mcp_oauth_token(self.name, server_info)
+
+        return session
 
     async def start_keepalive(self):
         """Start the background keepalive loop if configured."""
@@ -459,41 +565,21 @@ class HttpBasedMcpServer(McpServer):
                         f"Reconnection attempt {attempt} failed for {self.name}: {e}"
                     )
 
-    async def disconnect(self, cancel_keepalive: bool = True):
-        """
-        Disconnect from the MCP server and clean up resources.
+    async def _close_session(self, cancel_keepalive: bool = True):
+        if cancel_keepalive and self._keepalive_task:
+            self._keepalive_task.cancel()
 
-        Idempotent and safe to call from any task or thread: only one caller
-        performs the teardown; concurrent callers (possibly on another event
-        loop) return immediately once the session is marked gone.
-        """
-        with self._cleanup_lock:
-            if self._disconnecting:
-                self.session = None
-                return
-            self._disconnecting = True
+            try:
+                await asyncio.wait_for(self._keepalive_task, timeout=15)
+            except asyncio.CancelledError:
+                pass
 
-        try:
-            if cancel_keepalive and self._keepalive_task:
-                self._keepalive_task.cancel()
-                try:
-                    await asyncio.wait_for(self._keepalive_task, timeout=15)
-                except asyncio.CancelledError:
-                    pass
-                logger.info(f"Keepalive task stopped for {self.name}")
-            if hasattr(self, "_oauth_shutdown"):
-                self._oauth_shutdown()
-            await self.exit_stack.aclose()
-        except (asyncio.CancelledError, RuntimeError, GeneratorExit):
-            # Expected during shutdown - anyio cancel scopes don't play
-            # well with asyncio teardown. Resources are still cleaned up.
-            pass
-        except Exception as e:
-            logging.error(f"Error during cleanup of server {self.name}: {e}")
-        finally:
-            self.session = None
-            self._http_client = None
-            self._disconnecting = False
+            logger.info(f"Keepalive task stopped for {self.name}")
+
+        if hasattr(self, "_oauth_shutdown"):
+            self._oauth_shutdown()
+
+        self._http_client = None
 
 
 class HttpStreamingServer(HttpBasedMcpServer):
@@ -507,32 +593,17 @@ class HttpStreamingServer(HttpBasedMcpServer):
 class SseServer(McpServer):
     """SSE (Server-Sent Events) MCP server using mcp.client.sse_client."""
 
-    async def connect(self):
-        current_loop = asyncio.get_running_loop()
-        if self.session is not None:
-            if self._connection_loop is current_loop:
-                logging.info(f"Using existing session for SSE MCP server: {self.name}")
-                return self.session
-            logging.info(f"Reconnecting SSE MCP server {self.name} (event loop changed)")
-            await self.disconnect()
+    async def _open_session(self):
+        url = self.config.get("url")
+        headers = self.config.get("headers", {})
 
-        logging.info(f"Establishing new connection to SSE MCP server: {self.name}")
-        try:
-            url = self.config.get("url")
-            headers = self.config.get("headers", {})
-            sse_transport = await self.exit_stack.enter_async_context(
-                sse_client(url, headers=headers)
-            )
-            read, write = sse_transport
-            session = await self.exit_stack.enter_async_context(ClientSession(read, write))
-            await session.initialize()
-            self.session = session
-            self._connection_loop = current_loop
-            return session
-        except Exception as e:
-            logging.error(f"Error initializing SSE server {self.name}: {e}")
-            await self.disconnect()
-            raise
+        sse_transport = await self.exit_stack.enter_async_context(sse_client(url, headers=headers))
+        read, write = sse_transport
+        session = await self.exit_stack.enter_async_context(ClientSession(read, write))
+        await session.initialize()
+        self.session = session
+
+        return session
 
 
 class LocalServer(McpServer):