reposnap 0.7.0__tar.gz → 0.8.0__tar.gz

{reposnap-0.7.0 → reposnap-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reposnap
-Version: 0.7.0
+Version: 0.8.0
 Summary: Generate a Markdown file with all contents of your project
 Author: agoloborodko
 License-File: LICENSE
@@ -25,6 +25,7 @@ Description-Content-Type: text/markdown
 - **Structure Only Option**: The `--structure-only` flag can be used to generate the Markdown file with just the directory structure, omitting the contents of the files.
 - **Gitignore Support**: Automatically respects `.gitignore` patterns to exclude files and directories.
 - **Include and Exclude Patterns**: Use `--include` and `--exclude` to specify patterns for files and directories to include or exclude.
+- **Content Filtering**: Use `--contains` to filter files based on their content, including only files that contain specific substrings or code patterns.
 - **Changes Only Mode**: Use `-c` or `--changes` to snapshot only uncommitted files (staged, unstaged, untracked, and stashed changes).
 
 ## Installation
@@ -50,7 +51,7 @@ pip install -r requirements.lock
 To use `reposnap` from the command line, run it with the following options:
 
 ```bash
-reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]] [-e EXCLUDE [EXCLUDE ...]] [-c] paths [paths ...]
+reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]] [-e EXCLUDE [EXCLUDE ...]] [-c] [-S CONTAINS [CONTAINS ...]] [--contains-case] paths [paths ...]
 ```
 
 - `paths`: One or more paths (files or directories) within the repository whose content and structure should be rendered.
@@ -61,6 +62,8 @@ reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]
 - `-i, --include`: File/folder patterns to include. For example, `-i "*.py"` includes only Python files.
 - `-e, --exclude`: File/folder patterns to exclude. For example, `-e "*.md"` excludes all Markdown files.
 - `-c, --changes`: Use only files that are added/modified/untracked/stashed but not yet committed.
+- `-S, --contains`: Only include files whose contents contain these substrings. Multiple patterns can be specified.
+- `--contains-case`: Make `--contains` case-sensitive (default is case-insensitive).
 
 #### Pattern Matching
 
@@ -73,6 +76,41 @@ reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]
   - `-i "*.py"`: Includes only files ending with `.py`.
   - `-e "*.test.*"`: Excludes files with `.test.` in their names.
 
+#### Content Filtering
+
+The `--contains` (or `-S`) flag allows you to filter files based on their content, including only files that contain specific substrings. This is particularly useful for focusing on files that contain certain code patterns, imports, or keywords.
+
+- **Case Sensitivity**: By default, content matching is case-insensitive. Use the `--contains-case` flag to enable case-sensitive matching.
+- **Multiple Patterns**: You can specify multiple patterns, and files containing **any** of the patterns will be included (OR logic).
+- **Performance**: Large files (>5MB) and binary files are automatically skipped for performance and safety reasons.
+
+**Examples**:
+
+1. **Find files containing specific imports**:
+    ```bash
+    reposnap . -S "import logging"
+    ```
+
+2. **Search for multiple patterns (OR logic)**:
+    ```bash
+    reposnap . -S "TODO" "FIXME" "import requests"
+    ```
+
+3. **Case-sensitive content search**:
+    ```bash
+    reposnap . -S "TODO" --contains-case
+    ```
+
+4. **Combine content filtering with other filters**:
+    ```bash
+    reposnap . -S "class " -i "*.py" --structure-only
+    ```
+
+5. **Find files with specific function calls**:
+    ```bash
+    reposnap . -S "logger.error" "raise Exception"
+    ```
+
 #### Only Snapshot Your Current Work
 
 The `-c` or `--changes` flag allows you to generate documentation for only the files that have been modified but not yet committed. This includes:
