cecli-dev 1.2.3rc4__tar.gz → 1.3.0__tar.gz

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.2.3rc4
+Version: 1.3.0
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -43,6 +43,7 @@ Requires-Dist: PyYAML>=6.0.2
 Requires-Dist: tomli>=2.3.0; python_version <= "3.10"
 Requires-Dist: tomlkit>=0.14.0
 Requires-Dist: diff-match-patch>=20241021
+Requires-Dist: tqdm>3.0.0
 Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: pydub>=0.25.1
 Requires-Dist: sounddevice>=0.5.2
@@ -89,7 +90,7 @@ Requires-Dist: pympler; extra == "dev"
 Requires-Dist: guppy3; extra == "dev"
 Requires-Dist: psutil; extra == "dev"
 Provides-Extra: help
-Requires-Dist: llama-index-embeddings-huggingface; extra == "help"
+Requires-Dist: chromadb; extra == "help"
 Requires-Dist: numpy>=1.26.4; extra == "help"
 Provides-Extra: playwright
 Requires-Dist: playwright; extra == "playwright"

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0}/cecli/__init__.py

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

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.3rc4'
-__version_tuple__ = version_tuple = (1, 2, 3, 'rc4')
+__version__ = version = '1.3.0'
+__version_tuple__ = version_tuple = (1, 3, 0)
 
-__commit_id__ = commit_id = 'g0cce57c1b'
+__commit_id__ = commit_id = 'gc441a3967'

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0}/cecli/coders/base_coder.py

@@ -42,6 +42,7 @@ from cecli.helpers import command_parser, command_queue, coroutines, nested, res
 from cecli.helpers.conversation import ConversationService, MessageTag
 from cecli.helpers.file_system import FileSystemService
 from cecli.helpers.io_proxy import IOProxy
+from cecli.helpers.loop_detect import LoopDetectedError, LoopDetector
 from cecli.helpers.memory_control import trim_memory
 from cecli.helpers.observations.service import ObservationService
 from cecli.helpers.profiler import TokenProfiler
@@ -250,6 +251,8 @@ class Coder(metaclass=UsageMeta):
     cost_multiplier = 1
     stop_on_empty = True
     error_code = None
+    _output_loop_detected = False
+    _output_loop_message = ""
 
     # Task coordination state variables
     input_running = False
@@ -3649,6 +3652,8 @@ class Coder(metaclass=UsageMeta):
         self.got_reasoning_content = False
         self.ended_reasoning_content = False
         self.empty_response = False
+        self._output_loop_detected = False
+        self._output_loop_message = ""
 
         self._streaming_buffer_length = 0
         self.io.reset_streaming_response()
@@ -3857,11 +3862,14 @@ class Coder(metaclass=UsageMeta):
     async def show_send_output_stream(self, completion):
         received_content = False
         chunk_index = 0
+        content_detector = LoopDetector()
+        tool_detector = LoopDetector()
+        loop_detected = False
+
+        stream = coroutines.interruptible_async_generator(completion, self.interrupt_event)
 
         try:
-            async for chunk in coroutines.interruptible_async_generator(
-                completion, self.interrupt_event
-            ):
+            async for chunk in stream:
                 if self.args.debug:
                     with safe_open(".cecli/logs/chunks.log", "a") as f:
                         print(chunk, file=f)
@@ -3902,6 +3910,8 @@ class Coder(metaclass=UsageMeta):
                                             tool_call_chunk.function.arguments
                                         )
 
+                                        tool_detector.push(tool_call_chunk.function.arguments)
+
                     except (AttributeError, IndexError):
                         # Handle cases where the response structure doesn't match expectations
                         pass
@@ -3965,6 +3975,9 @@ class Coder(metaclass=UsageMeta):
                 chunk._hidden_params["created_at"] = chunk_index
                 self.partial_response_chunks.append(chunk)
 
+                if text:
+                    content_detector.push(text)
+
                 if self.show_pretty():
                     # Use simplified streaming - just call the method with full content
                     content_to_show = self.live_incremental_response(False)
@@ -3985,6 +3998,30 @@ class Coder(metaclass=UsageMeta):
         except (asyncio.CancelledError, KeyboardInterrupt):
             raise KeyboardInterrupt
 
