dirshot 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

dirshot/dirshot.py

@@ -11,6 +11,12 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from io import StringIO
 from contextlib import contextmanager
 
+
+def strip_markup(text: str) -> str:
+    """Removes rich-style markup tags from a string (e.g., [bold red]Error[/])"""
+    return re.sub(r"\[/?[^\]]+\]", "", str(text))
+
+
 # --- Dependency & Console Management ---
 try:
     from rich.console import Console
@@ -38,7 +44,11 @@ except ImportError:
 
         def add_task(self, description, total=None, **kwargs):
             task_id = self.task_count
-            self.tasks[task_id] = {"d": description, "t": total, "c": 0}
+            self.tasks[task_id] = {
+                "d": strip_markup(description),
+                "t": total,
+                "c": 0,
+            }
             self.task_count += 1
             return task_id
 
@@ -49,12 +59,20 @@ except ImportError:
                 return
             task = self.tasks[task_id]
             if description:
-                task["d"] = description
+                task["d"] = strip_markup(description)
             task["c"] = completed if completed is not None else task["c"] + advance
-            line = f"-> {task['d']}: {task['c']}" + (
-                f"/{task['t']}" if task["t"] else ""
-            )
-            sys.stdout.write("\r" + line.ljust(len(self.active_line) + 2))
+
+            # Simple progress string
+            count_str = f"{task['c']}"
+            if task["t"]:
+                percent = (task["c"] / task["t"]) * 100
+                count_str += f"/{task['t']} ({percent:.0f}%)"
+
+            line = f"-> {task['d']}: {count_str}"
+
+            # Pad with spaces to clear previous longer lines
+            padding = max(0, len(self.active_line) - len(line))
+            sys.stdout.write("\r" + line + " " * padding)
             sys.stdout.flush()
             self.active_line = line
 
@@ -78,7 +96,8 @@ class ConsoleManager:
         if self.console:
             self.console.log(message, style=style)
         else:
-            print(f"[{time.strftime('%H:%M:%S')}] {message}")
+            clean_msg = strip_markup(message)
+            print(f"[{time.strftime('%H:%M:%S')}] {clean_msg}")
 
     def print_table(self, title: str, columns: List[str], rows: List[List[str]]):
         """Prints a formatted table to the console."""
@@ -95,11 +114,36 @@ class ConsoleManager:
                 table.add_row(*row)
             self.console.print(table)
         else:
-            print(f"\n--- {title} ---")
-            print(" | ".join(columns))
-            for row in rows:
-                print(" | ".join(row))
-            print("-" * (len(title) + 6))
+            # Fallback ASCII table
+            print(f"\n{title}")
+
+            # Clean data and calculate widths
+            clean_cols = [strip_markup(c) for c in columns]
+            clean_rows = [[strip_markup(c) for c in r] for r in rows]
+
+            col_widths = [len(c) for c in clean_cols]
+            for row in clean_rows:
+                for i, cell in enumerate(row):
+                    if i < len(col_widths):
+                        col_widths[i] = max(col_widths[i], len(cell))
+
+            def print_sep(char="-", cross="+"):
+                print(cross + cross.join(char * (w + 2) for w in col_widths) + cross)
+
+            print_sep()
+            # Header
+            header_str = " | ".join(
+                f" {c:<{w}} " for c, w in zip(clean_cols, col_widths)
+            )
+            print(f"| {header_str} |")
+            print_sep("=")
+
+            # Rows
+            for row in clean_rows:
+                row_str = " | ".join(f" {c:<{w}} " for c, w in zip(row, col_widths))
+                print(f"| {row_str} |")
+
+            print_sep()
 
 
 # --- Configuration Constants ---
@@ -416,6 +460,8 @@ class FilterCriteria:
     file_extensions: Set[str] = field(default_factory=set)
     ignore_if_in_path: Set[str] = field(default_factory=set)
     ignore_extensions: Set[str] = field(default_factory=set)
