cecli-dev 0.95.5__py3-none-any.whl

cecli/tools/utils/output.py

@@ -0,0 +1,119 @@
+import json
+import re
+
+
+def print_tool_response(coder, mcp_server, tool_response):
+    """
+    Format the output for display.
+    Prints a Header to identify the tool, a body for the relevant information
+    for the user and a footer for verbose information
+
+    Args:
+        coder: An instance of base_coder
+        mcp_server: An mcp server instance
+        tool_response: a tool_response dictionary
+    """
+    tool_header(coder=coder, mcp_server=mcp_server, tool_response=tool_response)
+    tool_body(coder=coder, tool_response=tool_response)
+    tool_footer(coder=coder, tool_response=tool_response)
+
+
+def tool_header(coder, mcp_server, tool_response):
+    """
+    Prints the header for the tool call output
+
+    Args:
+        coder: An instance of base_coder
+        mcp_server: An mcp server instance
+        tool_response: a tool_response dictionary
+    """
+    color_start, color_end = color_markers(coder)
+
+    coder.io.tool_output(
+        f"{color_start}Tool Call:{color_end} {mcp_server.name} • {tool_response.function.name}",
+        type="Tool Call",
+    )
+
+
+def tool_body(coder, tool_response):
+    """
+    Prints the output body of a tool call as the raw json returned from the model
+
+    Args:
+        coder: An instance of base_coder
+        tool_response: a tool_response dictionary
+    """
+    color_start, color_end = color_markers(coder)
+
+    # Parse and format arguments as headers with values
+    if tool_response.function.arguments:
+        # For non-replace tools, show raw arguments
+        raw_args = tool_response.function.arguments
+        coder.io.tool_output(f"{color_start}Arguments:{color_end} {raw_args}")
+
+
+def tool_body_unwrapped(coder, tool_response):
+    """
+    Prints the output body of a tool call with the argument
+    and content sections separated
+
+    Args:
+        coder: An instance of base_coder
+        tool_response: a tool_response dictionary
+    """
+
+    color_start, color_end = color_markers(coder)
+
+    try:
+        args_dict = json.loads(tool_response.function.arguments)
+        first_key = True
+        for key, value in args_dict.items():
+            # Convert explicit \\n sequences to actual newlines using regex
+            # Only match \\n that is not preceded by any other backslashes
+            if isinstance(value, str):
+                value = re.sub(r"(?<!\\)\\n", "\n", value)
+            # Add extra newline before first key/header
+            if first_key:
+                coder.io.tool_output("\n")
+                first_key = False
+            coder.io.tool_output(f"{color_start}{key}:{color_end}")
+            # Split the value by newlines and output each line separately
+            if isinstance(value, str):
+                for line in value.split("\n"):
+                    coder.io.tool_output(f"{line}")
+            else:
+                coder.io.tool_output(f"{str(value)}")
+            coder.io.tool_output("")
+    except json.JSONDecodeError:
+        # If JSON parsing fails, show raw arguments
+        raw_args = tool_response.function.arguments
+        coder.io.tool_output(f"{color_start}Arguments:{color_end} {raw_args}")
+
+
+def tool_footer(coder, tool_response):
+    """
+    Prints the output footer of a tool call, generally a new line
+    But can include id's if ran in verbose mode
+
+    Args:
+        coder: An instance of base_coder
+        tool_response: a tool_response dictionary
+    """
+    if coder.verbose:
+        coder.io.tool_output(f"Tool ID: {tool_response.id}")
+        coder.io.tool_output(f"Tool type: {tool_response.type}")
+
+    coder.io.tool_output("\n", type="tool-footer")
+
+
+def color_markers(coder):
+    """
+    Rich.console color markers
+
+    Args:
+        coder: An instance of base_coder
+    """
+    color_start = "[bright_cyan]" if coder.pretty else ""
+    color_end = "[/bright_cyan]" if coder.pretty else ""
+
+    return color_start, color_end

cecli/tools/utils/registry.py