+        except LoopDetectedError as e:
+            self._output_loop_detected = True
+            self._output_loop_message = str(e)
+            loop_detected = True
+
+        if loop_detected:
+            self.io.tool_warning(
+                f"Output loop detected while streaming: {self._output_loop_message}"
+            )
+            # Explicitly close the async generators so the wrapper's interrupt
+            # task and the underlying provider generator are cleaned up instead
+            # of being left suspended after we stop consuming them.
+            if hasattr(stream, "aclose"):
+                try:
+                    await stream.aclose()
+                except Exception:
+                    pass
+            if hasattr(completion, "aclose"):
+                try:
+                    await completion.aclose()
+                except Exception:
+                    pass
+            return
+
         if (
             self.show_pretty()
             and nested.getter(self.args, "show_thinking")
@@ -4130,22 +4167,45 @@ class Coder(metaclass=UsageMeta):
                 self.tool_reflection = True
                 self.partial_response_tool_calls = extracted_calls
 
+        if self._output_loop_detected:
+            # A repeating output loop was caught while streaming; turn it into an
+            # assistant message so the model can adjust and drop any tool calls.
+            marker = "\n\n[SYSTEM CANCEL: OUTPUT LOOP DETECTED]\n"
+            self.partial_response_content += marker
+            self.partial_response_tool_calls = []
+            self.partial_response_function_call = dict()
+
+            # The assistant message stored in the conversation is built from the
+            # response object (via model_dump()), so the marker has to be written
+            # there too, otherwise it never reaches the model to react to.
+            message = response.choices[0].message
+            message.content = (message.content or "") + marker
+            message.tool_calls = []
+            if hasattr(message, "function_call"):
+                message.function_call = None
+
         self.partial_response_consolidated = (response, func_err, content_err)
         return response, func_err, content_err
 
     def _build_tool_calls_from_chunks(self):
-        """Rebuild tool calls from the raw streaming chunks, keyed by delta index.
-
-        Streaming deltas for parallel tool calls arrive interleaved and may start
-        at any index (not necessarily 0).  Indexing into a dict by the delta's
-        tool-call ``index`` before converting it back to a list ensures every
-        parallel call is preserved, correctly ordered, and keeps its
-        provider-specific fields (e.g. thought signatures) attached.
+        """Rebuild tool calls from the raw streaming chunks.
+
+        Parallel tool calls arrive interleaved and may start at any index.
+        Most providers key fragments by a per-call ``index`` (openai / anthropic /
+        gemini), but some (e.g. deepseek) reuse index0 for every call and only
+        distinguish them by the ``id`` announced on the first fragment.  Keying
+        by id when present -- and remembering the index -> key mapping so later
+        id-less fragments resolve to the right call -- preserves every parallel
+        call instead of collapsing them onto one, keeps them ordered by first
+        appearance, and retains provider-specific fields (e.g. thought
+        signatures) attached.
         """
         ChatCompletionMessageToolCall = litellm.types.utils.ChatCompletionMessageToolCall
         Function = litellm.types.utils.Function
 
         tool_calls_dict = {}
+        index_lookup = {}
+        last_key = None
 
         for chunk in self.partial_response_chunks:
             try:
@@ -4160,22 +4220,39 @@ class Coder(metaclass=UsageMeta):
                     if nested.getter(tool_call, "function") is None:
                         continue
 
+                    tool_id = nested.getter(tool_call, "id") or ""
                     index = nested.getter(tool_call, "index")
-                    if index is None:
-                        index = len(tool_calls_dict)
+
+                    if tool_id:
+                        key = ("id", tool_id)
+
+                        if index is not None:
+                            index_lookup[index] = key
+
+                        last_key = key
+                    elif index is not None and index in index_lookup:
+                        key = index_lookup[index]
+                    elif index is not None:
+                        key = ("index", index)
+                        index_lookup[index] = key
+                    elif last_key is not None:
+                        key = last_key
+                    else:
+                        key = ("slot", len(tool_calls_dict))
 
                     entry = tool_calls_dict.setdefault(
-                        index,
+                        key,
                         {
                             "id": None,
                             "name": None,
                             "type": "function",
                             "arguments": [],
                             "provider_specific_fields": {},
+                            "_order": len(tool_calls_dict),
                         },
                     )
 
-                    entry["id"] = nested.getter(tool_call, "id") or entry["id"]
+                    entry["id"] = tool_id or entry["id"]
                     entry["type"] = nested.getter(tool_call, "type") or entry["type"]
                     entry["name"] = nested.getter(tool_call, "function.name") or entry["name"]
 
@@ -4192,8 +4269,8 @@ class Coder(metaclass=UsageMeta):
                 continue
 
         tool_calls = []
-        for index in sorted(tool_calls_dict.keys()):
-            data = tool_calls_dict[index]
+        for key in sorted(tool_calls_dict.keys(), key=lambda k: tool_calls_dict[k]["_order"]):
+            data = tool_calls_dict[key]
             if not (data["id"] and data["name"]):
                 continue
 

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0}/cecli/commands/help.py

@@ -17,57 +17,74 @@ class HelpCommand(BaseCommand):
             await cls._basic_help(io, coder)
             return format_command_result(io, "help", "Displayed basic help")
 
+        import traceback
         from uuid import uuid4 as generate_unique_id
 
         from cecli.coders.base_coder import Coder
+        from cecli.commands import SwitchCoderSignal
         from cecli.help import Help, install_help_extra
 
         # Get the Commands instance from kwargs if available
         commands_instance = kwargs.get("commands_instance")
 
-        if not commands_instance or not hasattr(commands_instance, "help"):
-            res = await install_help_extra(io)
-            if not res:
-                io.tool_error("Unable to initialize interactive help.")
-                return format_command_result(io, "help", "Unable to initialize interactive help")
-
-            if not commands_instance:
-                # Create a minimal Commands instance if not provided
-                from cecli.commands import Commands
-
-                commands_instance = Commands(io, coder)
-            commands_instance.help = Help(coder=coder)
-
-        help_instance = commands_instance.help
-
-        # Use the editor_model from the main_model if it exists, otherwise use the main_model itself
-        editor_model = coder.main_model.editor_model or coder.main_model
-
-        original_coder = coder
-
-        kwargs = dict()
-        kwargs["io"] = io
-        kwargs["uuid"] = str(generate_unique_id())
-        kwargs["from_coder"] = coder
-        kwargs["edit_format"] = "help"
-        kwargs["summarize_from_coder"] = False
-        kwargs["map_tokens"] = 512
-        kwargs["map_mul_no_files"] = 1
-        kwargs["main_model"] = editor_model
-        kwargs["args"] = coder.args
-        kwargs["suggest_shell_commands"] = False
-        kwargs["cache_prompts"] = False
-        kwargs["num_cache_warming_pings"] = 0
-
-        help_coder = await Coder.create(**kwargs)
-        user_msg = help_instance.ask(args)
-        user_msg += """
+        # The announcement lines read ``coder.args``, which is None when a coder
+        # is created without CLI args (e.g. in tests). Skip them in that case.
+        has_args = bool(getattr(coder, "args", None))
+
+        try:
+            if not commands_instance or not hasattr(commands_instance, "help"):
+                res = await install_help_extra(io)
+                if not res:
+                    io.tool_error("Unable to initialize interactive help.")
+                    await cls._basic_help(io, coder)
+                    return format_command_result(
+                        io, "help", "Unable to initialize interactive help"
+                    )
+
+                if not commands_instance:
+                    # Create a minimal Commands instance if not provided
+                    from cecli.commands import Commands
+
+                    commands_instance = Commands(io, coder)
+                commands_instance.help = Help(coder=coder)
+
+            help_instance = commands_instance.help
+
+            # Use the editor_model from the main_model if it exists, otherwise use the main_model itself
+            editor_model = coder.main_model.editor_model or coder.main_model
+
+            original_coder = coder
+
+            kwargs = dict()
+            kwargs["io"] = io
+            kwargs["uuid"] = str(generate_unique_id())
+            kwargs["from_coder"] = coder
+            kwargs["edit_format"] = "help"
+            kwargs["summarize_from_coder"] = False
+            kwargs["map_tokens"] = 512
+            kwargs["map_mul_no_files"] = 1
+            kwargs["main_model"] = editor_model
+            kwargs["args"] = coder.args
+            kwargs["suggest_shell_commands"] = False
+            kwargs["cache_prompts"] = False
+            kwargs["num_cache_warming_pings"] = 0
+
+            help_coder = await Coder.create(**kwargs)
+            user_msg = help_instance.ask(args)
+            user_msg += """
 # Announcement lines from when this session of cecli was launched:
 
 """
-        user_msg += "\n".join(coder.get_announcements()) + "\n"
+            user_msg += "\n".join(coder.get_announcements() if has_args else []) + "\n"
 
-        await help_coder.run(user_msg, preproc=False)
+            await help_coder.run(user_msg, preproc=False)
+        except Exception as err:
+            io.tool_error(f"Interactive help failed to initialize: {err}")
+            io.tool_error(traceback.format_exc())
+            await cls._basic_help(io, coder)
+            return format_command_result(
+                io, "help", f"Interactive help failed to initialize: {err}"
+            )
 
         if coder.repo_map:
             map_tokens = coder.repo_map.max_map_tokens
@@ -76,8 +93,6 @@ class HelpCommand(BaseCommand):
             map_tokens = 0
             map_mul_no_files = 1
 
-        from cecli.commands import SwitchCoderSignal
-
         raise SwitchCoderSignal(
             edit_format=coder.edit_format,
             summarize_from_coder=False,

cecli_dev-1.3.0/cecli/help.py

@@ -0,0 +1,163 @@
+import os
+import warnings
+from pathlib import Path
+
+import importlib_resources
+
+from cecli import __version__, utils
+from cecli.help_pats import exclude_website_pats
+
+warnings.simplefilter("ignore", category=FutureWarning)
+
+os.environ["TQDM_DISABLE"] = "1"
+os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = "1"
+os.environ["HF_DATASETS_DISABLE_PROGRESS_BARS"] = "1"
+os.environ["TOKENIZERS_PARALLELISM"] = "true"
+
+
+async def install_help_extra(io):
+    """Ensure the local chromadb backend is installed for interactive /help.
+
+    The previous dependency chain (``llama_index.embeddings.huggingface`` ->
+    ``sentence_transformers`` -> ``datasets``) crashed on the WSL2 + OpenSSL 3.5 +
+    Python 3.14 lazy-init flake and on a ``datasets`` circular import. Chroma's
+    default ONNX embedding needs neither, so it is what ``Help`` uses.
+    """
+    pip_install_cmd = [
+        "cecli-dev[help]",
+        "--extra-index-url",
+        "https://download.pytorch.org/whl/cpu",
+    ]
+    return await utils.check_pip_install_extra(
+        io,
+        "chromadb",
+        "To use interactive /help you need to install the help extras",
+        pip_install_cmd,
+    )
+
+
+def get_package_files():
+    docs = importlib_resources.files("cecli.website") / "docs"
+    for path in docs.rglob("*.md"):
+        yield path
+
+
+def fname_to_url(filepath):
+    """Map a file path in the website package to its published URL.
+
+    Doc sources live under ``website/docs/`` and docmd renders each ``<name>.md``
+    to ``<name>/index.html``, so ``docs/<path>/page.md`` becomes
+    ``https://cecli.dev/docs/<path>/page/``. Top-level site files (``index.html``)
+    publish to the site root. Everything else — build artifacts, ``_includes``
+    partials, okf sources — is not a published page and returns ``""``.
+    """
+    website = "website"
+    docs = "docs"
+    index = "index.md"
+    md = ".md"
+
+    filepath = filepath.replace("\\", "/")
+    parts = Path(filepath).parts
+
+    try:
+        website_index = [p.lower() for p in parts].index(website.lower())
+    except ValueError:
+        return ""
+
+    relevant_parts = parts[website_index + 1 :]
+    if not relevant_parts:
+        return ""
+
+    # Doc pages live under website/docs/ and publish to /docs/<path>/.
+    if relevant_parts[0].lower() == docs:
+        url_path = _strip_doc_suffix("/".join(relevant_parts[1:]), index, md)
+        return _format_docs_url(url_path)
+
+    # Only top-level site files publish to the site root; anything nested
+    # (_includes, _site, .docmd-*, share, etc.) is not a page.
+    if len(relevant_parts) == 1:
+        return f"https://cecli.dev/{relevant_parts[0].lstrip('/')}"
+
+    return ""
+
+
+def get_index(coder=None):
+    """Build a local chromadb vector index over the bundled help docs.
+
+    Chroma's default ONNX embedding needs no ``sentence_transformers`` or
+    ``datasets``, so it avoids the WSL2 + OpenSSL 3.5 + Python 3.14 lazy-init
+    flake and the ``datasets`` circular import that broke ``/help <question>``.
+    Returns the chromadb collection ready for text queries.
+    """
+    import chromadb
+    from chromadb.utils.embedding_functions import DefaultEmbeddingFunction
+
+    dname = Path.home() / ".cecli" / "caches" / ("help." + __version__)
+    dname.parent.mkdir(parents=True, exist_ok=True)
+
+    client = chromadb.PersistentClient(path=str(dname))
+    collection = client.get_or_create_collection(
+        "help", embedding_function=DefaultEmbeddingFunction()
+    )
+
+    if collection.count() == 0:
+        documents = []
+        ids = []
+        metadatas = []
+        for fname in get_package_files():
+            fname = Path(fname)
+            if any(fname.match(pat) for pat in exclude_website_pats):
+                continue
+            documents.append(fname.read_text(encoding="utf-8"))
+            ids.append(str(fname))
+            metadatas.append(dict(filename=fname.name, url=fname_to_url(str(fname))))
+
+        if documents:
+            collection.add(ids=ids, documents=documents, metadatas=metadatas)
+
+    return collection
+
+
+class Help:
+    """Vector retriever over the bundled help docs using a local chromadb store."""
+
+    def __init__(self, coder=None):
+        self.collection = get_index(coder=coder)
+
+    def ask(self, question):
+        results = self.collection.query(
+            query_texts=[question],
+            n_results=20,
+            include=["documents", "metadatas"],
+        )
+        documents = results.get("documents", [[]])[0]
+        metadatas = results.get("metadatas", [[]])[0]
+
+        context = f"# Question: {question}\n\n# Relevant docs:\n\n"
+        for doc, meta in zip(documents, metadatas):
+            url = (meta or {}).get("url", "")
+            if url:
+                url = f' from_url="{url}"'
+            context += f"<doc{url}>\n"
+            context += doc
+            context += "\n</doc>\n\n"
+        return context
+
+
+def _strip_doc_suffix(url_path, index, md):
+    if url_path.lower().endswith(index.lower()):
+        return url_path[: -len(index)]
+
+    if url_path.lower().endswith(md.lower()):
+        return url_path[: -len(md)]
+
+    return url_path
+
+
+def _format_docs_url(url_path):
+    url_path = url_path.strip("/")
+
+    if not url_path:
+        return "https://cecli.dev/docs/"
+
+    return f"https://cecli.dev/docs/{url_path}/"

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0}/cecli/helpers/agents/defaults/memorizer.md

@@ -21,7 +21,7 @@ agent-config:
     - directory_structure
     - environment_info
     - git_status
-    - symbol_outli",
+    - symbol_outline
     - todo_list
     - sub_agents
     - skills
@@ -76,4 +76,4 @@ Before this number hits at most 10, update what you can and yield. Do not delibe
 Important facts will be easy to search for and extract from the given context.
 
 Always prefer **concrete, reusable** facts over vague prose.
-Focus on extracting clear results and aids for navigating, modifying, and extending the project in the future.
+Focus on extracting aids for navigating, modifying, and extending the project in the future.

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0}/cecli/helpers/conversation/integration.py

@@ -1,5 +1,6 @@
 import json
 import random
+import time
 import weakref
 from typing import Any, Dict, List
 
@@ -959,13 +960,23 @@ class ConversationChunks:
         if not block:
             return
 
+        if not hasattr(coder, "_last_child_agent_hash") or not coder._last_child_agent_hash:
+            coder._last_child_agent_hash = ""
+
+        message_hash = xxhash.xxh3_128_hexdigest(block.encode("utf-8"))
+
+        if message_hash == coder._last_child_agent_hash:
+            return  # No change in sub-agent states, skip adding message
+
+        coder._last_child_agent_hash = message_hash
+
         ConversationService.get_manager(coder).add_message(
             message_dict={"role": "user", "content": block},
             tag=MessageTag.STATIC,
-            priority=DEFAULT_TAG_PRIORITY[MessageTag.REMINDER] + 25,  # After post_message blocks
-            mark_for_delete=0,
-            hash_key=("sub_agent_states",),
-            force=True,
+            priority=DEFAULT_TAG_PRIORITY[
+                MessageTag.CUR
+            ],  # Inject on change in normal message sequence
+            hash_key=("sub_agent_states", str(time.monotonic_ns())),
         )
 
     def defer_removal(self, file_path: str):