cecli-dev 0.99.7__tar.gz → 0.99.9__tar.gz

{cecli_dev-0.99.7 → cecli_dev-0.99.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.99.7
+Version: 0.99.9
 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-0.99.7 → cecli_dev-0.99.9}/cecli/__init__.py

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

{cecli_dev-0.99.7 → cecli_dev-0.99.9}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.99.7'
-__version_tuple__ = version_tuple = (0, 99, 7)
+__version__ = version = '0.99.9'
+__version_tuple__ = version_tuple = (0, 99, 9)
 
-__commit_id__ = commit_id = 'gf217080c8'
+__commit_id__ = commit_id = 'g7edfde9ea'

{cecli_dev-0.99.7 → cecli_dev-0.99.9}/cecli/change_tracker.py

@@ -21,7 +21,7 @@ class ChangeTracker:
 
         Parameters:
         - file_path: Path to the file that was changed
-        - change_type: Type of change (e.g., 'replacetext', 'insertlines')
+        - change_type: Type of change (e.g., 'edittext', 'insertlines')
         - original_content: Original content before the change
         - new_content: New content after the change
         - metadata: Additional information about the change (line numbers, positions, etc.)

{cecli_dev-0.99.7 → cecli_dev-0.99.9}/cecli/coders/agent_coder.py

@@ -55,15 +55,15 @@ class AgentCoder(Coder):
             "commandinteractive",
             "explorecode",
             "ls",
+            "getlines",
             "grep",
-            "showcontext",
             "thinking",
             "updatetodolist",
         }
         self.write_tools = {
-            "deletetext",
-            "inserttext",
-            "replacetext",
+            "command",
+            "commandinteractive",
+            "edittext",
             "undochange",
         }
         self.edit_allowed = False
