cecli-dev 0.93.1__py3-none-any.whl

cecli/tools/insert_block.py

@@ -0,0 +1,263 @@
+import re
+import traceback
+
+from cecli.tools.utils.base_tool import BaseTool
+from cecli.tools.utils.helpers import (
+    ToolError,
+    apply_change,
+    find_pattern_indices,
+    format_tool_result,
+    generate_unified_diff_snippet,
+    handle_tool_error,
+    is_provided,
+    select_occurrence_index,
+    validate_file_for_edit,
+)
+from cecli.tools.utils.output import tool_body_unwrapped, tool_footer, tool_header
+
+
+class Tool(BaseTool):
+    NORM_NAME = "insertblock"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "InsertBlock",
+            "description": (
+                "Insert a block of content into a file. Mutually Exclusive Parameters:"
+                " after_pattern, before_pattern, position."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string"},
+                    "content": {"type": "string"},
+                    "after_pattern": {"type": "string"},
+                    "before_pattern": {"type": "string"},
+                    "occurrence": {"type": "integer", "default": 1},
+                    "change_id": {"type": "string"},
+                    "dry_run": {"type": "boolean", "default": False},
+                    "position": {"type": "string", "enum": ["top", "bottom", ""]},
+                    "auto_indent": {"type": "boolean", "default": True},
+                    "use_regex": {"type": "boolean", "default": False},
+                },
+                "required": ["file_path", "content"],
+            },
+        },
+    }
+
+    @classmethod
+    def execute(
+        cls,
+        coder,
+        file_path,
+        content,
+        after_pattern=None,
+        before_pattern=None,
+        occurrence=1,
+        change_id=None,
+        dry_run=False,
+        position=None,
+        auto_indent=True,
+        use_regex=False,
+    ):
+        """
+        Insert a block of text after or before a specified pattern using utility functions.
+
+        Args:
+            coder: The coder instance
+            file_path: Path to the file to modify
+            content: The content to insert
+            after_pattern: Pattern to insert after (mutually exclusive with before_pattern and position)
+            before_pattern: Pattern to insert before (mutually exclusive with after_pattern and position)
+            occurrence: Which occurrence of the pattern to use (1-based, or -1 for last)
+            change_id: Optional ID for tracking changes
+            dry_run: If True, only simulate the change
+            position: Special position like "top" or "bottom" (mutually exclusive with before_pattern and after_pattern)
+            auto_indent: If True, automatically adjust indentation of inserted content
+            use_regex: If True, treat patterns as regular expressions
+        """
+        tool_name = "InsertBlock"
+        try:
+            # 1. Validate parameters
+            if sum(is_provided(x) for x in [after_pattern, before_pattern, position]) != 1:
+                raise ToolError(
+                    "Must specify exactly one of: after_pattern, before_pattern, or position"
+                )
+
+            # 2. Validate file and get content
+            abs_path, rel_path, original_content = validate_file_for_edit(coder, file_path)
+            lines = original_content.splitlines()
+
+            # Handle empty files
+            if not lines:
+                lines = [""]
+
+            # 3. Determine insertion point
+            insertion_line_idx = 0
+            pattern_type = ""
+            pattern_desc = ""
+            occurrence_str = ""
+
+            if position:
+                # Handle special positions
+                if position == "start_of_file" or position == "top":
+                    insertion_line_idx = 0
+                    pattern_type = "at start of"
+                elif position == "end_of_file" or position == "bottom":
+                    insertion_line_idx = len(lines)
+                    pattern_type = "at end of"
+                else:
+                    raise ToolError(
+                        f"Invalid position: '{position}'. Valid values are 'start_of_file' or"
+                        " 'end_of_file'"
+                    )
+            else:
+                # Handle pattern-based insertion
+                pattern = after_pattern if after_pattern else before_pattern
+                pattern_type = "after" if after_pattern else "before"
+                pattern_desc = f"Pattern '{pattern}'"
+
+                # Find pattern matches
+                pattern_line_indices = find_pattern_indices(lines, pattern, use_regex=use_regex)
+
+                # Select the target occurrence
+                target_line_idx = select_occurrence_index(
+                    pattern_line_indices, occurrence, pattern_desc
+                )
+
+                # Determine insertion point
+                insertion_line_idx = target_line_idx
+                if pattern_type == "after":
+                    insertion_line_idx += 1  # Insert on the line *after* the matched line
+
+                # Format occurrence info for output
+                num_occurrences = len(pattern_line_indices)
+                occurrence_str = f"occurrence {occurrence} of " if num_occurrences > 1 else ""
+
+            # 4. Handle indentation if requested
+            content_lines = content.splitlines()
+
+            if auto_indent and content_lines:
+                # Determine base indentation level
+                base_indent = ""
+                if insertion_line_idx > 0 and lines:
+                    # Use indentation from the line before insertion point
+                    reference_line_idx = min(insertion_line_idx - 1, len(lines) - 1)
+                    reference_line = lines[reference_line_idx]
+                    base_indent = re.match(r"^(\s*)", reference_line).group(1)
+
+                # Apply indentation to content lines, preserving relative indentation
+                if content_lines:
+                    # Find minimum indentation in content to preserve relative indentation
+                    content_indents = [
+                        len(re.match(r"^(\s*)", line).group(1))
+                        for line in content_lines
+                        if line.strip()
+                    ]
+                    min_content_indent = min(content_indents) if content_indents else 0
+
+                    # Apply base indentation while preserving relative indentation
+                    indented_content_lines = []
+                    for line in content_lines:
+                        if not line.strip():  # Empty or whitespace-only line
+                            indented_content_lines.append("")
+                        else:
+                            # Remove existing indentation and add new base indentation
+                            stripped_line = (
+                                line[min_content_indent:]
+                                if min_content_indent <= len(line)
+                                else line
+                            )
+                            indented_content_lines.append(base_indent + stripped_line)
+
+                    content_lines = indented_content_lines
+
+            # 5. Prepare the insertion
+            new_lines = lines[:insertion_line_idx] + content_lines + lines[insertion_line_idx:]
+            new_content = "\n".join(new_lines)
+
+            # Restore trailing newline if original file had one
+            if original_content.endswith("\n"):
+                new_content += "\n"
+
+            if original_content == new_content:
+                coder.io.tool_warning("No changes made: insertion would not change file")
+                return "Warning: No changes made (insertion would not change file)"
+
+            # 6. Generate diff for feedback
+            diff_snippet = generate_unified_diff_snippet(original_content, new_content, rel_path)
+
+            # 7. Handle dry run
+            if dry_run:
+                if position:
+                    dry_run_message = f"Dry run: Would insert block {pattern_type} {file_path}."
+                else:
+                    dry_run_message = (
+                        f"Dry run: Would insert block {pattern_type} {occurrence_str}pattern"
+                        f" '{pattern}' in {file_path} at line {insertion_line_idx + 1}."
+                    )
+                return format_tool_result(
+                    coder,
+                    tool_name,
+                    "",
+                    dry_run=True,
+                    dry_run_message=dry_run_message,
+                    diff_snippet=diff_snippet,
+                )
+
+            # 8. Apply Change (Not dry run)
+            metadata = {
+                "insertion_line_idx": insertion_line_idx,
+                "after_pattern": after_pattern,
+                "before_pattern": before_pattern,
+                "position": position,
+                "occurrence": occurrence,
+                "content": content,
+                "auto_indent": auto_indent,
+                "use_regex": use_regex,
+            }
+            final_change_id = apply_change(
+                coder,
+                abs_path,
+                rel_path,
+                original_content,
+                new_content,
+                "insertblock",
+                metadata,
+                change_id,
+            )
+
+            coder.files_edited_by_tools.add(rel_path)
+
+            # 9. Format and return result
+            if position:
+                success_message = f"Inserted block {pattern_type} {file_path}"
+            else:
+                success_message = (
+                    f"Inserted block {pattern_type} {occurrence_str}pattern in {file_path} at line"
+                    f" {insertion_line_idx + 1}"
+                )
+
+            return format_tool_result(
+                coder,
+                tool_name,
+                success_message,
+                change_id=final_change_id,
+                diff_snippet=diff_snippet,
+            )
+
+        except ToolError as e:
+            # Handle errors raised by utility functions (expected errors)
+            return handle_tool_error(coder, tool_name, e, add_traceback=False)
+
+        except Exception as e:
+            coder.io.tool_error(
+                f"Error in InsertBlock: {str(e)}\n{traceback.format_exc()}"
+            )  # Add traceback
+            return f"Error: {str(e)}"
+
+    @classmethod
+    def format_output(cls, coder, mcp_server, tool_response):
+        tool_header(coder=coder, mcp_server=mcp_server, tool_response=tool_response)
+        tool_body_unwrapped(coder=coder, tool_response=tool_response)
+        tool_footer(coder=coder, tool_response=tool_response)

