cecli-dev 1.0.1__tar.gz → 1.0.2__tar.gz

{cecli_dev-1.0.1 → cecli_dev-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.0.1
+Version: 1.0.2
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -24,6 +24,7 @@ Requires-Dist: oslex>=0.1.3
 Requires-Dist: pexpect>=4.9.0
 Requires-Dist: psutil>=7.0.0
 Requires-Dist: watchfiles>=1.1.0
+Requires-Dist: charset-normalizer>=3.4.7
 Requires-Dist: GitPython>=3.1.45
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: litellm!=1.82.7,!=1.82.8,>=1.80.11

{cecli_dev-1.0.1 → cecli_dev-1.0.2}/cecli/__init__.py

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

{cecli_dev-1.0.1 → cecli_dev-1.0.2}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.1'
-__version_tuple__ = version_tuple = (1, 0, 1)
+__version__ = version = '1.0.2'
+__version_tuple__ = version_tuple = (1, 0, 2)
 
-__commit_id__ = commit_id = 'ga4f09aadf'
+__commit_id__ = commit_id = 'gbe5c3ba9d'

{cecli_dev-1.0.1 → cecli_dev-1.0.2}/cecli/coders/base_coder.py

@@ -34,6 +34,7 @@ from uuid import uuid4 as generate_unique_id
 import cecli.prompts.utils.system as prompts
 from cecli import __version__, models, urls, utils
 from cecli.commands import Commands, SwitchCoderSignal
+from cecli.decoding import safe_open
 from cecli.exceptions import LiteLLMExceptions
 from cecli.helpers import command_parser, coroutines, nested, responses
 from cecli.helpers.conversation import ConversationService, MessageTag
@@ -245,6 +246,7 @@ class Coder(metaclass=UsageMeta):
     model_kwargs = {}
     cost_multiplier = 1
     stop_on_empty = True
+    error_code = None
 
     # Task coordination state variables
     input_running = False
@@ -1429,7 +1431,7 @@ class Coder(metaclass=UsageMeta):
             if not mime_type:
                 continue
 
-            with open(fname, "rb") as image_file:
+            with safe_open(fname, "rb") as image_file:
                 encoded_string = base64.b64encode(image_file.read()).decode("utf-8")
             image_url = f"data:{mime_type};base64,{encoded_string}"
             rel_fname = self.get_rel_fname(fname)
@@ -1873,7 +1875,7 @@ class Coder(metaclass=UsageMeta):
         if not self.commands.is_command(user_message):
             ConversationService.get_chunks(self).flush_removals()
             self.last_user_message = user_message
-
+            self.error_code = None
             # 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
@@ -3648,6 +3650,7 @@ class Coder(metaclass=UsageMeta):
             self.calculate_and_show_tokens_and_cost(messages, completion)
 
         except litellm_ex.exceptions_tuple() as err:
+            self.error_code = 1
             ex_info = litellm_ex.get_ex_info(err)
             if ex_info.name == "ContextWindowExceededError":
                 # Still calculate costs for context window errors
@@ -3655,6 +3658,7 @@ class Coder(metaclass=UsageMeta):
                 self.calculate_and_show_tokens_and_cost(messages, completion)
             raise
         except (KeyboardInterrupt, asyncio.CancelledError) as kbi:
+            self.error_code = 130  # apparently standard?
             self.keyboard_interrupt()
             raise kbi
         finally:
@@ -3755,7 +3759,7 @@ class Coder(metaclass=UsageMeta):
                 completion, self.interrupt_event
             ):
                 if self.args.debug:
-                    with open(".cecli/logs/chunks.log", "a") as f:
+                    with safe_open(".cecli/logs/chunks.log", "a") as f:
                         print(chunk, file=f)
 
                 # Check if confirmation is in progress and wait if needed

{cecli_dev-1.0.1 → cecli_dev-1.0.2}/cecli/commands/history_search.py