@@ -618,9 +618,7 @@ class AgentCoder(Coder):
                         total_file_tokens += tokens
                         editable_tokens += tokens
                         size_indicator = (
-                            "🔴 Large"
-                            if tokens > 5000
-                            else "🟡 Medium" if tokens > 1000 else "🟢 Small"
+                            "Large" if tokens > 5000 else "Medium" if tokens > 1000 else "Small"
                         )
                         editable_files.append(
                             f"- {rel_fname}: {tokens:,} tokens ({size_indicator})"
@@ -642,9 +640,7 @@ class AgentCoder(Coder):
                         total_file_tokens += tokens
                         readonly_tokens += tokens
                         size_indicator = (
-                            "🔴 Large"
-                            if tokens > 5000
-                            else "🟡 Medium" if tokens > 1000 else "🟢 Small"
+                            "Large" if tokens > 5000 else "Medium" if tokens > 1000 else "Small"
                         )
                         readonly_files.append(
                             f"- {rel_fname}: {tokens:,} tokens ({size_indicator})"
@@ -999,7 +995,7 @@ I will proceed based on the tool results and updated context.""")
             context_parts.append("\n\n")
             context_parts.append("## File Editing Tools Disabled")
             context_parts.append(
-                "File editing tools are currently disabled.Use `ShowContext` to determine the"
+                "File editing tools are currently disabled.Use `GetLines` to determine the"
                 " current hashline prefixes needed to perform an edit and activate them when you"
                 " are ready to edit a file."
             )

{cecli_dev-0.99.7 → cecli_dev-0.99.9}/cecli/coders/base_coder.py

@@ -2178,6 +2178,8 @@ class Coder:
         # Notify IO that LLM processing is starting
         self.io.llm_started()
 
+        ConversationService.get_manager(self).flush_queue()
+
         if inp:
             # Make sure current coder actually has control of conversation system
             ConversationService.get_chunks(self).initialize_conversation_system()
@@ -3723,7 +3725,7 @@ class Coder:
             self.check_for_dirty_commit(path)
             return True
 
-        if self.repo and self.repo.git_ignored_file(path):
+        if self.repo and self.repo.git_ignored_file(path) and not self.add_gitignore_files:
             self.io.tool_warning(f"Skipping edits to {path} that matches gitignore spec.")
             return
 
@@ -3742,7 +3744,8 @@ class Coder:
                 # actually already part of the repo.
                 # But let's only add if we need to, just to be safe.
                 if need_to_add:
-                    self.repo.repo.git.add(full_path)
+                    if not (self.add_gitignore_files and self.repo.git_ignored_file(path)):
+                        self.repo.repo.git.add(full_path)
 
             self.abs_fnames.add(full_path)
             self.check_added_files()
@@ -3756,7 +3759,8 @@ class Coder:
             return
 
         if need_to_add:
-            self.repo.repo.git.add(full_path)
+            if not (self.add_gitignore_files and self.repo.git_ignored_file(path)):
+                self.repo.repo.git.add(full_path)
 
         self.abs_fnames.add(full_path)
         self.check_added_files()
@@ -4003,7 +4007,10 @@ class Coder:
         return edits
 
     def local_agent_folder(self, path):
-        os.makedirs(f".cecli/agents/{GLOBAL_DATE}/{self.uuid}", exist_ok=True)
+        os.makedirs(
+            self.abs_root_path(f".cecli/agents/{GLOBAL_DATE}/{self.uuid}"),
+            exist_ok=True,
+        )
 
         stripped = path.lstrip("/")
         return f".cecli/agents/{GLOBAL_DATE}/{self.uuid}/{stripped}"

{cecli_dev-0.99.7 → cecli_dev-0.99.9}/cecli/commands/load_session.py

@@ -18,7 +18,7 @@ class LoadSessionCommand(BaseCommand):
         from cecli import sessions
 
         session_manager = sessions.SessionManager(coder, io)
-        session_manager.load_session(args.strip())
+        await session_manager.load_session(args.strip())
 
         return format_command_result(io, "load-session", f"Loaded session: {args.strip()}")
 

{cecli_dev-0.99.7 → cecli_dev-0.99.9}/cecli/helpers/conversation/integration.py

@@ -446,7 +446,7 @@ class ConversationChunks:
                 dict(role="user", content=repo_content),
                 dict(
                     role="assistant",
-                    content="Ok, I won't try and edit those files without asking first.",
+                    content="Thank you, these files will help with navigating the codebase.",
                 ),
             ]
 
@@ -781,14 +781,14 @@ class ConversationChunks:
             }
 
             # Add to conversation manager
-            ConversationService.get_manager(coder).add_message(
+            ConversationService.get_manager(coder).queue_message(
                 message_dict=user_msg,
                 tag=MessageTag.FILE_CONTEXTS,
                 hash_key=("file_context_user", file_path),
                 force=True,
             )
 
-            ConversationService.get_manager(coder).add_message(
+            ConversationService.get_manager(coder).queue_message(
                 message_dict=assistant_msg,
                 tag=MessageTag.FILE_CONTEXTS,
                 hash_key=("file_context_assistant", file_path),

{cecli_dev-0.99.7 → cecli_dev-0.99.9}/cecli/helpers/conversation/manager.py

@@ -25,6 +25,7 @@ class ConversationManager:
         self._tag_cache: Dict[str, List[Dict[str, Any]]] = {}
         self._ALL_MESSAGES_CACHE_KEY = "__all__"
         self.DEFAULT_TAG_PROMOTION_VALUE: int = 999
+        self._queue: List[Dict[str, Any]] = []
 
     @classmethod
     def get_instance(cls, coder) -> "ConversationManager":
@@ -193,6 +194,33 @@ class ConversationManager:
             self._tag_cache.pop(self._ALL_MESSAGES_CACHE_KEY, None)
             return message
 
+    def queue_message(self, **kwargs) -> None:
+        """
+        Queue an add_message() call for later insertion.
+
+        Accepts the same keyword arguments as add_message()
+        and stores them in an internal queue to be flushed
+        later via flush_queue().
+        """
+        self._queue.append(kwargs)
+
+    def flush_queue(self) -> List[Any]:
+        """
+        Flush all queued add_message() calls.
+
+        Calls add_message() for each set of kwargs in the
+        internal queue, then clears the queue.
+
+        Returns:
+            List of BaseMessage instances returned by add_message()
+        """
+        results = []
+        while self._queue:
+            kwargs = self._queue.pop(0)
+            result = self.add_message(**kwargs)
+            results.append(result)
+        return results
+
     def base_sort(self, messages: List[BaseMessage]) -> List[BaseMessage]:
         """
         Sorts messages by effective priority (promotion if mark_for_demotion has not elapsed yet), then timestamp.

{cecli_dev-0.99.7 → cecli_dev-0.99.9}/cecli/main.py

@@ -361,64 +361,12 @@ def register_litellm_models(git_root, model_metadata_fname, io, verbose=False):
 
 def load_model_overrides(git_root, model_overrides_fname, io, verbose=False):
     """Load model tag overrides from a YAML file."""
-    from pathlib import Path
-
-    import yaml
-
-    model_overrides_files = generate_search_path_list(
-        ".cecli.model.overrides.yml", git_root, model_overrides_fname
-    )
-    overrides = {}
-    files_loaded = []
-    for fname in model_overrides_files:
-        try:
-            if Path(fname).exists():
-                with open(fname, "r") as f:
-                    content = yaml.safe_load(f)
-                    if content:
-                        for model_name, tags in content.items():
-                            if model_name not in overrides:
-                                overrides[model_name] = {}
-                            overrides[model_name].update(tags)
-                        files_loaded.append(fname)
-        except Exception as e:
-            io.tool_error(f"Error loading model overrides from {fname}: {e}")
-    if len(files_loaded) > 0 and verbose:
-        io.tool_output("Loaded model overrides from:")
-        for file_loaded in files_loaded:
-            io.tool_output(f"  - {file_loaded}")
-    if (
-        model_overrides_fname
-        and model_overrides_fname not in files_loaded
-        and model_overrides_fname != ".cecli.model.overrides.yml"
-    ):
-        io.tool_warning(f"Model Overrides File Not Found: {model_overrides_fname}")
-    return overrides
+    models.ModelOverrides.load_from_file(git_root, model_overrides_fname, io, verbose=verbose)
 
 
 def load_model_overrides_from_string(model_overrides_str, io):
     """Load model tag overrides from a JSON/YAML string."""
-    import json
-
-    import yaml
-
-    overrides = {}
-    if not model_overrides_str:
-        return overrides
-    try:
-        try:
-            content = json.loads(model_overrides_str)
-        except json.JSONDecodeError:
-            content = yaml.safe_load(model_overrides_str)
-        if content and isinstance(content, dict):
-            for model_name, tags in content.items():
-                if model_name not in overrides:
-                    overrides[model_name] = {}
-                overrides[model_name].update(tags)
-        return overrides
-    except Exception as e:
-        io.tool_error(f"Error parsing model overrides string: {e}")
-        return {}
+    models.ModelOverrides.load_from_string(model_overrides_str, io)
 
 
 async def sanity_check_repo(repo, io):
@@ -847,105 +795,52 @@ async def main_async(argv=None, input=None, output=None, force_git_root=None, re
     if not selected_model_name:
         return await graceful_exit(None, 1)
     args.model = selected_model_name
-    model_overrides = {}
+
+    # Load model tag overrides (stored in ModelOverrides class-level state)
     if args.model_overrides_file:
-        model_overrides = load_model_overrides(
+        models.ModelOverrides.load_from_file(
             git_root, args.model_overrides_file, io, verbose=args.verbose
         )
+
     if args.model_overrides:
-        direct_overrides = load_model_overrides_from_string(args.model_overrides, io)
-        for model_name, tags in direct_overrides.items():
-            if model_name not in model_overrides:
-                model_overrides[model_name] = {}
-            model_overrides[model_name].update(tags)
-    override_index = {}
-    for base_model, suffixes in model_overrides.items():
-        if not isinstance(suffixes, dict):
-            continue
-        for suffix, cfg in suffixes.items():
-            if not isinstance(cfg, dict):
-                continue
-            full_name = f"{base_model}:{suffix}"
-            override_index[full_name] = base_model, cfg
-
-    def apply_model_overrides(model_name):
-        """Return (effective_model_name, override_kwargs) for a given model_name.
-
-        If model_name ends with ":suffix" where suffix is configured for the
-        prefix (everything before the last colon), we switch to the prefix model
-        and apply that override dict. Otherwise we leave the name unchanged
-        and return empty overrides.
-        """
-        if not model_name:
-            return model_name, {}
-        prefix = ""
-        if model_name.startswith(models.COPY_PASTE_PREFIX):
-            prefix = models.COPY_PASTE_PREFIX
-            model_name = model_name[len(prefix) :]
-
-        # Try to find a matching override by checking all possible suffix matches.
-        # We iterate from right to left splitting on colons to handle cases where
-        # the base model name itself contains colons (e.g. "provider/model:tag:alias")
-        parts = model_name.split(":")
-        # We need at least one split to have a base and a suffix
-        for i in range(len(parts) - 1, 0, -1):
-            potential_base = ":".join(parts[:i])
-            potential_suffix = ":".join(parts[i:])
-
-            # Check if this base has the suffix configured
-            if potential_base in model_overrides:
-                suffixes = model_overrides[potential_base]
-                if isinstance(suffixes, dict) and potential_suffix in suffixes:
-                    cfg = suffixes[potential_suffix]
-                    if isinstance(cfg, dict):
-                        model_name = prefix + potential_base
-                        return model_name, cfg.copy()
-
-        # No match found
-        model_name = prefix + model_name
-        return model_name, {}
-
-    main_model_name, main_model_overrides = apply_model_overrides(args.model)
-    weak_model_name, weak_model_overrides = apply_model_overrides(args.weak_model)
-    editor_model_name, editor_model_overrides = apply_model_overrides(args.editor_model)
-    agent_model_name, agent_model_overrides = apply_model_overrides(args.agent_model)
+        models.ModelOverrides.load_from_string(args.model_overrides, io)
+
     weak_model_obj = None
-    if weak_model_name:
+    if args.weak_model:
         weak_model_obj = models.Model(
-            weak_model_name,
+            args.weak_model,
             weak_model=False,
             verbose=args.verbose,
             io=io,
-            override_kwargs=weak_model_overrides,
             retries=args.retries,
             debug=args.debug,
         )
+
     editor_model_obj = None
-    if editor_model_name:
+    if args.editor_model:
         editor_model_obj = models.Model(
-            editor_model_name,
+            args.editor_model,
             editor_model=False,
             verbose=args.verbose,
             io=io,
-            override_kwargs=editor_model_overrides,
             retries=args.retries,
             debug=args.debug,
         )
+
     agent_model_obj = None
-    if agent_model_name:
+    if args.agent_model:
         agent_model_obj = models.Model(
-            agent_model_name,
+            args.agent_model,
             agent_model=False,
             verbose=args.verbose,
             io=io,
-            override_kwargs=agent_model_overrides,
             retries=args.retries,
             debug=args.debug,
         )
 
-    if main_model_name.startswith("openrouter/") and not os.environ.get("OPENROUTER_API_KEY"):
+    if args.model.startswith("openrouter/") and not os.environ.get("OPENROUTER_API_KEY"):
         io.tool_warning(
-            f"The specified model '{main_model_name}' requires an OpenRouter API key, which was not"
+            f"The specified model '{args.model}' requires an OpenRouter API key, which was not"
             " found."
         )
         if await offer_openrouter_oauth(io):
@@ -958,24 +853,25 @@ async def main_async(argv=None, input=None, output=None, force_git_root=None, re
                 return await graceful_exit(None, 1)
         else:
             io.tool_error(
-                f"Unable to proceed without an OpenRouter API key for model '{main_model_name}'."
+                f"Unable to proceed without an OpenRouter API key for model '{args.model}'."
             )
             await io.offer_url(
                 urls.models_and_keys, "Open documentation URL for more info?", acknowledge=True
             )
             return await graceful_exit(None, 1)
+
     main_model = models.Model(
-        main_model_name,
+        args.model,
         weak_model=weak_model_obj,
         editor_model=editor_model_obj,
         agent_model=agent_model_obj,
         editor_edit_format=args.editor_edit_format,
         verbose=args.verbose,
         io=io,
-        override_kwargs=main_model_overrides,
         retries=args.retries,
         debug=args.debug,
     )
+
     if args.copy_paste and main_model.copy_paste_transport == "api":
         main_model.enable_copy_paste_mode()
     if main_model.remove_reasoning is not None:
@@ -1302,7 +1198,7 @@ async def main_async(argv=None, input=None, output=None, force_git_root=None, re
             from cecli.sessions import SessionManager
 
             session_manager = SessionManager(coder, io)
-            session_manager.load_session(
+            await session_manager.load_session(
                 args.auto_save_session_name if args.auto_save_session_name else "auto-save"
             )
         except Exception: