codeboarding 0.9.0__py3-none-any.whl

agents/tools/get_external_deps.py

@@ -0,0 +1,47 @@
+import logging
+from typing import Optional
+from langchain_core.tools import ArgsSchema
+from pydantic import BaseModel
+from agents.tools.base import BaseRepoTool
+from agents.dependency_discovery import discover_dependency_files
+
+logger = logging.getLogger(__name__)
+
+
+class ExternalDepsInput(BaseModel):
+    pass
+
+
+class ExternalDepsTool(BaseRepoTool):
+    name: str = "readExternalDeps"
+    description: str = (
+        "Scans the current repository to find common dependency files."
+        "Returns a list of file paths that can be examined with the readFile tool."
+    )
+    args_schema: Optional[ArgsSchema] = ExternalDepsInput
+    return_direct: bool = False
+
+    def _run(self) -> str:
+        """
+        Run the tool to find dependency files.
+        """
+        logger.info("[ExternalDeps Tool] Searching for dependency files")
+
+        discovered = discover_dependency_files(self.repo_dir, self.ignore_manager)
+
+        if not discovered:
+            logger.warning("[ExternalDeps Tool] No dependency files found in the repository.")
+            return "No dependency files found in this repository. Searched for common files like requirements.txt, pyproject.toml, setup.py, environment.yml, Pipfile, etc."
+
+        summary = f"Found {len(discovered)} dependency file(s):\n\n"
+
+        for i, item in enumerate(discovered, 1):
+            relative_path = item.path.relative_to(self.repo_dir)
+            summary += f'{i}. {relative_path}\n   To read this file: Use the readFile tool with file_path="{relative_path}" and line_number=0\n\n'
+
+        logger.info(
+            f"[ExternalDeps Tool] Found {len(discovered)} dependency file(s): "
+            f"{', '.join(str(d.path.relative_to(self.repo_dir)) for d in discovered)}"
+        )
+
+        return summary

agents/tools/get_method_invocations.py

@@ -0,0 +1,47 @@
+import logging
+from typing import Optional
+from langchain_core.tools import ArgsSchema
+from pydantic import BaseModel, Field
+from agents.tools.base import BaseRepoTool
+
+logger = logging.getLogger(__name__)
+
+
+class MethodInvocationsInput(BaseModel):
+    method: str = Field(description="The name of the method for which to retrieve its immediate callees and calls.")
+
+
+class MethodInvocationsTool(BaseRepoTool):
+    name: str = "getMethodInvocationsTool"
+    description: str = (
+        "Retrieves complete project control flow graph (CFG) in DOT format. "
+        "Use once at the start of analysis to understand overall architecture. "
+        "Shows all function/method calls and execution flow across the codebase. "
+        "Primary data source - analyze this output before using other tools. "
+        "No input arguments required."
+    )
+    args_schema: Optional[ArgsSchema] = MethodInvocationsInput
+
+    def _run(self, method: str) -> str:
+        """
+        Executes the tool to read and return the project's control flow graph.
+        """
+        if not self.static_analysis:
+            return "No static analysis data available."
+
+        results = ""
+        for lang in self.static_analysis.get_languages():
+            # Attempt to retrieve the control flow graph for the specified language
+            cfg = self.static_analysis.get_cfg(lang)
+            for edge in cfg.edges:
+                if edge.src_node.fully_qualified_name == method:
+                    results += (
+                        f"Method {edge.src_node.fully_qualified_name} is calling {edge.dst_node.fully_qualified_name}\n"
+                    )
+                if edge.dst_node.fully_qualified_name == method:
+                    results += f"Method {edge.dst_node.fully_qualified_name} is called by {edge.src_node.fully_qualified_name}\n"
+        if results:
+            return results.strip()
+        # If no results found, return a message indicating no calls or callees
+        logger.warning(f"[MethodInvocationsTool] No method invocations found for {method}.")
+        return f"No method invocations found for the {method}. Try reading the source with the `getSourceCode` tool for full details."

agents/tools/read_cfg.py