@@ -147,6 +185,18 @@ This is particularly useful when you want to:
     reposnap . -c
     ```
 
+7. **Find and document files containing specific code patterns**:
+
+    ```bash
+    reposnap . -S "import logging" "logger."
+    ```
+
+8. **Combine content filtering with file type filtering**:
+
+    ```bash
+    reposnap . -S "class " -i "*.py" --structure-only
+    ```
+
 ### Graphical User Interface
 
 `reposnap` also provides a GUI for users who prefer an interactive interface.

{reposnap-0.7.0 → reposnap-0.8.0}/README.md

@@ -12,6 +12,7 @@
 - **Structure Only Option**: The `--structure-only` flag can be used to generate the Markdown file with just the directory structure, omitting the contents of the files.
 - **Gitignore Support**: Automatically respects `.gitignore` patterns to exclude files and directories.
 - **Include and Exclude Patterns**: Use `--include` and `--exclude` to specify patterns for files and directories to include or exclude.
+- **Content Filtering**: Use `--contains` to filter files based on their content, including only files that contain specific substrings or code patterns.
 - **Changes Only Mode**: Use `-c` or `--changes` to snapshot only uncommitted files (staged, unstaged, untracked, and stashed changes).
 
 ## Installation
@@ -37,7 +38,7 @@ pip install -r requirements.lock
 To use `reposnap` from the command line, run it with the following options:
 
 ```bash
-reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]] [-e EXCLUDE [EXCLUDE ...]] [-c] paths [paths ...]
+reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]] [-e EXCLUDE [EXCLUDE ...]] [-c] [-S CONTAINS [CONTAINS ...]] [--contains-case] paths [paths ...]
 ```
 
 - `paths`: One or more paths (files or directories) within the repository whose content and structure should be rendered.
@@ -48,6 +49,8 @@ reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]
 - `-i, --include`: File/folder patterns to include. For example, `-i "*.py"` includes only Python files.
 - `-e, --exclude`: File/folder patterns to exclude. For example, `-e "*.md"` excludes all Markdown files.
 - `-c, --changes`: Use only files that are added/modified/untracked/stashed but not yet committed.
+- `-S, --contains`: Only include files whose contents contain these substrings. Multiple patterns can be specified.
+- `--contains-case`: Make `--contains` case-sensitive (default is case-insensitive).
 
 #### Pattern Matching
 
@@ -60,6 +63,41 @@ reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]
   - `-i "*.py"`: Includes only files ending with `.py`.
   - `-e "*.test.*"`: Excludes files with `.test.` in their names.
 
+#### Content Filtering
+
+The `--contains` (or `-S`) flag allows you to filter files based on their content, including only files that contain specific substrings. This is particularly useful for focusing on files that contain certain code patterns, imports, or keywords.
+
+- **Case Sensitivity**: By default, content matching is case-insensitive. Use the `--contains-case` flag to enable case-sensitive matching.
+- **Multiple Patterns**: You can specify multiple patterns, and files containing **any** of the patterns will be included (OR logic).
+- **Performance**: Large files (>5MB) and binary files are automatically skipped for performance and safety reasons.
+
+**Examples**:
+
+1. **Find files containing specific imports**:
+    ```bash
+    reposnap . -S "import logging"
+    ```
+
+2. **Search for multiple patterns (OR logic)**:
+    ```bash
+    reposnap . -S "TODO" "FIXME" "import requests"
+    ```
+
+3. **Case-sensitive content search**:
+    ```bash
+    reposnap . -S "TODO" --contains-case
+    ```
+
+4. **Combine content filtering with other filters**:
+    ```bash
+    reposnap . -S "class " -i "*.py" --structure-only
+    ```
+
+5. **Find files with specific function calls**:
+    ```bash
+    reposnap . -S "logger.error" "raise Exception"
+    ```
+
 #### Only Snapshot Your Current Work
 
 The `-c` or `--changes` flag allows you to generate documentation for only the files that have been modified but not yet committed. This includes:
@@ -134,6 +172,18 @@ This is particularly useful when you want to:
     reposnap . -c
     ```
 