+    specific_files: Set[str] = field(default_factory=set)
+    case_sensitive: bool = False
 
     @classmethod
     def normalize_inputs(
@@ -425,33 +471,48 @@ class FilterCriteria:
         ignore_extensions: Optional[List[str]] = None,
         lang_presets: Optional[List[LanguagePreset]] = None,
         ignore_presets: Optional[List[IgnorePreset]] = None,
+        files: Optional[List[str]] = None,
+        case_sensitive: bool = False,
     ) -> "FilterCriteria":
         """
         Consolidates various filter inputs into a single FilterCriteria object.
 
         Args:
             file_types (list, optional): A list of file extensions to include.
-            ignore_if_in_path (list, optional): A list of directory/file names to ignore.
+            ignore_if_in_path (list, optional): A list of directory/file substring names to ignore.
             ignore_extensions (list, optional): A list of file extensions to ignore.
             lang_presets (list, optional): A list of LanguagePreset enums.
             ignore_presets (list, optional): A list of IgnorePreset enums.
+            files (list, optional): A list of specific filenames to include.
+            case_sensitive (bool): If True, filters are case sensitive.
 
         Returns:
             FilterCriteria: An object containing the combined sets of filters.
         """
-        all_exts = {ft.lower().strip() for ft in file_types or []}
-        all_ignore_paths = {ip.lower().strip() for ip in ignore_if_in_path or []}
-        all_ignore_exts = {ie.lower().strip() for ie in ignore_extensions or []}
+
+        def clean(s):
+            s = s.strip()
+            return s if case_sensitive else s.lower()
+
+        all_exts = {clean(ft) for ft in file_types or []}
+        all_ignore_paths = {clean(ip) for ip in ignore_if_in_path or []}
+        all_ignore_exts = {clean(ie) for ie in ignore_extensions or []}
+        all_specific_files = {clean(f) for f in files or []}
 
         for p in lang_presets or []:
-            all_exts.update(p.value)
+            for item in p.value:
+                all_exts.add(clean(item))
+
         for p in ignore_presets or []:
-            all_ignore_paths.update(p.value)
+            for item in p.value:
+                all_ignore_paths.add(clean(item))
 
         return cls(
             file_extensions=all_exts,
             ignore_if_in_path=all_ignore_paths,
             ignore_extensions=all_ignore_exts,
+            specific_files=all_specific_files,
+            case_sensitive=case_sensitive,
         )
 
 