@@ -0,0 +1,145 @@
+"""
+Registry for tool discovery and management.
+
+Similar to the command registry in cecli/commands/utils/registry.py,
+this provides centralized tool registration, discovery, and filtering
+based on agent configuration.
+"""
+
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Type
+
+from cecli.helpers import plugin_manager
+from cecli.tools import TOOL_MODULES
+
+
+class ToolRegistry:
+    """Registry for tool discovery and management."""
+
+    _tools: Dict[str, Type] = {}  # normalized name -> Tool class
+    _essential_tools: Set[str] = {"contextmanager", "replacetext", "finished"}
+    _registry: Dict[str, Type] = {}  # cached filtered registry
+
+    @classmethod
+    def register(cls, tool_class):
+        """Register a tool class."""
+        name = tool_class.NORM_NAME
+        cls._tools[name] = tool_class
+
+    @classmethod
+    def get_tool(cls, name: str) -> Optional[Type]:
+        """Get tool class by normalized name."""
+        return cls._tools.get(name, None)
+
+    @classmethod
+    def list_tools(cls) -> List[str]:
+        """List all registered tool names."""
+        return list(cls._tools.keys())
+
+    @classmethod
+    def build_registry(cls, agent_config: Optional[Dict] = None) -> Dict[str, Type]:
+        """
+        Build a filtered registry of tools based on agent configuration.
+
+        Args:
+            agent_config: Agent configuration dictionary with optional
+                         tools_includelist/tools_excludelist keys
+
+        Returns:
+            Dictionary mapping normalized tool names to tool classes
+        """
+        if agent_config is None:
+            agent_config = {}
+
+        # Load tools from tool_paths if specified
+        tool_paths = agent_config.get("tool_paths", [])
+
+        for tool_path in tool_paths:
+            path = Path(tool_path)
+            if path.is_dir():
+                # Find all Python files in the directory
+                for py_file in path.glob("*.py"):
+                    try:
+                        # Load the module using plugin_manager
+                        module = plugin_manager.load_module(str(py_file))
+                        # Check if module has a Tool class
+                        if hasattr(module, "Tool"):
+                            cls.register(module.Tool)
+                    except Exception as e:
+                        # Log error but continue with other files
+                        print(f"Error loading tool from {py_file}: {e}")
+            else:
+                # If it's a file, try to load it directly
+                if path.exists() and path.suffix == ".py":
+                    try:
+                        module = plugin_manager.load_module(str(path))
+                        if hasattr(module, "Tool"):
+                            cls.register(module.Tool)
+                    except Exception as e:
+                        print(f"Error loading tool from {path}: {e}")
+
+        # Get include/exclude lists from config
+        tools_includelist = agent_config.get(
+            "tools_includelist", agent_config.get("tools_whitelist", [])
+        )
+        tools_excludelist = agent_config.get(
+            "tools_excludelist", agent_config.get("tools_blacklist", [])
+        )
+
+        registry = {}
+
+        for tool_name, tool_class in cls._tools.items():
+            should_include = True
+
+            # Apply include list if specified
+            if tools_includelist:
+                should_include = tool_name in tools_includelist
+
+            # Essential tools are always included
+            if tool_name in cls._essential_tools:
+                should_include = True
+
+            # Apply exclude list (unless essential)
+            if tool_name in tools_excludelist and tool_name not in cls._essential_tools:
+                should_include = False
+
+            if should_include:
+                registry[tool_name] = tool_class
+
+        # Store the built registry in the class attribute
+        cls._registry = registry
+        return registry
+
+    @classmethod
+    def get_registered_tools(cls) -> List[str]:
+        """
+        Get the list of registered tools from the cached registry.
+
+        Returns:
+            List of normalized tool names that are currently registered
+
+        Raises:
+            RuntimeError: If no tools are registered (registry is empty)
+        """
+        if not cls._registry:
+            raise RuntimeError(
+                "No tools are currently registered in the registry. "
+                "Call build_registry() first to initialize the registry."
+            )
+        return list(cls._registry.keys())
+
+    @classmethod
+    def initialize_registry(cls):
+        """Initialize the registry by importing and registering all tools."""
+        # Clear existing registry
+        cls._tools.clear()
+
+        # Register all tools from TOOL_MODULES
+        for module in TOOL_MODULES:
+            if hasattr(module, "Tool"):
+                tool_class = module.Tool
+                cls.register(tool_class)
+
+
+# Initialize the registry when module is imported
+ToolRegistry.initialize_registry()