+7. **Find and document files containing specific code patterns**:
+
+    ```bash
+    reposnap . -S "import logging" "logger."
+    ```
+
+8. **Combine content filtering with file type filtering**:
+
+    ```bash
+    reposnap . -S "class " -i "*.py" --structure-only
+    ```
+
 ### Graphical User Interface
 
 `reposnap` also provides a GUI for users who prefer an interactive interface.

{reposnap-0.7.0 → reposnap-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reposnap"
-version = "0.7.0"
+version = "0.8.0"
 description = "Generate a Markdown file with all contents of your project"
 authors = [
     { name = "agoloborodko" }

{reposnap-0.7.0 → reposnap-0.8.0}/reposnap/controllers/project_controller.py

@@ -19,7 +19,13 @@ class ProjectController:
             ]
             self.input_paths = []
             for p in input_paths:
-                candidate = (self.root_dir / p).resolve()
+                if p.is_absolute():
+                    # Handle absolute paths - use as-is but verify they're under root_dir
+                    candidate = p.resolve()
+                else:
+                    # Handle relative paths - join with root_dir
+                    candidate = (self.root_dir / p).resolve()
+
                 if candidate.exists():
                     try:
                         rel = candidate.relative_to(self.root_dir)
@@ -31,7 +37,7 @@ class ProjectController:
                         )
                 else:
                     self.logger.warning(
-                        f"Path {p} does not exist relative to repository root {self.root_dir}."
+                        f"Path {p} does not exist or is not under repository root {self.root_dir}."
                     )
             self.output_file: Path = (
                 Path(args.output).resolve()
@@ -48,6 +54,8 @@ class ProjectController:
                 args.exclude if hasattr(args, "exclude") else []
             )
             self.changes_only: bool = getattr(args, "changes", False)
+            self.contains: List[str] = getattr(args, "contains", [])
+            self.contains_case: bool = getattr(args, "contains_case", False)
         else:
             self.args = None
             self.input_paths = []
@@ -56,6 +64,8 @@ class ProjectController:
             self.include_patterns = []
             self.exclude_patterns = []
             self.changes_only = False
+            self.contains = []
+            self.contains_case = False
         self.file_tree: Optional[FileTree] = None
         self.gitignore_patterns: List[str] = []
         if self.root_dir:
@@ -110,6 +120,58 @@ class ProjectController:
             files = [f for f in files if not spec_exc.match_file(f.as_posix())]
         return files
 
+    def _apply_content_filter(self, files: List[Path]) -> List[Path]:
+        """
+        Filter files based on content substring matching.
+
+        Args:
+            files: List of relative file paths to filter
+
+        Returns:
+            Filtered list of files that contain at least one of the patterns
+            specified in self.contains. Returns original list if no patterns
+            are specified.
+
+        Note:
+            Uses case-insensitive matching by default unless self.contains_case
+            is True. Skips binary files and files larger than 5MB for performance.
+        """
+        if not self.contains:
+            return files
+
+        from reposnap.core.content_search import filter_files_by_content
+
+        initial_count = len(files)
+        ignore_case = not self.contains_case
+
+        self.logger.debug(
+            f"Applying content filter with patterns: {self.contains}, "
+            f"ignore_case: {ignore_case}"
+        )
+
+        # Convert relative paths to absolute for content search
+        absolute_paths = [self.root_dir / file_path for file_path in files]
+        filtered_absolute = filter_files_by_content(
+            absolute_paths, self.contains, ignore_case
+        )
+
+        # Convert back to relative paths
+        filtered_files = []
+        for abs_path in filtered_absolute:
+            try:
+                rel_path = abs_path.relative_to(self.root_dir)
+                filtered_files.append(rel_path)
+            except ValueError:
+                continue
+
+        kept_count = len(filtered_files)
+        self.logger.info(
+            f"Applied content filter (kept {kept_count} / {initial_count})"
+        )
+        self.logger.debug(f"Files kept after content filter: {filtered_files}")
+
+        return filtered_files
+
     def collect_file_tree(self) -> None:
         if self.changes_only:
             self.logger.info("Collecting uncommitted files from Git repository.")
