cecli-dev 0.96.6__tar.gz → 0.96.8__tar.gz

{cecli_dev-0.96.6 → cecli_dev-0.96.8}/PKG-INFO

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

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

{cecli_dev-0.96.6 → cecli_dev-0.96.8}/cecli/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.96.6'
-__version_tuple__ = version_tuple = (0, 96, 6)
+__version__ = version = '0.96.8'
+__version_tuple__ = version_tuple = (0, 96, 8)
 
-__commit_id__ = commit_id = 'g275cf49cc'
+__commit_id__ = commit_id = 'gd43775efe'

{cecli_dev-0.96.6 → cecli_dev-0.96.8}/cecli/args.py

@@ -957,6 +957,7 @@ def get_parser(default_config_files, git_root):
         "-c",
         "--config",
         is_config_file=True,
+        env_var="CECLI_CONFIG_FILE",
         metavar="CONFIG_FILE",
         help=(
             "Specify the config file (default: search for .cecli.conf.yml in git root, cwd"

{cecli_dev-0.96.6 → cecli_dev-0.96.8}/cecli/coders/agent_coder.py

@@ -41,6 +41,7 @@ class AgentCoder(Coder):
 
     edit_format = "agent"
     prompt_format = "agent"
+    context_management_enabled = True
 
     def __init__(self, *args, **kwargs):
         self.recently_removed = {}
@@ -71,7 +72,6 @@ class AgentCoder(Coder):
         }
         self.max_tool_calls = 10000
         self.large_file_token_threshold = 8192
-        self.context_management_enabled = True
         self.skills_manager = None
         self.change_tracker = ChangeTracker()
         self.args = kwargs.get("args")

{cecli_dev-0.96.6 → cecli_dev-0.96.8}/cecli/coders/base_coder.py

@@ -262,6 +262,7 @@ class Coder:
 
                 # Transfer TUI app weak reference
                 res.tui = from_coder.tui
+                res.context_management_enabled = from_coder.context_management_enabled
 
             await res.initialize_mcp_tools()
 
@@ -2095,6 +2096,10 @@ class Coder:
         self.io.llm_started()
 
         if inp:
+            # Make sure current coder actually has control of conversation system
+            ConversationChunks.initialize_conversation_system(self)
+            self.format_chat_chunks()
+
             # Always add user message to conversation manager
             ConversationManager.add_message(
                 message_dict=dict(role="user", content=inp),

{cecli_dev-0.96.6 → cecli_dev-0.96.8}/cecli/commands/add.py

@@ -6,6 +6,7 @@ from typing import List
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import (
     format_command_result,
+    get_file_completions,
     parse_quoted_filenames,
     quote_filename,
 )
@@ -82,10 +83,6 @@ class AddCommand(BaseCommand):
         for matched_file in sorted(all_matched_files):
             abs_file_path = coder.abs_root_path(matched_file)
 
-            if not abs_file_path.startswith(coder.root) and not is_image_file(matched_file):
-                io.tool_error(f"Can not add {abs_file_path}, which is not within {coder.root}")
-                continue
-
             if (
                 coder.repo
                 and coder.repo.git_ignored_file(matched_file)
@@ -205,10 +202,22 @@ class AddCommand(BaseCommand):
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]:
         """Get completion options for add command."""
-        files = set(coder.get_all_relative_files())
-        files = files - set(coder.get_inchat_relative_files())
-        files = [quote_filename(fn) for fn in files]
-        return files
+        # Get both directory-based completions and filtered "all" completions
+        directory_completions = get_file_completions(
+            coder,
+            args=args,
+            completion_type="directory",
+            include_directories=True,
+            filter_in_chat=False,
+        )
+
+        all_completions = get_file_completions(
+            coder, args=args, completion_type="all", include_directories=False, filter_in_chat=True
+        )
+
+        # Return the joint set (union) of both completion types
+        joint_set = set(directory_completions) | set(all_completions)
+        return sorted(joint_set)
 
     @classmethod
     def get_help(cls) -> str:

{cecli_dev-0.96.6 → cecli_dev-0.96.8}/cecli/commands/context_management.py

@@ -2,6 +2,11 @@ from typing import List
 
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import format_command_result
+from cecli.helpers.conversation import (
+    ConversationFiles,
+    ConversationManager,
+    MessageTag,
+)
 
 
 class ContextManagementCommand(BaseCommand):
@@ -19,6 +24,10 @@ class ContextManagementCommand(BaseCommand):
 
         # Toggle the setting
         coder.context_management_enabled = not coder.context_management_enabled
+        ConversationManager.clear_tag(MessageTag.READONLY_FILES)
+        ConversationManager.clear_tag(MessageTag.EDIT_FILES)
+        ConversationManager.clear_tag(MessageTag.CHAT_FILES)
+        ConversationFiles.clear_file_cache()
 
         # Report the new state
         if coder.context_management_enabled:

{cecli_dev-0.96.6 → cecli_dev-0.96.8}/cecli/commands/read_only.py

@@ -7,6 +7,7 @@ from typing import List
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import (
     format_command_result,
+    get_file_completions,
     parse_quoted_filenames,
     quote_filename,
 )
@@ -207,50 +208,22 @@ class ReadOnlyCommand(BaseCommand):
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]:
         """Get completion options for read-only command."""
-        from pathlib import Path
-
-        root = Path(coder.root) if hasattr(coder, "root") else Path.cwd()
-
-        # Handle the prefix - could be partial path like "src/ma" or just "ma"
-        if "/" in args:
-            # Has directory component
-            dir_part, file_part = args.rsplit("/", 1)
-            if dir_part == "":
-                search_dir = Path("/")
-                path_prefix = "/"
-            else:
-                # Use os.path.expanduser for ~ support if needed, but Path handles it mostly
-                search_dir = (root / dir_part).resolve()
-                path_prefix = dir_part + "/"
-            search_prefix = file_part.lower()
-        else:
-            search_dir = root
-            search_prefix = args.lower()
-            path_prefix = ""
-
-        completions = []
-        try:
-            if search_dir.exists() and search_dir.is_dir():
-                for entry in search_dir.iterdir():
-                    name = entry.name
-                    if search_prefix and not name.lower().startswith(search_prefix):
-                        continue
-
-                    # Add trailing slash for directories
-                    if entry.is_dir():
-                        completions.append(path_prefix + name + "/")
-                    else:
-                        completions.append(path_prefix + name)
-        except (PermissionError, OSError):
-            pass
+        # Get both directory-based completions and filtered "all" completions
+        directory_completions = get_file_completions(
+            coder,
+            args=args,
+            completion_type="directory",
+            include_directories=True,
+            filter_in_chat=False,
+        )
 
-        # Also include files already in the chat that match
-        add_completions = coder.commands.get_completions("/add")
-        for c in add_completions:
-            if args.lower() in str(c).lower() and str(c) not in completions:
-                completions.append(str(c))
+        all_completions = get_file_completions(
+            coder, args=args, completion_type="all", include_directories=False, filter_in_chat=True
+        )
 
-        return sorted(completions)
+        # Return the joint set (union) of both completion types
+        joint_set = set(directory_completions) | set(all_completions)
+        return sorted(joint_set)
 
     @classmethod
     def get_help(cls) -> str:

{cecli_dev-0.96.6 → cecli_dev-0.96.8}/cecli/commands/read_only_stub.py

@@ -7,6 +7,7 @@ from typing import List
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import (
     format_command_result,
+    get_file_completions,
     parse_quoted_filenames,
     quote_filename,
 )
@@ -207,49 +208,22 @@ class ReadOnlyStubCommand(BaseCommand):
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]:
         """Get completion options for read-only-stub command."""
-        from pathlib import Path
-
-        root = Path(coder.root) if hasattr(coder, "root") else Path.cwd()
-
-        # Handle the prefix - could be partial path like "src/ma" or just "ma"
-        if "/" in args:
-            # Has directory component
-            dir_part, file_part = args.rsplit("/", 1)
-            if dir_part == "":
-                search_dir = Path("/")
-                path_prefix = "/"
-            else:
-                search_dir = (root / dir_part).resolve()
-                path_prefix = dir_part + "/"
-            search_prefix = file_part.lower()
-        else:
-            search_dir = root
-            search_prefix = args.lower()
-            path_prefix = ""
-
-        completions = []
-        try:
-            if search_dir.exists() and search_dir.is_dir():
-                for entry in search_dir.iterdir():
-                    name = entry.name
-                    if search_prefix and not name.lower().startswith(search_prefix):
-                        continue
-
-                    # Add trailing slash for directories
-                    if entry.is_dir():
-                        completions.append(path_prefix + name + "/")
-                    else:
-                        completions.append(path_prefix + name)
-        except (PermissionError, OSError):
-            pass
+        # Get both directory-based completions and filtered "all" completions
+        directory_completions = get_file_completions(
+            coder,
+            args=args,
+            completion_type="directory",
+            include_directories=True,
+            filter_in_chat=False,
+        )
 
