cecli-dev 0.99.1__tar.gz → 0.99.3__tar.gz

{cecli_dev-0.99.1 → cecli_dev-0.99.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.99.1
+Version: 0.99.3
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -52,6 +52,7 @@ Requires-Dist: textual>=6.0.0
 Requires-Dist: tomlkit>=0.14.0
 Requires-Dist: truststore
 Requires-Dist: xxhash>=3.6.0
+Requires-Dist: py-cymbal>=0.1.5
 Requires-Dist: rustworkx>=0.15.0
 Requires-Dist: scipy>=1.15.3
 Requires-Dist: importlib-metadata>=7.2.1

{cecli_dev-0.99.1 → cecli_dev-0.99.3}/cecli/__init__.py

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

{cecli_dev-0.99.1 → cecli_dev-0.99.3}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.99.1'
-__version_tuple__ = version_tuple = (0, 99, 1)
+__version__ = version = '0.99.3'
+__version_tuple__ = version_tuple = (0, 99, 3)
 
-__commit_id__ = commit_id = 'g587390916'
+__commit_id__ = commit_id = 'g2909d229a'

{cecli_dev-0.99.1 → cecli_dev-0.99.3}/cecli/args.py

@@ -593,6 +593,12 @@ def get_parser(default_config_files, git_root):
         help="Show token processing and generation speed in usage report (default: False)",
         default=False,
     )