@@ -0,0 +1,60 @@
+import logging
+from agents.agent_responses import Component
+from agents.tools.base import BaseRepoTool
+
+logger = logging.getLogger(__name__)
+
+
+class GetCFGTool(BaseRepoTool):
+    name: str = "getControlFlowGraph"
+    description: str = (
+        "Retrieves complete project control flow graph (CFG) showing all method calls. "
+        "Primary analysis tool - use this first to understand project execution flow. "
+        "Provides graphical representation of function/method relationships. "
+        "Essential data - analyze this output thoroughly before using other tools. "
+        "No input arguments required."
+    )
+
+    def _run(self) -> str:
+        """
+        Executes the tool to read and return the project's control flow graph.
+        """
+        if not self.static_analysis:
+            return "No static analysis data available."
+        result_str = ""
+        for lang in self.static_analysis.get_languages():
+            cfg = self.static_analysis.get_cfg(lang)
+            logger.info(
+                f"[CFG Tool] Reading control flow graph for {lang}, nodes: {len(cfg.nodes)}, edges: {len(cfg.edges)}"
+            )
+            if cfg is None:
+                logging.warning(f"[CFG Tool] No control flow graph found for {lang}.")
+                continue
+            result_str += f"Control flow graph for {lang}:\n{cfg.llm_str()}\n"
+        if not result_str:
+            logging.error("[CFG Tool] No control flow graph data available.")
+            return "No control flow graph data available. Ensure static analysis was performed correctly."
+        return result_str
+
+    def component_cfg(self, component: Component) -> str:
+        if not self.static_analysis:
+            return "No static analysis data available."
+        items = 0
+        result = f"Control flow graph for {component.name}:\n"
+        skip_nodes: list = []
+        for lang in self.static_analysis.get_languages():
+            logger.info(f"[CFG Tool] Filtering CFG for component {component.name} in {lang}")
+            cfg = self.static_analysis.get_cfg(lang)
+            if cfg is None:
+                logging.warning(f"[CFG Tool] No control flow graph found for {lang}.")
+                continue
+            for _, node in cfg.nodes.items():
+                if node.file_path not in component.assigned_files:
+                    skip_nodes.append(node)
+            result += f"{lang}:\n{cfg.llm_str(skip_nodes=skip_nodes)}\n"
+            items += len(cfg.nodes) - len(skip_nodes)
+
+        logger.info(f"[CFG Tool] Filtering CFG for component {component.name}, items found: {items}")
+        if items == 0:
+            return "No control flow graph data available for this component. Ensure static analysis was performed correctly or the component has valid source code references."
+        return result

agents/tools/read_docs.py