cecli/tools/list_changes.py

@@ -0,0 +1,71 @@
+import traceback
+from datetime import datetime
+
+from cecli.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "listchanges"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "ListChanges",
+            "description": "List recent changes made.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string"},
+                    "limit": {"type": "integer", "default": 10},
+                },
+            },
+        },
+    }
+
+    @classmethod
+    def execute(cls, coder, file_path=None, limit=10):
+        """
+        List recent changes made to files.
+
+        Parameters:
+        - coder: The Coder instance
+        - file_path: Optional path to filter changes by file
+        - limit: Maximum number of changes to list
+
+        Returns a formatted list of changes.
+        """
+        try:
+            # If file_path is specified, get the absolute path
+            rel_file_path = None
+            if file_path:
+                abs_path = coder.abs_root_path(file_path)
+                rel_file_path = coder.get_rel_fname(abs_path)
+
+            # Get the list of changes
+            changes = coder.change_tracker.list_changes(rel_file_path, limit)
+
+            if not changes:
+                if file_path:
+                    return f"No changes found for file '{file_path}'"
+                else:
+                    return "No changes have been made yet"
+
+            # Format the changes into a readable list
+            result = "Recent changes:\n"
+            for i, change in enumerate(changes):
+                change_time = datetime.fromtimestamp(change["timestamp"]).strftime("%H:%M:%S")
+                change_type = change["type"]
+                file_path = change["file_path"]
+                change_id = change["id"]
+
+                result += (
+                    f"{i + 1}. [{change_id}] {change_time} - {change_type.upper()} on {file_path}\n"
+                )
+
+            coder.io.tool_output(result)  # Also print to console for user
+            return result
+
+        except Exception as e:
+            coder.io.tool_error(
+                f"Error in ListChanges: {str(e)}\n{traceback.format_exc()}"
+            )  # Add traceback
+            return f"Error: {str(e)}"

