21class CatTool:
 22    """
 23    Simulates `cat` cli tool.
 24    """
 25
 26    def __init__(self, root_folder: str, config: Config) -> None:
 27        """
 28        Initialize the CatTool class.
 29
 30        Args:
 31            root_folder (str): The root folder path for file operations.
 32            config (Config): The developer input that bot shouldn't set.
 33        """
 34        self.root_folder = root_folder
 35        self.config = config
 36
 37    @log()
 38    def cat_markdown(
 39        self,
 40        file_paths: list[str],
 41        number_lines: bool = True,
 42        squeeze_blank: bool = False,
 43    ) -> str:
 44        """
 45        Concatenates the content of given file paths and formats them as markdown.
 46
 47        Args:
 48            file_paths (list[str]): List of file paths to concatenate.
 49            number_lines (bool, optional): If True, number all output lines.
 50            squeeze_blank (bool, optional): If True, consecutive blank lines are squeezed to one.
 51
 52        Returns:
 53            str: The concatenated and formatted content as a string.
 54        """
 55        output = StringIO()
 56        for line in self.cat(file_paths, number_lines, squeeze_blank):
 57            output.write(line)
 58            # output.write("\n")
 59        output.seek(0)
 60        return output.read()
 61
 62    @log()
 63    def cat(
 64        self,
 65        file_paths: list[str],
 66        number_lines: bool = True,
 67        squeeze_blank: bool = False,
 68    ) -> Generator[str, None, None]:
 69        """
 70        Mimics the basic functionalities of the 'cat' command in Unix.
 71
 72        Args:
 73            file_paths (list[str]): A list of file paths to concatenate.
 74            number_lines (bool, optional): If True, number all output lines.
 75            squeeze_blank (bool, optional): If True, consecutive blank lines are squeezed to one.
 76
 77        Returns:
 78            Generator[str, None, None]
 79
 80        Yields:
 81            str: Each line of the concatenated files.
 82        """
 83        file_paths = convert_to_list(file_paths)
 84        for location, file_path in enumerate(file_paths):
 85            if file_path.startswith("./"):
 86                file_paths[location] = file_path[2:]
 87
 88        logger.info(f"cat --file_paths {file_paths} " f"--number_lines {number_lines} --squeeze_blank {squeeze_blank}")
 89        for file_path in file_paths:
 90            if not is_file_in_root_folder(file_path, self.root_folder):
 91                raise TypeError("No parent folder traversals allowed")
 92
 93        line_number = 1
 94        for glob_pattern in file_paths:
 95            for file_path in safe_glob(glob_pattern, self.root_folder):
 96                if not os.path.isabs(file_path):
 97                    file_path = self.root_folder + "/" + file_path
 98                try:
 99                    with open(file_path, "rb") as file:
100                        for line in self._process_cat_file(file, line_number, number_lines, squeeze_blank):
101                            yield line
102                            line_number += 1
103                except PermissionError:
104                    logger.warning(f"Permission denied: {file_path}, suppressing from output.")
105
106    def _process_cat_file(
107        self,
108        file: IO[bytes],
109        line_number: int,
110        number_lines: bool,
111        squeeze_blank: bool,
112    ) -> Generator[str, None, None]:
113        """
114        Processes a file for concatenation, applying the specified formatting.
115
116        Args:
117            file: The file object to process.
118            line_number (int): Current line number for numbering lines.
119            number_lines (bool): If True, number all output lines.
120            squeeze_blank (bool): If True, consecutive blank lines are squeezed to one.
121
122        Returns:
123            Generator[str, None, None]: A generator of processed lines.
124
125        Yields:
126            str: Each processed line of the file.
127        """
128        was_blank = False
129        for byte_lines in file:
130            # if isinstance(byte_lines, bytes):
131            line = byte_lines.decode("utf-8")  # Decode bytes to string
132
133            # Use StringIO for memory-efficient line processing
134            with StringIO() as line_buffer:
135                # Normalize line endings to \n
136                line = line.replace("\r\n", "\n")
137                line_buffer.write(line)
138
139                if squeeze_blank and was_blank and line.strip() == "":
140                    continue  # Skip consecutive blank lines
141
142                was_blank = line.strip() == ""
143
144                if number_lines:
145                    line_buffer.seek(0)
146                    line = f"{line_number}\t{line_buffer.read()}"
147                    line_number += 1
148                else:
149                    line = line_buffer.getvalue()
150
151                yield line

 67@dataclasses.dataclass
 68class CutTool:
 69    """
 70    Simulates `cut` cli tool.
 71    """
 72
 73    def __init__(self, root_folder: str, config: Config) -> None:
 74        """
 75        Initialize the CatTool class.
 76
 77        Args:
 78            root_folder (str): The root folder path for file operations.
 79            config (Config): The developer input that bot shouldn't set.
 80        """
 81        self.root_folder = root_folder
 82        self.config = config
 83        self.utf8_errors = config.get_value("utf8_errors", "surrogateescape")
 84
 85    @log()
 86    def cut_characters(self, file_path: str, character_ranges: str) -> str:
 87        """Reads a file and extracts characters based on specified ranges.
 88
 89        Args:
 90            file_path: The name of the file to process.
 91            character_ranges: A string representing character ranges, e.g., "1-5,10".
 92
 93        Returns:
 94            A string containing the selected characters from the file.
 95        """
 96        if not is_file_in_root_folder(file_path, self.root_folder):
 97            raise ValueError(f"File {file_path} is not in root folder {self.root_folder}.")
 98        ranges = parse_ranges(character_ranges)
 99        output = io.StringIO()