@@ -3,6 +3,7 @@ from typing import List
 
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import format_command_result
+from cecli.decoding import safe_open
 from cecli.utils import run_fzf
 
 
@@ -68,7 +69,7 @@ class HistorySearchCommand(BaseCommand):
             return []
 
         try:
-            with open(file_path, "r") as f:
+            with safe_open(file_path, "r") as f:
                 content = f.read()
         except (OSError, IOError):
             return []

{cecli_dev-1.0.1 → cecli_dev-1.0.2}/cecli/commands/terminal_setup.py

@@ -12,6 +12,7 @@ except ImportError:
 
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import format_command_result
+from cecli.decoding import safe_open
 
 
 class TerminalSetupCommand(BaseCommand):
@@ -177,7 +178,7 @@ class TerminalSetupCommand(BaseCommand):
                 data = {
                     "keyboard": {"bindings": [{"key": "Return", "mods": "Shift", "chars": "\n"}]}
                 }
-                with open(path, "w", encoding="utf-8") as f:
+                with safe_open(path, "w") as f:
                     tomlkit.dump(data, f)
                 io.tool_output("Created Alacritty config with shift+enter binding.")
                 return True
@@ -189,7 +190,7 @@ class TerminalSetupCommand(BaseCommand):
             io.tool_output(f"DRY-RUN: Would check Alacritty config at {path}")
             io.tool_output(f"DRY-RUN: Would add binding: {new_binding}")
             try:
-                with open(path, "r", encoding="utf-8") as f:
+                with safe_open(path, "r") as f:
                     data = tomlkit.load(f)
 
                 # Check if binding already exists
@@ -222,7 +223,7 @@ class TerminalSetupCommand(BaseCommand):
         cls._backup_file(path, io)
 
         try:
-            with open(path, "r", encoding="utf-8") as f:
+            with safe_open(path, "r") as f:
                 data = tomlkit.load(f)
 
             # Ensure keyboard section exists
@@ -253,7 +254,7 @@ class TerminalSetupCommand(BaseCommand):
             data["keyboard"]["bindings"].append(new_binding)
 
             # Write back to file
-            with open(path, "w", encoding="utf-8") as f:
+            with safe_open(path, "w") as f:
                 tomlkit.dump(data, f)
 
             io.tool_output("Updated Alacritty config.")
@@ -280,7 +281,7 @@ class TerminalSetupCommand(BaseCommand):
             else:
                 io.tool_output(f"Creating Kitty config at {path}")
                 # Create Kitty config with shift+enter binding
-                with open(path, "w", encoding="utf-8") as f:
+                with safe_open(path, "w") as f:
                     f.write(cls.KITTY_BINDING)
                 io.tool_output("Created Kitty config with shift+enter binding.")
                 return True
@@ -290,7 +291,7 @@ class TerminalSetupCommand(BaseCommand):
             io.tool_output(f"DRY-RUN: Would append binding:\n{cls.KITTY_BINDING.strip()}")
             # Simulate checking for duplicates
             try:
-                with open(path, "r", encoding="utf-8") as f:
+                with safe_open(path, "r") as f:
                     content = f.read()
                 if "map shift+enter send_text all \\n" in content:
                     io.tool_output("DRY-RUN: Kitty already configured.")
@@ -304,14 +305,14 @@ class TerminalSetupCommand(BaseCommand):
 
         cls._backup_file(path, io)
 
-        with open(path, "r", encoding="utf-8") as f:
+        with safe_open(path, "r") as f:
             content = f.read()
 
         if "map shift+enter send_text all \\n" in content:
             io.tool_output("Kitty already configured.")
             return False
 
-        with open(path, "a", encoding="utf-8") as f:
+        with safe_open(path, "a") as f:
             f.write(cls.KITTY_BINDING)
         io.tool_output("Updated Kitty config.")
         return True
@@ -336,7 +337,7 @@ class TerminalSetupCommand(BaseCommand):
                 return False
 
         try:
-            with open(path, "r", encoding="utf-8") as f:
+            with safe_open(path, "r") as f:
                 content = f.read()
 
             import re
@@ -359,7 +360,7 @@ class TerminalSetupCommand(BaseCommand):
 
                 cls._backup_file(path, io)
                 new_content = re.sub(pattern, new_rule, content, flags=re.MULTILINE)
-                with open(path, "w", encoding="utf-8") as f:
+                with safe_open(path, "w") as f:
                     f.write(new_content)
                 io.tool_output("Updated Konsole keytab rule.")
                 return True
@@ -369,7 +370,7 @@ class TerminalSetupCommand(BaseCommand):
                     return True
 
                 cls._backup_file(path, io)
-                with open(path, "a", encoding="utf-8") as f:
+                with safe_open(path, "a") as f:
                     f.write(f"\n{new_rule}\n")
                 io.tool_output("Added Konsole Return+Shift rule.")
                 return True
@@ -399,7 +400,7 @@ class TerminalSetupCommand(BaseCommand):
                 io.tool_output(f"Creating Windows Terminal config at {path}")
                 # Create minimal Windows Terminal config with shift+enter binding
                 data = {"actions": [cls.WT_ACTION], "keybindings": [cls.WT_KEYBINDING]}
-                with open(path, "w", encoding="utf-8") as f:
+                with safe_open(path, "w") as f:
                     json.dump(data, f, indent=4)
                 io.tool_output("Created Windows Terminal config with shift+enter binding.")
                 return True
@@ -412,7 +413,7 @@ class TerminalSetupCommand(BaseCommand):
             )
             # Simulate checking for duplicates
             try:
-                with open(path, "r", encoding="utf-8") as f:
+                with safe_open(path, "r") as f:
                     data = json.load(f)
 
                 # Check if already configured
@@ -451,7 +452,7 @@ class TerminalSetupCommand(BaseCommand):
                 return False
 
         try:
-            with open(path, "r", encoding="utf-8") as f:
+            with safe_open(path, "r") as f:
                 data = json.load(f)
 
             # Check if already configured
@@ -493,7 +494,7 @@ class TerminalSetupCommand(BaseCommand):
 
             cls._backup_file(path, io)
 
-            with open(path, "w", encoding="utf-8") as f:
+            with safe_open(path, "w") as f:
                 json.dump(data, f, indent=4)
             io.tool_output("Updated Windows Terminal config.")
             return True
@@ -522,7 +523,7 @@ class TerminalSetupCommand(BaseCommand):
                 io.tool_output(f"Creating VS Code keybindings.json at {path}")
                 # Create file with our binding
                 data = [cls.VSCODE_SHIFT_ENTER_BINDING]
-                with open(path, "w", encoding="utf-8") as f:
+                with safe_open(path, "w") as f:
                     json.dump(data, f, indent=4)
                 io.tool_output("Created VS Code config with shift+enter binding.")
                 return True
@@ -536,7 +537,7 @@ class TerminalSetupCommand(BaseCommand):
             # Simulate checking for duplicates
             try:
                 content = ""
-                with open(path, "r", encoding="utf-8") as f:
+                with safe_open(path, "r") as f:
                     content = f.read()
 
                 # Strip comments before parsing
@@ -580,7 +581,7 @@ class TerminalSetupCommand(BaseCommand):
 
         try:
             content = ""
-            with open(path, "r", encoding="utf-8") as f:
+            with safe_open(path, "r") as f:
                 content = f.read()
 
             # Strip comments before parsing
@@ -618,7 +619,7 @@ class TerminalSetupCommand(BaseCommand):
             data.append(cls.VSCODE_SHIFT_ENTER_BINDING)
 
             # Write back to file
-            with open(path, "w", encoding="utf-8") as f:
+            with safe_open(path, "w") as f:
                 json.dump(data, f, indent=4)
 
             io.tool_output("Updated VS Code config.")