cecli/tools/load_skill.py

@@ -0,0 +1,51 @@
+from cecli.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "loadskill"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "LoadSkill",
+            "description": (
+                "Load a skill by name (agent mode only). Adds skill to include list and removes"
+                " from exclude list."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "skill_name": {
+                        "type": "string",
+                        "description": "Name of the skill to load",
+                    },
+                },
+                "required": ["skill_name"],
+            },
+        },
+    }
+
+    @classmethod
+    def execute(cls, coder, skill_name):
+        """
+        Load a skill by name (agent mode only).
+        """
+        if not skill_name:
+            return "Error: Skill name is required."
+
+        # Check if we're in agent mode
+        if not hasattr(coder, "edit_format") or coder.edit_format != "agent":
+            return "Error: Skill loading is only available in agent mode."
+
+        # Check if skills_manager is available
+        if not hasattr(coder, "skills_manager") or coder.skills_manager is None:
+            error_msg = "Error: Skills manager is not initialized. Skills may not be configured."
+            # Check if skills directories are configured
+            if hasattr(coder, "skills_directory_paths") and not coder.skills_directory_paths:
+                error_msg += (
+                    "\nNo skills directories configured. Use --skills-paths to configure skill"
+                    " directories."
+                )
+            return error_msg
+
+        # Use the instance method on skills_manager
+        return coder.skills_manager.load_skill(skill_name)

