code-lm 0.1.0__py3-none-any.whl

gemini_cli/tools/base.py

@@ -0,0 +1,86 @@
+"""
+Base tool implementation and interfaces.
+"""
+
+import shlex
+import inspect
+from abc import ABC, abstractmethod
+from google.generativeai.types import FunctionDeclaration
+import logging
+
+log = logging.getLogger(__name__)
+
+class BaseTool(ABC):
+    """Base class for all tools."""
+    
+    name = None
+    description = "Base tool"
+    
+    @abstractmethod
+    def execute(self, *args, **kwargs):
+        """Execute the tool with the given arguments."""
+        pass
+    
+    @classmethod
+    def get_function_declaration(cls) -> FunctionDeclaration | None:
+        """Generates FunctionDeclaration based on the execute method's signature."""
+        if not cls.name or not cls.description:
+            log.warning(f"Tool {cls.__name__} is missing name or description. Cannot generate declaration.")
+            return None
+
+        try:
+            exec_sig = inspect.signature(cls.execute)
+            parameters = {}
+            required = []
+
+            for param_name, param in exec_sig.parameters.items():
+                # Skip 'self' if it's the first parameter
+                if param_name == 'self':
+                    continue 
+                
+                # Basic type mapping (can be enhanced)
+                param_type = "string" # Default to string
+                if param.annotation == str: param_type = "string"
+                elif param.annotation == int: param_type = "integer"
+                elif param.annotation == float: param_type = "number"
+                elif param.annotation == bool: param_type = "boolean"
+                elif param.annotation == list: param_type = "array" # Note: items type not specified here
+                elif param.annotation == dict: param_type = "object" # Note: properties not specified here
+                # Add more complex type handling if needed (e.g., from typing import List, Dict)
+
+                # Assume description from docstring or default
+                # (More advanced: parse docstring for arg descriptions)
+                param_description = f"Parameter {param_name}"
+
+                parameters[param_name] = {
+                    "type": param_type,
+                    "description": param_description
+                }
+
+                # Check if parameter is required (no default value)
+                if param.default is inspect.Parameter.empty:
+                    required.append(param_name)
+
+            # Handle case where no parameters are needed (besides self)
+            if not parameters:
+                schema = None
+            else:
+                schema = {
+                    "type": "object",
+                    "properties": parameters,
+                     # Ensure required list is not empty if there are required params
+                    "required": required if required else None 
+                }
+                # Clean up schema if required is None/empty
+                if schema["required"] is None:
+                    del schema["required"]
+
+            return FunctionDeclaration(
+                name=cls.name,
+                description=cls.description,
+                parameters=schema
+            )
+
+        except Exception as e:
+            log.error(f"Error generating FunctionDeclaration for tool '{cls.name}': {e}", exc_info=True)
+            return None

gemini_cli/tools/directory_tools.py

@@ -0,0 +1,120 @@
+"""
+Tools for directory operations.
+"""
+import os
+import logging
+import subprocess
+from .base import BaseTool
+
+log = logging.getLogger(__name__)
+
+class CreateDirectoryTool(BaseTool):
+    """Tool to create a new directory."""
+    name = "create_directory"
+    description = "Creates a new directory, including any necessary parent directories."
+
+    def execute(self, dir_path: str) -> str:
+        """
+        Creates a directory.
+
+        Args:
+            dir_path: The path of the directory to create.
+
+        Returns:
+            A success or error message.
+        """
+        try:
+            # Basic path safety
+            if ".." in dir_path.split(os.path.sep):
+                 log.warning(f"Attempted to access parent directory in create_directory path: {dir_path}")
+                 return f"Error: Invalid path '{dir_path}'. Cannot access parent directories."
+
+            target_path = os.path.abspath(os.path.expanduser(dir_path))
+            log.info(f"Attempting to create directory: {target_path}")
+
+            if os.path.exists(target_path):
+                if os.path.isdir(target_path):
+                    log.warning(f"Directory already exists: {target_path}")
+                    return f"Directory already exists: {dir_path}"
+                else:
+                    log.error(f"Path exists but is not a directory: {target_path}")
+                    return f"Error: Path exists but is not a directory: {dir_path}"
+
+            os.makedirs(target_path, exist_ok=True) # exist_ok=True handles race conditions slightly better
+            log.info(f"Successfully created directory: {target_path}")
+            return f"Successfully created directory: {dir_path}"
+
+        except OSError as e:
+            log.error(f"Error creating directory '{dir_path}': {e}", exc_info=True)
+            return f"Error creating directory: {str(e)}"
+        except Exception as e:
+            log.error(f"Unexpected error creating directory '{dir_path}': {e}", exc_info=True)
+            return f"Error creating directory: {str(e)}"
+
+class LsTool(BaseTool):
+    """Tool to list directory contents using 'ls -lA'."""
+    name = "ls"
+    description = "Lists the contents of a specified directory (long format, including hidden files)."
+    args_schema: dict = {
+        "path": {
+            "type": "string",
+            "description": "Optional path to a specific directory relative to the workspace root. If omitted, uses the current directory.",
+        }
+    }
+    required_args: list[str] = []
+
+    def execute(self, path: str | None = None) -> str:
+        """Executes the 'ls -lA' command."""
+        target_path = "."  # Default to current directory
+        if path:
+            # Basic path safety - prevent navigating outside workspace root if needed
+            # For simplicity, assuming relative paths are okay for now
+            target_path = os.path.normpath(path) # Normalize path
+            if target_path.startswith(".."):
+                 log.warning(f"Attempted to access parent directory in ls path: {path}")
+                 return f"Error: Invalid path '{path}'. Cannot access parent directories."
+
+        command = ['ls', '-lA', target_path]
+        log.info(f"Executing ls command: {' '.join(command)}")
+
+        try:
+            process = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                check=False,  # Don't raise exception on non-zero exit code
+                timeout=15    # Add a timeout
+            )
+
+            if process.returncode == 0:
+                log.info(f"ls command successful for path '{target_path}'.")
+                # Limit output size? ls -l can be long.
+                output = process.stdout.strip()
+                # Example truncation (adjust as needed)
+                if len(output.splitlines()) > 100:
+                     log.warning(f"ls output for '{target_path}' exceeded 100 lines. Truncating.")
+                     output = "\n".join(output.splitlines()[:100]) + "\n... (output truncated)"
+                return output
+            else:
+                # Handle cases like directory not found specifically if possible
+                stderr_lower = process.stderr.lower()
+                if "no such file or directory" in stderr_lower:
+                     log.error(f"ls command failed: Directory not found '{target_path}'. Stderr: {process.stderr.strip()}")
+                     return f"Error: Directory not found: '{target_path}'"
+                else:
+                     log.error(f"ls command failed with return code {process.returncode}. Path: '{target_path}'. Stderr: {process.stderr.strip()}")
+                     error_detail = process.stderr.strip() if process.stderr else "(No stderr)"
+                     return f"Error executing ls command (Code: {process.returncode}): {error_detail}"
+
+        except FileNotFoundError:
+             # This means 'ls' itself wasn't found - unlikely but possible
+             log.error("'ls' command not found (FileNotFoundError). It might not be installed or in PATH.")
+             return "Error: 'ls' command not found. Please ensure it is installed and in the system's PATH."
+        except subprocess.TimeoutExpired:
+             log.error(f"ls command timed out for path '{target_path}' after 15 seconds.")
+             return f"Error: ls command timed out for path '{target_path}'."
+        except Exception as e:
+            log.exception(f"An unexpected error occurred while executing ls command for path '{target_path}': {e}")
+            return f"An unexpected error occurred while executing ls: {str(e)}"
+
+    # Assuming BaseTool provides a working get_function_declaration implementation

gemini_cli/tools/file_tools.py

