cecli-dev 1.0.3rc1__tar.gz → 1.0.4__tar.gz

{cecli_dev-1.0.3rc1 → cecli_dev-1.0.4}/.github/workflows/pages.yml

@@ -1,10 +1,5 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-
-# Sample workflow for building and deploying a Jekyll site to GitHub Pages
-name: Deploy Jekyll site to Pages
+# Workflow for building and deploying the docmd site to GitHub Pages
+name: Deploy site to Pages
 
 on:
   push:
@@ -40,21 +35,21 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - name: Setup Ruby
-        uses: ruby/setup-ruby@v1
+      - name: Setup Node
+        uses: actions/setup-node@v4
         with:
-          ruby-version: '3.3' # Not needed with a .ruby-version file
-          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
-          cache-version: 0 # Increment this number if you need to re-download cached gems
-          working-directory: '${{ github.workspace }}/cecli/website'
+          node-version: '20'
+          cache: npm
+          cache-dependency-path: 'cecli/website/package-lock.json'
       - name: Setup Pages
         id: pages
         uses: actions/configure-pages@v3
-      - name: Build with Jekyll
-        # Outputs to the './_site' directory by default
-        run: bundle exec jekyll build --baseurl "${{ steps.pages.outputs.base_path }}"
-        env:
-          JEKYLL_ENV: production
+      - name: Install dependencies
+        run: npm ci
+        working-directory: cecli/website
+      - name: Build site with docmd
+        run: bash ../../scripts/docmd_build.sh
+        working-directory: cecli/website
       - name: Upload artifact
         uses: actions/upload-pages-artifact@v3
         with:
@@ -71,7 +66,7 @@ jobs:
       - name: Deploy to GitHub Pages
         id: deployment
         uses: actions/deploy-pages@v4
-        
+
       - name: Set up Python 3.12
         uses: actions/setup-python@v5
         with:
@@ -84,4 +79,4 @@ jobs:
 
       - name: Run linkchecker
         run: |
-          linkchecker --ignore-url='.+\.(mp4|mov|avi)' https://cecli.dev
+          linkchecker --ignore-url='.+\\.(mp4|mov|avi)' https://cecli.dev

{cecli_dev-1.0.3rc1 → cecli_dev-1.0.4}/.gitignore

@@ -44,4 +44,7 @@ env/
 __pycache__/
 
 # Ignore Folders