cecli/tools/ls.py

@@ -0,0 +1,77 @@
+import os
+
+from cecli.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "ls"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "Ls",
+            "description": "List files in a directory.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "directory": {
+                        "type": "string",
+                        "description": "The directory to list.",
+                    },
+                },
+                "required": ["directory"],
+            },
+        },
+    }
+
+    @classmethod
+    def execute(cls, coder, dir_path=None, directory=None):
+        # Handle both positional and keyword arguments for backward compatibility
+        if dir_path is None and directory is not None:
+            dir_path = directory
+        elif dir_path is None:
+            return "Error: Missing directory parameter"
+        """
+        List files in directory and optionally add some to context.
+
+        This provides information about the structure of the codebase,
+        similar to how a developer would explore directories.
+        """
+        try:
+            # Make the path relative to root if it's absolute
+            if dir_path.startswith("/"):
+                rel_dir = os.path.relpath(dir_path, coder.root)
+            else:
+                rel_dir = dir_path
+
+            # Get absolute path
+            abs_dir = coder.abs_root_path(rel_dir)
+
+            # Check if path exists
+            if not os.path.exists(abs_dir):
+                coder.io.tool_output(f"⚠️ Directory '{dir_path}' not found")
+                return "Directory not found"
+
+            # Get directory contents
+            contents = []
+            try:
+                with os.scandir(abs_dir) as entries:
+                    for entry in entries:
+                        if entry.is_file() and not entry.name.startswith("."):
+                            rel_path = os.path.join(rel_dir, entry.name)
+                            contents.append(rel_path)
+            except NotADirectoryError:
+                # If it's a file, just return the file
+                contents = [rel_dir]
+
+            if contents:
+                coder.io.tool_output(f"📋 Listed {len(contents)} file(s) in '{dir_path}'")
+                if len(contents) > 10:
+                    return f"Found {len(contents)} files: {', '.join(contents[:10])}..."
+                else:
+                    return f"Found {len(contents)} files: {', '.join(contents)}"
+            else:
+                coder.io.tool_output(f"📋 No files found in '{dir_path}'")
+                return "No files found in directory"
+        except Exception as e:
+            coder.io.tool_error(f"Error in ls: {str(e)}")
+            return f"Error: {str(e)}"

cecli/tools/remove_skill.py

@@ -0,0 +1,51 @@
+from cecli.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "removeskill"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "RemoveSkill",
+            "description": (
+                "Remove a skill by name (agent mode only). Removes skill from include list and adds"
+                " to exclude list."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "skill_name": {
+                        "type": "string",
+                        "description": "Name of the skill to remove",
+                    },
+                },
+                "required": ["skill_name"],
+            },
+        },
+    }
+
+    @classmethod
+    def execute(cls, coder, skill_name):
+        """
+        Remove a skill by name (agent mode only).
+        """
+        if not skill_name:
+            return "Error: Skill name is required."
+
+        # Check if we're in agent mode
+        if not hasattr(coder, "edit_format") or coder.edit_format != "agent":
+            return "Error: Skill removal is only available in agent mode."
+
+        # Check if skills_manager is available
+        if not hasattr(coder, "skills_manager") or coder.skills_manager is None:
+            error_msg = "Error: Skills manager is not initialized. Skills may not be configured."
+            # Check if skills directories are configured
+            if hasattr(coder, "skills_directory_paths") and not coder.skills_directory_paths:
+                error_msg += (
+                    "\nNo skills directories configured. Use --skills-paths to configure skill"
+                    " directories."
+                )
+            return error_msg
+
+        # Use the instance method on skills_manager
+        return coder.skills_manager.remove_skill(skill_name)