cecli/tools/view_files_matching.py

@@ -0,0 +1,138 @@
+import fnmatch
+import re
+
+from cecli.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "viewfilesmatching"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "ViewFilesMatching",
+            "description": "View files containing a specific pattern.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "pattern": {
+                        "type": "string",
+                        "description": "The pattern to search for in file contents.",
+                    },
+                    "file_pattern": {
+                        "type": "string",
+                        "description": (
+                            "An optional glob pattern to filter which files are searched."
+                        ),
+                    },
+                    "regex": {
+                        "type": "boolean",
+                        "description": (
+                            "Whether the pattern is a regular expression. Defaults to False."
+                        ),
+                    },
+                },
+                "required": ["pattern"],
+            },
+        },
+    }
+
+    @classmethod
+    def execute(cls, coder, pattern, file_pattern=None, regex=False):
+        """
+        Search for pattern (literal string or regex) in files and return matching files as text.
+
+        Args:
+            coder: The Coder instance.
+            pattern (str): The pattern to search for.
+                Treated as a literal string by default.
+            file_pattern (str, optional): Glob pattern to filter which files are searched.
+                Defaults to None (search all files).
+            regex (bool, optional): If True, treat pattern as a regular expression.
+                Defaults to False.
+
+        This tool lets the LLM search for content within files, mimicking
+        how a developer would use grep or regex search to find relevant code.
+        """
+        try:
+            # Get list of files to search
+            if file_pattern:
+                # Use glob pattern to filter files
+                all_files = coder.get_all_relative_files()
+                files_to_search = []
+                for file in all_files:
+                    if fnmatch.fnmatch(file, file_pattern):
+                        files_to_search.append(file)
+
+                if not files_to_search:
+                    return f"No files matching '{file_pattern}' to search for pattern '{pattern}'"
+            else:
+                # Search all files if no pattern provided
+                files_to_search = coder.get_all_relative_files()
+
+            # Search for pattern in files
+            matches = {}
+            num_matches = 0
+            inspecific_search_flag = False
+
+            for file in files_to_search:
+                abs_path = coder.abs_root_path(file)
+
+                if num_matches >= 25:
+                    inspecific_search_flag = True
+
+                try:
+                    if coder.repo.ignored_file(abs_path):
+                        continue
+
+                    with open(abs_path, "r", encoding="utf-8") as f:
+                        content = f.read()
+                        match_count = 0
+                        if regex:
+                            try:
+                                matches_found = re.findall(pattern, content)
+                                match_count = len(matches_found)
+                            except re.error as e:
+                                # Handle invalid regex patterns gracefully
+                                coder.io.tool_error(f"Invalid regex pattern '{pattern}': {e}")
+                                # Skip this file for this search if regex is invalid
+                                continue
+                        else:
+                            # Exact string matching
+                            match_count = content.count(pattern)
+
+                        if match_count > 0:
+                            matches[file] = match_count
+                            num_matches += 1
+                except Exception:
+                    # Skip files that can't be read (binary, etc.)
+                    pass
+
+            # Return formatted text instead of adding to context
+            if matches:
+                # Sort by number of matches (most matches first)
+                sorted_matches = sorted(matches.items(), key=lambda x: x[1], reverse=True)
+                match_list = [f"{file} ({count} matches)" for file, count in sorted_matches]
+
+                if len(matches) > 10:
+                    result = (
+                        f"Found '{pattern}' in {len(matches)} files:"
+                        f" {', '.join(match_list[:10])} and {len(matches) - 10} more"
+                        "\nTry more specific search terms going forward"
+                        if inspecific_search_flag
+                        else ""
+                    )
+                    coder.io.tool_output(f"🔍 Found '{pattern}' in {len(matches)} files")
+                else:
+                    result = f"Found '{pattern}' in {len(matches)} files: {', '.join(match_list)}"
+                    coder.io.tool_output(
+                        f"🔍 Found '{pattern}' in:"
+                        f" {', '.join(match_list[:5])}{' and more' if len(matches) > 5 else ''}"
+                    )
+
+                return result
+            else:
+                coder.io.tool_output(f"⚠️ Pattern '{pattern}' not found in any files")
+                return "Pattern not found in any files"
+        except Exception as e:
+            coder.io.tool_error(f"Error in ViewFilesMatching: {str(e)}")
+            return f"Error: {str(e)}"