-        # Also include files already in the chat that match
-        add_completions = coder.commands.get_completions("/add")
-        for c in add_completions:
-            if args.lower() in str(c).lower() and str(c) not in completions:
-                completions.append(str(c))
+        all_completions = get_file_completions(
+            coder, args=args, completion_type="all", include_directories=False, filter_in_chat=True
+        )
 
-        return sorted(completions)
+        # Return the joint set (union) of both completion types
+        joint_set = set(directory_completions) | set(all_completions)
+        return sorted(joint_set)
 
     @classmethod
     def get_help(cls) -> str:

cecli_dev-0.96.8/cecli/commands/utils/helpers.py

@@ -0,0 +1,237 @@
+import os
+import re
+from pathlib import Path
+from typing import List
+
+
+class CommandError(Exception):
+    """Custom exception for command-specific errors."""
+
+    pass
+
+
+def quote_filename(fname: str) -> str:
+    """Quote filename if it contains spaces."""
+    if " " in fname and '"' not in fname:
+        fname = f'"{fname}"'
+    return fname
+
+
+def parse_quoted_filenames(args: str) -> List[str]:
+    """Parse filenames from command arguments, handling quoted names."""
+    filenames = re.findall(r"\"(.+?)\"|(\S+)", args)
+    filenames = [name for sublist in filenames for name in sublist if name]
+    return filenames
+
+
+def glob_filtered_to_repo(pattern: str, root: str, repo) -> List[Path]:
+    """
+    Glob pattern and filter results to repository files.
+
+    Args:
+        pattern: Glob pattern to match
+        root: Project root directory
+        repo: GitRepo instance (may be None)
+
+    Returns:
+        List of Path objects matching pattern
+    """
+    if not pattern.strip():
+        return []
+
+    try:
+        if os.path.isabs(pattern):
+            # Handle absolute paths
+            raw_matched_files = [Path(pattern)]
+        else:
+            try:
+                raw_matched_files = list(Path(root).glob(pattern))
+            except (IndexError, AttributeError, ValueError):
+                # Handle patterns like "**/*.py" that might fail on empty dirs
+                raw_matched_files = []
+
+        # Expand directories and filter
+        matched_files = []
+        for f in raw_matched_files:
+            matched_files.extend(expand_subdir(f))
+
+        # Filter to repository files
+        matched_files = [fn.relative_to(root) for fn in matched_files if fn.is_relative_to(root)]
+
+        # if repo, filter against it
+        if repo:
+            git_files = repo.get_tracked_files()
+            matched_files = [fn for fn in matched_files if str(fn) in git_files]
+
+        return matched_files
+    except Exception as e:
+        raise CommandError(f"Error processing pattern '{pattern}': {e}")
+
+
+def get_file_completions(
+    coder,
+    args: str = "",
+    completion_type: str = "all",
+    include_directories: bool = False,
+    filter_in_chat: bool = False,
+) -> List[str]:
+    """
+    Get file completions for command line arguments.
+
+    This function provides unified file completion logic that can be used by
+    multiple commands (add, read-only, read-only-stub, etc.).
+
+    Args:
+        coder: Coder instance
+        args: Command arguments to complete
+        completion_type: Type of completion to perform:
+            - "all": Return all available files (default)
+            - "glob": Treat args as glob pattern and expand
+            - "directory": Perform directory-based prefix matching
+        include_directories: Whether to include directories in results
+        filter_in_chat: Whether to filter out files already in chat
+
+    Returns:
+        List of completion strings (quoted if needed)
+    """
+    from pathlib import Path
+
+    root = Path(coder.root) if hasattr(coder, "root") else Path.cwd()
+
+    if completion_type == "glob":
+        # Handle glob pattern completion
+        if not args.strip():
+            return []
+
+        try:
+            matched_files = glob_filtered_to_repo(args, str(root), coder.repo)
+            completions = [str(fn) for fn in matched_files]
+        except CommandError:
+            completions = []
+
+    elif completion_type == "directory":
+        # Handle directory-based prefix matching (like read-only commands)
+        if "/" in args:
+            # Has directory component
+            dir_part, file_part = args.rsplit("/", 1)
+            if dir_part == "":
+                search_dir = Path("/")
+                path_prefix = "/"
+            else:
+                search_dir = (root / dir_part).resolve()
+                path_prefix = dir_part + "/"
+            search_prefix = file_part.lower()
+        else:
+            search_dir = root
+            search_prefix = args.lower()
+            path_prefix = ""
+
+        completions = []
+        try:
+            if search_dir.exists() and search_dir.is_dir():
+                for entry in search_dir.iterdir():
+                    name = entry.name
+                    if search_prefix and not name.lower().startswith(search_prefix):
+                        continue
+
+                    # Add trailing slash for directories if requested
+                    if entry.is_dir() and include_directories:
+                        completions.append(path_prefix + name + "/")
+                    elif entry.is_file():
+                        completions.append(path_prefix + name)
+        except (PermissionError, OSError):
+            pass
+
+    else:  # "all" completion type
+        # Get all available files
+        if filter_in_chat:
+            files = set(coder.get_all_relative_files())
+            files = files - set(coder.get_inchat_relative_files())
+            completions = list(files)
+        else:
+            completions = coder.get_all_relative_files()
+
+    # Quote filenames with spaces
+    completions = [quote_filename(fn) for fn in completions]
+    return sorted(completions)
+
+
+def validate_file_access(io, coder, file_path: str, require_in_chat: bool = False) -> bool:
+    """
+    Validate file access permissions and state.
+
+    Args:
+        io: InputOutput instance
+        coder: Coder instance
+        file_path: File path to validate
+        require_in_chat: Whether file must be in chat context
+
+    Returns:
+        True if file is accessible
+    """
+    abs_path = coder.abs_root_path(file_path)
+
+    if not os.path.isfile(abs_path):
+        io.tool_error(f"File not found: {file_path}")
+        return False
+
+    if require_in_chat and abs_path not in coder.abs_fnames:
+        io.tool_error(f"File not in chat: {file_path}")
+        return False
+
+    return True
+
+
+def format_command_result(
+    io, command_name: str, success_message: str, error: Exception | str = None
+):
+    """
+    Format command execution result consistently.
+
+    Args:
+        io: InputOutput instance
+        command_name: Name of the command
+        success_message: Message for successful execution
+        error: Exception if command failed
+
+    Returns:
+        Formatted result string
+    """
+    if error:
+        io.tool_error(f"\nError in {command_name}: {str(error)}")
+        return f"Error: {str(error)}"
+    else:
+        io.tool_output(f"\n✅ {success_message}")
+        return f"Successfully executed {command_name}."
+
+
+def get_available_files(coder, in_chat: bool = False) -> List[str]:
+    """
+    Get list of available files (either all files or files in chat).
+
+    Args:
+        coder: Coder instance
+        in_chat: If True, return files in chat context
+
+    Returns:
+        List of relative file paths
+    """
+    if in_chat:
+        return coder.get_inchat_relative_files()
+    else:
+        return coder.get_all_relative_files()
+
+
+def expand_subdir(file_path: Path) -> List[Path]:
+    """Expand a directory path to all files within it."""
+    if file_path.is_file():
+        return [file_path]
+
+    if file_path.is_dir():
+        files = []
+        for file in file_path.rglob("*"):
+            if file.is_file():
+                files.append(file)
+        return files
+
+    return []