cecli/tools/replace_all.py

@@ -0,0 +1,113 @@
+from cecli.tools.utils.base_tool import BaseTool
+from cecli.tools.utils.helpers import (
+    ToolError,
+    apply_change,
+    format_tool_result,
+    generate_unified_diff_snippet,
+    handle_tool_error,
+    validate_file_for_edit,
+)
+from cecli.tools.utils.output import tool_body_unwrapped, tool_footer, tool_header
+
+
+class Tool(BaseTool):
+    NORM_NAME = "replaceall"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "ReplaceAll",
+            "description": "Replace all occurrences of text in a file.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {"type": "string"},
+                    "find_text": {"type": "string"},
+                    "replace_text": {"type": "string"},
+                    "change_id": {"type": "string"},
+                    "dry_run": {"type": "boolean", "default": False},
+                },
+                "required": ["file_path", "find_text", "replace_text"],
+            },
+        },
+    }
+
+    @classmethod
+    def execute(cls, coder, file_path, find_text, replace_text, change_id=None, dry_run=False):
+        """
+        Replace all occurrences of text in a file using utility functions.
+        """
+        # Get absolute file path
+        abs_path = coder.abs_root_path(file_path)
+        rel_path = coder.get_rel_fname(abs_path)
+        tool_name = "ReplaceAll"
+        try:
+            # 1. Validate file and get content
+            abs_path, rel_path, original_content = validate_file_for_edit(coder, file_path)
+
+            # 2. Count occurrences
+            count = original_content.count(find_text)
+            if count == 0:
+                coder.io.tool_warning(f"Text '{find_text}' not found in file '{file_path}'")
+                return "Warning: Text not found in file"
+
+            # 3. Perform the replacement
+            new_content = original_content.replace(find_text, replace_text)
+
+            if original_content == new_content:
+                coder.io.tool_warning("No changes made: replacement text is identical to original")
+                return "Warning: No changes made (replacement identical to original)"
+
+            # 4. Generate diff for feedback
+            diff_examples = generate_unified_diff_snippet(original_content, new_content, rel_path)
+
+            # 5. Handle dry run
+            if dry_run:
+                dry_run_message = (
+                    f"Dry run: Would replace {count} occurrences of '{find_text}' in {file_path}."
+                )
+                return format_tool_result(
+                    coder,
+                    tool_name,
+                    "",
+                    dry_run=True,
+                    dry_run_message=dry_run_message,
+                    diff_snippet=diff_examples,
+                )
+
+            # 6. Apply Change (Not dry run)
+            metadata = {"find_text": find_text, "replace_text": replace_text, "occurrences": count}
+            final_change_id = apply_change(
+                coder,
+                abs_path,
+                rel_path,
+                original_content,
+                new_content,
+                "replaceall",
+                metadata,
+                change_id,
+            )
+
+            coder.files_edited_by_tools.add(rel_path)
+
+            # 7. Format and return result
+            success_message = f"Replaced {count} occurrences in {file_path}"
+            return format_tool_result(
+                coder,
+                tool_name,
+                success_message,
+                change_id=final_change_id,
+                diff_snippet=diff_examples,
+            )
+
+        except ToolError as e:
+            # Handle errors raised by utility functions
+            return handle_tool_error(coder, tool_name, e, add_traceback=False)
+        except Exception as e:
+            # Handle unexpected errors
+            return handle_tool_error(coder, tool_name, e)
+
+    @classmethod
+    def format_output(cls, coder, mcp_server, tool_response):
+        tool_header(coder=coder, mcp_server=mcp_server, tool_response=tool_response)
+        tool_body_unwrapped(coder=coder, tool_response=tool_response)
+        tool_footer(coder=coder, tool_response=tool_response)