@@ -147,6 +209,8 @@ class ProjectController:
                         continue
         all_files = self._apply_include_exclude(all_files)
         self.logger.debug(f"All files after applying include/exclude: {all_files}")
+        all_files = self._apply_content_filter(all_files)
+        self.logger.debug(f"All files after applying content filter: {all_files}")
         if self.input_paths:
             trees = []
             for input_path in self.input_paths:

reposnap-0.8.0/reposnap/core/content_search.py

@@ -0,0 +1,104 @@
+# src/reposnap/core/content_search.py
+
+"""
+Private content search helpers for substring matching in files.
+
+This module provides stateless utility functions for searching file contents.
+It is intended for internal use by the project controller and should not be
+imported directly by external consumers.
+"""
+
+import logging
+from pathlib import Path
+from typing import List
+
+
+logger = logging.getLogger(__name__)
+
+# Configuration constants
+MAX_FILE_SIZE = 5 * 1024 * 1024  # 5 MiB
+BINARY_CHECK_SIZE = 1024  # First 1KB to check for binary content
+
+
+def file_matches(path: Path, patterns: List[str], ignore_case: bool = True) -> bool:
+    """
+    Check if a file contains any of the given patterns.
+
+    Args:
+        path: Path to the file to search
+        patterns: List of substring patterns to search for
+        ignore_case: Whether to perform case-insensitive matching (default: True)
+
+    Returns:
+        True if file contains any pattern, False otherwise
+
+    Note:
+        Uses streaming read with utf-8 encoding and error handling for binary files.
+        Returns False if file cannot be read as text or if file is too large/binary.
+    """
+    if not patterns:
+        return True
+
+    if not path.is_file():
+        return False
+
+    # Check file size - skip files larger than MAX_FILE_SIZE
+    try:
+        file_size = path.stat().st_size
+        if file_size > MAX_FILE_SIZE:
+            logger.debug(f"Skipping large file {path} ({file_size} bytes)")
+            return False
+    except OSError as e:
+        logger.debug(f"Could not stat file {path}: {e}")
+        return False
+
+    # Check for binary content in first KB
+    try:
+        with path.open("rb") as f:
+            first_chunk = f.read(BINARY_CHECK_SIZE)
+            if b"\0" in first_chunk:
+                logger.debug(f"Skipping binary file {path}")
+                return False
+    except Exception as e:
+        logger.debug(f"Could not read file {path} for binary check: {e}")
+        return False
+
+    # Pre-compute search patterns (case-normalized if needed)
+    search_patterns = [p.lower() if ignore_case else p for p in patterns]
+
+    try:
+        with path.open("r", encoding="utf-8", errors="ignore") as f:
+            for line in f:
+                search_line = line.lower() if ignore_case else line
+
+                if any(pattern in search_line for pattern in search_patterns):
+                    return True
+        return False
+    except Exception as e:
+        logger.debug(f"Could not read file {path} for content search: {e}")
+        return False
+
+
+def filter_files_by_content(
+    files: List[Path], patterns: List[str], ignore_case: bool = True
+) -> List[Path]:
+    """
+    Filter a list of files to only include those containing the given patterns.
+
+    Args:
+        files: List of file paths to filter
+        patterns: List of substring patterns to search for
+        ignore_case: Whether to perform case-insensitive matching (default: True)
+
+    Returns:
+        Filtered list of files that contain at least one pattern
+    """
+    if not patterns:
+        return files
+
+    matched_files = []
+    for file_path in files:
+        if file_matches(file_path, patterns, ignore_case):
+            matched_files.append(file_path)
+
+    return matched_files

{reposnap-0.7.0 → reposnap-0.8.0}/reposnap/interfaces/cli.py