@@ -477,11 +538,26 @@ def _discover_files(
         nonlocal dirs_scanned
         try:
             for entry in os.scandir(current_path):
-                entry_path, entry_lower = Path(entry.path), entry.name.lower()
-                if entry_lower in criteria.ignore_if_in_path:
+                # Path relative to the project root, used for substring check in path
+                # We use string representation for the check
+                rel_path = Path(entry.path).relative_to(root_dir)
+                rel_path_str = str(rel_path)
+                entry_name = entry.name
+
+                # Normalize for case check
+                if not criteria.case_sensitive:
+                    rel_path_str = rel_path_str.lower()
+                    entry_name = entry_name.lower()
+
+                # Ignore Logic: Substring matching in the path
+                # If any ignore string is a substring of the relative path, skip it.
+                if any(
+                    ignored in rel_path_str for ignored in criteria.ignore_if_in_path
+                ):
                     continue
+
                 if entry.is_dir():
-                    recursive_scan(entry_path)
+                    recursive_scan(Path(entry.path))
                     dirs_scanned += 1
                     if progress:
                         progress.update(
@@ -490,17 +566,36 @@ def _discover_files(
                             description=f"Discovering files in [cyan]{entry.name}[/cyan]",
                         )
                 elif entry.is_file():
-                    file_ext = entry_path.suffix.lower()
+                    # Specific File Inclusion
+                    if (
+                        criteria.specific_files
+                        and entry_name not in criteria.specific_files
+                    ):
+                        continue
+
+                    # Extension filtering
+                    file_ext = Path(entry.path).suffix
+                    if not criteria.case_sensitive:
+                        file_ext = file_ext.lower()
+
                     if (
                         criteria.ignore_extensions
                         and file_ext in criteria.ignore_extensions
                     ):
                         continue
+                    
+                    # Inclusion Logic
+                    # Include if no inclusion filters are set OR ext is allowed OR file is specifically allowed
                     if (
                         not criteria.file_extensions
                         or file_ext in criteria.file_extensions
+                        or (
+                            criteria.specific_files
+                            and entry_name in criteria.specific_files
+                        )
                     ):
-                        candidate_files.append(entry_path)
+                        candidate_files.append(Path(entry.path))
+
         except (PermissionError, FileNotFoundError):
             pass
 
@@ -515,29 +610,24 @@ def process_file_for_search(
     full_path: bool,
     activity: Dict,
     read_binary_files: bool,
+    case_sensitive: bool,
 ) -> Optional[Path]:
     """
     Processes a single file to see if it matches the search criteria.
 
     A match can occur if a keyword is found in the filename or, if enabled,
     within the file's content.
-
-    Args:
-        file_path (Path): The absolute path to the file to process.
-        keywords (List[str]): A list of keywords to search for.
-        search_content (bool): If True, search the content of the file.
-        full_path (bool): If True, compare keywords against the full file path.
-        activity (Dict): A dictionary to track thread activity.
-        read_binary_files (bool): If True, attempt to read and search binary files.
-
-    Returns:
-        Optional[Path]: The path to the file if it's a match, otherwise None.
     """
     thread_id = threading.get_ident()
     activity[thread_id] = file_path.name
     try:
         compare_target = str(file_path) if full_path else file_path.name
-        if any(key in compare_target.lower() for key in keywords):
+        
+        if not case_sensitive:
+            compare_target = compare_target.lower()
+            # Keywords should already be normalized by the caller if not case_sensitive
+        
+        if any(key in compare_target for key in keywords):
             return file_path
 
         if search_content and (
@@ -546,7 +636,9 @@ def process_file_for_search(
             try:
                 with file_path.open("r", encoding="utf-8", errors="ignore") as f:
                     for line in f:
-                        if any(key in line.lower() for key in keywords):
+                        if not case_sensitive:
+                            line = line.lower()
+                        if any(key in line for key in keywords):
                             return file_path
             except OSError:
                 pass
@@ -564,24 +656,17 @@ def _process_files_concurrently(
     progress: Any,
     task_id: Any,
     read_binary_files: bool,
+    case_sensitive: bool,
 ) -> Set[Path]:
     """
     Uses a thread pool to process a list of files for search matches concurrently.
-
-    Args:
-        files (List[Path]): The list of candidate files to search through.
-        keywords (List[str]): The keywords to search for.
-        search_content (bool): Whether to search inside file contents.
-        full_path (bool): Whether to compare keywords against the full path.
-        max_workers (Optional[int]): The maximum number of threads to use.
-        progress (Any): The progress bar object.
-        task_id (Any): The ID of the processing task on the progress bar.
-        read_binary_files (bool): If True, search the content of binary files.
-
-    Returns:
-        Set[Path]: A set of absolute paths for all files that matched.
     """
     matched_files, thread_activity = set(), {}
+    
+    # Normalize keywords once if case insensitive
+    if not case_sensitive:
+        keywords = [k.lower() for k in keywords]
+
     with ThreadPoolExecutor(
         max_workers=max_workers or (os.cpu_count() or 1) + 4,
         thread_name_prefix="scanner",
@@ -595,6 +680,7 @@ def _process_files_concurrently(
                 full_path,
                 thread_activity,
                 read_binary_files,
+                case_sensitive,
             ): f
             for f in files
         }
@@ -632,17 +718,7 @@ def _process_files_concurrently(
 def _generate_tree_with_stats(
     root_dir: Path, file_paths: List[Path], show_stats: bool
 ) -> List[str]:
-    """
-    Generates a directory tree structure from a list of file paths.
-
-    Args:
-        root_dir (Path): The root directory of the project, used as the tree's base.
-        file_paths (List[Path]): A list of file paths to include in the tree.
-        show_stats (bool): If True, include file and directory counts in the tree.
-
-    Returns:
-        List[str]: A list of strings, where each string is a line in the tree.
-    """
+    """Generates a directory tree structure from a list of file paths."""
     tree_dict: Dict[str, Any] = {}
     for path in file_paths:
         level = tree_dict
@@ -694,23 +770,9 @@ def _collate_content_to_file(
     exclude_whitespace: bool,
     progress: Any,
     task_id: Any,
+    only_show_tree: bool,
 ) -> Tuple[float, int]:
-    """
-    Collates the file tree and file contents into a single output file.
-
-    Args:
-        output_path (Path): The path to the final output file.
-        tree_lines (List): The generated file tree lines.
-        files (List[FileToProcess]): The files whose content needs to be collated.
-        show_tree_stats (bool): Whether to include the stats key in the header.
-        show_token_count (bool): Whether to calculate and include the token count.
-        exclude_whitespace (bool): If True, exclude whitespace from token counting.
-        progress (Any): The progress bar object.
-        task_id (Any): The ID of the collation task on the progress bar.
-
-    Returns:
-        Tuple[float, int]: A tuple containing the total bytes written and the token count.
-    """
+    """Collates the file tree and file contents into a single output file."""
     output_path.parent.mkdir(parents=True, exist_ok=True)
     buffer, total_bytes, token_count = StringIO(), 0, 0
 
@@ -724,9 +786,14 @@ def _collate_content_to_file(
         if RICH_AVAILABLE:
             content = "\n".join(Text.from_markup(line).plain for line in tree_lines)
         else:
-            content = "\n".join(tree_lines)
+            content = "\n".join(strip_markup(line) for line in tree_lines)
         buffer.write(content + "\n\n")
 
+    if only_show_tree:
+        with output_path.open("w", encoding=DEFAULT_ENCODING) as outfile:
+            outfile.write(buffer.getvalue())
+        return total_bytes, token_count
+
     for file_info in files:
         if progress:
             progress.update(
@@ -778,48 +845,13 @@ def generate_snapshot(
     show_token_count: bool = False,
     exclude_whitespace_in_token_count: bool = False,
     read_binary_files: bool = False,
+    files: Optional[List[str]] = None,
+    only_show_tree: bool = False,
+    case_sensitive_filter: bool = False,
+    case_sensitive_search: bool = False,
 ) -> None:
     """
     Orchestrates the entire process of scanning, filtering, and collating project files.
-
-    This function serves as the main entry point for the utility. It can be used
-    to create a full "snapshot" of a project's source code or to search for
-    specific keywords within file names and/or contents. It is highly configurable
-    through presets and manual overrides.
-
-    Args:
-        root_directory (str): The starting directory for the scan. Defaults to ".".
-        output_file_name (str): The name of the file to save the results to.
-            Defaults to "project_snapshot.txt".
-        search_keywords (List[str], optional): A list of keywords to search for. If
-            None or empty, the function runs in "snapshot" mode, including all
-            files that match the other criteria. Defaults to None.
-        file_extensions (List[str], optional): A list of specific file
-            extensions to include (e.g., [".py", ".md"]). Defaults to None.
-        ignore_if_in_path (List[str], optional): A list of directory or file
-            names to exclude from the scan. Defaults to None.
-        ignore_extensions (List[str], optional): A list of file extensions to
-            explicitly ignore (e.g., [".log", ".tmp"]). Defaults to None.
-        language_presets (List[LanguagePreset], optional): A list of LanguagePreset
-            enums for common file types (e.g., [LanguagePreset.PYTHON]). Defaults to None.
-        ignore_presets (List[IgnorePreset], optional): A list of IgnorePreset enums
-            for common ignore patterns (e.g., [IgnorePreset.PYTHON]). Defaults to None.
-        search_file_contents (bool): If True, search for keywords within file
-            contents. Defaults to True.
-        full_path_compare (bool): If True, search for keywords in the full file path,
-            not just the filename. Defaults to True.
-        max_workers (Optional[int]): The maximum number of worker threads for
-            concurrent processing. Defaults to CPU count + 4.
-        generate_tree (bool): If True, a file tree of the matched files will be
-            included at the top of the output file. Defaults to True.
-        show_tree_stats (bool): If True, display file and directory counts in the
-            generated tree. Defaults to False.
-        show_token_count (bool): If True, display an approximated token count in the
-            summary and output file. Defaults to False.
-        exclude_whitespace_in_token_count (bool): If True, whitespace is removed
-            before counting tokens, giving a more compact count. Defaults to False.
-        read_binary_files (bool): If True, the content search will attempt to read
-            and search through binary files. Defaults to False.
     """
     console, start_time = ConsoleManager(), time.perf_counter()
     root_dir = Path(root_directory or ".").resolve()
@@ -827,19 +859,31 @@ def generate_snapshot(
         console.log(f"Error: Root directory '{root_dir}' not found.", style="bold red")
         return
 
-    keywords = [k.lower().strip() for k in search_keywords or [] if k.strip()]
+    # Normalize keywords for display/logic
+    keywords = [k.strip() for k in search_keywords or [] if k.strip()]
+    if not case_sensitive_search:
+        # We don't lower here for the variable passed to functions,
+        # but for consistent display in the table we might want to.
+        # However, logic downstream handles lowering if case_sensitive_search is False.
+        pass
+
     snapshot_mode = not keywords
+    
+    # Normalize filtering criteria
     criteria = FilterCriteria.normalize_inputs(
         file_types=file_extensions,
         ignore_if_in_path=ignore_if_in_path,
         ignore_extensions=ignore_extensions,
         lang_presets=language_presets,
         ignore_presets=ignore_presets,
+        files=files,
+        case_sensitive=case_sensitive_filter,
     )
 
     config_rows = [
         ["Root Directory", str(root_dir)],
         ["File Types", ", ".join(criteria.file_extensions) or "All"],
+        ["Specific Files", ", ".join(criteria.specific_files) or "None"],
         ["Ignore Paths", ", ".join(criteria.ignore_if_in_path) or "None"],
         ["Ignore Extensions", ", ".join(criteria.ignore_extensions) or "None"],
         ["Generate Tree", "[green]Yes[/green]" if generate_tree else "[red]No[/red]"],
@@ -868,6 +912,12 @@ def generate_snapshot(
 
     if snapshot_mode:
         config_rows.insert(1, ["Mode", "[bold blue]Snapshot[/bold blue]"])
+        config_rows.append(
+            [
+                "Case Sensitive Filter",
+                "[green]Yes[/green]" if case_sensitive_filter else "[red]No[/red]",
+            ]
+        )
     else:
         config_rows.insert(1, ["Mode", "[bold yellow]Search[/bold yellow]"])
         config_rows.insert(
@@ -885,6 +935,16 @@ def generate_snapshot(
                 "[green]Yes[/green]" if read_binary_files else "[red]No[/red]",
             ]
         )
+        config_rows.append(
+            [
+                "Case Sensitive Search",
+                "[green]Yes[/green]" if case_sensitive_search else "[red]No[/red]",
+            ]
+        )
+
+    if only_show_tree:
+        config_rows.append(["Output Content", "[yellow]Tree Only[/yellow]"])
+
     console.print_table(
         "Project Scan Configuration", ["Parameter", "Value"], config_rows
     )
@@ -948,6 +1008,7 @@ def generate_snapshot(
                     progress,
                     process_task,
                     read_binary_files,
+                    case_sensitive_search,
                 )
 
         output_path, total_bytes, token_count = None, 0, 0
@@ -986,6 +1047,7 @@ def generate_snapshot(
                 exclude_whitespace_in_token_count,
                 progress,
                 collate_task,
+                only_show_tree,
             )
 
     end_time = time.perf_counter()
@@ -1019,4 +1081,4 @@ if __name__ == "__main__":
         show_tree_stats=True,
         show_token_count=True,
         exclude_whitespace_in_token_count=True,
-    )
+    )

dirshot/reconstruct.py

@@ -0,0 +1,110 @@
+import os
+import re
+
+# --- Configuration ---
+# You can edit these variables to match your needs.
+
+# 1. The name of the file containing the project structure and content.
+INPUT_FILENAME = 'repo.txt'
+
+# 2. The name of the directory where the project will be created.
+OUTPUT_DIRECTORY = 'studio'
+# --- End of Configuration ---
+
+
+def reconstruct_and_populate_project(file_path, root_dir):
+    """
+    Parses a formatted text file to reconstruct a project's directory
+    structure and correctly populates all files with their content.
+
+    Args:
+        file_path (str): The path to the input text file (e.g., 'repo.txt').
+        root_dir (str): The name of the root directory for the reconstructed project.
+    """
+    print(f"Starting project reconstruction from '{file_path}'...")
+    print(f"Output will be saved in the '{root_dir}' directory.")
+
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+    except FileNotFoundError:
+        print(f"\nERROR: The input file '{file_path}' was not found.")
+        print("Please make sure the script is in the same directory as the input file.")
+        return
+    except Exception as e:
+        print(f"\nAn error occurred while reading the file: {e}")
+        return
+
+    # A line of 80 hyphens is the separator. We split the entire document by it.
+    separator = '--------------------------------------------------------------------------------'
+    # The split operation will result in a list where file paths and contents alternate.
+    sections = content.split(separator)
+
+    # The very first section is the visual tree, which we don't need.
+    # We start processing from the first "FILE:" header.
+    # We skip any empty sections that might result from splitting.
+    file_chunks = [s.strip() for s in sections if s.strip()]
+
+    # Create a dictionary to hold {'filepath': 'content'}
+    file_data = {}
+
+    # The new logic iterates through the chunks. When it finds a file header,
+    # it assumes the *next* chunk is the content for that file.
+    i = 0
+    while i < len(file_chunks):
+        chunk = file_chunks[i]
+        if chunk.startswith('FILE:'):
+            # This chunk is a file header. Extract the path.
+            # It might have other text like the tree, so we find the 'FILE:' line specifically.
+            path_line = [line for line in chunk.splitlines() if line.startswith('FILE:')][0]
+            relative_path = path_line[5:].strip()
+
+            # The very next chunk in the list is the content for this file.
+            if i + 1 < len(file_chunks):
+                content = file_chunks[i + 1]
+                file_data[relative_path] = content
+                # We've processed the header and the content, so we can skip the next item.
+                i += 2
+            else:
+                # Found a file header without any content after it (end of file).
+                file_data[relative_path] = '' # Create an empty file
+                i += 1
+        else:
+            # This chunk is not a file header, so we skip it (e.g., the initial tree view).
+            i += 1
+            
+    if not file_data:
+        print("\nERROR: Could not find any valid 'FILE:' sections. Nothing to create.")
+        return
+
+    # Create the main output directory if it doesn't already exist.
+    if not os.path.exists(root_dir):
+        print(f"\nCreating root directory: '{root_dir}'")
+        os.makedirs(root_dir)
+    else:
+        print(f"\nOutput directory '{root_dir}' already exists. Files may be overwritten.")
+
+    # Now, create the directories and write the populated files.
+    for relative_path, file_content in file_data.items():
+        full_path = os.path.join(root_dir, relative_path)
+        parent_dir = os.path.dirname(full_path)
+
+        # Ensure the directory for the file exists (e.g., 'src/components/ui/').
+        if parent_dir:
+            os.makedirs(parent_dir, exist_ok=True)
+
+        # Write the captured content into the file.
+        try:
+            with open(full_path, 'w', encoding='utf-8') as f:
+                f.write(file_content)
+            print(f"  - Created and populated: {full_path}")
+        except Exception as e:
+            print(f"  - FAILED to create file {full_path}: {e}")
+
+    print(f"\nProject reconstruction complete!")
+    print(f"Check the '{root_dir}' directory to see your populated project.")
+
+
+# --- Script Execution ---
+if __name__ == '__main__':
+    reconstruct_and_populate_project(file_path=INPUT_FILENAME, root_dir=OUTPUT_DIRECTORY)

{dirshot-0.2.0.dist-info → dirshot-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirshot
-Version: 0.2.0
+Version: 0.3.0
 Summary: A flexible, high-performance utility for creating project snapshots and searching files with a rich terminal UI.
 Author-email: init-helpful <init.helpful@gmail.com>
 Project-URL: Homepage, https://github.com/init-helpful/dirshot
@@ -168,10 +168,11 @@ The `generate_snapshot()` function accepts the following parameters:
 | `root_directory`                      | `str`                        | `"."`                        | The starting directory for the scan.                                                                    |
 | `output_file_name`                    | `str`                        | `"project_snapshot.txt"`     | The name of the file to save the results to.                                                            |
 | `search_keywords`                     | `Optional[List[str]]`        | `None`                       | If provided, switches to **Search Mode**. Otherwise, runs in **Snapshot Mode**.                         |
+| `files`                               | `Optional[List[str]]`        | `None`                       | A list of specific filenames to include. If provided, checks this list first before extensions.         |
 | `language_presets`                    | `Optional[List[LanguagePreset]]` | `None`                       | A list of `LanguagePreset` enums for common file types (e.g., `LanguagePreset.PYTHON`).                 |
 | `ignore_presets`                      | `Optional[List[IgnorePreset]]`   | `None`                       | A list of `IgnorePreset` enums for common ignore patterns (e.g., `IgnorePreset.NODE_JS`).             |
 | `file_extensions`                     | `Optional[List[str]]`        | `None`                       | A manual list of file extensions to include (e.g., `[".py", ".md"]`).                                   |
-| `ignore_if_in_path`                   | `Optional[List[str]]`        | `None`                       | A manual list of directory or file names to exclude.                                                    |
+| `ignore_if_in_path`                   | `Optional[List[str]]`        | `None`                       | A list of directory or file substring names to exclude (e.g., `["temp"]` excludes `src/temp/file.py`).  |
 | `ignore_extensions`                   | `Optional[List[str]]`        | `None`                       | A manual list of file extensions to explicitly ignore (e.g., `[".log", ".tmp"]`).                       |
 | `search_file_contents`                | `bool`                       | `True`                       | In Search Mode, search for keywords within file contents.                                               |
 | `generate_tree`                       | `bool`                       | `True`                       | Include a file tree of the matched files at the top of the output.                                      |
@@ -180,6 +181,9 @@ The `generate_snapshot()` function accepts the following parameters:
 | `exclude_whitespace_in_token_count`   | `bool`                       | `False`                      | If `True`, removes whitespace before counting tokens for a more compact count.                          |
 | `max_workers`                         | `Optional[int]`              | `CPU count + 4`              | The maximum number of worker threads for concurrent processing.                                         |
 | `read_binary_files`                   | `bool`                       | `False`                      | If `True`, the content search will attempt to read and search through binary files.                     |
+| `only_show_tree`                      | `bool`                       | `False`                      | If `True`, the output file will contain only the file tree (and stats), omitting file content.          |
+| `case_sensitive_filter`               | `bool`                       | `False`                      | If `True`, file filtering (extensions, ignore paths) is case-sensitive.                                 |
+| `case_sensitive_search`               | `bool`                       | `False`                      | If `True`, keyword searching is case-sensitive.                                                         |
 
 ## 🤝 Contributing
 
@@ -191,4 +195,3 @@ Contributions are welcome! Please feel free to submit a pull request or open an
 4.  Commit your changes (`git commit -m 'Add some feature'`).
 5.  Push to the branch (`git push origin feature/your-feature-name`).
 6.  Open a pull request.
-

dirshot-0.3.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+dirshot/__init__.py,sha256=OpzEFnxp6FpjdapuhBF5UTEc-rpR-Z9r0B2wa9gTSwo,476
+dirshot/dirshot.py,sha256=VpRVuLabAN1S8lFXuKFB4vYvsQjz9vPSpVu6ieTvpvY,38595
+dirshot/reconstruct.py,sha256=rM9rcNoE7tQkqUhP1Fisg2Hlxb3CE0iDvvCdCOOdS8k,4628
+dirshot-0.3.0.dist-info/METADATA,sha256=0uzuFJGJSEQgzGTgPauUpWTNcw9YOX5BboeoR53tuP4,11236
+dirshot-0.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+dirshot-0.3.0.dist-info/top_level.txt,sha256=ROGW8gTcmwJ2jJ1Fp7TV1REZLRUGbL3L-Lfoy8tPxOA,8
+dirshot-0.3.0.dist-info/RECORD,,

{dirshot-0.2.0.dist-info → dirshot-0.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dirshot-0.2.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-dirshot/__init__.py,sha256=OpzEFnxp6FpjdapuhBF5UTEc-rpR-Z9r0B2wa9gTSwo,476
-dirshot/dirshot.py,sha256=ScuXzqd3GKxR_sEwnPXCE-6Bh4h34NehfQo8u-oZGNk,38031
-dirshot-0.2.0.dist-info/METADATA,sha256=IEiMd97Wsa8CTJJBEW78DqsYluu7G3_zTxm9ClpSFT8,10394
-dirshot-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dirshot-0.2.0.dist-info/top_level.txt,sha256=ROGW8gTcmwJ2jJ1Fp7TV1REZLRUGbL3L-Lfoy8tPxOA,8
-dirshot-0.2.0.dist-info/RECORD,,