@@ -0,0 +1,207 @@
+"""
+File operation tools.
+"""
+# --- ADDED IMPORT ---
+from .base import BaseTool
+# --- END IMPORT ---
+
+import os
+import glob
+import re
+import logging
+from pathlib import Path
+# Note: MAX_CHARS_FOR_FULL_CONTENT is now defined in summarizer_tool.py,
+# so we import it or redefine it here if ViewTool uses it independently.
+# Let's import it for consistency.
+try:
+    from .summarizer_tool import MAX_CHARS_FOR_FULL_CONTENT
+except ImportError:
+    # Fallback if summarizer_tool doesn't exist or fails import
+    MAX_CHARS_FOR_FULL_CONTENT = 50 * 1024
+    logging.warning("Could not import MAX_CHARS_FOR_FULL_CONTENT from summarizer_tool, using fallback.")
+
+
+log = logging.getLogger(__name__)
+
+class ViewTool(BaseTool):
+    """Tool to view specific sections or small files. For large files, use summarize_code."""
+    name = "view"
+    description = "View specific sections of a file using offset/limit, or view small files entirely. Use summarize_code for large files."
+
+    def execute(self, file_path: str, offset: int | None = None, limit: int | None = None) -> str:
+        """
+        View specific parts or small files. Suggests summarize_code for large files if no offset/limit.
+
+        Args:
+            file_path: Path to the file to view.
+            offset: Line number to start reading from (1-based index, optional).
+            limit: Maximum number of lines to read (optional).
+        Returns:
+            The requested content or an error/suggestion message.
+        """
+        try:
+            # Basic path safety
+            if ".." in file_path.split(os.path.sep):
+                 log.warning(f"Attempted to access parent directory in path: {file_path}")
+                 return f"Error: Invalid file path '{file_path}'. Cannot access parent directories."
+
+            path = os.path.abspath(os.path.expanduser(file_path))
+            log.info(f"Viewing file: {path} (Offset: {offset}, Limit: {limit})")
+
+            if not os.path.exists(path):
+                log.warning(f"File not found for view: {file_path}")
+                return f"Error: File not found: {file_path}"
+            if not os.path.isfile(path):
+                 log.warning(f"Attempted to view a directory: {file_path}")
+                 return f"Error: Cannot view a directory: {file_path}"
+
+            # Check size if offset/limit are NOT provided
+            if offset is None and limit is None:
+                 file_size = os.path.getsize(path)
+                 if file_size > MAX_CHARS_FOR_FULL_CONTENT:
+                      log.warning(f"File '{file_path}' is large ({file_size} bytes) and no offset/limit provided for view.")
+                      return f"Error: File '{file_path}' is large. Use the 'summarize_code' tool for an overview, or 'view' with offset/limit for specific sections."
+
+            # Proceed with reading
+            with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+                lines = f.readlines()
+
+            start_index = 0
+            if offset is not None:
+                start_index = max(0, int(offset) - 1)
+
+            end_index = len(lines)
+            if limit is not None:
+                end_index = start_index + max(0, int(limit))
+
+            content_slice = lines[start_index:end_index]
+
+            result = []
+            for i, line in enumerate(content_slice):
+                original_line_num = start_index + i + 1
+                result.append(f"{original_line_num:6d} {line}")
+
+            prefix = f"--- Content of {file_path} (Lines {start_index+1}-{start_index+len(content_slice)}) ---" if offset is not None or limit is not None else f"--- Full Content of {file_path} ---"
+            return prefix + "\n" + "".join(result) if result else f"{prefix}\n(File is empty or slice resulted in no lines)"
+
+        except Exception as e:
+            log.error(f"Error viewing file '{file_path}': {e}", exc_info=True)
+            return f"Error viewing file: {str(e)}"
+
+
+class EditTool(BaseTool):
+    """Tool to edit/create files. Can overwrite, replace strings, or create new."""
+    name = "edit"
+    description = (
+        "Edit or create a file. Use 'content' to provide the **entire** new file content (for creation or full overwrite). "
+        "Use 'old_string' and 'new_string' to replace the **first** occurrence of an exact string. "
+        "For precise changes, it's best to first `view` the relevant section, then use `edit` with the exact `old_string` and `new_string`, "
+        "or provide the complete, modified content using the `content` parameter."
+    )
+
+    def execute(self, file_path: str, content: str | None = None, old_string: str | None = None, new_string: str | None = None) -> str:
+        """
+        Edits or creates a file.
+
+        Args:
+            file_path: Path to the file to edit or create.
+            content: The full content to write to the file. Prioritized over old/new string.
+            old_string: The exact string to find for replacement.
+            new_string: The string to replace old_string with. Use '' to delete.
+        Returns:
+            A success message or an error message.
+        """
+        try:
+            if ".." in file_path.split(os.path.sep):
+                 log.warning(f"Attempted access to parent directory: {file_path}")
+                 return f"Error: Invalid file path '{file_path}'."
+            path = os.path.abspath(os.path.expanduser(file_path))
+            log.info(f"Editing file: {path}")
+            directory = os.path.dirname(path)
+            if directory and not os.path.exists(directory):
+                 log.info(f"Creating directory: {directory}"); os.makedirs(directory, exist_ok=True)
+
+            if content is not None:
+                if old_string is not None or new_string is not None: log.warning("Prioritizing 'content' over 'old/new_string'.")
+                log.info(f"Writing content (length: {len(content)}) to {path}.")
+                with open(path, 'w', encoding='utf-8') as f: f.write(content)
+                return f"Successfully wrote content to {file_path}."
+            elif old_string is not None and new_string is not None:
+                log.info(f"Replacing '{old_string[:50]}...' with '{new_string[:50]}...' in {path}.")
+                if not os.path.exists(path): return f"Error: File not found for replacement: {file_path}"
+                try:
+                    with open(path, 'r', encoding='utf-8') as f: original_content = f.read()
+                except Exception as read_err: return f"Error reading file for replacement: {read_err}"
+                if old_string not in original_content: return f"Error: `old_string` not found in {file_path}."
+                new_content = original_content.replace(old_string, new_string, 1)
+                with open(path, 'w', encoding='utf-8') as f: f.write(new_content)
+                return f"Successfully replaced first occurrence in {file_path}." if new_string else f"Successfully deleted first occurrence in {file_path}."
+            elif old_string is None and new_string is None and content is None:
+                 log.info(f"Creating empty file: {path}")
+                 with open(path, 'w', encoding='utf-8') as f: f.write("")
+                 return f"Successfully created/emptied file {file_path}."
+            else: return "Error: Invalid arguments. Use 'content' OR ('old_string' and 'new_string')."
+        except IsADirectoryError: return f"Error: Cannot edit a directory: {file_path}"
+        except Exception as e: log.error(f"Error editing file '{file_path}': {e}", exc_info=True); return f"Error editing file: {str(e)}"
+
+
+class GrepTool(BaseTool):
+    """Tool to search for patterns in files."""
+    name = "grep"
+    description = "Search for a pattern (regex) in files within a directory."
+    def execute(self, pattern: str, path: str = '.', include: str | None = None) -> str:
+        # No CWD logging needed here for now, focusing on ls/glob/summarize
+        try:
+            if ".." in path.split(os.path.sep): return f"Error: Invalid path '{path}'."
+            target_path = os.path.abspath(os.path.expanduser(path)); log.info(f"Grepping in {target_path} for '{pattern}' (Include: {include})")
+            if not os.path.isdir(target_path): return f"Error: Path is not a directory: {path}"
+            try: regex = re.compile(pattern)
+            except re.error as re_err: return f"Error: Invalid regex pattern: {pattern} ({re_err})"
+            results = []; files_to_search = []
+            if include:
+                recursive = '**' in include; glob_pattern = os.path.join(target_path, include)
+                try: files_to_search = glob.glob(glob_pattern, recursive=recursive)
+                except Exception as glob_err: return f"Error finding files with include pattern: {glob_err}"
+            else:
+                for root, _, filenames in os.walk(target_path):
+                    basename = os.path.basename(root)
+                    if basename.startswith('.') or basename == '__pycache__': continue
+                    files_to_search.extend(os.path.join(root, filename) for filename in filenames)
+            log.info(f"Found {len(files_to_search)} potential files to search.")
+            files_searched_count = 0; matches_found_count = 0; max_matches = 500
+            for file_path in files_to_search:
+                if not os.path.isfile(file_path): continue
+                files_searched_count += 1
+                try:
+                    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                        for i, line in enumerate(f, 1):
+                            if regex.search(line):
+                                matches_found_count += 1; rel_path = os.path.relpath(file_path, target_path)
+                                if os.path.dirname(rel_path) == '': rel_path = f"./{rel_path}"
+                                results.append(f"{rel_path}:{i}: {line.rstrip()}")
+                                if matches_found_count >= max_matches: results.append("--- Match limit reached ---"); break
+                except OSError: continue
+                except Exception as e: log.warning(f"Error grepping file {file_path}: {e}"); continue
+                if matches_found_count >= max_matches: break
+            log.info(f"Searched {files_searched_count} files, found {matches_found_count} matches.")
+            return "\n".join(results) if results else f"No matches found for pattern: {pattern}"
+        except Exception as e: log.error(f"Error during grep: {e}", exc_info=True); return f"Error searching files: {str(e)}"
+
+class GlobTool(BaseTool):
+    """Tool to find files using glob patterns."""
+    name = "glob"
+    description = "Find files/directories matching specific glob patterns recursively."
+    def execute(self, pattern: str, path: str = '.') -> str:
+        log.debug(f"[GlobTool] Current working directory: {os.getcwd()}")
+        try:
+            if ".." in path.split(os.path.sep): return f"Error: Invalid path '{path}'."
+            target_path = os.path.abspath(os.path.expanduser(path)); log.info(f"Globbing in {target_path} for '{pattern}'")
+            if not os.path.isdir(target_path): return f"Error: Path is not a directory: {path}"
+            search_pattern = os.path.join(target_path, pattern)
+            matches = glob.glob(search_pattern, recursive=True)
+            if matches:
+                relative_matches = sorted([os.path.relpath(m, target_path) for m in matches])
+                formatted_matches = [f"./{m}" if os.path.dirname(m) == '' else m for m in relative_matches]
+                return "\n".join(formatted_matches)
+            else: return f"No files or directories found matching pattern: {pattern}"
+        except Exception as e: log.error(f"Error finding files with glob: {e}", exc_info=True); return f"Error finding files: {str(e)}"