-cecli/website/_site/*
+cecli/website/_site/*
+cecli/website/.sass-cache/*
+cecli/website/.docmd-*/*
+cecli/website/node_modules/*

{cecli_dev-1.0.3rc1 → cecli_dev-1.0.4}/CONTRIBUTING.md

@@ -23,7 +23,7 @@ ensure that your contributions can be integrated smoothly.
 
 ```bash
 # Clone the repository
-git clone https://github.com/dwash96/cecli.git
+git clone https://github.com/cecli-dev/cecli.git
 cd cecli
 
 # Make a venv
@@ -68,12 +68,12 @@ In order for your PR to be accepted it must:
 2. Comply with project coding standards (including running the pre-commit formatting hooks)
 3. Include test coverage
 4. Update relevant user-facing documentation:
-   - Primary documentation will live in `aider/website/docs/config/`
+   - Primary documentation will live in `cecli/website/docs/config/`
    - Check new cli arguments with the output of `/help` and `--help`
 
 ### Python Compatibility
 
-cecli supports Python versions 3.10, 3.11, 3.12, 3.13, and 3.14. When contributing code, ensure compatibility with these supported Python versions.
+Cecli supports Python versions 3.10, 3.11, 3.12, 3.13, and 3.14. When contributing code, ensure compatibility with these supported Python versions.
 
 ### Code Style
 
@@ -81,7 +81,7 @@ The project follows the [PEP 8](https://www.python.org/dev/peps/pep-0008/) style
 
 ### Testing
 
-The project uses [pytest](https://docs.pytest.org/en/latest/) for running unit tests. The test files are located in the `aider/tests` directory and follow the naming convention `test_*.py`.
+The project uses [pytest](https://docs.pytest.org/en/latest/) for running unit tests. The test files are located in the `tests` directory and follow the naming convention `test_*.py`.
 
 #### Running Tests
 
@@ -105,7 +105,7 @@ The project uses GitHub Actions for continuous integration. The testing workflow
 - `.github/workflows/ubuntu-tests.yml`: Runs tests on Ubuntu for Python versions 3.9 through 3.12.
 - `.github/workflows/windows-tests.yml`: Runs that on Windows
 
-These workflows are triggered on push and pull request events to the `main` branch, ignoring changes to the `aider/website/**` and `README.md` files.
+These workflows are triggered on push and pull request events to the `main` branch, ignoring changes to the `cecli/website/**` and `README.md` files.
 
 #### Docker Build and Test
 
@@ -113,9 +113,9 @@ The `.github/workflows/docker-build-test.yml` workflow is used to build a Docker
 
 #### Writing Tests
 
-When contributing new features or making changes to existing code, ensure that you write appropriate tests to maintain code coverage. Follow the existing patterns and naming conventions used in the `aider/tests` directory.
+When contributing new features or making changes to existing code, ensure that you write appropriate tests to maintain code coverage. Follow the existing patterns and naming conventions used in the `tests` directory.
 
-If you need to mock or create test data, consider adding it to the test files or creating separate fixtures or utility functions within the `aider/tests` directory.
+If you need to mock or create test data, consider adding it to the test files or creating separate fixtures or utility functions within the `tests` directory.
 
 #### Test Requirements
 
@@ -142,21 +142,27 @@ You can also pass one argument to `pip-compile.sh`, which will flow through to `
 
 ### Building the Documentation
 
-The project's documentation is built using Jekyll and hosted on GitHub Pages. To build the documentation locally, follow these steps:
+The project's documentation is built with [docmd](https://docmd.io) and hosted on GitHub Pages. To build the documentation locally, follow these steps:
 
-1. Install Ruby and Bundler (if not already installed).
-2. Navigate to the `aider/website` directory.
-3. Install the required gems:
+1. Install Node.js 18 or newer (the build uses `npx`).
+2. Navigate to the `cecli/website` directory.
+3. Install the required npm dependencies:
    ```
-   bundle install
+   npm install
    ```
 4. Build the documentation:
    ```
-   bundle exec jekyll build
+   npm run build
+   ```
+   Or run the full site build (homepage + docs + assets) with:
+   ```
+   bash ../../scripts/docmd_build.sh
    ```
 5. Preview the website while editing (optional):
    ```
-   bundle exec jekyll serve
+   npm run dev
    ```
 
+Built documentation is written to `cecli/website/_site` by `scripts/docmd_build.sh` (docs land in `_site/docs`, the homepage in `_site/index.html`).
+
 The built documentation will be available in the `cecli/website/_site` directory.

{cecli_dev-1.0.3rc1 → cecli_dev-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.0.3rc1
+Version: 1.0.4
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.0.3rc1 → cecli_dev-1.0.4}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.3rc1'
-__version_tuple__ = version_tuple = (1, 0, 3, 'rc1')
+__version__ = version = '1.0.4'
+__version_tuple__ = version_tuple = (1, 0, 4)
 
-__commit_id__ = commit_id = 'gdbb496122'
+__commit_id__ = commit_id = 'g906b4a888'

{cecli_dev-1.0.3rc1 → cecli_dev-1.0.4}/cecli/coders/agent_coder.py

@@ -12,6 +12,8 @@ from collections import defaultdict
 from datetime import datetime
 from pathlib import Path
 
+import xxhash
+
 from cecli.args import AGENT_CONFIG_LIST_FIELDS
 from cecli.change_tracker import ChangeTracker
 from cecli.helpers import nested, responses
@@ -631,6 +633,8 @@ class AgentCoder(Coder):
         ConversationService.get_chunks(self).add_readonly_files_messages()
         ConversationService.get_chunks(self).add_chat_files_messages()
 
+        ConversationService.get_manager(self).flush_queue()
+
         # Add post-message context blocks (priority 250 - between CUR and REMINDER)
         ConversationService.get_chunks(self).add_post_message_context_blocks()
 
@@ -920,20 +924,20 @@ class AgentCoder(Coder):
                     "# Fix the linting errors below, and then continue with your task.",
                     1,
                 )
+                lint_hash = xxhash.xxh3_128_hexdigest(lint_errors.encode("utf-8", errors="replace"))
                 ConversationService.get_manager(self).add_message(
                     message_dict=dict(role="user", content=lint_errors),
                     tag=MessageTag.LINT,
-                    hash_key=("lint_errors", "agent", lint_errors),
+                    hash_key=("lint_errors", "agent", lint_hash),
                 )
-                ConversationService.get_manager(self).add_message(
+                ConversationService.get_manager(self).queue_message(
                     message_dict=dict(
                         role="user", content="Please address the latest linting errors."
                     ),
                     tag=MessageTag.LINT,
-                    hash_key=("lint_errors", "agent", lint_errors, "cta"),
+                    hash_key=("lint_errors", "agent", lint_hash, "cta"),
                     promotion=ConversationService.get_manager(self).DEFAULT_TAG_PROMOTION_VALUE,
                     mark_for_demotion=1,
-                    mark_for_delete=0,
                 )
             else:
                 if has_errors:
@@ -1351,7 +1355,7 @@ class AgentCoder(Coder):
             )
 
         if repetition_warning:
-            ConversationService.get_manager(self).add_message(
+            ConversationService.get_manager(self).queue_message(
                 message_dict=dict(role="user", content=repetition_warning),
                 tag=MessageTag.CUR,
                 hash_key=("repetition", "agent"),

{cecli_dev-1.0.3rc1 → cecli_dev-1.0.4}/cecli/coders/base_coder.py

@@ -19,6 +19,8 @@ import weakref
 from collections import defaultdict
 from datetime import date, datetime
 
+import xxhash
+
 # Optional dependency: used to convert locale codes (eg ``en_US``)
 # into human-readable language names (eg ``English``).
 try:
@@ -40,6 +42,7 @@ from cecli.helpers import command_parser, coroutines, nested, responses
 from cecli.helpers.conversation import ConversationService, MessageTag
 from cecli.helpers.file_system import FileSystemService
 from cecli.helpers.io_proxy import IOProxy
+from cecli.helpers.memory_control import trim_memory
 from cecli.helpers.observations.service import ObservationService
 from cecli.helpers.profiler import TokenProfiler
 from cecli.helpers.threading import ThreadSafeEvent
@@ -317,6 +320,7 @@ class Coder(metaclass=UsageMeta):
                 mcp_manager=from_coder.mcp_manager,
                 registered_tools=copy.deepcopy(from_coder.registered_tools),
                 registered_servers=copy.deepcopy(from_coder.registered_servers),
+                auto_memory=from_coder.auto_memory,
                 uuid=from_coder.uuid,
                 parent_uuid=from_coder.parent_uuid,
                 repo=from_coder.repo,
@@ -464,9 +468,13 @@ class Coder(metaclass=UsageMeta):
         self.abs_root_path_cache = {}
 
         self.auto_copy_context = auto_copy_context
-        self.security_config = security_config or {}
         self.auto_accept_architect = auto_accept_architect
 
+        try:
+            self.security_config = json.loads(security_config)
+        except (json.JSONDecodeError, TypeError):
+            self.security_config = {}
+
         self.ignore_mentions = ignore_mentions
         if not self.ignore_mentions:
             self.ignore_mentions = set()
@@ -1793,6 +1801,8 @@ class Coder(metaclass=UsageMeta):
             self.run_one_completed = True
             self.compact_context_completed = True
             self.io.stop_spinner()
+            # Trim memory in the background so it doesn't stall the event loop
+            coroutines.fire_and_forget(asyncio.to_thread(trim_memory))
 
     def copy_context(self):
         if self.auto_copy_context:
@@ -1876,6 +1886,8 @@ class Coder(metaclass=UsageMeta):
             ConversationService.get_chunks(self).flush_removals()
             self.last_user_message = user_message
             self.error_code = None
+            # Trim memory in the background so it doesn't delay the response
+            coroutines.fire_and_forget(asyncio.to_thread(trim_memory))
             # Fire memorizer after each user request
             # if self.auto_memory and self.edit_format not in ["subagent"]:
             #    from cecli.helpers.memory.utils import invoke_memorizer
@@ -2435,6 +2447,8 @@ class Coder(metaclass=UsageMeta):
         # Add chat and edit file messages
         ConversationService.get_chunks(self).add_chat_files_messages()
 
+        ConversationService.get_manager(self).flush_queue()
+
         # Return formatted messages for LLM
         return ConversationService.get_manager(self).get_messages_dict()
 
@@ -2563,12 +2577,14 @@ class Coder(metaclass=UsageMeta):
             self.format_chat_chunks()
 
             # Always add user message to conversation manager
-            ConversationService.get_manager(self).add_message(
+            ConversationService.get_manager(self).queue_message(
                 message_dict=dict(role="user", content=inp),
                 tag=MessageTag.CUR,
-                hash_key=("user_message", inp, str(time.monotonic_ns())),
-                promotion=ConversationService.get_manager(self).DEFAULT_TAG_PROMOTION_VALUE,
-                mark_for_demotion=1,
+                hash_key=(
+                    "user_message",
+                    xxhash.xxh3_128_hexdigest(inp.encode("utf-8", errors="replace")),
+                    str(time.monotonic_ns()),
+                ),
             )
 
         ConversationService.get_manager(self).decrement_message_markers()
@@ -2761,6 +2777,7 @@ class Coder(metaclass=UsageMeta):
 
             await self.show_exhausted_error()
             self.num_exhausted_context_windows += 1
+            self._release_response_buffers()
             return
         if self.partial_response_function_call:
             args = self.parse_partial_args()
@@ -2794,6 +2811,9 @@ class Coder(metaclass=UsageMeta):
                 mark_for_demotion=1,
             )
 
+            # The reply was interrupted mid-stream; drop the partial chunk buffers
+            # rather than holding them until the next send().
+            self._release_response_buffers()
             return
 
         edited = await self.apply_updates()
@@ -2879,6 +2899,11 @@ class Coder(metaclass=UsageMeta):
                     self.reflected_message = test_errors
                     return
 
+        # Turn complete: drop the per-turn LLM stream buffers.  They are reset at
+        # the start of the next send(), so holding on to them while idle only
+        # wastes memory (chunks can be large for long streaming responses).
+        self._release_response_buffers()
+
     def _extract_and_prepare_tool_calls(self, tool_call_response):
         """
         Unified extraction and preparation of tool calls.
@@ -3397,6 +3422,16 @@ class Coder(metaclass=UsageMeta):
         """Cleanup when the Coder object is destroyed."""
         self.ok_to_warm_cache = False
 
+    def _release_response_buffers(self):
+        """Drop per-turn LLM stream data now that the turn has completed.
+
+        `partial_response_content` is intentionally kept: subclasses and callers
+        (get_edits, reply_completed, run_stream, ...) read it after the turn.
+        """
+        self.partial_response_chunks = []
+        self.partial_response_consolidated = None
+        self.partial_response_reasoning_content = ""
+
     async def add_assistant_reply_to_cur_messages(self):
         """
         Add the assistant's reply to `cur_messages`.
@@ -3443,10 +3478,17 @@ class Coder(metaclass=UsageMeta):
                 self.io.tool_warning("Execution stopped by end message hook")
                 return
 
+            if self.edit_format in ("agent", "subagent"):
+                msg.pop("function_call", None)
+
             ConversationService.get_manager(self).add_message(
                 message_dict=msg,
                 tag=MessageTag.CUR,
-                hash_key=("assistant_message", str(msg), str(time.monotonic_ns())),
+                hash_key=(
+                    "assistant_message",
+                    xxhash.xxh3_128_hexdigest(str(msg).encode("utf-8", errors="replace")),
+                    str(time.monotonic_ns()),
+                ),
                 # promotion=ConversationService.get_manager(self).DEFAULT_TAG_PROMOTION_VALUE,
                 # mark_for_demotion=1,
             )

{cecli_dev-1.0.3rc1 → cecli_dev-1.0.4}/cecli/commands/__init__.py

@@ -13,6 +13,7 @@ from .agent_model import AgentModelCommand
 from .agent_tree import AgentTreeCommand
 from .architect import ArchitectCommand
 from .ask import AskCommand
+from .auto_memory import AutoMemoryCommand
 from .clear import ClearCommand
 from .code import CodeCommand
 from .command_prefix import CommandPrefixCommand
@@ -61,6 +62,7 @@ from .reap_agent import ReapAgentCommand
 from .reasoning_effort import ReasoningEffortCommand
 from .remove_hook import RemoveHookCommand
 from .remove_mcp import RemoveMcpCommand
+from .remove_memory import RemoveMemoryCommand
 from .remove_skill import RemoveSkillCommand
 from .report import ReportCommand
 from .reset import ResetCommand
@@ -68,6 +70,7 @@ from .rules import RulesCommand
 from .run import RunCommand
 from .save import SaveCommand
 from .save_session import SaveSessionCommand
+from .search_memory import SearchMemoryCommand
 from .settings import SettingsCommand
 from .spawn_agent import SpawnAgentCommand
 from .switch_agent import SwitchAgentCommand
@@ -100,6 +103,7 @@ CommandRegistry.register(AgentModelCommand)
 CommandRegistry.register(AgentTreeCommand)
 CommandRegistry.register(ArchitectCommand)
 CommandRegistry.register(AskCommand)
+CommandRegistry.register(AutoMemoryCommand)
 CommandRegistry.register(ClearCommand)
 CommandRegistry.register(CodeCommand)
 CommandRegistry.register(CommandPrefixCommand)
@@ -150,6 +154,7 @@ CommandRegistry.register(ReadOnlyStubCommand)
 CommandRegistry.register(ReasoningEffortCommand)
 CommandRegistry.register(RemoveHookCommand)
 CommandRegistry.register(RemoveMcpCommand)
+CommandRegistry.register(RemoveMemoryCommand)
 CommandRegistry.register(RemoveSkillCommand)
 CommandRegistry.register(ReportCommand)
 CommandRegistry.register(ResetCommand)
@@ -157,6 +162,7 @@ CommandRegistry.register(RulesCommand)
 CommandRegistry.register(RunCommand)
 CommandRegistry.register(SaveCommand)
 CommandRegistry.register(SaveSessionCommand)
+CommandRegistry.register(SearchMemoryCommand)
 CommandRegistry.register(SettingsCommand)
 CommandRegistry.register(TerminalSetupCommand)
 CommandRegistry.register(TestCommand)
@@ -176,6 +182,7 @@ __all__ = [
     "AgentTreeCommand",
     "ArchitectCommand",
     "AskCommand",
+    "AutoMemoryCommand",
     "BaseCommand",
     "ClearCommand",
     "CodeCommand",
@@ -237,6 +244,7 @@ __all__ = [
     "ReloadProgramSignal",
     "RemoveHookCommand",
     "RemoveMcpCommand",
+    "RemoveMemoryCommand",
     "RemoveSkillCommand",
     "ReportCommand",
     "ResetCommand",
@@ -244,6 +252,7 @@ __all__ = [
     "RunCommand",
     "SaveCommand",
     "SaveSessionCommand",
+    "SearchMemoryCommand",
     "SettingsCommand",
     "SwitchCoderSignal",
     "TerminalSetupCommand",

cecli_dev-1.0.4/cecli/commands/auto_memory.py

@@ -0,0 +1,117 @@
+"""Auto-memory command - view or toggle automatic memorizer invocation.
+
+Controls the ``coder.auto_memory`` flag, which decides whether the
+memorizer sub-agent is fired automatically after context compaction.
+``on``/``off`` propagate the setting to every tracked sub-agent so the
+whole agent tree stays consistent.
+"""
+
+from typing import List
+
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+from cecli.helpers.agents.service import AgentService
+
+
+class AutoMemoryCommand(BaseCommand):
+    NORM_NAME = "auto-memory"
+    DESCRIPTION = "View or toggle automatic memory (memorizer) on/off"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """View or toggle automatic memory on/off.
+
+        Syntax:
+            /auto-memory           — Show the current status
+            /auto-memory on        — Enable for this coder and all sub-agents
+            /auto-memory off       — Disable for this coder and all sub-agents
+        """
+        arg = args.strip().lower()
+
+        if not arg:
+            cls._show_status(io, coder)
+
+            return format_command_result(io, cls.NORM_NAME, "Displayed auto-memory status")
+
+        if arg not in ("on", "off"):
+            io.tool_error("Usage: /auto-memory [on|off]")
+
+            return format_command_result(
+                io,
+                cls.NORM_NAME,
+                "Unknown option",
+                f"Expected 'on' or 'off', got '{arg}'",
+            )
+
+        enabled = arg == "on"
+        updated = cls._set_auto_memory(coder, enabled)
+        state = "ON" if enabled else "OFF"
+
+        io.tool_output(
+            f"Auto memory is now {state} for the current coder and {len(updated)} sub-agent(s)."
+        )
+
+        return format_command_result(io, cls.NORM_NAME, f"Auto memory set to {state}")
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Return completion options for auto-memory."""
+        return ["on", "off"]
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the auto-memory command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /auto-memory              # Show the current status\n"
+        help_text += "  /auto-memory on           # Enable automatic memory for all agents\n"
+        help_text += "  /auto-memory off          # Disable automatic memory for all agents\n"
+        help_text += "\nWith 'on' or 'off' the setting is applied to the current coder and\n"
+        help_text += "iterated through every sub-agent so the whole tree stays consistent.\n"
+
+        return help_text
+
+    @classmethod
+    def _show_status(cls, io, coder) -> None:
+        """Print the current auto-memory status for the coder and its sub-agents."""
+        state = "ON" if getattr(coder, "auto_memory", True) else "OFF"
+        io.tool_output(f"Auto memory is {state} for the current coder.")
+
+        sub_infos = cls._get_sub_agent_infos(coder)
+
+        if not sub_infos:
+            return
+
+        io.tool_output(f"Sub-agents ({len(sub_infos)}):")
+
+        for info in sub_infos:
+            sub_state = "ON" if getattr(info.coder, "auto_memory", True) else "OFF"
+            io.tool_output(f"  {info.name} ({info.coder.uuid}): {sub_state}")
+
+    @classmethod
+    def _set_auto_memory(cls, coder, enabled: bool) -> list:
+        """Set auto_memory on *coder* and every tracked sub-agent coder.
+
+        Returns the list of sub-agent info objects whose coder was updated.
+        """
+        coder.auto_memory = enabled
+        updated = []
+
+        for info in cls._get_sub_agent_infos(coder):
+            try:
+                info.coder.auto_memory = enabled
+                updated.append(info)
+            except Exception:
+                continue
+
+        return updated
+
+    @classmethod
+    def _get_sub_agent_infos(cls, coder) -> list:
+        """Return all sub-agent info objects tracked by the coder's AgentService."""
+        try:
+            agent_service = AgentService.get_instance(coder)
+
+            return list(agent_service.sub_agents.values())
+        except Exception:
+            return []

{cecli_dev-1.0.3rc1 → cecli_dev-1.0.4}/cecli/commands/code.py

@@ -16,7 +16,7 @@ class CodeCommand(BaseCommand):
             edit_format = coder.main_model.edit_format
         else:
             # Default to a reasonable edit format if main_model is not available
-            edit_format = "wholefile"
+            edit_format = "whole"
         return await cls._generic_chat_command(io, coder, args, edit_format)
 
     @classmethod

{cecli_dev-1.0.3rc1 → cecli_dev-1.0.4}/cecli/commands/copy.py

@@ -15,7 +15,9 @@ class CopyCommand(BaseCommand):
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
         # Get all messages from ConversationManager
-        all_messages = ConversationService.get_manager(coder).get_messages_dict()
+        manager = ConversationService.get_manager(coder)
+        manager.flush_queue()
+        all_messages = manager.get_messages_dict()
         assistant_messages = [msg for msg in reversed(all_messages) if msg["role"] == "assistant"]
 
         if not assistant_messages:

{cecli_dev-1.0.3rc1 → cecli_dev-1.0.4}/cecli/commands/copy_context.py

@@ -16,6 +16,7 @@ class CopyContextCommand(BaseCommand):
     async def execute(cls, io, coder, args, **kwargs):
         """Execute the copy-context command with given parameters."""
         manager = ConversationService.get_manager(coder)
+        manager.flush_queue()
 
         markdown = ""
 

{cecli_dev-1.0.3rc1 → cecli_dev-1.0.4}/cecli/commands/help.py

@@ -17,6 +17,8 @@ class HelpCommand(BaseCommand):
             await cls._basic_help(io, coder)
             return format_command_result(io, "help", "Displayed basic help")
 
+        from uuid import uuid4 as generate_unique_id
+
         from cecli.coders.base_coder import Coder
         from cecli.help import Help, install_help_extra
 
@@ -34,15 +36,18 @@ class HelpCommand(BaseCommand):
                 from cecli.commands import Commands
 
                 commands_instance = Commands(io, coder)
-            commands_instance.help = Help()
+            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
@@ -76,7 +81,7 @@ class HelpCommand(BaseCommand):
         raise SwitchCoderSignal(
             edit_format=coder.edit_format,
             summarize_from_coder=False,
-            from_coder=help_coder,
+            from_coder=original_coder,
             map_tokens=map_tokens,
             map_mul_no_files=map_mul_no_files,
             show_announcements=False,