cecli/tools/view_files_with_symbol.py

@@ -0,0 +1,117 @@
+from cecli.tools.utils.base_tool import BaseTool
+
+
+class Tool(BaseTool):
+    NORM_NAME = "viewfileswithsymbol"
+    SCHEMA = {
+        "type": "function",
+        "function": {
+            "name": "ViewFilesWithSymbol",
+            "description": "View files that contain a specific symbol (e.g., class, function).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "symbol": {
+                        "type": "string",
+                        "description": "The symbol to search for.",
+                    },
+                },
+                "required": ["symbol"],
+            },
+        },
+    }
+
+    @classmethod
+    def execute(cls, coder, symbol):
+        """
+        Find files containing a symbol using RepoMap and return them as text.
+        Checks files already in context first.
+        """
+        if not coder.repo_map:
+            coder.io.tool_output("⚠️ Repo map not available, cannot use ViewFilesWithSymbol tool.")
+            return "Repo map not available"
+
+        if not symbol:
+            return "Error: Missing 'symbol' parameter for ViewFilesWithSymbol"
+
+        # 1. Check files already in context
+        files_in_context = list(coder.abs_fnames) + list(coder.abs_read_only_fnames)
+        found_in_context = []
+        for abs_fname in files_in_context:
+            rel_fname = coder.get_rel_fname(abs_fname)
+            try:
+                # Use get_tags for consistency with RepoMap usage elsewhere for now.
+                tags = coder.repo_map.get_tags(abs_fname, rel_fname)
+                for tag in tags:
+                    if tag.name == symbol:
+                        found_in_context.append(rel_fname)
+                        break  # Found in this file, move to next
+            except Exception as e:
+                coder.io.tool_warning(
+                    f"Could not get symbols for {rel_fname} while checking context: {e}"
+                )
+
+        if found_in_context:
+            # Symbol found in already loaded files. Report this and stop.
+            file_list = ", ".join(sorted(list(set(found_in_context))))
+            coder.io.tool_output(f"Symbol '{symbol}' found in already loaded file(s): {file_list}")
+            return f"Symbol '{symbol}' found in already loaded file(s): {file_list}"
+
+        # 2. If not found in context, search the repository using RepoMap
+        coder.io.tool_output(f"🔎 Searching for symbol '{symbol}' in repository...")
+        try:
+            found_files = set()
+            current_context_files = coder.abs_fnames | coder.abs_read_only_fnames
+            files_to_search = set(coder.get_all_abs_files()) - current_context_files
+
+            rel_fname_to_abs = {}
+            all_tags = []
+
+            for fname in files_to_search:
+                rel_fname = coder.get_rel_fname(fname)
+                rel_fname_to_abs[rel_fname] = fname
+                try:
+                    tags = coder.repo_map.get_tags(fname, rel_fname)
+                    all_tags.extend(tags)
+                except Exception as e:
+                    coder.io.tool_warning(f"Could not get tags for {rel_fname}: {e}")
+
+            # Find matching symbols
+            for tag in all_tags:
+                if tag.name == symbol:
+                    # Use absolute path directly if available, otherwise resolve from relative path
+                    abs_fname = rel_fname_to_abs.get(tag.rel_fname) or coder.abs_root_path(
+                        tag.fname
+                    )
+                    if (
+                        abs_fname in files_to_search
+                    ):  # Ensure we only add files we intended to search
+                        found_files.add(coder.get_rel_fname(abs_fname))
+
+            # Return formatted text instead of adding to context
+            if found_files:
+                found_files_list = sorted(list(found_files))
+                if len(found_files) > 10:
+                    result = (
+                        f"Found symbol '{symbol}' in {len(found_files)} files:"
+                        f" {', '.join(found_files_list[:10])} and {len(found_files) - 10} more"
+                    )
+                    coder.io.tool_output(f"🔎 Found '{symbol}' in {len(found_files)} files")
+                else:
+                    result = (
+                        f"Found symbol '{symbol}' in {len(found_files)} files:"
+                        f" {', '.join(found_files_list)}"
+                    )
+                    coder.io.tool_output(
+                        f"🔎 Found '{symbol}' in files:"
+                        f" {', '.join(found_files_list[:5])}{' and more' if len(found_files) > 5 else ''}"
+                    )
+
+                return result
+            else:
+                coder.io.tool_output(f"⚠️ Symbol '{symbol}' not found in searchable files")
+                return f"Symbol '{symbol}' not found in searchable files"
+
+        except Exception as e:
+            coder.io.tool_error(f"Error in ViewFilesWithSymbol: {str(e)}")
+            return f"Error: {str(e)}"