gemini_cli/tools/quality_tools.py

@@ -0,0 +1,108 @@
+"""
+Tools for code quality (linting, formatting).
+Requires external tools like 'ruff', 'black', 'flake8' etc. to be installed
+in the environment where this CLI runs.
+"""
+import subprocess
+import logging
+import shlex
+import os
+from .base import BaseTool
+
+log = logging.getLogger(__name__)
+
+# --- Helper for running commands ---
+def _run_quality_command(command: list[str], tool_name: str) -> str:
+    log.info(f"Executing {tool_name} command: {' '.join(command)}")
+    try:
+        process = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=False, # Check return code manually
+            timeout=120 # 2 minute timeout
+        )
+        stdout = process.stdout.strip()
+        stderr = process.stderr.strip()
+        log.info(f"{tool_name} completed. Exit Code: {process.returncode}")
+        log.debug(f"{tool_name} stdout:\n{stdout}")
+        if stderr: log.debug(f"{tool_name} stderr:\n{stderr}")
+
+        result = f"{tool_name} Result (Exit Code: {process.returncode}):\n"
+        if stdout: result += f"-- Output --\n{stdout}\n"
+        if stderr: result += f"-- Errors --\n{stderr}\n"
+        if not stdout and not stderr: result += "(No output)"
+
+        # Truncate long results?
+        max_len = 2000
+        if len(result) > max_len:
+             result = result[:max_len] + "\n... (output truncated)"
+
+        return result
+
+    except FileNotFoundError:
+        cmd_str = command[0]
+        log.error(f"{tool_name} command '{cmd_str}' not found.")
+        return f"Error: Command '{cmd_str}' not found. Is '{cmd_str}' installed and in PATH?"
+    except subprocess.TimeoutExpired:
+        log.error(f"{tool_name} run timed out.")
+        return f"Error: {tool_name} run timed out (2 minutes)."
+    except Exception as e:
+        log.error(f"Unexpected error running {tool_name}: {e}", exc_info=True)
+        return f"Error running {tool_name}: {str(e)}"
+
+
+class LinterCheckerTool(BaseTool):
+    """Tool to run a code linter (e.g., ruff, flake8)."""
+    name = "linter_checker"
+    description = "Runs a code linter (default: 'ruff check') on a specified path to find potential issues."
+
+    def execute(self, path: str = '.', linter_command: str = 'ruff check') -> str:
+        """
+        Runs the linter.
+
+        Args:
+            path: The file or directory path to lint (default: current directory).
+            linter_command: The base command for the linter (default: 'ruff check'). Arguments like the path will be appended.
+
+        Returns:
+            The output from the linter.
+        """
+        if ".." in path.split(os.path.sep):
+             log.warning(f"Attempted to access parent directory in linter path: {path}")
+             return f"Error: Invalid path '{path}'. Cannot access parent directories."
+        target_path = os.path.abspath(os.path.expanduser(path))
+
+        # Basic command splitting, assumes simple command name possibly with one arg
+        command_parts = shlex.split(linter_command)
+        command = command_parts + [target_path]
+
+        return _run_quality_command(command, "Linter")
+
+
+class FormatterTool(BaseTool):
+    """Tool to run a code formatter (e.g., black, prettier)."""
+    name = "formatter"
+    description = "Runs a code formatter (default: 'black') on a specified path to automatically fix styling."
+
+    def execute(self, path: str = '.', formatter_command: str = 'black') -> str:
+        """
+        Runs the formatter.
+
+        Args:
+            path: The file or directory path to format (default: current directory).
+            formatter_command: The base command for the formatter (default: 'black'). Arguments like the path will be appended.
+
+        Returns:
+            The output from the formatter.
+        """
+        if ".." in path.split(os.path.sep):
+             log.warning(f"Attempted to access parent directory in formatter path: {path}")
+             return f"Error: Invalid path '{path}'. Cannot access parent directories."
+        target_path = os.path.abspath(os.path.expanduser(path))
+
+        # Basic command splitting
+        command_parts = shlex.split(formatter_command)
+        command = command_parts + [target_path]
+
+        return _run_quality_command(command, "Formatter")