{cecli_dev-0.96.6 → cecli_dev-0.96.8}/cecli/helpers/conversation/files.py

@@ -93,7 +93,7 @@ class ConversationFiles:
         fname: str,
         generate_stub: bool = False,
         context_management_enabled: bool = False,
-        large_file_token_threshold: int = 1000,
+        large_file_token_threshold: int = 8192,
     ) -> Optional[str]:
         """
         Get file content with optional stub generation for large files.
@@ -111,7 +111,6 @@ class ConversationFiles:
             File content, stub for large files, or None if file cannot be read
         """
         abs_fname = os.path.abspath(fname)
-
         # First, ensure file is in cache (read-through cache)
         if abs_fname not in cls._file_contents_original:
             cls.add_file(fname)
@@ -129,14 +128,14 @@ class ConversationFiles:
         if not context_management_enabled:
             return content
 
+        coder = cls.get_coder()
+
         # Check if file is large
-        content_length = len(content)
+        content_length = coder.main_model.token_count(content)
 
         if content_length <= large_file_token_threshold:
             return content
 
-        # File is large, generate stub
-        coder = cls.get_coder()
         # Use RepoMap to generate file stub
         return RepoMap.get_file_stub(fname, coder.io, line_numbers=True)
 
@@ -181,6 +180,7 @@ class ConversationFiles:
 
         # Read current content using coder.io.read_text()
         coder = cls.get_coder()