cecli/tui/__init__.py

@@ -0,0 +1,83 @@
+"""Textual TUI interface for cecli.
+
+This package provides an experimental TUI (Terminal User Interface) for cecli
+using the Textual framework. Launch with: cecli --tui
+"""
+
+import queue
+import weakref
+
+from .app import TUI
+from .io import TextualInputOutput
+from .worker import CoderWorker
+
+__all__ = ["TUI", "TextualInputOutput", "CoderWorker", "create_tui_io", "launch_tui"]
+
+
+def create_tui_io(args, editing_mode):
+    """Create TUI IO instance and communication queues.
+
+    Args:
+        args: Parsed command line arguments
+        editing_mode: EditingMode.VI or EditingMode.EMACS
+
+    Returns:
+        Tuple of (io, output_queue, input_queue)
+    """
+    output_queue = queue.Queue()
+    input_queue = queue.Queue()
+
+    io = TextualInputOutput(
+        output_queue=output_queue,
+        input_queue=input_queue,
+        pretty=True,
+        yes=args.yes_always,
+        input_history_file=args.input_history_file,
+        chat_history_file=args.chat_history_file,
+        input=None,
+        output=None,
+        user_input_color=args.user_input_color,
+        tool_output_color=args.tool_output_color,
+        tool_warning_color=args.tool_warning_color,
+        tool_error_color=args.tool_error_color,
+        completion_menu_color=args.completion_menu_color,
+        completion_menu_bg_color=args.completion_menu_bg_color,
+        completion_menu_current_color=args.completion_menu_current_color,
+        completion_menu_current_bg_color=args.completion_menu_current_bg_color,
+        assistant_output_color=args.assistant_output_color,
+        code_theme=args.code_theme,
+        dry_run=args.dry_run,
+        encoding=args.encoding,
+        line_endings=args.line_endings,
+        editingmode=editing_mode,
+        fancy_input=False,
+        multiline_mode=args.multiline,
+        notifications=args.notifications,
+        notifications_command=args.notifications_command,
+        verbose=args.verbose,
+    )
+
+    return io, output_queue, input_queue
+
+
+async def launch_tui(coder, output_queue, input_queue, args):
+    """Launch the TUI application.
+
+    Args:
+        coder: Initialized Coder instance
+        output_queue: Queue for output messages
+        input_queue: Queue for input messages
+
+    Returns:
+        Exit code from TUI
+    """
+    worker = CoderWorker(coder, output_queue, input_queue)
+    app = TUI(worker, output_queue, input_queue, args)
+
+    # Set weak reference to TUI app on the coder instance
+    coder.tui = weakref.ref(app)
+
+    return_code = await app.run_async()
+
+    worker.stop()
+    return return_code if return_code else 0