V0.100.12

cecli/args.py

@@ -132,6 +132,15 @@ def get_parser(default_config_files, git_root):
             "Specify a file with model tag overrides (e.g., gpt-4o:high -> reasoning_effort: high)"
         ),
     ).complete = shtab.FILE
+    group.add_argument(
+        "--model-providers",
+        metavar="MODEL_PROVIDERS_JSON",
+        help=(
+            "Specify custom OpenAI-compatible model providers as a JSON/YAML string (e.g.,"
+            ' \'{"my-provider": {"api_base": "https://...", "api_key_env": ["MY_KEY"]}}\')'
+        ),
+        default=None,
+    )
     group.add_argument(
         "--reasoning-effort",
         type=str,
@@ -1113,7 +1122,7 @@ def get_parser(default_config_files, git_root):
     group.add_argument(
         "--notification-bell",
         action=argparse.BooleanOptionalAction,
-        default=True,
+        default=False,
         help=(
             "Allow notification commands to produce an audible bell. When enabled, command"
             " output is not suppressed so terminal bell escape sequences can ring through"

cecli/change_tracker.py

@@ -21,7 +21,7 @@ def track_change(
 
         Parameters:
         - file_path: Path to the file that was changed
-        - change_type: Type of change (e.g., 'edittext', 'insertlines')
+        - change_type: Type of change (e.g., 'editfile', '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/coders/agent_coder.py

@@ -65,15 +65,15 @@ def __init__(self, *args, **kwargs):
             "commandinteractive",
             "explorecode",
             "ls",
-            "readrange",
+            "readfile",
             "grep",
             "thinking",
             "updatetodolist",
         }
         self.write_tools = {
             "command",
             "commandinteractive",
-            "edittext",
+            "editfile",
             "undochange",
         }
         self.edit_allowed = True
@@ -1138,7 +1138,7 @@ def _generate_tool_context(self, repetitive_tools):
             context_parts.append("\n\n")
             context_parts.append("## File Editing Tools Disabled")
             context_parts.append(
-                "File editing tools are currently disabled. Use `ReadRange` to determine the"
+                "File editing tools are currently disabled. Use `ReadFile` to determine the"
                 " current content ID prefixes needed to perform an edit and activate them when"
                 " you are ready to edit a file."
             )

cecli/commands/add.py

@@ -125,10 +125,11 @@ async def execute(cls, io, coder, args, **kwargs):
                 else:
                     io.tool_error(f"Cannot add {matched_file} as it's not part of the repository")
             else:
-                if is_image_file(matched_file) and not coder.main_model.info.get("supports_vision"):
+                active_model = coder.get_active_model()
+                if is_image_file(matched_file) and not active_model.info.get("supports_vision"):
                     io.tool_error(
                         f"Cannot add image file {matched_file} as the"
-                        f" {coder.main_model.name} does not support images."
+                        f" {active_model.name} does not support images."
                     )
                     continue
                 content = io.read_text(abs_file_path)

cecli/commands/read_only.py

@@ -156,10 +156,11 @@ def _add_read_only_file(
         source_mode="read-only",
         target_mode="read-only",
     ):
-        if is_image_file(original_name) and not coder.main_model.info.get("supports_vision"):
+        active_model = coder.get_active_model()
+        if is_image_file(original_name) and not active_model.info.get("supports_vision"):
             io.tool_error(
                 f"Cannot add image file {original_name} as the"
-                f" {coder.main_model.name} does not support images."
+                f" {active_model.name} does not support images."
             )
             return
 

cecli/commands/read_only_stub.py

@@ -156,10 +156,11 @@ def _add_read_only_file(
         source_mode="read-only",
         target_mode="read-only",
     ):
-        if is_image_file(original_name) and not coder.main_model.info.get("supports_vision"):
+        active_model = coder.get_active_model()
+        if is_image_file(original_name) and not active_model.info.get("supports_vision"):
             io.tool_error(
                 f"Cannot add image file {original_name} as the"
-                f" {coder.main_model.name} does not support images."
+                f" {active_model.name} does not support images."
             )
             return
 

cecli/helpers/agents/service.py

@@ -191,8 +191,13 @@ def build_registry(cls, paths: List[str]) -> None:
 
         from .config import parse_subagent_file
 
+        # Always check the default sub-agents directory in the user's home
+        default_dir = str(Path.home() / ".cecli" / "subagents")
+        if default_dir not in paths:
+            paths = [default_dir] + list(paths)
+
         for directory in paths:
-            dir_path = Path(directory)
+            dir_path = Path(directory).expanduser()
             if not dir_path.is_dir():
                 continue
             for md_file in sorted(dir_path.glob("*.md")):

cecli/helpers/conversation/files.py

@@ -252,6 +252,7 @@ def generate_diff(self, fname: str) -> Optional[str]:
         )
 
         if not snapshot_content:
+            self.add_file(abs_fname, content=current_content)
             return None
 
         # Generate diff between snapshot and current content using hashline helper

cecli/helpers/conversation/integration.py

@@ -1092,21 +1092,21 @@ def add_copy_paste_tool_instructions(self) -> None:
             "   <parameter=param_name>param_value_json</parameter>\n"
             "   </function>\n\n"
             "   Example:\n"
-            "   <function=Local--ReadRange>\n"
+            "   <function=Local--ReadFile>\n"
             '   <parameter=read>[{"file_path": "example.py", "range_start": "def hello",'
             ' "range_end": "def goodbye"}]</parameter>\n'
             "   </function>\n\n"
             "2. JSON Tool-Call Format:\n"
             '   Embed a JSON object with "name" and "arguments" keys.\n\n'
             "   Example:\n"
-            '   {"name": "Local--ReadRange", "arguments": {"read": [{"file_path": "example.py",'
+            '   {"name": "Local--ReadFile", "arguments": {"read": [{"file_path": "example.py",'
             ' "range_start": "class A", "range_end": "class Z"}]}}\n\n'
             "3. Bracket Format:\n"
             "   [ToolName(key1=value1, key2=value2)]\n\n"
             "   Example:\n"
-            '   [Local--ReadRange(read=[{"file_path": "example.py", "range_start": "class A"}])]\n\n'
+            '   [Local--ReadFile(read=[{"file_path": "example.py", "range_start": "class A"}])]\n\n'
             "IMPORTANT: Use the FULL prefixed tool name "
-            '(e.g., "Local--ReadRange" not just "ReadRange").\n'
+            '(e.g., "Local--ReadFile" not just "ReadFile").\n'
             "</context>"
         )
 

cecli/helpers/hashline.py

@@ -317,7 +317,7 @@ def _looks_like_content_id(value: str) -> bool:
 
     def _find_substring_matches(lines, value):
         """Find all line indices where the value appears as a substring."""
-        value_stripped = value.rstrip("\r\n")
+        value_stripped = value.strip()
         return [i for i, line in enumerate(lines) if value_stripped in line]
 
     def _resolve_to_hash_id(lines, idx, hp):

cecli/helpers/model_providers.py

@@ -289,6 +289,16 @@ def __init__(self, provider_configs: Optional[Dict[str, Dict]] = None) -> None:
     def set_verify_ssl(self, verify_ssl: bool) -> None:
         self.verify_ssl = verify_ssl
 
+    def merge_provider_configs(self, user_configs: Dict[str, Dict]) -> None:
+        """Merge user-defined provider configs into the existing provider configs."""
+        for slug, cfg in user_configs.items():
+            if slug in self.provider_configs:
+                self.provider_configs[slug] = _deep_merge(self.provider_configs[slug], cfg)
+            else:
+                self.provider_configs[slug] = deepcopy(cfg)
+                self._provider_cache[slug] = None
+                self._cache_loaded[slug] = False
+
     def supports_provider(self, provider: Optional[str]) -> bool:
         return bool(provider and provider in self.provider_configs)
 
@@ -571,6 +581,12 @@ def _get_account_id(self, provider: str) -> Optional[str]:
         return None
 
 
+def register_user_providers_with_litellm(user_configs: Dict[str, Dict]) -> None:
+    """Register user-defined providers with LiteLLM for custom handler support."""
+    for slug, cfg in user_configs.items():
+        _register_provider_with_litellm(slug, cfg)
+
+
 def ensure_litellm_providers_registered() -> None:
     """One-time registration guard for LiteLLM provider metadata."""
     global _PROVIDERS_REGISTERED

cecli/helpers/responses.py

@@ -166,7 +166,7 @@ def extract_tools_from_pseudo_json(content: str) -> Optional[List[ChatCompletion
     The parser handles nested parentheses and commas inside JSON values.
 
     Example:
-    [Local--ReadRange(show=[{"file_path": "agent.py", "start_text": "class A"}], verbose=true, mode="strict")]
+    [Local--ReadFile(show=[{"file_path": "agent.py", "start_text": "class A"}], verbose=true, mode="strict")]
     """
     from litellm.types.utils import ChatCompletionMessageToolCall, Function  # noqa
 

cecli/helpers/skills.py

@@ -66,6 +66,11 @@ def __init__(
             git_root: Optional git root directory for relative path resolution
             coder: Optional reference to the coder instance (weak reference)
         """
+        # Always include the default skills directory in the user's home
+        default_skill_dir = str(Path.home() / ".cecli" / "skills")
+        if default_skill_dir not in directory_paths:
+            directory_paths = [default_skill_dir] + list(directory_paths)
+
         self.directory_paths = [Path(p).expanduser().resolve() for p in directory_paths]
         self.include_list = set(include_list) if include_list else None
         self.exclude_list = set(exclude_list) if exclude_list else set()

cecli/io.py

@@ -367,7 +367,7 @@ def __init__(
         root=".",
         notifications=False,
         notifications_command=None,
-        notification_bell=True,
+        notification_bell=False,
         verbose=False,
     ):
         self.console = Console()
@@ -386,6 +386,7 @@ def __init__(
         self.bell_on_next_input = False
         self.notifications = notifications
         self.notification_bell = notification_bell
+        self.custom_notification_command = False
         self.verbose = verbose
         self.profile_start_time = None
         self.profile_last_time = None
@@ -404,10 +405,19 @@ def __init__(
         self.confirmation_input_active = False
         self.saved_input_text = ""
 
-        if notifications and notifications_command is None:
-            self.notifications_command = self.get_default_notification_command()
-        else:
+        if notifications_command is not None:
+            # Custom notification command overrides everything
             self.notifications_command = notifications_command
+            self.custom_notification_command = True
+        elif notification_bell and not notifications:
+            # Bell only mode - no command needed, _send_notification will fallback to bell
+            self.notifications_command = None
+        elif notifications:
+            # Generate default notification command based on notification_bell flag
+            include_bell = notification_bell is not False
+            self.notifications_command = self.get_default_notification_command(bell=include_bell)
+        else:
+            self.notifications_command = None
 
         no_color = os.environ.get("NO_COLOR")
         if no_color is not None and no_color != "":
@@ -1693,8 +1703,8 @@ def llm_started(self):
         """Mark that the LLM has started processing, so we should ring the bell on next input"""
         self.bell_on_next_input = True
 
-    def get_default_notification_command(self):
-        """Return a command that triggers a system bell followed by a notification."""
+    def get_default_notification_command(self, bell=True):
+        """Return a command that triggers a notification, optionally with a bell."""
         import platform
         import shutil
 
@@ -1744,13 +1754,18 @@ def get_default_notification_command(self):
             )
             notif_cmd = f"powershell -WindowStyle Hidden -Command {ps_body}"
 
-        # 3. Concatenate them
+        # 3. Concatenate them based on bell preference
         if notif_cmd:
-            # Using ';' as a command separator works for both shell=True on Unix and Windows
-            return f"{bell_cmd} ; {notif_cmd}"
+            if bell:
+                # Using ';' as a command separator works for both shell=True on Unix and Windows
+                return f"{bell_cmd} ; {notif_cmd}"
+            return notif_cmd
 
         # Fallback if no notification tool is found
-        return bell_cmd
+        if bell:
+            return bell_cmd
+
+        return None
 
     def _send_notification(self):
         # Cooldown to prevent notification spam
@@ -1787,18 +1802,33 @@ def _send_notification(self):
 
             except Exception as e:
                 self.tool_warning(f"Failed to run notifications command: {e}")
-        else:
-            print("\a", end="", flush=True)  # Ring the bell
+        elif self.notification_bell is not False:
+            bell_cmd = self.get_default_notification_command(bell=True)
+            if bell_cmd:
+                try:
+                    kwargs = {
+                        "shell": True,
+                    }
+
+                    if platform.system() == "Windows":
+                        kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+                    else:
+                        kwargs["start_new_session"] = True
+
+                    subprocess.Popen(bell_cmd, **kwargs)
+                except Exception as e:
+                    self.tool_warning(f"Failed to run bell command: {e}")
 
     def notify_user_input_required(self):
         """Send a notification that user input is required."""
-        if self.notifications:
+        if self.notifications or self.notification_bell or self.custom_notification_command:
             self._send_notification()
 
     def ring_bell(self):
         """Ring the terminal bell if needed and clear the flag"""
-        if self.bell_on_next_input and self.notifications:
-            self._send_notification()
+        if self.bell_on_next_input:
+            if self.notifications or self.notification_bell or self.custom_notification_command:
+                self._send_notification()
             self.bell_on_next_input = False
 
     def toggle_multiline_mode(self):

cecli/llm.py

@@ -53,7 +53,11 @@ def _load_litellm(self):
         self._lazy_module.suppress_debug_info = True
         self._lazy_module.set_verbose = False
         self._lazy_module.drop_params = True
-        self._lazy_module._logging._disable_debugging()
+        try:
+            self._lazy_module._logging._disable_debugging()
+        except AttributeError:
+            # litellm >= 1.62.0 removed the _logging module
+            pass
 
         # Make sure JSON-based OpenAI-compatible providers are registered
         ensure_litellm_providers_registered()

cecli/main.py

@@ -311,6 +311,12 @@ def load_dotenv_files(git_root, dotenv_fname, encoding="utf-8"):
     if oauth_keys_file.exists():
         dotenv_files.insert(0, str(oauth_keys_file.resolve()))
         dotenv_files = list(dict.fromkeys(dotenv_files))
+
+    # Also check ~/.cecli/.env as a default dotenv file (lowest priority)
+    cecli_env_file = Path.home() / ".cecli" / ".env"
+    if cecli_env_file.exists():
+        dotenv_files.insert(0, str(cecli_env_file.resolve()))
+        dotenv_files = list(dict.fromkeys(dotenv_files))
     loaded = []
     for fname in dotenv_files:
         try:
@@ -554,6 +560,7 @@ async def main_async(
         git_root = get_git_root()
     conf_fname = handle_core_files(Path(".cecli.conf.yml"))
     default_config_files = [
+        str(Path.home() / ".cecli" / "conf.yml"),
         str(Path.home() / ".cecli.conf.yml"),
         str(Path(".cecli.conf.yml")),
     ]
@@ -622,6 +629,8 @@ async def main_async(
         args.hooks = convert_yaml_to_json_string(args.hooks)
     if hasattr(args, "workspaces") and args.workspaces is not None:
         args.workspaces = convert_yaml_to_json_string(args.workspaces)
+    if hasattr(args, "model_providers") and args.model_providers is not None:
+        args.model_providers = convert_yaml_to_json_string(args.model_providers)
 
     # Interpolate environment variables in all string arguments
     for key, value in vars(args).items():
@@ -855,6 +864,23 @@ def get_io(pretty):
     await check_and_load_imports(io, is_first_run, verbose=args.verbose)
     register_models(git_root, args.model_settings_file, io, verbose=args.verbose)
     register_litellm_models(git_root, args.model_metadata_file, io, verbose=args.verbose)
+    if args.model_providers:
+        try:
+            user_providers = json.loads(args.model_providers)
+            if isinstance(user_providers, dict):
+                models.model_info_manager.provider_manager.merge_provider_configs(user_providers)
+                from cecli.helpers.model_providers import (
+                    register_user_providers_with_litellm,
+                )
+
+                register_user_providers_with_litellm(user_providers)
+                if args.verbose:
+                    io.tool_output(f"Loaded {len(user_providers)} custom model provider(s):")
+                    for slug in user_providers:
+                        io.tool_output(f"  - {slug}")
+        except json.JSONDecodeError as e:
+            io.tool_error(f"Failed to parse --model-providers JSON: {e}")
+
     if args.list_models:
         models.print_matching_models(io, args.list_models)
         return await graceful_exit(None)