reposnap 0.6.5__tar.gz → 0.7.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reposnap
-Version: 0.6.5
+Version: 0.7.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.
+- **Changes Only Mode**: Use `-c` or `--changes` to snapshot only uncommitted files (staged, unstaged, untracked, and stashed changes).
 
 ## Installation
 
@@ -49,7 +50,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 ...]] paths [paths ...]
+reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]] [-e EXCLUDE [EXCLUDE ...]] [-c] paths [paths ...]
 ```
 
 - `paths`: One or more paths (files or directories) within the repository whose content and structure should be rendered.
@@ -59,6 +60,7 @@ reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]
 - `--debug`: Enable debug-level logging.
 - `-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.
 
 #### Pattern Matching
 
@@ -71,6 +73,42 @@ 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.
 
+#### 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:
+
+- **Staged changes**: Files that have been added to the index with `git add`
+- **Unstaged changes**: Files that have been modified but not yet staged
+- **Untracked files**: New files that haven't been added to Git yet
+- **Stashed changes**: Files that are stored in Git stash entries
+
+This is particularly useful when you want to:
+- Document only your current work-in-progress
+- Create a snapshot of changes before committing
+- Review what files you've been working on
+
+**Examples**:
+
+1. **Generate documentation for only your uncommitted changes**:
+    ```bash
+    reposnap . -c
+    ```
+
+2. **Combine with structure-only for a quick overview**:
+    ```bash
+    reposnap . -c --structure-only
+    ```
+
+3. **Filter uncommitted changes by file type**:
+    ```bash
+    reposnap . -c -i "*.py"
+    ```
+
+4. **Exclude test files from uncommitted changes**:
+    ```bash
+    reposnap . -c -e "*test*"
+    ```
+
 #### Examples
 
 1. **Generate a full project structure with file contents**:
@@ -103,6 +141,12 @@ reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]
     reposnap my_project/ -e "gui"
     ```
 
+6. **Document only your current uncommitted work**:
+
+    ```bash
+    reposnap . -c
+    ```
+
 ### Graphical User Interface
 
 `reposnap` also provides a GUI for users who prefer an interactive interface.

{reposnap-0.6.5 → reposnap-0.7.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.
+- **Changes Only Mode**: Use `-c` or `--changes` to snapshot only uncommitted files (staged, unstaged, untracked, and stashed changes).
 
 ## Installation
 
@@ -36,7 +37,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 ...]] paths [paths ...]
+reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]] [-e EXCLUDE [EXCLUDE ...]] [-c] paths [paths ...]
 ```
 
 - `paths`: One or more paths (files or directories) within the repository whose content and structure should be rendered.
@@ -46,6 +47,7 @@ reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]
 - `--debug`: Enable debug-level logging.
 - `-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.
 
 #### Pattern Matching
 
@@ -58,6 +60,42 @@ 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.
 
+#### 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:
+
+- **Staged changes**: Files that have been added to the index with `git add`
+- **Unstaged changes**: Files that have been modified but not yet staged
+- **Untracked files**: New files that haven't been added to Git yet
+- **Stashed changes**: Files that are stored in Git stash entries
+
+This is particularly useful when you want to:
+- Document only your current work-in-progress
+- Create a snapshot of changes before committing
+- Review what files you've been working on
+
+**Examples**:
+
+1. **Generate documentation for only your uncommitted changes**:
+    ```bash
+    reposnap . -c
+    ```
+
+2. **Combine with structure-only for a quick overview**:
+    ```bash
+    reposnap . -c --structure-only
+    ```
+
+3. **Filter uncommitted changes by file type**:
+    ```bash
+    reposnap . -c -i "*.py"
+    ```
+
+4. **Exclude test files from uncommitted changes**:
+    ```bash
+    reposnap . -c -e "*test*"
+    ```
+
 #### Examples
 
 1. **Generate a full project structure with file contents**:
@@ -90,6 +128,12 @@ reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]
     reposnap my_project/ -e "gui"
     ```
 
+6. **Document only your current uncommitted work**:
+
+    ```bash
+    reposnap . -c
+    ```
+
 ### Graphical User Interface
 
 `reposnap` also provides a GUI for users who prefer an interactive interface.

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

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

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