@@ -647,7 +648,7 @@ class TerminalSetupCommand(BaseCommand):
             try:
                 if settings_path.exists():
                     content = ""
-                    with open(settings_path, "r", encoding="utf-8") as f:
+                    with safe_open(settings_path, "r") as f:
                         content = f.read()
 
                     content_no_comments = cls._strip_json_comments(content)
@@ -703,7 +704,7 @@ class TerminalSetupCommand(BaseCommand):
             if settings_path.exists():
                 cls._backup_file(settings_path, io)
                 content = ""
-                with open(settings_path, "r", encoding="utf-8") as f:
+                with safe_open(settings_path, "r") as f:
                     content = f.read()
 
                 # Strip comments before parsing
@@ -770,7 +771,7 @@ class TerminalSetupCommand(BaseCommand):
                 ]
 
             # Write back to file
-            with open(settings_path, "w", encoding="utf-8") as f:
+            with safe_open(settings_path, "w") as f:
                 json.dump(data, f, indent=4)
 
             io.tool_output("Updated VS Code settings.")

{cecli_dev-1.0.1 → cecli_dev-1.0.2}/cecli/commands/utils/save_load_manager.py

@@ -2,6 +2,8 @@ import os
 from pathlib import Path
 from typing import List
 
+from cecli.decoding import safe_open
+
 
 class SaveLoadManager:
     """Manager for saving and loading command files."""
@@ -35,7 +37,7 @@ class SaveLoadManager:
             # Ensure parent directory exists
             os.makedirs(filepath.parent, exist_ok=True)
 
-            with open(filepath, "w", encoding=self.io.encoding) as f:
+            with safe_open(filepath, "w") as f:
                 f.write("/drop\n")
                 # Write commands to add editable files
                 for fname in sorted(self.coder.abs_fnames):
@@ -68,7 +70,7 @@ class SaveLoadManager:
         filepath = self.resolve_filepath(filename)
 
         try:
-            with open(filepath, "r", encoding=self.io.encoding, errors="replace") as f:
+            with safe_open(filepath, "r", errors="replace") as f:
                 commands = f.readlines()
             return [
                 cmd.strip() for cmd in commands if cmd.strip() and not cmd.strip().startswith("#")

{cecli_dev-1.0.1 → cecli_dev-1.0.2}/cecli/commands/workspace.py

@@ -1,6 +1,7 @@
 import subprocess
 
 from cecli.commands.utils.base_command import BaseCommand
+from cecli.decoding import safe_open
 
 
 class WorkspaceCommand(BaseCommand):
@@ -26,7 +27,7 @@ class WorkspaceCommand(BaseCommand):
         config = {}
         if metadata_path.exists():
             try:
-                with open(metadata_path, "r") as f:
+                with safe_open(metadata_path, "r") as f:
                     config = json.load(f)
             except Exception:
                 pass

cecli_dev-1.0.2/cecli/decoding.py

@@ -0,0 +1,115 @@
+"""
+Encoding-aware file operations with automatic encoding detection for reading
+and configurable encoding for writing.
+
+Provides safe_open() as a drop-in replacement for built-in open() that handles
+encoding intelligently on reads, smart_read() for direct file reading with
+fallback encoding detection via charset_normalizer, and safe_write() for
+writing files with a configurable default encoding.
+
+The module-level DEFAULT_ENCODING variable can be overridden at runtime
+(e.g., from main.py) to set the preferred encoding for write operations.
+"""
+
+import charset_normalizer
+
+# Global encoding setting used by safe_open() and safe_write() for write
+# operations. Can be overridden at runtime from main.py or elsewhere.
+DEFAULT_ENCODING = "utf-8"
+
+
+def smart_read(filepath):
+    """
+    Read a text file, automatically detecting the encoding if not UTF-8.
+
+    Attempts a fast UTF-8 decode first using Python's optimized native
+    decoder. Falls back to charset_normalizer for legacy encodings (e.g.
+    GBK, Latin-1, Shift-JIS) when a UnicodeDecodeError is raised.
+
+    Args:
+        filepath: Path to the file to read.
+
+    Returns:
+        The file contents as a string.
+
+    Raises:
+        ValueError: If the encoding cannot be determined.
+        FileNotFoundError: If the file does not exist.
+    """
+    try:
+        # FAST PATH: Try standard UTF-8 first using Python's optimized
+        # native decoder — this handles the vast majority of modern files.
+        with open(filepath, "r", encoding="utf-8") as f:
+            return f.read()
+
+    except UnicodeDecodeError:
+        # SLOW PATH: A decode error means this is likely a legacy encoding.
+        # Let the library read the raw bytes and guess the correct encoding.
+        results = charset_normalizer.from_path(filepath)
+        match = results.best()
+
+        if match is None:
+            raise ValueError(f"Could not determine text encoding for {filepath}")
+
+        return str(match)
+
+
+def safe_write(filepath, content, encoding=None):
+    """
+    Write string content to a file using the specified or default encoding.
+
+    Args:
+        filepath: Path to the file to write.
+        content: The string content to write.
+        encoding: Encoding to use. Defaults to the module-level
+            DEFAULT_ENCODING if not provided.
+
+    Returns:
+        The content that was written (for convenience / chaining).
+    """
+    if encoding is None:
+        encoding = DEFAULT_ENCODING
+
+    with open(filepath, "w", encoding=encoding) as f:
+        f.write(content)
+
+    return content
+
+
+def safe_open(filepath, mode="r", encoding=None, **kwargs):
+    """
+    Open a file with intelligent encoding handling.
+    """
+    # Binary modes — pass through to built-in open() unchanged.
+    if "b" in mode:
+        return open(filepath, mode, **kwargs)
+
+    # If the user explicitly provided an encoding, respect it unconditionally.
+    if encoding is not None:
+        return open(filepath, mode, encoding=encoding, **kwargs)
+
+    # Write / append modes (with no explicit encoding) — use DEFAULT_ENCODING.
+    # Note: We don't check for "r+" here because if a file is being read,
+    # we must detect its existing encoding first so we don't corrupt it.
+    if "w" in mode or "a" in mode or "x" in mode:
+        return open(filepath, mode, encoding=DEFAULT_ENCODING, **kwargs)
+
+    # Read modes (and read/write "r+" modes) — Auto-detect the encoding.
+    try:
+        # FAST PATH: Try UTF-8 first by opening and reading a tiny chunk
+        with open(filepath, mode, encoding="utf-8", **kwargs) as f:
+            f.read(1)  # Test if it raises a DecodeError
+
+        # If we got here, UTF-8 is valid. Return a fresh file object.
+        return open(filepath, mode, encoding="utf-8", **kwargs)
+
+    except UnicodeDecodeError:
+        # SLOW PATH: Detect encoding using charset_normalizer
+        results = charset_normalizer.from_path(filepath)
+        match = results.best()
+
+        if match is None:
+            raise ValueError(f"Could not determine text encoding for {filepath}")
+
+        # Return a real file object using the detected encoding
+        return open(filepath, mode, encoding=match.encoding, **kwargs)

{cecli_dev-1.0.1 → cecli_dev-1.0.2}/cecli/diffs.py

@@ -1,6 +1,8 @@
 import difflib
 import sys
 
+from cecli.decoding import safe_open
+
 from .dump import dump  # noqa: F401
 
 
@@ -11,10 +13,10 @@ def main():
 
     file_orig, file_updated = sys.argv[1], sys.argv[2]
 
-    with open(file_orig, "r", encoding="utf-8") as f:
+    with safe_open(file_orig, "r") as f:
         lines_orig = f.readlines()
 
-    with open(file_updated, "r", encoding="utf-8") as f:
+    with safe_open(file_updated, "r") as f:
         lines_updated = f.readlines()
 
     for i in range(len(file_updated)):

{cecli_dev-1.0.1 → cecli_dev-1.0.2}/cecli/editor.py

@@ -15,6 +15,7 @@ import tempfile
 
 from rich.console import Console
 
+from cecli.decoding import safe_open
 from cecli.dump import dump  # noqa
 
 DEFAULT_EDITOR_NIX = "vi"
@@ -132,7 +133,7 @@ def pipe_editor(input_data="", suffix=None, editor=None):
     command_str += " " + filepath
 
     subprocess.call(command_str, shell=True)
-    with open(filepath, "r") as f:
+    with safe_open(filepath, "r") as f:
         output_data = f.read()
     try:
         os.remove(filepath)

{cecli_dev-1.0.1 → cecli_dev-1.0.2}/cecli/helpers/agents/config.py

@@ -10,6 +10,8 @@ from typing import Any, Dict, Optional
 
 import yaml
 
+from cecli.decoding import safe_open
+
 
 @dataclass
 class SubAgentConfig:
@@ -49,7 +51,7 @@ def parse_subagent_file(file_path: str) -> Optional[SubAgentConfig]:
     """
 
     try:
-        with open(file_path, "r", encoding="utf-8") as f:
+        with safe_open(file_path, "r") as f:
             content = f.read()
     except (FileNotFoundError, IOError, OSError) as e:
         raise ValueError(f"Cannot read file '{file_path}': {e}")

{cecli_dev-1.0.1 → cecli_dev-1.0.2}/cecli/helpers/background_commands.py

@@ -12,6 +12,8 @@ import threading
 from collections import deque
 from typing import Dict, List, Optional, Tuple
 
+from cecli.decoding import safe_open
+
 try:
     import pty
     import termios
@@ -783,7 +785,7 @@ class BackgroundCommandManager:
             filename = f"{page_num}.txt"
             abs_path = os.path.join(abs_folder, filename)
             page_content = output[i * page_size : (i + 1) * page_size]
-            with open(abs_path, "w") as f:
+            with safe_open(abs_path, "w") as f:
                 f.write(page_content)
 
         file_paths = [f"{folder_path}/{page_num}.txt" for page_num in range(1, num_pages + 1)]

{cecli_dev-1.0.1 → cecli_dev-1.0.2}/cecli/helpers/config_utils.py

@@ -6,6 +6,8 @@ from typing import Any, Dict, List
 
 import yaml
 
+from cecli.decoding import safe_open
+
 
 def load_and_apply_cecli_conf_files(
     cecli_conf_yml_files: List[str], args: Any, parser: Any
@@ -23,7 +25,7 @@ def load_and_apply_cecli_conf_files(
 
         for config_file in existing_cecli_conf:
             try:
-                with open(config_file, "r") as f:
+                with safe_open(config_file, "r") as f:
                     config_data = yaml.safe_load(f)
 
                     if isinstance(config_data, dict):
@@ -199,7 +201,7 @@ def read_and_merge_all_configs(
     for path in all_config_paths:
         if os.path.exists(path):
             try:
-                with open(path, "r") as f:
+                with safe_open(path, "r") as f:
                     data = yaml.safe_load(f)
 
                     if isinstance(data, dict):

{cecli_dev-1.0.1 → cecli_dev-1.0.2}/cecli/helpers/conversation/manager.py

@@ -4,6 +4,7 @@ import time
 import weakref
 from typing import Any, Dict, List, Optional, Tuple, Union
 
+from cecli.decoding import safe_open
 from cecli.helpers import nested
 
 from .base_message import BaseMessage
@@ -354,7 +355,7 @@ class ConversationManager:
             import os
 
             os.makedirs(".cecli/logs", exist_ok=True)
-            with open(".cecli/logs/conversation.log", "w") as f:
+            with safe_open(".cecli/logs/conversation.log", "w") as f:
                 json.dump(messages_dict, f, indent=4, default=lambda o: "<not serializable>")
 
         # Add cache control headers when getting all messages (for LLM consumption)