+    group.add_argument(
+        "--use-reminders",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Enable/disable injecting reminder messages (default: True)",
+    )
     group.add_argument(
         "--completion-menu-color",
         metavar="COLOR",

{cecli_dev-0.99.1 → cecli_dev-0.99.3}/cecli/coders/agent_coder.py

@@ -25,6 +25,7 @@ from cecli.helpers.skills import SkillsManager
 from cecli.hooks import HookIntegration
 from cecli.llm import litellm
 from cecli.mcp import LocalServer, McpServerManager
+from cecli.tools.utils.base_tool import BaseTool
 from cecli.tools.utils.registry import ToolRegistry
 from cecli.utils import copy_tool_call, tool_call_to_dict
 
@@ -52,12 +53,9 @@ class AgentCoder(Coder):
         self.read_tools = {
             "command",
             "commandinteractive",
-            "viewfilesatglob",
-            "viewfilesmatching",
+            "exploresymbols",
             "ls",
-            "viewfileswithsymbol",
             "grep",
-            "listchanges",
             "showcontext",
             "thinking",
             "updatetodolist",
@@ -95,7 +93,7 @@ class AgentCoder(Coder):
         super().__init__(*args, **kwargs)
 
     def _setup_agent(self):
-        os.makedirs(".cecli/workspace", exist_ok=True)
+        os.makedirs(".cecli/temp", exist_ok=True)
 
     def _get_agent_config(self):
         """
@@ -328,7 +326,7 @@ class AgentCoder(Coder):
                 {"role": "tool", "tool_call_id": tool_call.id, "content": result_message}
             )
 
-        if self.auto_lint and used_write_tool and not self.edit_allowed:
+        if self.auto_lint and used_write_tool:
             edited = list(self.files_edited_by_tools)
             lint_errors = self.lint_edited(edited, show_output=False)
             self.lint_outcome = not lint_errors
@@ -1020,7 +1018,7 @@ I will proceed based on the tool results and updated context.""")
                 self.model_kwargs = {
                     "temperature": default_temp + 0.1,
                     "frequency_penalty": default_fp + 0.2,
-                    "presence_penalty": 0.1,
+                    # "presence_penalty": 0.1,
                 }
             else:
                 temperature = nested.getter(self.model_kwargs, "temperature", default_temp)
@@ -1160,7 +1158,7 @@ I will proceed based on the tool results and updated context.""")
 
         Parameters:
         - file_path: Path to the file to add
-        - explicit: Whether this was an explicit view command (vs. implicit through ViewFilesMatching)
+        - explicit: Whether this was an explicit view command (vs. implicit through other tools)
         """
         abs_path = self.abs_root_path(file_path)
         rel_path = self.get_rel_fname(abs_path)
@@ -1205,7 +1203,7 @@ I will proceed based on the tool results and updated context.""")
 
         Override parent's method to disable implicit file mention handling in agent mode.
         Files should only be added via explicit tool commands
-        (`View`, `ViewFilesAtGlob`, `ViewFilesMatching`, `ViewFilesWithSymbol`).
+        (`ContextManager`).
         """
         pass
 
@@ -1217,6 +1215,7 @@ I will proceed based on the tool results and updated context.""")
         inp = await super().preproc_user_input(inp)
         inp = self.wrap_user_input(inp)
 
+        BaseTool.clear_invocation_cache()
         self.agent_finished = False
         self.turn_count = 0
         return inp

{cecli_dev-0.99.1 → cecli_dev-0.99.3}/cecli/coders/base_coder.py

@@ -42,6 +42,7 @@ from cecli.commands import Commands, SwitchCoderSignal
 from cecli.exceptions import LiteLLMExceptions
 from cecli.helpers import command_parser, coroutines, nested, responses
 from cecli.helpers.conversation import ConversationService, MessageTag
+from cecli.helpers.observations.manager import ObservationManager
 from cecli.helpers.profiler import TokenProfiler
 from cecli.history import ChatSummary
 from cecli.hooks import HookIntegration
@@ -229,6 +230,7 @@ class Coder:
                 file_watcher=from_coder.file_watcher,
                 mcp_manager=from_coder.mcp_manager,
                 uuid=from_coder.uuid,
+                repo=from_coder.repo,
             )
             use_kwargs.update(update)  # override to complete the switch
             use_kwargs.update(kwargs)  # override passed kwargs
@@ -328,6 +330,7 @@ class Coder:
         uuid="",
     ):
         # initialize from args.map_cache_dir
+        self.interrupt_event = asyncio.Event()
         self.uuid = generate_unique_id()
         if uuid:
             self.uuid = uuid
@@ -439,6 +442,7 @@ class Coder:
 
         # Initialize conversation system if enabled
         ConversationService.get_chunks(self).initialize_conversation_system()
+        self.observation_manager = ObservationManager.get_instance(self)
 
         self.commands = commands or Commands(self.io, self, args=args)
         self.commands.coder = self
@@ -919,10 +923,10 @@ class Coder:
                             file_stub = RepoMap.get_file_stub(fname, self.io)
 
                             # Add message about showing definitions instead of full content
-                            self.io.tool_output(
-                                f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
-                                "Use /context-management to toggle truncation off if needed."
-                            )
+                            # self.io.tool_output(
+                            #    f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
+                            #    "Use /context-management to toggle truncation off if needed."
+                            # )
 
                             # Add a message in the content itself so the model knows it's truncated
                             truncation_note = (
@@ -987,10 +991,10 @@ class Coder:
                         file_stub = RepoMap.get_file_stub(fname, self.io)
 
                         # Add message about showing definitions instead of full content
-                        self.io.tool_output(
-                            f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
-                            "Use /context-management to toggle truncation off if needed."
-                        )
+                        # self.io.tool_output(
+                        #    f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
+                        #    "Use /context-management to toggle truncation off if needed."
+                        # )
 
                         # Add a message in the content itself so the model knows it's truncated
                         truncation_note = (
@@ -1735,6 +1739,7 @@ class Coder:
 
         self.io.tool_warning("\n\n^C KeyboardInterrupt")
 
+        self.interrupt_event.set()
         self.last_keyboard_interrupt = time.time()
 
     # Old summarization system removed - using context compaction logic instead
@@ -1743,11 +1748,14 @@ class Coder:
         if not self.enable_context_compaction:
             return
 
-        # Check if combined messages exceed the token limit,
-        # Get messages from ConversationManager
-        done_messages = ConversationService.get_manager(self).get_messages_dict(MessageTag.DONE)
-        cur_messages = ConversationService.get_manager(self).get_messages_dict(MessageTag.CUR)
-        diff_messages = ConversationService.get_manager(self).get_messages_dict(MessageTag.DIFFS)
+        # Trigger background observation/reflection check
+        await self.observation_manager.check_and_trigger()
+
+        manager = ConversationService.get_manager(self)
+        done_messages = manager.get_messages_dict(MessageTag.DONE)
+        cur_messages = manager.get_messages_dict(MessageTag.CUR)
+        diff_messages = manager.get_messages_dict(MessageTag.DIFFS)
+
         # Exclude first cur_message since that's the user's initial input
         done_tokens = self.summarizer.count_tokens(done_messages)
         cur_tokens = self.summarizer.count_tokens(cur_messages[1:] if len(cur_messages) > 1 else [])
@@ -1765,129 +1773,97 @@ class Coder:
         self.io.update_spinner("Compacting...")
 
         try:
-            # Check if done_messages alone exceed the limit
-            if done_tokens > self.context_compaction_max_tokens or done_tokens > cur_tokens:
-                # Create a summary of the done_messages
-                # Append custom message to compaction prompt if provided
-                compaction_prompt = self.gpt_prompts.compaction_prompt
-                if message:
-                    compaction_prompt = f"{compaction_prompt}\n\n{message}"
-
-                summary_text = await self.summarizer.summarize_all_as_text(
-                    done_messages,
+            compaction_prompt = self.gpt_prompts.compaction_prompt
+            if message:
+                compaction_prompt = f"{compaction_prompt}\n\n{message}"
+
+            async def summarize_and_update(messages, tag):
+                text = await self.summarizer.summarize_all_as_text(
+                    messages,
                     compaction_prompt,
                     self.context_compaction_summary_tokens,
                 )
+                if not text:
+                    raise ValueError(f"Summarization of {tag} messages returned empty.")
 
-                if not summary_text:
-                    raise ValueError("Summarization returned an empty result.")
-
-                # Replace old DONE messages with the summary in ConversationManager
-                ConversationService.get_manager(self).clear_tag(MessageTag.DONE)
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "user",
-                        "content": summary_text,
-                    },
-                    tag=MessageTag.DONE,
-                )
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "assistant",
-                        "content": (
-                            "Ok, I will use this summary as the context for our conversation going"
-                            " forward."
-                        ),
-                    },
-                    tag=MessageTag.DONE,
-                )
+                if self.observation_manager.observations:
+                    obs_text = "\n".join(self.observation_manager.observations)
+                    text = f"HISTORICAL OBSERVATIONS:\n{obs_text}\n\n{text}"
 
-            # Check if cur_messages alone exceed the limit (after potentially compacting done_messages)
-            if cur_tokens > self.context_compaction_max_tokens or cur_tokens > done_tokens:
-                # Create a summary of the cur_messages
-                # Append custom message to compaction prompt if provided
-                compaction_prompt = self.gpt_prompts.compaction_prompt
-                if message:
-                    compaction_prompt = f"{compaction_prompt}\n\n{message}"
-
-                cur_summary_text = await self.summarizer.summarize_all_as_text(
-                    cur_messages,
-                    compaction_prompt,
-                    self.context_compaction_summary_tokens,
-                )
+                manager.clear_tag(tag)
 
-                if not cur_summary_text:
-                    raise ValueError("Summarization of current messages returned an empty result.")
+                if tag == MessageTag.DONE:
+                    manager.add_message({"role": "user", "content": text}, tag=tag)
+                    manager.add_message(
+                        {
+                            "role": "assistant",
+                            "content": (
+                                "Ok, I will use this summary and the observations as context for"
+                                " our conversation going forward."
+                            ),
+                        },
+                        tag=tag,
+                    )
+                else:
+                    if self.last_user_message:
+                        manager.add_message(
+                            {"role": "user", "content": self.last_user_message}, tag=tag
+                        )
 
-                # Replace current CUR messages with the summary in ConversationManager
-                ConversationService.get_manager(self).clear_tag(MessageTag.CUR)
+                    manager.add_message(
+                        {
+                            "role": "assistant",
+                            "content": "Ok. I am awaiting your summary of our goals to proceed.",
+                        },
+                        tag=tag,
+                        force=True,
+                    )
 
-                if self.last_user_message:
-                    ConversationService.get_manager(self).add_message(
-                        message_dict={
+                    manager.add_message(
+                        {
                             "role": "user",
-                            "content": self.last_user_message,
+                            "content": (
+                                "Here is a summary of our current goals and historical"
+                                f" context:\n{text}"
+                            ),
                         },
-                        tag=MessageTag.CUR,
+                        tag=tag,
                     )
 
-                # Add the summary conversation
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "assistant",
-                        "content": "Ok. I am awaiting your summary of our goals to proceed.",
-                    },
-                    tag=MessageTag.CUR,
-                    force=True,
-                )
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "user",
-                        "content": f"Here is a summary of our current goals:\n{cur_summary_text}",
-                    },
-                    tag=MessageTag.CUR,
-                )
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "assistant",
-                        "content": (
-                            "Ok, I will use this summary and proceed with our task."
-                            " I will first apply any changes in the summary and then"
-                            " continue exploration as necessary."
-                        ),
-                    },
-                    tag=MessageTag.CUR,
-                    force=True,
-                )
-
-                # Find the last assistant messages in the current conversation
-                latest_messages = []
+                    manager.add_message(
+                        {
+                            "role": "assistant",
+                            "content": (
+                                "Ok, I will use this summary and proceed with our task. I will"
+                                " first apply any changes in the summary and then continue"
+                                " exploration as necessary."
+                            ),
+                        },
+                        tag=tag,
+                        force=True,
+                    )
 
-                # Search from the end to find the most recent assistant messages
-                for msg in reversed(cur_messages):
-                    latest_messages.append(msg)
+                    latest_messages = []
+                    for msg in reversed(messages):
+                        latest_messages.append(msg)
+                        if msg["role"] == "assistant":
+                            break
+                    for msg in reversed(latest_messages):
+                        manager.add_message(msg, tag=tag)
 
-                    if msg["role"] == "assistant":
-                        break
+            if done_tokens > self.context_compaction_max_tokens or done_tokens > cur_tokens:
+                await summarize_and_update(done_messages, MessageTag.DONE)
 
-                for msg in reversed(latest_messages):
-                    ConversationService.get_manager(self).add_message(
-                        message_dict={
-                            "role": msg["role"],
-                            "content": msg["content"],
-                        },
-                        tag=MessageTag.CUR,
-                    )
+            if cur_tokens > self.context_compaction_max_tokens or cur_tokens > done_tokens:
+                await summarize_and_update(cur_messages, MessageTag.CUR)
 
             self.io.tool_output("...chat history compacted.")
             self.io.update_spinner(self.io.last_spinner_text)
 
-            # Clear all diff and file context messages
-            ConversationService.get_manager(self).clear_tag(MessageTag.DIFFS)
-            ConversationService.get_manager(self).clear_tag(MessageTag.FILE_CONTEXTS)
-
-            # Reset ConversationFiles cache entirely
+            manager.clear_tag(MessageTag.DIFFS)
+            manager.clear_tag(MessageTag.FILE_CONTEXTS)
             ConversationService.get_files(self).clear_file_cache()
+
         except Exception as e:
             self.io.tool_warning(f"Context compaction failed: {e}")
             self.io.tool_warning("Proceeding with full history for now.")
@@ -2230,10 +2206,11 @@ class Coder:
 
         self.multi_response_content = ""
         if self.show_pretty():
-            spinner_text = (
-                f"Waiting for {self.get_active_model().name} •"
-                f" ${self.format_cost(self.total_cost)} session"
-            )
+            spinner_text = f"Waiting for {self.get_active_model().name}"
+
+            if not self.tui:
+                spinner_text += f" • ${self.format_cost(self.total_cost)} session"
+
             self.io.start_spinner(spinner_text)
             if self.stream:
                 self.mdstream = True
@@ -2768,6 +2745,7 @@ class Coder:
 
     def _print_tool_call_info(self, server_tool_calls):
         """Print information about an MCP tool call."""
+        self.io.ring_bell()
         # self.io.tool_output("Preparing to run MCP tools", bold=False)
 
         for server, tool_calls in server_tool_calls.items():
@@ -3039,6 +3017,7 @@ class Coder:
             return prompts.added_files.format(fnames=", ".join(added_fnames))
 
     async def send(self, messages, model=None, functions=None, tools=None):
+        self.interrupt_event.clear()
         self.got_reasoning_content = False
         self.ended_reasoning_content = False
 
@@ -3058,15 +3037,33 @@ class Coder:
         self.token_profiler.start()
 
         try:
-            hash_object, completion = await model.send_completion(
-                messages,
-                functions,
-                self.stream,
-                self.temperature,
-                # This could include any tools, but for now it is just MCP tools
-                tools=tools,
-                override_kwargs=self.model_kwargs.copy(),
+            completion_task = asyncio.create_task(
+                model.send_completion(
+                    messages,
+                    functions,
+                    self.stream,
+                    self.temperature,
+                    # This could include any tools, but for now it is just MCP tools
+                    tools=tools,
+                    override_kwargs=self.model_kwargs.copy(),
+                )
+            )
+            interrupt_task = asyncio.create_task(self.interrupt_event.wait())
+
+            done, pending = await asyncio.wait(
+                {completion_task, interrupt_task},
+                return_when=asyncio.FIRST_COMPLETED,
             )
+
+            if interrupt_task in done:
+                completion_task.cancel()
+                try:
+                    await completion_task
+                except asyncio.CancelledError:
+                    pass
+                raise KeyboardInterrupt
+
+            hash_object, completion = completion_task.result()
             self.chat_completion_call_hashes.append(hash_object.hexdigest())
 
             if not isinstance(completion, ModelResponse):
@@ -3518,13 +3515,18 @@ class Coder:
 
         self.message_tokens_received += completion_tokens
 
-        tokens_report = f"Tokens: {format_tokens(self.message_tokens_sent)} sent"
+        # Build the new streamlined format
+        tokens_parts = [format_tokens(prompt_tokens)]
 
-        if cache_write_tokens:
-            tokens_report += f", {format_tokens(cache_write_tokens)} cache write"
         if cache_hit_tokens:
-            tokens_report += f", {format_tokens(cache_hit_tokens)} cache hit"
-        tokens_report += f", {format_tokens(self.message_tokens_received)} received."
+            tokens_parts.append(f"{format_tokens(cache_hit_tokens)}")
+        if cache_write_tokens:
+            tokens_parts.append(f"{format_tokens(cache_write_tokens)}")
+
+        tokens_str = "/".join(tokens_parts)
+
+        tokens_report = f"{tokens_str} ↑ {format_tokens(completion_tokens)} ↓"
+
         tokens_report = self.token_profiler.add_to_usage_report(
             tokens_report, self.message_tokens_sent, self.message_tokens_received
         )
@@ -3547,9 +3549,12 @@ class Coder:
         self.total_cost += cost
         self.message_cost += cost
 
+        total_combined_tokens = (
+            self.total_tokens_sent + self.total_tokens_received + prompt_tokens + completion_tokens
+        )
         cost_report = (
-            f"Cost: ${self.format_cost(self.message_cost)} message,"
-            f" ${self.format_cost(self.total_cost)} session."
+            f"${self.format_cost(self.message_cost)} • {format_tokens(total_combined_tokens)} ↑↓"
+            f" ${self.format_cost(self.total_cost)}"
         )
 
         if cache_hit_tokens and cache_write_tokens:
@@ -3607,8 +3612,11 @@ class Coder:
         self.total_tokens_sent += self.message_tokens_sent
         self.total_tokens_received += self.message_tokens_received
 
-        self.io.tool_output(self.usage_report)
-        self.io.rule()
+        if self.tui and self.tui():
+            self.tui().update_cost(self.usage_report.replace("\n", " "))
+        else:
+            self.io.tool_output(self.usage_report)
+            self.io.rule()
 
         self.message_cost = 0.0
         self.message_tokens_sent = 0

{cecli_dev-0.99.1 → cecli_dev-0.99.3}/cecli/commands/clear.py

@@ -19,6 +19,7 @@ class ClearCommand(BaseCommand):
         ConversationService.get_manager(coder).clear_tag(MessageTag.FILE_CONTEXTS)
 
         ConversationService.get_files(coder).reset()
+        coder.observation_manager.reset()
 
         # Clear TUI output if available
         if coder.tui and coder.tui():

{cecli_dev-0.99.1 → cecli_dev-0.99.3}/cecli/commands/reset.py

@@ -22,6 +22,7 @@ class ResetCommand(BaseCommand):
             # Re-initialize Conversation components with current coder
             ConversationService.get_manager(coder).initialize(reformat=True)
             ConversationService.get_files(coder)  # Ensure instance exists/initialized
+            coder.observation_manager.reset()
 
             # Clear TUI output if available
             if coder.tui and coder.tui():

{cecli_dev-0.99.1 → cecli_dev-0.99.3}/cecli/helpers/conversation/integration.py

@@ -85,7 +85,12 @@ class ConversationChunks:
                 )
 
         # Add system reminder as a pre-prompt context block
-        if hasattr(coder.gpt_prompts, "system_reminder") and coder.gpt_prompts.system_reminder:
+        use_reminders = getattr(coder.args, "use_reminders", True)
+        if (
+            use_reminders
+            and hasattr(coder.gpt_prompts, "system_reminder")
+            and coder.gpt_prompts.system_reminder
+        ):
             msg = dict(
                 role="user",
                 content=coder.fmt_system_prompt(coder.gpt_prompts.system_reminder),
@@ -235,7 +240,8 @@ class ConversationChunks:
             for f in editable_rel_files:
                 reminder_lines.append(f"  - {f}")
 
-        if len(reminder_lines) > 1:  # Only add reminder if there are files
+        use_reminders = getattr(coder.args, "use_reminders", True)
+        if use_reminders and len(reminder_lines) > 1:  # Only add reminder if there are files
             reminder_lines.append("</context>\n")
             reminder_content = "\n".join(reminder_lines)
             ConversationService.get_manager(coder).add_message(

{cecli_dev-0.99.1 → cecli_dev-0.99.3}/cecli/helpers/monorepo/project.py

@@ -11,6 +11,7 @@ class Project:
         self.config = config
         self.name = config["name"]
         self.repo_url = config["repo"]
+        self.ignore_file = config.get("ignore")
         self.base_path = workspace_path / self.name
         self.main_path = self.base_path / "main"
 

{cecli_dev-0.99.1 → cecli_dev-0.99.3}/cecli/helpers/monorepo/workspace.py

@@ -24,6 +24,17 @@ class WorkspaceManager:
             project = Project(self.path, proj_cfg)
             project.initialize()
 
+        # Copy ignore files to workspace root
+        for proj_cfg in projects_config:
+            ignore_file = proj_cfg.get("ignore")
+            if ignore_file:
+                ignore_path = Path(ignore_file).expanduser()
+                if ignore_path.exists():
+                    import shutil
+
+                    dest_path = self.path / f"{proj_cfg['name']}.ignore"
+                    shutil.copy2(ignore_path, dest_path)
+
         # Write metadata
         import json