@@ -15,7 +15,7 @@ class ProjectController:
             self.args = args
             # Treat positional arguments as literal file/directory names.
             input_paths = [
-                Path(p) for p in (args.paths if hasattr(args, "paths") else [args.path])
+                Path(p) for p in (args.paths if hasattr(args, "paths") else [])
             ]
             self.input_paths = []
             for p in input_paths:
@@ -47,6 +47,7 @@ class ProjectController:
             self.exclude_patterns: List[str] = (
                 args.exclude if hasattr(args, "exclude") else []
             )
+            self.changes_only: bool = getattr(args, "changes", False)
         else:
             self.args = None
             self.input_paths = []
@@ -54,6 +55,7 @@ class ProjectController:
             self.structure_only = False
             self.include_patterns = []
             self.exclude_patterns = []
+            self.changes_only = False
         self.file_tree: Optional[FileTree] = None
         self.gitignore_patterns: List[str] = []
         if self.root_dir:
@@ -109,13 +111,23 @@ class ProjectController:
         return files
 
     def collect_file_tree(self) -> None:
-        self.logger.info("Collecting files from Git tracked files if available.")
+        if self.changes_only:
+            self.logger.info("Collecting uncommitted files from Git repository.")
+        else:
+            self.logger.info("Collecting files from Git tracked files if available.")
         try:
             from reposnap.core.git_repo import GitRepo
 
             git_repo = GitRepo(self.root_dir)
-            all_files = git_repo.get_git_files()
-            self.logger.debug(f"Git tracked files: {all_files}")
+            if self.changes_only:
+                all_files = git_repo.get_uncommitted_files()
+                self.logger.info(
+                    "Using only uncommitted files (staged, unstaged, untracked, stashed)."
+                )
+            else:
+                all_files = git_repo.get_git_files()
+                self.logger.info("Using all Git tracked files.")
+            self.logger.debug(f"Git files: {all_files}")
         except Exception as e:
             self.logger.warning(f"Error obtaining Git tracked files: {e}.")
             all_files = []

reposnap-0.7.0/reposnap/core/git_repo.py

@@ -0,0 +1,100 @@
+# src/reposnap/core/git_repo.py
+
+import logging
+from pathlib import Path
+from git import Repo, InvalidGitRepositoryError
+from typing import List
+
+
+class GitRepo:
+    def __init__(self, repo_path: Path):
+        self.repo_path: Path = repo_path.resolve()
+        self.logger = logging.getLogger(__name__)
+
+    def get_git_files(self) -> List[Path]:
+        try:
+            repo: Repo = Repo(self.repo_path, search_parent_directories=True)
+            repo_root: Path = Path(repo.working_tree_dir).resolve()
+            git_files: List[str] = repo.git.ls_files().splitlines()
+            self.logger.debug(f"Git files from {repo_root}: {git_files}")
+            git_files_relative: List[Path] = []
+            for f in git_files:
+                absolute_path: Path = (repo_root / f).resolve()
+                try:
+                    relative_path: Path = absolute_path.relative_to(self.repo_path)
+                    git_files_relative.append(relative_path)
+                except ValueError:
+                    # Skip files not under root_dir
+                    continue
+            return git_files_relative
+        except InvalidGitRepositoryError:
+            self.logger.error(f"Invalid Git repository at: {self.repo_path}")
+            return []
+
+    def get_uncommitted_files(self) -> List[Path]:
+        """
+        Return every *working-copy* file that differs from HEAD - staged,
+        unstaged, untracked, plus everything referenced in `git stash list`.
+        Paths are *relative to* self.repo_path.
+        """
+        try:
+            repo: Repo = Repo(self.repo_path, search_parent_directories=True)
+            repo_root: Path = Path(repo.working_tree_dir).resolve()
+            paths: set = set()
+
+            # Staged changes (diff between index and HEAD)
+            for diff in repo.index.diff("HEAD"):
+                paths.add(diff.a_path or diff.b_path)
+
+            # Unstaged changes (diff between working tree and index)
+            for diff in repo.index.diff(None):
+                paths.add(diff.a_path or diff.b_path)
+
+            # Untracked files
+            paths.update(repo.untracked_files)
+
+            # Stash entries - with performance guard
+            try:
+                stash_refs = repo.git.stash("list", "--format=%gd").splitlines()
+                # Limit stash processing to prevent performance issues
+                max_stashes = 10
+                if len(stash_refs) > max_stashes:
+                    self.logger.warning(
+                        f"Large stash stack detected ({len(stash_refs)} entries). "
+                        f"Processing only the first {max_stashes} stashes."
+                    )
+                    stash_refs = stash_refs[:max_stashes]
+
+                for ref in stash_refs:
+                    if ref.strip():  # Skip empty lines
+                        stash_files = repo.git.diff(
+                            "--name-only", f"{ref}^1", ref
+                        ).splitlines()
+                        paths.update(stash_files)
+            except Exception as e:
+                self.logger.debug(f"Error processing stash entries: {e}")
+
+            # Convert to relative paths and filter existing files
+            relative_paths = []
+            for path_str in paths:
+                if path_str:  # Skip empty strings
+                    absolute_path = (repo_root / path_str).resolve()
+                    try:
+                        relative_path = absolute_path.relative_to(self.repo_path)
+                        if absolute_path.is_file():
+                            relative_paths.append(relative_path)
+                    except ValueError:
+                        # Log warning for paths outside repo root
+                        self.logger.warning(
+                            f"Path {path_str} is outside repository root {self.repo_path}. Skipping."
+                        )
+                        continue
+
+            # Return sorted, deduplicated list for deterministic output
+            result = sorted(set(relative_paths))
+            self.logger.debug(f"Uncommitted files from {repo_root}: {result}")
+            return result
+
+        except InvalidGitRepositoryError:
+            self.logger.error(f"Invalid Git repository at: {self.repo_path}")
+            return []

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