@@ -46,6 +46,18 @@ def main():
         action="store_true",
         help="Use only files that are added/modified/untracked/stashed but not yet committed.",
     )
+    parser.add_argument(
+        "-S",
+        "--contains",
+        nargs="+",
+        default=[],
+        help="Only include files whose contents contain these substrings",
+    )
+    parser.add_argument(
+        "--contains-case",
+        action="store_true",
+        help="Make --contains case-sensitive",
+    )
 
     args = parser.parse_args()
 

{reposnap-0.7.0 → reposnap-0.8.0}/tests/reposnap/test_cli.py

@@ -126,3 +126,98 @@ def test_cli_without_changes_flag(mock_controller, temp_dir):
     args = mock_controller.call_args[0][0]
     assert args.changes is False
     mock_controller_instance.run.assert_called_once()
+
+
+@patch("reposnap.interfaces.cli.ProjectController")
+def test_cli_with_contains_flag_single(mock_controller, temp_dir):
+    """Test that the --contains flag with single value is properly parsed."""
+    mock_controller_instance = MagicMock()
+    mock_controller.return_value = mock_controller_instance
+
+    with patch("sys.argv", ["cli.py", str(temp_dir), "--contains", "import"]):
+        main()
+
+    # Verify controller was called with args containing contains=["import"]
+    mock_controller.assert_called_once()
+    args = mock_controller.call_args[0][0]
+    assert args.contains == ["import"]
+    assert args.contains_case is False  # Default
+    mock_controller_instance.run.assert_called_once()
+
+
+@patch("reposnap.interfaces.cli.ProjectController")
+def test_cli_with_contains_flag_multiple(mock_controller, temp_dir):
+    """Test that the --contains flag with multiple values is properly parsed."""
+    mock_controller_instance = MagicMock()
+    mock_controller.return_value = mock_controller_instance
+
+    with patch(
+        "sys.argv", ["cli.py", str(temp_dir), "-S", "import", "logging", "TODO"]
+    ):
+        main()
+
+    # Verify controller was called with args containing multiple patterns
+    mock_controller.assert_called_once()
+    args = mock_controller.call_args[0][0]
+    assert args.contains == ["import", "logging", "TODO"]
+    assert args.contains_case is False  # Default
+    mock_controller_instance.run.assert_called_once()
+
+
+@patch("reposnap.interfaces.cli.ProjectController")
+def test_cli_with_contains_case_flag(mock_controller, temp_dir):
+    """Test that the --contains-case flag is properly parsed."""
+    mock_controller_instance = MagicMock()
+    mock_controller.return_value = mock_controller_instance
+
+    with patch("sys.argv", ["cli.py", str(temp_dir), "-S", "TODO", "--contains-case"]):
+        main()
+
+    # Verify controller was called with args containing contains_case=True
+    mock_controller.assert_called_once()
+    args = mock_controller.call_args[0][0]
+    assert args.contains == ["TODO"]
+    assert args.contains_case is True
+    mock_controller_instance.run.assert_called_once()
+
+
+@patch("reposnap.interfaces.cli.ProjectController")
+def test_cli_contains_defaults(mock_controller, temp_dir):
+    """Test that contains flags default correctly when not provided."""
+    mock_controller_instance = MagicMock()
+    mock_controller.return_value = mock_controller_instance
+
+    with patch("sys.argv", ["cli.py", str(temp_dir)]):
+        main()
+
+    # Verify controller was called with default contains values
+    mock_controller.assert_called_once()
+    args = mock_controller.call_args[0][0]
+    assert args.contains == []  # Default empty list
+    assert args.contains_case is False  # Default False
+    mock_controller_instance.run.assert_called_once()
+
+
+@patch("reposnap.interfaces.cli.ProjectController")
+def test_cli_contains_with_binary_files(mock_controller, temp_dir):
+    """Test that binary files are properly handled in contains filter."""
+    mock_controller_instance = MagicMock()
+    mock_controller.return_value = mock_controller_instance
+
+    # Create a binary file and a text file
+    binary_file = os.path.join(temp_dir, "binary.bin")
+    with open(binary_file, "wb") as f:
+        f.write(b"\x00\x01binary\x00data\xff")
+
+    text_file = os.path.join(temp_dir, "text.py")
+    with open(text_file, "w") as f:
+        f.write("import logging\ndef main(): pass\n")
+
+    with patch("sys.argv", ["cli.py", str(temp_dir), "-S", "import"]):
+        main()
+
+    # Should have been called and run successfully
+    mock_controller.assert_called_once()
+    args = mock_controller.call_args[0][0]
+    assert args.contains == ["import"]
+    mock_controller_instance.run.assert_called_once()