100
101        try:
102            with open(file_path, encoding="utf-8", errors=self.utf8_errors) as file:
103                for line in file:
104                    for i, char in enumerate(line, start=1):
105                        if is_in_ranges(i, ranges):
106                            output.write(char)
107
108                    # Optionally add a newline character after each line
109                    output.write("\n")
110        except FileNotFoundError:
111            tree_text = tree(Path(os.getcwd()))
112            markdown_content = f"# File {file_path} not found. Here are all the files you can see\n\n{tree_text}"
113            return markdown_content
114
115        return output.getvalue()
116
117    @log()
118    def cut_fields(self, filename: str, field_ranges: str, delimiter: str = ",") -> str:
119        """Reads a file and extracts fields based on specified ranges using the given delimiter.
120
121        Args:
122            filename: The name of the file to process.
123            field_ranges: A string representing field ranges, e.g., "1-3,5".
124            delimiter: A single character used as the field delimiter.
125
126        Returns:
127            A string containing the selected fields from the file.
128        """
129        if not is_file_in_root_folder(filename, self.root_folder):
130            raise ValueError(f"File {filename} is not in root folder {self.root_folder}.")
131        ranges = parse_ranges(field_ranges)
132        output = io.StringIO()
133        try:
134            with open(filename, encoding="utf-8", errors=self.utf8_errors) as file:
135                reader = csv.reader(file, delimiter=delimiter)
136
137                for row in reader:
138                    selected_fields = [field for i, field in enumerate(row, start=1) if is_in_ranges(i, ranges)]
139                    output.write(delimiter.join(selected_fields) + "\n")
140        except FileNotFoundError:
141            # Host app should always have cwd == root dir.
142            tree_text = tree(Path(os.getcwd()))
143            markdown_content = f"# File {filename} not found. Here are all the files you can see\n\n{tree_text}"
144            return markdown_content
145
146        return output.getvalue()
147
148    @log()
149    def cut_fields_by_name(self, filename: str, field_names: list[str], delimiter: str = ",") -> str:
150        """Reads a file and extracts fields based on specified field names using the given delimiter.
151
152        Args:
153            filename(str): The name of the file to process.
154            field_names(list[str]): A list of field names to extract.
155            delimiter(str): A single character used as the field delimiter.
156
157        Returns:
158            A string containing the selected fields from the file.
159        """
160        if not is_file_in_root_folder(filename, self.root_folder):
161            raise ValueError(f"File {filename} is not in root folder {self.root_folder}.")
162        output = io.StringIO()
163
164        try:
165            with open(filename, encoding="utf-8", errors=self.utf8_errors) as file:
166                reader = csv.DictReader(file, delimiter=delimiter)
167                # field_indices = {field: i for i, field in enumerate(reader.fieldnames)}
168
169                for row in reader:
170                    selected_fields = [row[field] for field in field_names if field in row]
171                    output.write(delimiter.join(selected_fields) + "\n")
172        except FileNotFoundError:
173            tree_text = tree(Path(os.getcwd()))
174            markdown_content = f"# File {filename} not found. Here are all the files you can see\n\n{tree_text}"
175            return markdown_content
176
177        return output.getvalue()

 22class FindTool:
 23    def __init__(self, root_folder: str, config: Config) -> None:
 24        """
 25        Initialize the FindTool class.
 26
 27        Args:
 28            root_folder (str): The root folder path for file operations.
 29            config (Config): The developer input that bot shouldn't set.
 30        """
 31        self.root_folder = root_folder
 32        self.config = config
 33        self.auto_cat = config.get_flag("auto_cat", True)
 34
 35    @log()
 36    def find_files(
 37        self,
 38        name: str | None = None,
 39        regex: str | None = None,
 40        file_type: str | None = None,
 41        size: str | None = None,
 42    ) -> list[str]:
 43        """
 44        Recursively search for files or directories matching given criteria in a directory and its subdirectories.
 45
 46        Args:
 47            name (str | None, optional): The exact name to match filenames against.
 48            regex (str | None, optional): The regex pattern to match filenames against.
 49            file_type (str | None, optional): The type to filter ('file' or 'directory').
 50            size (str | None, optional): The size to filter files by, e.g., '+100' for files larger than 100 bytes.
 51
 52        Returns:
 53            list[str]: A list of paths to files or directories that match the criteria.
 54        """
 55        logger.info(f"find --name {name} --regex {regex} --type {file_type} --size {size}")
 56        matching_files = []
 57        for root, dirs, files in os.walk(os.getcwd()):
 58            # Combine files and directories for type filtering
 59            combined = files
 60            if file_type == "directory":
 61                combined += dirs
 62
 63            for entry in combined:
 64                full_path = os.path.join(root, entry)
 65                # TODO: handle this differently
 66                if "__pycache__" not in full_path:
 67                    # TODO: handle differently. The bot
 68                    # is put into the root_folder as cwd, so as long as there isn't .. in path we should be good.
 69                    # if is_file_in_root_folder(full_path, self.root_folder):
 70                    short_path = remove_root_folder(full_path, self.root_folder)
 71                    # Check for name, regex, and size match
 72                    if (name and fnmatch.fnmatch(entry, name)) or name is None:
 73                        if self._match_type_and_size(full_path, file_type, size):
 74                            matching_files.append(short_path)
 75                    elif regex and re.search(regex, entry):
 76                        if self._match_type_and_size(full_path, file_type, size):
 77                            matching_files.append(short_path)
 78
 79        # Not the best way to remove hidden.
 80        return list(sorted(_ for _ in matching_files if not _.startswith(".")))
 81
 82    def _match_type_and_size(self, path: str, file_type: str | None, size: str | None) -> bool:
 83        """
 84        Check if a file/directory matches the specified type and size criteria.
 85
 86        Args:
 87            path (str): The path to the file/directory.
 88            file_type (Optional[str]): The type to filter ('file' or 'directory').
 89            size (Optional[str]): The size to filter files by.
 90
 91        Returns:
 92            bool: True if the file/directory matches the criteria, False otherwise.
 93        """
 94        if file_type:
 95            if file_type == "file" and not os.path.isfile(path):
 96                return False
 97            if file_type == "directory" and not os.path.isdir(path):
 98                return False
 99