gemini_cli/tools/summarizer_tool.py

@@ -0,0 +1,144 @@
+"""
+Tool for summarizing code files using an LLM.
+"""
+import google.generativeai as genai
+import logging
+import os
+from .base import BaseTool
+
+log = logging.getLogger(__name__)
+
+# Define thresholds for summarization vs. full view
+MAX_LINES_FOR_FULL_CONTENT = 1000 # View files smaller than this directly
+MAX_CHARS_FOR_FULL_CONTENT = 50 * 1024 # 50 KB
+
+# Simple summarization prompt
+SUMMARIZATION_SYSTEM_PROMPT = """You are an expert code summarizer. Given the following code file content, provide a concise summary focusing on:
+- The file's main purpose.
+- Key classes and functions defined (names and brief purpose).
+- Any major dependencies imported or used.
+- Overall structure.
+Keep the summary brief and informative, suitable for providing context to another AI agent."""
+
+class SummarizeCodeTool(BaseTool):
+    """
+    Tool to summarize a code file, especially useful for large files.
+    Returns full content for small files.
+    """
+    name = "summarize_code"
+    description = "Provides a summary of a code file's purpose, key functions/classes, and structure. Use for large files or when only an overview is needed."
+
+    def __init__(self, model_instance: genai.GenerativeModel | None = None):
+        """
+        Requires the initialized Gemini model instance for performing summarization.
+        (This implies the tool needs access to the model from the main class)
+        """
+        super().__init__()
+        # This creates a dependency: the tool needs the model.
+        # We'll need to modify how tools are instantiated or pass the model reference.
+        self.model = model_instance
+
+    def execute(self, file_path: str | None = None, directory_path: str | None = None, query: str | None = None, glob_pattern: str | None = None) -> str:
+        """
+        Summarizes code based on path, directory, or query.
+        # ... (rest of docstring)
+        """
+        log.debug(f"[SummarizeCodeTool] Current working directory: {os.getcwd()}")
+        log.info(f"SummarizeCodeTool called with file='{file_path}', dir='{directory_path}', query='{query}', glob='{glob_pattern}'")
+
+        if not self.model:
+             # This check is important if the model wasn't passed during init
+             log.error("SummarizeCodeTool cannot execute: Model instance not provided.")
+             return "Error: Summarization tool not properly configured (missing model instance)."
+
+        try:
+            # Basic path safety
+            if ".." in file_path.split(os.path.sep):
+                 log.warning(f"Attempted access to parent directory: {file_path}")
+                 return f"Error: Invalid file path '{file_path}'."
+
+            target_path = os.path.abspath(os.path.expanduser(file_path))
+            log.info(f"Summarize/View file: {target_path}")
+
+            if not os.path.exists(target_path):
+                 return f"Error: File not found: {file_path}"
+            if not os.path.isfile(target_path):
+                 return f"Error: Path is not a file: {file_path}"
+
+            # Check file size/lines
+            file_size = os.path.getsize(target_path)
+            line_count = 0
+            try:
+                 with open(target_path, 'r', encoding='utf-8', errors='ignore') as f:
+                      for _ in f:
+                           line_count += 1
+            except Exception:
+                 pass # Ignore line count errors, rely on size
+
+            log.debug(f"File '{file_path}': Size={file_size} bytes, Lines={line_count}")
+
+            # Return full content if file is small
+            if line_count < MAX_LINES_FOR_FULL_CONTENT and file_size < MAX_CHARS_FOR_FULL_CONTENT:
+                log.info(f"File '{file_path}' is small, returning full content.")
+                try:
+                    with open(target_path, 'r', encoding='utf-8', errors='ignore') as f:
+                        content = f.read()
+                    # Add a prefix to indicate it's full content
+                    return f"--- Full Content of {file_path} ---\n{content}"
+                except Exception as read_err:
+                    log.error(f"Error reading small file '{target_path}': {read_err}", exc_info=True)
+                    return f"Error reading file: {read_err}"
+
+            # Generate summary if file is large
+            else:
+                log.info(f"File '{file_path}' is large, attempting summarization...")
+                try:
+                    with open(target_path, 'r', encoding='utf-8', errors='ignore') as f:
+                        # Limit content sent for summarization to avoid exceeding limits there too?
+                        # E.g., read only first/last N lines or first X KB. For now, read all.
+                        content_to_summarize = f.read()
+
+                    if not content_to_summarize.strip():
+                         return f"--- Summary of {file_path} ---\n(File is empty)"
+
+                    # Prepare prompt for internal summarization call
+                    summarization_prompt = f"Please summarize the following code from the file '{file_path}':\n\n```\n{content_to_summarize[:20000]}\n```" # Limit sent content
+
+                    # Make the internal LLM call for summarization
+                    # Use a simpler generation config? No tools needed here.
+                    summary_config = genai.types.GenerationConfig(temperature=0.3) # Low temp for factual summary
+                    summary_response = self.model.generate_content(
+                        contents=[
+                             # Provide system prompt separately if API supports it, otherwise prepend
+                             {'role': 'user', 'parts': [SUMMARIZATION_SYSTEM_PROMPT, summarization_prompt]}
+                        ],
+                        generation_config=summary_config,
+                        # safety_settings= ... # Use parent's safety settings?
+                    )
+
+                    summary_text = self._extract_text_from_summary_response(summary_response)
+
+                    # Add a prefix to indicate it's a summary
+                    return f"--- Summary of {file_path} ---\n{summary_text}"
+
+                except Exception as summary_err:
+                    log.error(f"Error generating summary for '{target_path}': {summary_err}", exc_info=True)
+                    return f"Error generating summary: {summary_err}"
+
+        except Exception as e:
+            log.error(f"Error in SummarizeCodeTool for '{file_path}': {e}", exc_info=True)
+            return f"Error processing file for summary/view: {str(e)}"
+
+    # Helper to extract text from the internal summarization call's response
+    def _extract_text_from_summary_response(self, response):
+        try:
+            if response.candidates:
+                 if response.candidates[0].finish_reason.name == "STOP":
+                      return "".join(part.text for part in response.candidates[0].content.parts if hasattr(part, 'text'))
+                 else:
+                      return f"(Summarization failed: {response.candidates[0].finish_reason.name})"
+            else:
+                 return "(Summarization failed: No candidates)"
+        except Exception as e:
+             log.error(f"Error extracting summary text: {e}")
+             return "(Error extracting summary text)"