reposnap-0.8.0/tests/reposnap/test_contains_filter.py

@@ -0,0 +1,295 @@
+# tests/reposnap/test_contains_filter.py
+
+from pathlib import Path
+from reposnap.core.content_search import file_matches, filter_files_by_content
+
+
+class TestContentSearch:
+    """Test content search functionality."""
+
+    def test_file_matches_single_pattern(self, tmp_path):
+        """Test matching a single pattern in file content."""
+        test_file = tmp_path / "test.py"
+        test_file.write_text("def main():\n    print('needle in haystack')\n")
+
+        assert file_matches(test_file, ["needle"], ignore_case=True)
+        assert not file_matches(test_file, ["nonexistent"], ignore_case=True)
+
+    def test_file_matches_multiple_patterns_or_logic(self, tmp_path):
+        """Test that multiple patterns use OR logic (any match is sufficient)."""
+        test_file = tmp_path / "test.py"
+        test_file.write_text("import logging\ndef main():\n    pass\n")
+
+        # Should match because file contains "import"
+        assert file_matches(test_file, ["import", "nonexistent"], ignore_case=True)
+        # Should match because file contains "logging"
+        assert file_matches(test_file, ["nonexistent", "logging"], ignore_case=True)
+        # Should not match because file contains neither
+        assert not file_matches(test_file, ["foo", "bar"], ignore_case=True)
+
+    def test_file_matches_case_insensitive_default(self, tmp_path):
+        """Test case insensitive matching by default."""
+        test_file = tmp_path / "test.py"
+        test_file.write_text("TODO: Fix this bug\n")
+
+        assert file_matches(test_file, ["todo"], ignore_case=True)
+        assert file_matches(test_file, ["TODO"], ignore_case=True)
+        assert file_matches(test_file, ["Todo"], ignore_case=True)
+
+    def test_file_matches_case_sensitive_flag(self, tmp_path):
+        """Test case sensitive matching when flag is set."""
+        test_file = tmp_path / "test.py"
+        test_file.write_text("TODO: Fix this bug\n")
+
+        assert file_matches(test_file, ["TODO"], ignore_case=False)
+        assert not file_matches(test_file, ["todo"], ignore_case=False)
+        assert not file_matches(test_file, ["Todo"], ignore_case=False)
+
+    def test_file_matches_empty_patterns(self, tmp_path):
+        """Test that empty patterns list returns True."""
+        test_file = tmp_path / "test.py"
+        test_file.write_text("any content\n")
+
+        assert file_matches(test_file, [], ignore_case=True)
+
+    def test_file_matches_nonexistent_file(self, tmp_path):
+        """Test that non-existent file returns False."""
+        nonexistent = tmp_path / "nonexistent.py"
+
+        assert not file_matches(nonexistent, ["pattern"], ignore_case=True)
+
+    def test_file_matches_binary_file_handling(self, tmp_path):
+        """Test that binary files are handled gracefully."""
+        binary_file = tmp_path / "test.bin"
+        binary_file.write_bytes(b"\x00\x01\x02\x03\xff\xfe")
+
+        # Should not crash and should return False for binary content
+        assert not file_matches(binary_file, ["pattern"], ignore_case=True)
+
+    def test_file_matches_large_file_handling(self, tmp_path):
+        """Test that large files are skipped for performance."""
+        from reposnap.core.content_search import MAX_FILE_SIZE
+
+        large_file = tmp_path / "large.txt"
+        # Create a file slightly larger than MAX_FILE_SIZE
+        large_content = "x" * (MAX_FILE_SIZE + 1000)
+        large_file.write_text(large_content)
+
+        # Should skip large files and return False
+        assert not file_matches(large_file, ["x"], ignore_case=True)
+
+    def test_file_matches_binary_detection_in_middle(self, tmp_path):
+        """Test binary detection with null bytes after text content."""
+        mixed_file = tmp_path / "mixed.txt"
+        # Write text content followed by binary content with null bytes
+        with mixed_file.open("wb") as f:
+            f.write(b"some text content\n")
+            f.write(b"\x00binary\x00data\xff")
+
+        # Should detect binary content and return False
+        assert not file_matches(mixed_file, ["text"], ignore_case=True)
+
+    def test_filter_files_by_content_basic(self, tmp_path):
+        """Test basic file filtering by content."""
+        file1 = tmp_path / "file1.py"
+        file1.write_text("import logging\ndef main(): pass\n")
+
+        file2 = tmp_path / "file2.py"
+        file2.write_text("import os\ndef helper(): pass\n")
+
+        file3 = tmp_path / "file3.py"
+        file3.write_text("print('hello world')\n")
+
+        files = [file1, file2, file3]
+
+        # Filter for files containing "import"
+        filtered = filter_files_by_content(files, ["import"])
+        assert set(filtered) == {file1, file2}
+
+        # Filter for files containing "logging"
+        filtered = filter_files_by_content(files, ["logging"])
+        assert filtered == [file1]
+
+    def test_filter_files_by_content_empty_patterns(self, tmp_path):
+        """Test that empty patterns return all files."""
+        file1 = tmp_path / "file1.py"
+        file1.write_text("content1")
+
+        file2 = tmp_path / "file2.py"
+        file2.write_text("content2")
+
+        files = [file1, file2]
+        filtered = filter_files_by_content(files, [])
+        assert filtered == files
+
+    def test_filter_files_by_content_case_sensitivity(self, tmp_path):
+        """Test case sensitivity in file filtering."""
+        test_file = tmp_path / "test.py"
+        test_file.write_text("TODO: Important task\n")
+
+        files = [test_file]
+
+        # Case insensitive (default)
+        filtered = filter_files_by_content(files, ["todo"], ignore_case=True)
+        assert filtered == [test_file]
+
+        # Case sensitive
+        filtered = filter_files_by_content(files, ["todo"], ignore_case=False)
+        assert filtered == []
+
+        filtered = filter_files_by_content(files, ["TODO"], ignore_case=False)
+        assert filtered == [test_file]
+
+
+class TestProjectControllerIntegration:
+    """Test integration of contains filter with ProjectController."""
+
+    def test_contains_filter_integration(self, tmp_path):
+        """Test that ProjectController properly applies content filters."""
+        from reposnap.controllers.project_controller import ProjectController
+        from unittest.mock import Mock
+
+        # Create test files
+        file1 = tmp_path / "file1.py"
+        file1.write_text("import logging\ndef main(): pass\n")
+
+        file2 = tmp_path / "file2.py"
+        file2.write_text("import os\ndef helper(): pass\n")
+
+        file3 = tmp_path / "file3.txt"
+        file3.write_text("This is a text file\n")
+
+        # Mock args object
+        args = Mock()
+        args.paths = [str(tmp_path)]
+        args.output = "output.md"
+        args.structure_only = False
+        args.include = []
+        args.exclude = []
+        args.changes = False
+        args.contains = ["import"]
+        args.contains_case = False
+
+        # Create controller and test content filtering
+        controller = ProjectController(args)
+        controller.set_root_dir(tmp_path)
+
+        # Test the _apply_content_filter method directly
+        files = [Path("file1.py"), Path("file2.py"), Path("file3.txt")]
+        filtered = controller._apply_content_filter(files)
+
+        # Should only keep files with "import"
+        assert set(f.name for f in filtered) == {"file1.py", "file2.py"}
+
+    def test_contains_filter_case_sensitivity_integration(self, tmp_path):
+        """Test case sensitivity integration in ProjectController."""
+        from reposnap.controllers.project_controller import ProjectController
+        from unittest.mock import Mock
+
+        # Create test file
+        test_file = tmp_path / "test.py"
+        test_file.write_text("TODO: Fix this\n")
+
+        # Test case insensitive (default)
+        args = Mock()
+        args.paths = [str(tmp_path)]
+        args.output = "output.md"
+        args.structure_only = False
+        args.include = []
+        args.exclude = []
+        args.changes = False
+        args.contains = ["todo"]
+        args.contains_case = False
+
+        controller = ProjectController(args)
+        controller.set_root_dir(tmp_path)
+
+        files = [Path("test.py")]
+        filtered = controller._apply_content_filter(files)
+        assert len(filtered) == 1
+
+        # Test case sensitive
+        args.contains_case = True
+        controller = ProjectController(args)
+        controller.set_root_dir(tmp_path)
+
+        filtered = controller._apply_content_filter(files)
+        assert len(filtered) == 0  # "todo" != "TODO"
+
+    def test_no_contains_patterns_returns_all_files(self, tmp_path):
+        """Test that empty contains patterns return all files unchanged."""
+        from reposnap.controllers.project_controller import ProjectController
+        from unittest.mock import Mock
+
+        # Create test files
+        file1 = tmp_path / "file1.py"
+        file1.write_text("content1")
+
+        file2 = tmp_path / "file2.py"
+        file2.write_text("content2")
+
+        # Mock args with empty contains
+        args = Mock()
+        args.paths = [str(tmp_path)]
+        args.output = "output.md"
+        args.structure_only = False
+        args.include = []
+        args.exclude = []
+        args.changes = False
+        args.contains = []
+        args.contains_case = False
+
+        controller = ProjectController(args)
+        controller.set_root_dir(tmp_path)
+
+        files = [Path("file1.py"), Path("file2.py")]
+        filtered = controller._apply_content_filter(files)
+
+        # Should return all files unchanged
+        assert set(filtered) == set(files)
+
+    def test_absolute_path_handling(self, tmp_path):
+        """Test that ProjectController properly handles absolute paths."""
+        from reposnap.controllers.project_controller import ProjectController
+        from unittest.mock import Mock
+
+        # Create test file
+        test_file = tmp_path / "test.py"
+        test_file.write_text("import logging\ndef main(): pass\n")
+
+        # Mock args with absolute path
+        args = Mock()
+        args.paths = [str(test_file)]  # Absolute path
+        args.output = "output.md"
+        args.structure_only = False
+        args.include = []
+        args.exclude = []
+        args.changes = False
+        args.contains = ["import"]
+        args.contains_case = False
+
+        # Create controller with the temp directory as root from the start
+        # This simulates how the controller would actually work
+        controller = ProjectController()
+        controller.set_root_dir(tmp_path)
+
+        # Process the args manually after setting root dir
+        input_paths = [Path(p) for p in args.paths]
+        controller.input_paths = []
+        for p in input_paths:
+            if p.is_absolute():
+                candidate = p.resolve()
+            else:
+                candidate = (controller.root_dir / p).resolve()
+
+            if candidate.exists():
+                try:
+                    rel = candidate.relative_to(controller.root_dir)
+                    if rel != Path("."):
+                        controller.input_paths.append(rel)
+                except ValueError:
+                    pass  # Path not under root
+
+        # Should have processed the absolute path correctly
+        assert len(controller.input_paths) == 1
+        assert controller.input_paths[0].name == "test.py"