@@ -40,6 +40,12 @@ def main():
         default=[],
         help="File/folder patterns to exclude.",
     )
+    parser.add_argument(
+        "-c",
+        "--changes",
+        action="store_true",
+        help="Use only files that are added/modified/untracked/stashed but not yet committed.",
+    )
 
     args = parser.parse_args()
 

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

@@ -78,3 +78,51 @@ def test_cli(mock_controller, temp_dir):
         main()
 
     mock_controller_instance.run.assert_called_once()
+
+
+@patch("reposnap.interfaces.cli.ProjectController")
+def test_cli_with_changes_flag(mock_controller, temp_dir):
+    """Test that the --changes flag is properly parsed and passed to controller."""
+    mock_controller_instance = MagicMock()
+    mock_controller.return_value = mock_controller_instance
+
+    with patch("sys.argv", ["cli.py", str(temp_dir), "--changes"]):
+        main()
+
+    # Verify controller was called with args containing changes=True
+    mock_controller.assert_called_once()
+    args = mock_controller.call_args[0][0]
+    assert args.changes is True
+    mock_controller_instance.run.assert_called_once()
+
+
+@patch("reposnap.interfaces.cli.ProjectController")
+def test_cli_with_changes_short_flag(mock_controller, temp_dir):
+    """Test that the -c flag is properly parsed and passed to controller."""
+    mock_controller_instance = MagicMock()
+    mock_controller.return_value = mock_controller_instance
+
+    with patch("sys.argv", ["cli.py", str(temp_dir), "-c"]):
+        main()
+
+    # Verify controller was called with args containing changes=True
+    mock_controller.assert_called_once()
+    args = mock_controller.call_args[0][0]
+    assert args.changes is True
+    mock_controller_instance.run.assert_called_once()
+
+
+@patch("reposnap.interfaces.cli.ProjectController")
+def test_cli_without_changes_flag(mock_controller, temp_dir):
+    """Test that changes defaults to False when flag is 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 args containing changes=False (default)
+    mock_controller.assert_called_once()
+    args = mock_controller.call_args[0][0]
+    assert args.changes is False
+    mock_controller_instance.run.assert_called_once()

reposnap-0.7.0/tests/reposnap/test_git_repo.py

@@ -0,0 +1,211 @@
+# tests/reposnap/test_git_repo.py
+
+from unittest.mock import patch, MagicMock
+from reposnap.core.git_repo import GitRepo
+from pathlib import Path
+
+
+@patch("reposnap.core.git_repo.Repo")
+def test_get_git_files(mock_repo):
+    mock_repo_instance = MagicMock()
+    mock_repo_instance.git.ls_files.return_value = "file1.py\nsubdir/file2.py"
+    mock_repo_instance.working_tree_dir = "/path/to/repo"
+    mock_repo.return_value = mock_repo_instance
+
+    git_repo = GitRepo(Path("/path/to/repo/subdir"))
+    files = git_repo.get_git_files()
+
+    expected_files = [Path("file2.py")]
+
+    assert files == expected_files
+
+
+@patch("reposnap.core.git_repo.Repo")
+@patch("pathlib.Path.is_file")
+def test_get_uncommitted_files_staged_and_unstaged(mock_is_file, mock_repo):
+    """Test get_uncommitted_files with staged and unstaged changes."""
+    mock_repo_instance = MagicMock()
+    mock_repo_instance.working_tree_dir = "/path/to/repo"
+
+    # Mock staged changes
+    staged_diff = MagicMock()
+    staged_diff.a_path = "staged_file.py"
+    staged_diff.b_path = None
+
+    # Mock unstaged changes
+    unstaged_diff = MagicMock()
+    unstaged_diff.a_path = "unstaged_file.py"
+    unstaged_diff.b_path = None
+
+    mock_repo_instance.index.diff.side_effect = lambda ref: {
+        "HEAD": [staged_diff],
+        None: [unstaged_diff],
+    }[ref]
+
+    # Mock untracked files
+    mock_repo_instance.untracked_files = ["untracked_file.py"]
+
+    # Mock stash (empty)
+    mock_repo_instance.git.stash.return_value = ""
+
+    # Mock file existence
+    mock_is_file.return_value = True
+
+    mock_repo.return_value = mock_repo_instance
+
+    git_repo = GitRepo(Path("/path/to/repo"))
+    files = git_repo.get_uncommitted_files()
+
+    expected_files = [
+        Path("staged_file.py"),
+        Path("unstaged_file.py"),
+        Path("untracked_file.py"),
+    ]
+
+    # Compare sorted lists since the method now returns sorted output
+    assert files == sorted(expected_files)
+
+
+@patch("reposnap.core.git_repo.Repo")
+@patch("pathlib.Path.is_file")
+def test_get_uncommitted_files_with_stash(mock_is_file, mock_repo):
+    """Test get_uncommitted_files with stash entries."""
+    mock_repo_instance = MagicMock()
+    mock_repo_instance.working_tree_dir = "/path/to/repo"
+
+    # Mock no staged/unstaged changes
+    mock_repo_instance.index.diff.return_value = []
+
+    # Mock untracked files
+    mock_repo_instance.untracked_files = []
+
+    # 1) Mock stash list
+    mock_repo_instance.git.stash.return_value = "stash@{0}\nstash@{1}"
+
+    # 2) Mock diff calls to get stash file names
+    mock_repo_instance.git.diff.side_effect = lambda *args: {
+        ("--name-only", "stash@{0}^1", "stash@{0}"): "stash_file1.py\nstash_file2.py",
+        ("--name-only", "stash@{1}^1", "stash@{1}"): "stash_file3.py",
+    }[args]
+
+    # Mock file existence
+    mock_is_file.return_value = True
+
+    mock_repo.return_value = mock_repo_instance
+
+    git_repo = GitRepo(Path("/path/to/repo"))
+    files = git_repo.get_uncommitted_files()
+
+    expected_files = [
+        Path("stash_file1.py"),
+        Path("stash_file2.py"),
+        Path("stash_file3.py"),
+    ]
+
+    # Compare sorted lists since the method now returns sorted output
+    assert files == sorted(expected_files)
+
+
+@patch("reposnap.core.git_repo.Repo")
+def test_get_uncommitted_files_empty_working_tree(mock_repo):
+    """Test get_uncommitted_files with no changes."""
+    mock_repo_instance = MagicMock()
+    mock_repo_instance.working_tree_dir = "/path/to/repo"
+
+    # Mock no changes
+    mock_repo_instance.index.diff.return_value = []
+    mock_repo_instance.untracked_files = []
+    mock_repo_instance.git.stash.return_value = ""
+
+    mock_repo.return_value = mock_repo_instance
+
+    git_repo = GitRepo(Path("/path/to/repo"))
+    files = git_repo.get_uncommitted_files()
+
+    assert files == []
+
+
+@patch("reposnap.core.git_repo.Repo")
+def test_get_uncommitted_files_invalid_repo(mock_repo):
+    """Test get_uncommitted_files with invalid repository."""
+    from git import InvalidGitRepositoryError
+
+    mock_repo.side_effect = InvalidGitRepositoryError("Not a git repo")
+
+    git_repo = GitRepo(Path("/path/to/repo"))
+    files = git_repo.get_uncommitted_files()
+
+    assert files == []
+
+
+@patch("reposnap.core.git_repo.Repo")
+@patch("pathlib.Path.is_file")
+def test_get_uncommitted_files_stash_error_handling(mock_is_file, mock_repo):
+    """Test get_uncommitted_files handles stash errors gracefully."""
+    mock_repo_instance = MagicMock()
+    mock_repo_instance.working_tree_dir = "/path/to/repo"
+
+    # Mock staged changes
+    staged_diff = MagicMock()
+    staged_diff.a_path = "staged_file.py"
+    staged_diff.b_path = None
+    mock_repo_instance.index.diff.return_value = [staged_diff]
+
+    # Mock untracked files
+    mock_repo_instance.untracked_files = []
+
+    # Mock stash error
+    mock_repo_instance.git.stash.side_effect = Exception("Stash error")
+
+    # Mock file existence
+    mock_is_file.return_value = True
+
+    mock_repo.return_value = mock_repo_instance
+
+    git_repo = GitRepo(Path("/path/to/repo"))
+    files = git_repo.get_uncommitted_files()
+
+    # Should still return staged changes even if stash fails
+    expected_files = [Path("staged_file.py")]
+    assert files == expected_files
+
+
+@patch("reposnap.core.git_repo.Repo")
+@patch("pathlib.Path.is_file")
+def test_get_uncommitted_files_stash_limit(mock_is_file, mock_repo):
+    """Test get_uncommitted_files respects the stash limit."""
+    mock_repo_instance = MagicMock()
+    mock_repo_instance.working_tree_dir = "/path/to/repo"
+
+    # Mock no staged/unstaged changes
+    mock_repo_instance.index.diff.return_value = []
+
+    # Mock untracked files
+    mock_repo_instance.untracked_files = []
+
+    # Mock many stash entries (more than the limit of 10)
+    many_stashes = "\n".join([f"stash@{{{i}}}" for i in range(15)])
+    mock_repo_instance.git.stash.return_value = many_stashes
+
+    # Mock diff calls for the first 10 stashes (the limit)
+    def mock_diff(*args):
+        if args[0] == "--name-only" and len(args) == 3:
+            stash_ref = args[2]  # e.g., 'stash@{0}'
+            stash_num = int(stash_ref.split("{")[1].split("}")[0])
+            if stash_num < 10:  # Only the first 10 should be processed
+                return f"stash_file_{stash_num}.py"
+        return ""
+
+    mock_repo_instance.git.diff.side_effect = mock_diff
+
+    # Mock file existence
+    mock_is_file.return_value = True
+
+    mock_repo.return_value = mock_repo_instance
+
+    git_repo = GitRepo(Path("/path/to/repo"))
+    files = git_repo.get_uncommitted_files()
+
+    # Should only process the first 10 stashes
+    # The exact number depends on how many unique files are in those stashes
+    assert len(files) >= 0  # At minimum, should not crash

{reposnap-0.6.5 → reposnap-0.7.0}/tests/reposnap/test_project_controller.py

@@ -350,3 +350,82 @@ def test_project_controller_multiple_paths():
         assert "LICENSE" not in tree
         assert "tests" not in tree
         assert "extras" not in tree
+
+
+def test_project_controller_changes_only():
+    """Test that changes_only flag calls get_uncommitted_files instead of get_git_files."""
+    with tempfile.TemporaryDirectory() as temp_dir:
+        structure = {
+            "file1.py": 'print("File 1")',
+            "file2.py": 'print("File 2")',
+        }
+        create_directory_structure(temp_dir, structure)
+        args = type(
+            "Args",
+            (object,),
+            {
+                "paths": [temp_dir],
+                "output": os.path.join(temp_dir, "output.md"),
+                "structure_only": False,
+                "debug": False,
+                "include": [],
+                "exclude": [],
+                "changes": True,
+            },
+        )
+        with patch(
+            "reposnap.controllers.project_controller.ProjectController._get_repo_root",
+            return_value=Path(temp_dir),
+        ):
+            with patch("reposnap.core.git_repo.GitRepo") as MockGitRepo:
+                mock_git_repo = MagicMock()
+                mock_git_repo.get_uncommitted_files.return_value = [Path("file1.py")]
+                MockGitRepo.return_value = mock_git_repo
+
+                controller = ProjectController(args)
+                controller.collect_file_tree()
+
+                # Verify get_uncommitted_files was called instead of get_git_files
+                mock_git_repo.get_uncommitted_files.assert_called_once()
+                mock_git_repo.get_git_files.assert_not_called()
+
+
+def test_project_controller_changes_only_false():
+    """Test that when changes_only is False, get_git_files is called."""
+    with tempfile.TemporaryDirectory() as temp_dir:
+        structure = {
+            "file1.py": 'print("File 1")',
+            "file2.py": 'print("File 2")',
+        }
+        create_directory_structure(temp_dir, structure)
+        args = type(
+            "Args",
+            (object,),
+            {
+                "paths": [temp_dir],
+                "output": os.path.join(temp_dir, "output.md"),
+                "structure_only": False,
+                "debug": False,
+                "include": [],
+                "exclude": [],
+                "changes": False,
+            },
+        )
+        with patch(
+            "reposnap.controllers.project_controller.ProjectController._get_repo_root",
+            return_value=Path(temp_dir),
+        ):
+            with patch("reposnap.core.git_repo.GitRepo") as MockGitRepo:
+                mock_git_repo = MagicMock()
+                mock_git_repo.get_git_files.return_value = [
+                    Path("file1.py"),
+                    Path("file2.py"),
+                ]
+                MockGitRepo.return_value = mock_git_repo
+
+                controller = ProjectController(args)
+                controller.collect_file_tree()
+
+                # Verify get_git_files was called instead of get_uncommitted_files
+                mock_git_repo.get_git_files.assert_called_once()
+                mock_git_repo.get_uncommitted_files.assert_not_called()

reposnap-0.6.5/reposnap/core/git_repo.py

@@ -1,32 +0,0 @@
-# src/reposnap/core/git_repo.py
-
-import logging
-from pathlib import Path
-from git import Repo, InvalidGitRepositoryError
-from typing import List
-
-
-class GitRepo:
-    def __init__(self, repo_path: Path):
-        self.repo_path: Path = repo_path.resolve()
-        self.logger = logging.getLogger(__name__)
-
-    def get_git_files(self) -> List[Path]:
-        try:
-            repo: Repo = Repo(self.repo_path, search_parent_directories=True)
-            repo_root: Path = Path(repo.working_tree_dir).resolve()
-            git_files: List[str] = repo.git.ls_files().splitlines()
-            self.logger.debug(f"Git files from {repo_root}: {git_files}")
-            git_files_relative: List[Path] = []
-            for f in git_files:
-                absolute_path: Path = (repo_root / f).resolve()
-                try:
-                    relative_path: Path = absolute_path.relative_to(self.repo_path)
-                    git_files_relative.append(relative_path)
-                except ValueError:
-                    # Skip files not under root_dir
-                    continue
-            return git_files_relative
-        except InvalidGitRepositoryError:
-            self.logger.error(f"Invalid Git repository at: {self.repo_path}")
-            return []

reposnap-0.6.5/tests/reposnap/test_git_repo.py

@@ -1,20 +0,0 @@
-# tests/reposnap/test_git_repo.py
-
-from unittest.mock import patch, MagicMock
-from reposnap.core.git_repo import GitRepo
-from pathlib import Path
-
-
-@patch("reposnap.core.git_repo.Repo")
-def test_get_git_files(mock_repo):
-    mock_repo_instance = MagicMock()
-    mock_repo_instance.git.ls_files.return_value = "file1.py\nsubdir/file2.py"
-    mock_repo_instance.working_tree_dir = "/path/to/repo"
-    mock_repo.return_value = mock_repo_instance
-
-    git_repo = GitRepo(Path("/path/to/repo/subdir"))
-    files = git_repo.get_git_files()
-
-    expected_files = [Path("file2.py")]
-
-    assert files == expected_files