+        rel_fname = coder.get_rel_fname(fname)
         try:
             current_content = coder.io.read_text(abs_fname)
         except Exception:
@@ -199,8 +199,8 @@ class ConversationFiles:
         diff_lines = difflib.unified_diff(
             snapshot_content.splitlines(),
             current_content.splitlines(),
-            fromfile=f"{abs_fname} (snapshot)",
-            tofile=f"{abs_fname} (current)",
+            fromfile=f"{rel_fname} (snapshot)",
+            tofile=f"{rel_fname} (current)",
             lineterm="",
             n=3,
         )
@@ -224,20 +224,25 @@ class ConversationFiles:
         Returns:
             Diff string or None if no changes
         """
+        coder = cls.get_coder()
         diff = cls.generate_diff(fname)
+
         if diff:
             # Store diff
             abs_fname = os.path.abspath(fname)
             cls._file_diffs[abs_fname] = diff
 
+            rel_fname = fname
+
+            if coder:
+                rel_fname = coder.get_rel_fname(fname)
+
             # Add diff message to conversation
             diff_message = {
                 "role": "user",
-                "content": f"File {fname} has changed:\n\n{diff}",
+                "content": f"File {rel_fname} has changed:\n\n{diff}",
             }
 
-            # Determine tag based on file type
-            coder = cls.get_coder()
             if coder and hasattr(coder, "abs_fnames"):
                 tag = (
                     MessageTag.EDIT_FILES

{cecli_dev-0.96.6 → cecli_dev-0.96.8}/cecli/helpers/conversation/integration.py

@@ -373,9 +373,11 @@ class ConversationChunks:
             content = ConversationFiles.get_file_stub(fname)
             if content:
                 # Add user message with file path as hash_key
+                rel_fname = coder.get_rel_fname(fname)
+
                 user_msg = {
                     "role": "user",
-                    "content": f"File Contents {fname}:\n\n{content}",
+                    "content": f"File Contents {rel_fname}:\n\n{content}",
                 }
                 ConversationManager.add_message(
                     message_dict=user_msg,
@@ -423,7 +425,6 @@ class ConversationChunks:
                         message_dict=assistant_msg,
                         tag=MessageTag.READONLY_FILES,
                         hash_key=("image_assistant", fname),
-                        force=True,
                     )
 
         return messages
@@ -469,16 +470,18 @@ class ConversationChunks:
             if not content:
                 continue
 
+            rel_fname = coder.get_rel_fname(fname)
+
             # Create user message
             user_msg = {
                 "role": "user",
-                "content": f"File Contents {fname}:\n\n{content}",
+                "content": f"File Contents {rel_fname}:\n\n{content}",
             }
 
             # Create assistant message
             assistant_msg = {
                 "role": "assistant",
-                "content": "Ok, I will view and/or modify this file as is necessary.",
+                "content": "Ok, I will modify this file as is necessary.",
             }
 
             # Determine tag based on editability
@@ -526,7 +529,6 @@ class ConversationChunks:
                         message_dict=assistant_msg,
                         tag=MessageTag.CHAT_FILES,
                         hash_key=("image_assistant", fname),
-                        force=True,
                     )
 
         return result

{cecli_dev-0.96.6 → cecli_dev-0.96.8}/cecli/main.py

@@ -181,7 +181,9 @@ async def setup_git(git_root, io):
         )
         return
     elif cwd and await io.confirm_ask(
-        "No git repo found, create one to track cecli's changes (recommended)?", acknowledge=True
+        "No git repo found, create one to track cecli's changes (recommended)?",
+        acknowledge=True,
+        explicit_yes_required=True,
     ):
         git_root = str(cwd.resolve())
         repo = await make_new_repo(git_root, io)

{cecli_dev-0.96.6 → cecli_dev-0.96.8}/cecli/tools/command.py

@@ -34,7 +34,7 @@ class Tool(BaseTool):
     }
 
     @classmethod
-    async def execute(cls, coder, command_string, background=False, stop_background=None):
+    async def execute(cls, coder, command_string, background=False, stop_background=None, **kwargs):
         """
         Execute a shell command, optionally in background.
         """