@@ -0,0 +1,132 @@
+import logging
+from pathlib import Path
+from langchain_core.tools import ArgsSchema
+from pydantic import BaseModel, Field
+from agents.tools.base import BaseRepoTool
+
+logger = logging.getLogger(__name__)
+
+
+class ReadDocsFile(BaseModel):
+    """Input for ReadDocsTool."""
+
+    file_path: str | None = Field(
+        None,
+        description="Path to the documentation file to read, use relative paths from the root of the project. If not provided, will read README.md",
+    )
+    line_number: int | None = Field(
+        0, description="Line number to focus on. The tool will return content centered around this line."
+    )
+
+
+class ReadDocsTool(BaseRepoTool):
+    name: str = "readDocs"
+    description: str = (
+        "Reads project documentation files (README, .md, .rst, .txt). "
+        "Use early in analysis to understand project purpose and architecture. "
+        "Defaults to README.md if no path specified. "
+        "Provides project understanding without code analysis. "
+        "Focus on architecture sections, not detailed API documentation."
+    )
+    args_schema: ArgsSchema | None = ReadDocsFile
+    return_direct: bool = False
+    LINES_TO_RETURN: int = 300
+
+    @property
+    def cached_files(self) -> list[Path]:
+        """
+        Returns documentation files from the cached file list.
+        """
+        files = self.context.get_files()
+        patterns = (".md", ".rst", ".txt", ".html")
+        doc_files = []
+        for path in files:
+            if path.suffix.lower() in patterns:
+                # Maintain additional test exclusion if needed, though get_files already handles ignore_manager
+                if "tests" in path.parts or "test" in path.name.lower():
+                    continue
+                doc_files.append(path)
+        return sorted(doc_files, key=lambda x: len(x.parts))
+
+    def _run(self, file_path: str | None = None, line_number: int = 0) -> str:
+        """
+        Run the tool with the given input.
+        """
+        if file_path is None:
+            file_path = "README"
+        file_path_obj = Path(file_path)
+
+        read_file: Path | None = None
+        if self.cached_files:
+            for cached_file in self.cached_files:
+                if self.is_subsequence(file_path_obj, cached_file):
+                    read_file = cached_file
+                    break
+
+        if read_file is None:
+            if file_path_obj.stem.lower() == "readme":
+                if self.cached_files and self.repo_dir:
+                    available_files = [str(f.relative_to(self.repo_dir)) for f in self.cached_files]
+                    if not available_files:
+                        return "No documentation files found in this repository."
+                    return "README not found. Available documentation files:\n\n" + "\n".join(
+                        f"- {f}" for f in available_files
+                    )
+                else:
+                    return "No documentation files found in this repository."
+
+            if self.cached_files and self.repo_dir:
+                files_str = "\n".join([str(f.relative_to(self.repo_dir)) for f in self.cached_files])
+            else:
+                files_str = "No files available"
+            return (
+                f"Error: The specified file '{file_path_obj}' was not found. "
+                f"Available documentation files:\n{files_str}"
+            )
+
+        try:
+            with open(read_file, "r", encoding="utf-8") as file:
+                logger.info(f"[ReadDocs Tool] Reading file {read_file} around line {line_number}")
+                lines = file.readlines()
+        except Exception as e:
+            return f"Error reading file {file_path_obj}: {str(e)}"
+
+        total_lines = len(lines)
+        if line_number < 0 or line_number >= total_lines:
+            if total_lines == 0:
+                return f"File {file_path_obj} is empty."
+            return f"Error: Line number {line_number} is out of range (0-{total_lines - 1})"
+
+        if line_number < self.LINES_TO_RETURN // 2:
+            start_line = 0
+            end_line = min(total_lines, self.LINES_TO_RETURN)
+        else:
+            start_line = max(0, line_number - (self.LINES_TO_RETURN // 2))
+            end_line = min(total_lines, start_line + self.LINES_TO_RETURN)
+            if end_line - start_line < self.LINES_TO_RETURN and start_line > 0:
+                potential_start = max(0, total_lines - self.LINES_TO_RETURN)
+                if potential_start < start_line:
+                    start_line = potential_start
+
+        selected_lines = lines[start_line:end_line]
+        numbered_lines = [f"{i + start_line:4}:{line}" for i, line in enumerate(selected_lines)]
+        content = "".join(numbered_lines)
+
+        file_info = f"File: {file_path_obj}\n"
+        if total_lines > self.LINES_TO_RETURN:
+            file_info += f"Lines {start_line}-{end_line - 1} (centered around line {line_number}, total lines: {total_lines})\n\n"
+        else:
+            file_info += f"Full content ({total_lines} lines):\n\n"
+
+        if self.cached_files:
+            other_files = [f for f in self.cached_files if f != read_file]
+        else:
+            other_files = []
+        result = file_info + content
+
+        if other_files and self.repo_dir is not None:
+            relative_files = [str(f.relative_to(self.repo_dir)) for f in other_files]
+            result += "\n\n--- Other Available Documentation Files ---\n"
+            result += "\n".join(f"- {f}" for f in relative_files)
+
+        return result

agents/tools/read_file.py

@@ -0,0 +1,90 @@
+import logging
+from pathlib import Path
+from langchain_core.tools import ArgsSchema
+from pydantic import BaseModel, Field
+from agents.tools.base import BaseRepoTool
+
+logger = logging.getLogger(__name__)
+
+
+class ReadFileInput(BaseModel):
+    """Input for ReadFileTool."""
+
+    file_path: str = Field(
+        ..., description="Path to the file to read, use relative paths from the root of the project. "
+    )
+    line_number: int = Field(..., description="Line number to focus on")
+
+
+class ReadFileTool(BaseRepoTool):
+    name: str = "readFile"
+    description: str = (
+        "Reads specific file content around a target line number. "
+        "Use only when specific implementation details are needed that CFG cannot provide. "
+        "Returns 300 lines centered on the requested line. "
+        "Avoid exploratory reading - use only when you know exactly what to examine."
+    )
+    args_schema: ArgsSchema | None = ReadFileInput
+    return_direct: bool = False
+
+    @property
+    def cached_files(self) -> list[Path]:
+        files = self.context.get_files()
+        return sorted(files, key=lambda x: len(x.parts))
+
+    def _run(self, file_path: str, line_number: int) -> str:
+        """
+        Run the tool with the given input.
+        """
+        logger.info(f"[ReadFile Tool] Reading file {file_path} around line {line_number}")
+
+        file_path_obj = Path(file_path)
+        read_file: Path | None = None
+        if self.cached_files:
+            for cached_file in self.cached_files:
+                if self.is_subsequence(file_path_obj, cached_file):
+                    read_file = cached_file
+                    break
+
+        common_prefix = str(self.repo_dir) if self.repo_dir else ""
+        if read_file is None:
+            if self.cached_files and self.repo_dir:
+                files_str = "\n".join(
+                    [str(f.relative_to(self.repo_dir)) for f in self.cached_files if f.suffix == file_path_obj.suffix]
+                )
+            else:
+                files_str = "No files cached"
+            logger.error(f"[ReadFile Tool] File {file_path} not found in cached files.")
+            return (
+                f"Error: The specified file '{file_path}' was not found in the indexed source files. "
+                f"Please ensure the path is correct and points to an existing file: {common_prefix}/\n{files_str}."
+            )
+
+        # Read the file content
+        with open(read_file, "r", encoding="utf-8") as file:
+            lines = file.readlines()
+
+        total_lines = len(lines)
+        if line_number < 0 or line_number >= total_lines:
+            logger.error(f"[ReadFile Tool] Line number {line_number} is out of range. Total lines: {total_lines}")
+            return f"Error: Line number {line_number} is out of range (0-{total_lines - 1})"
+
+        # Calculate start and end line numbers
+        if line_number < 150:
+            start_line = 0
+            end_line = min(total_lines, 300)
+        else:
+            start_line = max(0, line_number - 150)
+            end_line = min(total_lines, start_line + 300)
+            if end_line - start_line < 300 and start_line > 0:
+                potential_start = max(0, total_lines - 300)
+                if potential_start < start_line:
+                    start_line = potential_start
+
+        selected_lines = lines[start_line:end_line]
+        numbered_lines = [f"{i + 1 + start_line:4}:{line}" for i, line in enumerate(selected_lines)]
+        content = "".join(numbered_lines)
+        logger.info(f"[ReadFile Tool] Successfully read {len(selected_lines)} lines from {file_path} ")
+        return (
+            f"File: {file_path}\nLines {start_line}-{end_line - 1} (centered around line {line_number}):\n\n{content}"
+        )

agents/tools/read_file_structure.py

@@ -0,0 +1,156 @@
+import logging
+from pathlib import Path
+from langchain_core.tools import ArgsSchema
+from pydantic import BaseModel, Field
+
+from agents.constants import FileStructureConfig
+from agents.tools.base import BaseRepoTool
+
+logger = logging.getLogger(__name__)
+
+
+class DirInput(BaseModel):
+    dir: str | None = Field(
+        default=".",
+        description=(
+            "Relative path to the directory whose file structure should be retrieved. "
+            "Defaults to the project root if not specified (i.e., use '.' for root)."
+        ),
+    )
+
+
+class FileStructureTool(BaseRepoTool):
+    name: str = "getFileStructure"
+    description: str = (
+        "Returns project directory structure as a tree. "
+        "Use only when project layout is unclear from existing context. "
+        "Most effective for understanding overall project organization. "
+        "Avoid recursive calls - use once for high-level structure understanding."
+    )
+    args_schema: ArgsSchema | None = DirInput
+    return_direct: bool = False
+
+    @property
+    def cached_dirs(self) -> list[Path]:
+        dirs = self.context.get_directories()
+        # Ensure they are sorted by depth for is_subsequence logic
+        return sorted(dirs, key=lambda x: len(x.parts))
+
+    def _run(self, dir: str | None = None) -> str:
+        """
+        Run the tool with the given input.
+        """
+        if dir == "." and self.repo_dir:
+            # Start with a reasonable depth limit
+            max_depth = 10
+            tree_lines = get_tree_string(self.repo_dir, max_depth=max_depth, ignore_manager=self.ignore_manager)
+
+            # If we hit the line limit, try again with progressively lower depths
+            while len(tree_lines) >= FileStructureConfig.MAX_LINES and max_depth > 1:
+                max_depth -= 1
+                tree_lines = get_tree_string(self.repo_dir, max_depth=max_depth, ignore_manager=self.ignore_manager)
+
+            tree_structure = "\n".join(tree_lines)
+            depth_info = f" (limited to depth {max_depth})" if max_depth < 10 else ""
+            return f"The file tree for {dir}{depth_info} is:\n{tree_structure}"
+
+        if not dir:
+            return "Error: No directory specified."
+
+        dir_path = Path(dir)
+        searching_dir: Path | None = None
+        if self.cached_dirs:
+            for d in self.cached_dirs:
+                # check if dir is a subdirectory of the cached directory
+                if self.is_subsequence(dir_path, d):
+                    logger.info(f"[File Structure Tool] Found directory {d}")
+                    searching_dir = d
+                    break
+
+            if searching_dir is None:
+                dir_path = Path(*dir_path.parts[1:])
+                for d in self.cached_dirs:
+                    # check if dir is a subdirectory of the cached directory
+                    if self.is_subsequence(dir_path, d):
+                        logger.info(f"[File Structure Tool] Found directory {d}")
+                        searching_dir = d
+                        break
+
+        if searching_dir is None:
+            logger.error(f"[File Structure Tool] Directory {dir} not found in cached directories.")
+            cached_str = ", ".join([str(d) for d in self.cached_dirs]) if self.cached_dirs else "None"
+            return f"Error: The specified directory does not exist or is empty. Available directories are: {cached_str}"
+
+        logger.info(f"[File Structure Tool] Reading file structure for {searching_dir}")
+
+        # Start with a reasonable depth limit
+        max_depth = 10
+        tree_lines = get_tree_string(searching_dir, max_depth=max_depth, ignore_manager=self.ignore_manager)
+
+        # If we hit the line limit, try again with progressively lower depths
+        while len(tree_lines) >= 50000 and max_depth > 1:
+            max_depth -= 1
+            tree_lines = get_tree_string(
+                searching_dir,
+                max_depth=max_depth,
+                max_lines=FileStructureConfig.MAX_LINES,
+                ignore_manager=self.ignore_manager,
+            )
+
+        tree_structure = "\n".join(tree_lines)
+        depth_info = f" (limited to depth {max_depth})" if max_depth < 10 else ""
+        return f"The file tree for {dir}{depth_info} is:\n{tree_structure}"
+
+
+def get_tree_string(
+    startpath: Path,
+    indent: str = "",
+    max_depth: float = float("inf"),
+    current_depth: int = 0,
+    max_lines: int = 100,
+    ignore_manager=None,
+) -> list[str]:
+    """
+    Generate a tree-like string representation of the directory structure.
+    """
+    tree_lines: list[str] = []
+
+    # Stop if we've exceeded max depth
+    if current_depth > max_depth:
+        return tree_lines
+
+    try:
+        # Filter entries using the ignore manager
+        entries = sorted([p for p in startpath.iterdir() if not (ignore_manager and ignore_manager.should_ignore(p))])
+    except (PermissionError, FileNotFoundError):
+        # Handle permission errors or non-existent directories
+        return [indent + "└── [Error reading directory]"]
+
+    for i, entry_path in enumerate(entries):
+        # Check if we've exceeded the maximum number of lines
+        if len(tree_lines) >= max_lines:
+            tree_lines.append(indent + "└── [Output truncated due to size limits]")
+            return tree_lines
+
+        connector = "└── " if i == len(entries) - 1 else "├── "
+        tree_lines.append(indent + connector + entry_path.name)
+
+        if entry_path.is_dir():
+            extension = "    " if i == len(entries) - 1 else "│   "
+            subtree = get_tree_string(
+                entry_path,
+                indent + extension,
+                max_depth,
+                current_depth + 1,
+                max_lines - len(tree_lines),
+                ignore_manager=ignore_manager,
+            )
+            tree_lines.extend(subtree)
+
+            # Check again after adding subtree
+            if len(tree_lines) >= max_lines:
+                if tree_lines[-1] != indent + "└── [Output truncated due to size limits]":
+                    tree_lines.append(indent + "└── [Output truncated due to size limits]")
+                return tree_lines
+
+    return tree_lines

agents/tools/read_git_diff.py

@@ -0,0 +1,131 @@
+import logging
+from langchain_core.tools import ArgsSchema
+from pydantic import BaseModel, Field
+from agents.tools.base import BaseRepoTool
+from repo_utils.git_diff import FileChange
+
+logger = logging.getLogger(__name__)
+
+
+class ReadDiffInput(BaseModel):
+    """Input for ReadDiffTool."""
+
+    file_path: str = Field(
+        ..., description="Path to the file to read diff for, use relative paths from the root of the project"
+    )
+    line_number: int = Field(
+        default=1,
+        description="Line number to focus on within the diff (1-based). For large diffs, this allows viewing different sections. Default is 1 to start from the beginning.",
+    )
+
+
+class ReadDiffTool(BaseRepoTool):
+    name: str = "readDiffFile"
+    description: str = (
+        "Reads the diff for a specified file and returns the changes made (additions and deletions). "
+        "This tool shows what lines were added (+) and removed (-) in the file. "
+        "For large diffs, it shows up to 100 lines around the specified line_number. "
+        "If the diff is truncated, you can call this tool again with a different line_number to see other sections."
+    )
+    args_schema: ArgsSchema | None = ReadDiffInput
+    return_direct: bool = False
+    diffs: list[FileChange] | None = None
+
+    def __init__(self, **kwargs):
+        # Allow passing diffs via kwargs
+        diffs = kwargs.pop("diffs", None)
+        super().__init__(**kwargs)
+        self.diffs = diffs
+
+    def _run(self, file_path: str, line_number: int = 1) -> str:
+        """
+        Run the tool with the given input.
+        """
+        logger.info(f"[ReadDiff Tool] Reading diff for file {file_path} around line {line_number}")
+
+        if not self.diffs:
+            return "Error: No diff information available."
+
+        # Find the matching file change
+        matching_change = None
+        for change in self.diffs:
+            if change.filename == file_path or change.filename.endswith(file_path):
+                matching_change = change
+                break
+
+        if matching_change is None:
+            # Provide helpful error message with available files
+            available_files = [change.filename for change in self.diffs]
+            files_str = "\n".join(available_files) if available_files else "No files with changes found"
+            return f"Error: No diff found for file '{file_path}'. Available files with changes:\n{files_str}"
+
+        # Format the diff output
+        result = [
+            f"File: {matching_change.filename}",
+            f"Total additions: {matching_change.additions}, Total deletions: {matching_change.deletions}",
+            "",
+        ]
+
+        # Combine all diff lines for pagination
+        all_diff_lines = []
+
+        # Add deletions with prefixes
+        for line in matching_change.removed_lines:
+            all_diff_lines.append(f"- {line}")
+
+        # Add additions with prefixes
+        for line in matching_change.added_lines:
+            all_diff_lines.append(f"+ {line}")
+
+        total_diff_lines = len(all_diff_lines)
+        if total_diff_lines == 0:
+            result.append(
+                "No detailed line changes available (file may have been moved, renamed, or had binary changes)"
+            )
+            return "\n".join(result)
+
+        # Handle pagination similar to ReadFileTool
+        max_lines_to_show = 100
+        line_number = max(1, line_number)  # Ensure line_number is at least 1
+
+        if line_number > total_diff_lines:
+            result.append(f"Error: Line number {line_number} is out of range (1-{total_diff_lines})")
+            return "\n".join(result)
+
+        # Calculate start and end line numbers
+        if line_number <= 50:
+            start_line = 0
+            end_line = min(total_diff_lines, max_lines_to_show)
+        else:
+            # Center around the specified line number
+            start_line = max(0, line_number - 51)  # -51 because line_number is 1-based
+            end_line = min(total_diff_lines, start_line + max_lines_to_show)
+
+            if end_line - start_line < max_lines_to_show and start_line > 0:
+                potential_start = max(0, total_diff_lines - max_lines_to_show)
+                if potential_start < start_line:
+                    start_line = potential_start
+
+        # Extract the lines to display
+        displayed_lines = all_diff_lines[start_line:end_line]
+
+        result.append(f"=== DIFF CONTENT (Lines {start_line + 1}-{end_line} of {total_diff_lines}) ===")
+        for i, line in enumerate(displayed_lines):
+            result.append(f"{start_line + i + 1:4}: {line}")
+
+        # Add truncation notice if needed
+        if total_diff_lines > max_lines_to_show:
+            if end_line < total_diff_lines:
+                result.append("")
+                result.append(
+                    f"*** DIFF TRUNCATED: Showing lines {start_line + 1}-{end_line} of {total_diff_lines} total diff lines ***"
+                )
+                result.append(f"To see more, call this tool again with line_number > {end_line}")
+            elif start_line > 0:
+                result.append("")
+                result.append(
+                    f"*** DIFF TRUNCATED: Showing lines {start_line + 1}-{end_line} of {total_diff_lines} total diff lines ***"
+                )
+                result.append(f"To see earlier content, call this tool again with a smaller line_number")
+
+        return "\n".join(result)