100        if size:
101            size_prefix = size[0]
102            size_value = int(size[1:])
103            file_size = os.path.getsize(path)
104
105            if size_prefix == "+" and file_size <= size_value:
106                return False
107            if size_prefix == "-" and file_size >= size_value:
108                return False
109        return True
110
111    @log()
112    def find_files_markdown(
113        self,
114        name: str | None = None,
115        regex: str | None = None,
116        file_type: str | None = None,
117        size: str | None = None,
118    ) -> str:
119        """
120        Recursively search for files or directories matching given criteria in a directory and its subdirectories.
121
122        Args:
123            name (str | None, optional): The exact name to match filenames against.
124            regex (str | None, optional): The regex pattern to match filenames against.
125            file_type (str | None, optional): The type to filter ('file' or 'directory').
126            size (str | None, optional): The size to filter files by, e.g., '+100' for files larger than 100 bytes.
127
128        Returns:
129            str: Markdown of paths to files or directories that match the criteria.
130        """
131        output = StringIO()
132        results = self.find_files(name, regex, file_type, size)
133        for item in results:
134            output.write(item)
135            output.write("\n")
136        output.seek(0)
137        return output.read()

 46class GrepTool:
 47    """A tool for searching files using regular expressions."""
 48
 49    def __init__(self, root_folder: str, config: Config) -> None:
 50        """
 51        Initialize the GrepTool with a root folder.
 52
 53        Args:
 54            root_folder (str): The root folder to search within.
 55            config (Config): The developer input that bot shouldn't set.
 56        """
 57        self.root_folder: str = root_folder
 58        self.config = config
 59        self.auto_cat = config.get_flag("auto_cat", True)
 60        self.utf8_errors = config.get_value("utf8_errors", "surrogateescape")
 61
 62    @log()
 63    def grep_markdown(
 64        self, regex: str, glob_pattern: str, skip_first_matches: int = -1, maximum_matches: int = -1
 65    ) -> str:
 66        """
 67        Search for lines matching a regular expression in files and returns markdown formatted results.
 68
 69        Args:
 70            regex (str): A regular expression string to search for.
 71            glob_pattern (str): A glob pattern string to specify files.
 72            skip_first_matches (int, optional): Number of initial matches to skip.
 73            maximum_matches (int, optional): Maximum number of matches to return.
 74
 75        Returns:
 76            str: Markdown formatted string of grep results.
 77        """
 78        results = self.grep(regex, glob_pattern, skip_first_matches, maximum_matches)
 79        matches_found = results.matches_found
 80
 81        output = StringIO()
 82        for file_match in results.data:
 83            output.write(file_match.filename + "\n")
 84            for match in file_match.found:
 85                output.write(f"line {match.line_number}: {match.line}\n")
 86        output.write(
 87            f"{matches_found} matches found and {min(matches_found, maximum_matches) if maximum_matches != -1 else matches_found} displayed. "
 88            f"Skipped {skip_first_matches}\n"
 89        )
 90        output.seek(0)
 91        return output.read()
 92
 93    @log()
 94    def grep(
 95        self,
 96        regex: str,
 97        glob_pattern: str,
 98        skip_first_matches: int = -1,
 99        maximum_matches_per_file: int = -1,
100        maximum_matches_total: int = -1,
101    ) -> GrepResults:
102        """
103        Search for lines matching a regular expression in files specified by a glob pattern.
104
105        Args:
106            regex (str): A regular expression string to search for.
107            glob_pattern (str): A glob pattern string to specify files.
108            skip_first_matches (int, optional): Number of initial matches to skip.
109            maximum_matches_per_file (int, optional): Maximum number of matches to return for one file.
110            maximum_matches_total (int, optional): Maximum number of matches to return total.
111
112        Returns:
113            GrepResults: The results of the grep operation.
114        """
115        logger.info(
116            f"grep --regex {regex} --glob_pattern {glob_pattern} "
117            f"--skip_first_matches {skip_first_matches} "
118            f"--maximum_matches_total {maximum_matches_total} "
119            f"--maximum_matches_per_file {maximum_matches_per_file}"
120        )
121        pattern = re.compile(regex)
122        matches_total = 0
123        skip_count = 0 if skip_first_matches < 0 else skip_first_matches
124
125        results = GrepResults(matches_found=-1)
126
127        for filename in glob.glob(glob_pattern, root_dir=self.root_folder, recursive=True):
128            matches_per_file = 0
129            if os.path.isdir(filename):
130                logging.warning(f"Skipping directory {filename}, because it isn't a file.")
131                continue
132            if not os.path.exists(filename):
133                # What a hack
134                open_path = self.root_folder + "/" + filename
135            else:
136                open_path = filename
137            with open(open_path, encoding="utf-8", errors=self.utf8_errors) as file:
138                if not is_file_in_root_folder(filename, self.root_folder):
139                    logging.warning(f"Skipping file {filename}, because it isn't in the root folder.")
140                    continue
141                line_number = 0
142                for line in file:
143                    below_maximum = matches_per_file < maximum_matches_per_file
144                    maximum_not_set = maximum_matches_per_file == -1
145                    if below_maximum or maximum_not_set:
146                        line_number += 1
147                        if pattern.search(line):
148                            matches_total += 1
149                            matches_per_file += 1
150
151                            if matches_total <= (matches_total + skip_count) or matches_total == -1:
152                                if (0 < skip_first_matches < matches_total) or skip_first_matches == -1:
153                                    # This creates names like \..\..\..\ etc.
154                                    minimal_filename = remove_root_folder(filename, self.root_folder)
155                                    # avoid double count
156                                    found = next((fm for fm in results.data if fm.filename == minimal_filename), None)
157                                    if not found:
158                                        found = FileMatches(filename=minimal_filename)
159                                        results.data.append(found)
160
161                                    found.found.append(Match(line_number=line_number, line=line.strip()))
162        results.data = list(sorted(results.data, key=lambda x: x.filename))
163        results.matches_found = matches_total
164        return results

 16class HeadTailTool:
 17    def __init__(self, root_folder: str, config: Config) -> None:
 18        """Initialize the HeadTailTool with a root folder.
 19
 20        Args:
 21            root_folder (str): The root folder where files will be checked.
 22            config (Config): The developer input that bot shouldn't set.
 23        """
 24        self.root_folder = root_folder
 25        self.config = config
 26        self.auto_cat = config.get_flag("auto_cat", True)
 27
 28    @log()
 29    def head_markdown(self, file_path: str, lines: int = 10) -> str:
 30        """Return the first 'lines' lines of a file formatted as markdown.
 31
 32        Args:
 33            file_path (str): Path to the file.
 34            lines (int, optional): Number of lines to return. Defaults to 10.
 35
 36        Returns:
 37            str: String containing the first 'lines' lines of the file.
 38        """
 39        return "\n".join(self.head(file_path, lines))
 40
 41    @log()
 42    def head(self, file_path: str, lines: int = 10, byte_count: int | None = None) -> list[str]:
 43        """Return the first 'lines' or 'byte_count' from a file.
 44
 45        Args:
 46            file_path (str): Path to the file.
 47            lines (int): Number of lines to return. Ignored if byte_count is specified. Defaults to 10.
 48            byte_count (int | None, optional): Number of bytes to return. If specified, overrides lines.
 49
 50        Returns:
 51            list[str]: Lines or byte_count of bytes from the start of the file.
 52        """
 53        return self.head_tail(file_path, lines, "head", byte_count)
 54
 55    @log()
 56    def tail_markdown(self, file_path: str, lines: int = 10) -> str:
 57        """Return the last 'lines' lines of a file formatted as markdown.
 58
 59        Args:
 60            file_path (str): Path to the file.
 61            lines (int, optional): Number of lines to return. Defaults to 10.
 62
 63        Returns:
 64            str: String containing the last 'lines' lines of the file.
 65        """
 66        return "\n".join(self.tail(file_path, lines))
 67
 68    @log()
 69    def tail(self, file_path: str, lines: int = 10, byte_count: int | None = None) -> list[str]:
 70        """Return the last 'lines' or 'bytes' from a file.
 71
 72        Args:
 73            file_path (str): Path to the file.
 74            lines (int): Number of lines to return. Ignored if byte_count is specified. Defaults to 10.
 75            byte_count (int | None, optional): Number of bytes to return. If specified, overrides lines.
 76
 77        Returns:
 78            list[str]: Lines or bytes from the end of the file.
 79        """
 80        return self.head_tail(file_path, lines, "tail", byte_count)
 81
 82    def head_tail(
 83        self, file_path: str, lines: int = 10, mode: str = "head", byte_count: int | None = None
 84    ) -> list[str]:
 85        """Read lines or bytes from the start ('head') or end ('tail') of a file.
 86
 87        Args:
 88            file_path (str): Path to the file.
 89            lines (int): Number of lines to read. Ignored if byte_count is specified. Defaults to 10.
 90            mode (str): Operation mode, either 'head' or 'tail'. Defaults to 'head'.
 91            byte_count (int | None, optional): Number of bytes to read. If specified, overrides lines.
 92
 93        Returns:
 94            list[str]: Requested lines or bytes from the file.
 95
 96        Raises:
 97            ValueError: If mode is not 'head' or 'tail'.
 98            FileNotFoundError: If the file is not found in the root folder.
 99        """
100        if mode == "head":
101            logger.info(f"head --file_path {file_path} --lines {lines}")
102        else:
103            logger.info(f"tail --file_path {file_path} --lines {lines}")
104        if mode not in ["head", "tail"]:
105            raise ValueError("Mode must be 'head' or 'tail'")
106
107        if not is_file_in_root_folder(file_path, self.root_folder):
108            raise FileNotFoundError(f"File {file_path} not found in root folder {self.root_folder}")
109
110        with open(file_path, "rb") as file:
111            if byte_count is not None:
112                if mode == "head":
113                    return [file.read(byte_count).decode()]
114                # mode == 'tail'
115                file.seek(-byte_count, 2)  # Seek from end of file
116                return [file.read(byte_count).decode()]
117
118            # Read by lines if byte_count is not specified
119            if mode == "head":
120                head_lines = []
121                for _ in range(lines):
122                    try:
123                        line = next(file).decode("utf-8")
124                        head_lines.append(line.rstrip("\r\n"))
125                    except StopIteration:
126                        break
127                return head_lines
128                # return [next(file).decode("utf-8").rstrip("\r\n") for _ in range(lines)]
129            # mode == 'tail'
130            return [line.decode("utf-8").rstrip("\r\n") for line in list(file)[-lines:]]