reposnap 0.6.4__py3-none-any.whl → 0.7.0__py3-none-any.whl

reposnap/controllers/project_controller.py

@@ -0,0 +1,259 @@
+import logging
+from pathlib import Path
+from reposnap.core.file_system import FileSystem
+from reposnap.models.file_tree import FileTree
+import pathspec
+from typing import List, Optional
+
+
+class ProjectController:
+    def __init__(self, args: Optional[object] = None):
+        self.logger = logging.getLogger(__name__)
+        # Always determine repository root using Git (or cwd)
+        self.root_dir = self._get_repo_root().resolve()
+        if args:
+            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 [])
+            ]
+            self.input_paths = []
+            for p in input_paths:
+                candidate = (self.root_dir / p).resolve()
+                if candidate.exists():
+                    try:
+                        rel = candidate.relative_to(self.root_dir)
+                        if rel != Path("."):
+                            self.input_paths.append(rel)
+                    except ValueError:
+                        self.logger.warning(
+                            f"Path {p} is not under repository root {self.root_dir}. Ignoring."
+                        )
+                else:
+                    self.logger.warning(
+                        f"Path {p} does not exist relative to repository root {self.root_dir}."
+                    )
+            self.output_file: Path = (
+                Path(args.output).resolve()
+                if args.output
+                else self.root_dir / "output.md"
+            )
+            self.structure_only: bool = (
+                args.structure_only if hasattr(args, "structure_only") else False
+            )
+            self.include_patterns: List[str] = (
+                args.include if hasattr(args, "include") else []
+            )
+            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 = []
+            self.output_file = self.root_dir / "output.md"
+            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:
+            self.gitignore_patterns = self._load_gitignore_patterns()
+
+    def _get_repo_root(self) -> Path:
+        """
+        Determine the repository root using Git if available,
+        otherwise use the current directory.
+        """
+        from git import Repo, InvalidGitRepositoryError
+
+        try:
+            repo = Repo(Path.cwd(), search_parent_directories=True)
+            return Path(repo.working_tree_dir).resolve()
+        except InvalidGitRepositoryError:
+            self.logger.warning(
+                "Not a git repository. Using current directory as root."
+            )
+            return Path.cwd().resolve()
+
+    def set_root_dir(self, root_dir: Path) -> None:
+        self.root_dir = root_dir.resolve()
+        self.gitignore_patterns = self._load_gitignore_patterns()
+
+    def get_file_tree(self) -> Optional[FileTree]:
+        return self.file_tree
+
+    def _apply_include_exclude(self, files: List[Path]) -> List[Path]:
+        """Filter a list of file paths using include and exclude patterns."""
+
+        def adjust_patterns(patterns):
+            adjusted = []
+            for p in patterns:
+                if any(ch in p for ch in ["*", "?", "["]):
+                    adjusted.append(p)
+                else:
+                    adjusted.append(f"*{p}*")
+            return adjusted
+
+        if self.include_patterns:
+            inc = adjust_patterns(self.include_patterns)
+            spec_inc = pathspec.PathSpec.from_lines(
+                pathspec.patterns.GitWildMatchPattern, inc
+            )
+            files = [f for f in files if spec_inc.match_file(f.as_posix())]
+        if self.exclude_patterns:
+            exc = adjust_patterns(self.exclude_patterns)
+            spec_exc = pathspec.PathSpec.from_lines(
+                pathspec.patterns.GitWildMatchPattern, exc
+            )
+            files = [f for f in files if not spec_exc.match_file(f.as_posix())]
+        return files
+
+    def collect_file_tree(self) -> None:
+        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)
+            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 = []
+        # If Git returns an empty list but files exist on disk, fall back to filesystem scan.
+        if not all_files:
+            file_list = [p for p in self.root_dir.rglob("*") if p.is_file()]
+            if file_list:
+                self.logger.info(
+                    "Git tracked files empty, using filesystem scan fallback."
+                )
+                all_files = []
+                for path in file_list:
+                    try:
+                        rel = path.relative_to(self.root_dir)
+                        all_files.append(rel)
+                    except ValueError:
+                        continue
+        all_files = self._apply_include_exclude(all_files)
+        self.logger.debug(f"All files after applying include/exclude: {all_files}")
+        if self.input_paths:
+            trees = []
+            for input_path in self.input_paths:
+                subset = [
+                    f
+                    for f in all_files
+                    if f == input_path
+                    or list(f.parts[: len(input_path.parts)]) == list(input_path.parts)
+                ]
+                self.logger.debug(f"Files for input path '{input_path}': {subset}")
+                if subset:
+                    tree = FileSystem(self.root_dir).build_tree_structure(subset)
+                    trees.append(tree)
+            if trees:
+                merged_tree = self.merge_trees(trees)
+            else:
+                merged_tree = {}
+        else:
+            merged_tree = FileSystem(self.root_dir).build_tree_structure(all_files)
+        self.logger.info("Merged tree built from input paths.")
+        self.file_tree = FileTree(merged_tree)
+        self.logger.debug(f"Merged tree structure: {self.file_tree.structure}")
+
+    def merge_trees(self, trees: List[dict]) -> dict:
+        """Recursively merge a list of tree dictionaries."""
+        merged = {}
+        for tree in trees:
+            merged = self._merge_two_trees(merged, tree)
+        return merged
+
+    def _merge_two_trees(self, tree1: dict, tree2: dict) -> dict:
+        merged = dict(tree1)
+        for key, value in tree2.items():
+            if key in merged:
+                if isinstance(merged[key], dict) and isinstance(value, dict):
+                    merged[key] = self._merge_two_trees(merged[key], value)
+                else:
+                    merged[key] = value
+            else:
+                merged[key] = value
+        return merged
+
+    def apply_filters(self) -> None:
+        self.logger.info("Applying .gitignore filters to the merged tree.")
+        spec = pathspec.PathSpec.from_lines(
+            pathspec.patterns.GitWildMatchPattern, self.gitignore_patterns
+        )
+        self.logger.debug(f".gitignore patterns: {self.gitignore_patterns}")
+        self.file_tree.filter_files(spec)
+
+    def generate_output(self) -> None:
+        self.logger.info("Starting Markdown generation.")
+        from reposnap.core.markdown_generator import MarkdownGenerator
+
+        markdown_generator = MarkdownGenerator(
+            root_dir=self.root_dir,
+            output_file=self.output_file,
+            structure_only=self.structure_only,
+        )
+        markdown_generator.generate_markdown(
+            self.file_tree.structure, self.file_tree.get_all_files()
+        )
+        self.logger.info(f"Markdown generated at {self.output_file}.")
+
+    def generate_output_from_selected(self, selected_files: set) -> None:
+        self.logger.info("Generating Markdown from selected files.")
+        pruned_tree = self.file_tree.prune_tree(selected_files)
+        from reposnap.core.markdown_generator import MarkdownGenerator
+
+        markdown_generator = MarkdownGenerator(
+            root_dir=self.root_dir,
+            output_file=self.output_file,
+            structure_only=False,
+            hide_untoggled=True,
+        )
+        markdown_generator.generate_markdown(
+            pruned_tree, [Path(f) for f in selected_files]
+        )
+        self.logger.info(f"Markdown generated at {self.output_file}.")
+
+    def run(self) -> None:
+        """Run the entire process: collect files, apply filters, and generate Markdown."""
+        self.collect_file_tree()
+        self.apply_filters()
+        self.generate_output()
+
+    def _load_gitignore_patterns(self) -> List[str]:
+        gitignore_path = self.root_dir / ".gitignore"
+        if not gitignore_path.exists():
+            for parent in self.root_dir.parents:
+                candidate = parent / ".gitignore"
+                if candidate.exists():
+                    gitignore_path = candidate
+                    break
+            else:
+                gitignore_path = None
+        if gitignore_path and gitignore_path.exists():
+            with gitignore_path.open("r") as gitignore:
+                patterns = [
+                    line.strip()
+                    for line in gitignore
+                    if line.strip() and not line.strip().startswith("#")
+                ]
+            self.logger.debug(
+                f"Loaded .gitignore patterns from {gitignore_path.parent}: {patterns}"
+            )
+            return patterns
+        else:
+            self.logger.debug(f"No .gitignore found starting from {self.root_dir}.")
+            return []

reposnap/core/file_system.py

@@ -0,0 +1,32 @@
+# src/reposnap/core/file_system.py
+
+import logging
+from pathlib import Path
+from typing import List, Dict, Any
+
+
+class FileSystem:
+    def __init__(self, root_dir: Path):
+        self.root_dir: Path = root_dir.resolve()
+        self.logger = logging.getLogger(__name__)
+
+    def build_tree_structure(self, files: List[Path]) -> Dict[str, Any]:
+        """
+        Builds a hierarchical tree structure from the list of files.
+
+        Args:
+            files (List[Path]): List of file paths relative to root_dir.
+
+        Returns:
+            Dict[str, Any]: Nested dictionary representing the directory structure.
+        """
+        tree: Dict[str, Any] = {}
+        self.logger.debug("Building tree structure.")
+        for relative_path in files:
+            parts = relative_path.parts
+            current_level = tree
+            for part in parts[:-1]:
+                current_level = current_level.setdefault(part, {})
+            current_level[parts[-1]] = None  # Indicate a file node
+        self.logger.debug(f"Tree structure built: {tree}")
+        return tree

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/core/markdown_generator.py

@@ -0,0 +1,91 @@
+# src/reposnap/core/markdown_generator.py           ★ fully-rewritten file
+import logging
+from pathlib import Path
+from typing import Dict, List, Any
+
+from reposnap.utils.path_utils import format_tree
+
+
+class MarkdownGenerator:
+    """Render the collected file-tree into a single Markdown document."""
+
+    def __init__(
+        self,
+        root_dir: Path,
+        output_file: Path,
+        structure_only: bool = False,
+        hide_untoggled: bool = False,
+    ):
+        self.root_dir = root_dir.resolve()
+        self.output_file = output_file.resolve()
+        self.structure_only = structure_only
+        self.hide_untoggled = hide_untoggled
+        self.logger = logging.getLogger(__name__)
+
+    # --------------------------------------------------------------
+    # public API
+    # --------------------------------------------------------------
+    def generate_markdown(
+        self, tree_structure: Dict[str, Any], files: List[Path]
+    ) -> None:
+        """Write header (tree) and, unless *structure_only*, every file body."""
+        self._write_header(tree_structure)
+        if not self.structure_only:
+            self._write_file_contents(files)
+
+    # --------------------------------------------------------------
+    # helpers
+    # --------------------------------------------------------------
+    def _write_header(self, tree_structure: Dict[str, Any]) -> None:
+        """Emit the *Project Structure* section."""
+        self.logger.debug("Writing Markdown header and project structure.")
+        try:
+            with self.output_file.open(mode="w", encoding="utf-8") as fh:
+                fh.write("# Project Structure\n\n```\n")
+                for line in format_tree(
+                    tree_structure, hide_untoggled=self.hide_untoggled
+                ):
+                    fh.write(line)
+                fh.write("```\n\n")
+        except OSError as exc:
+            self.logger.error("Failed to write header: %s", exc)
+            raise
+
+    def _write_file_contents(self, files: List[Path]) -> None:
+        """Append every file in *files* under its own fenced section."""
+        self.logger.debug("Writing file contents to Markdown.")
+        for rel_path in files:
+            abs_path = self.root_dir / rel_path
+            if not abs_path.exists():  # git had stale entry
+                self.logger.debug("File not found: %s -- skipping.", abs_path)
+                continue
+            try:
+                self._write_single_file(abs_path, rel_path.as_posix())
+            except UnicodeDecodeError as exc:
+                self.logger.error("Unicode error for %s: %s", abs_path, exc)
+
+    # --------------------------------------------------------------
+    # single-file writer
+    # --------------------------------------------------------------
+    def _write_single_file(self, file_path: Path, rel_str: str) -> None:
+        """
+        Append one file.
+
+        We guarantee **one and only one** newline between the last character
+        of *content* and the closing code-fence so the output is stable and
+        deterministic (important for tests and downstream diff-tools).
+        """
+        try:
+            with file_path.open(encoding="utf-8") as src:
+                content = src.read()
+
+            with self.output_file.open(mode="a", encoding="utf-8") as dst:
+                dst.write(f"## {rel_str}\n\n")
+                dst.write("```python\n" if file_path.suffix == ".py" else "```\n")
+
+                # normalise trailing EOL → exactly one '\n'
+                dst.write(content if content.endswith("\n") else f"{content}\n")
+
+                dst.write("```\n\n")
+        except OSError as exc:
+            self.logger.error("Error processing %s: %s", file_path, exc)

reposnap/interfaces/cli.py

@@ -0,0 +1,62 @@
+# src/reposnap/interfaces/cli.py
+
+import argparse
+import logging
+from reposnap.controllers.project_controller import ProjectController
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate a Markdown representation of a Git repository."
+    )
+    # Changed positional argument to allow one or more paths.
+    parser.add_argument(
+        "paths",
+        nargs="+",
+        help="One or more paths (files or directories) to include in the Markdown output.",
+    )
+    parser.add_argument(
+        "-o", "--output", help="Output Markdown file", default="output.md"
+    )
+    parser.add_argument(
+        "--structure-only",
+        action="store_true",
+        help="Only include the file structure without content.",
+    )
+    parser.add_argument(
+        "--debug", action="store_true", help="Enable debug-level logging."
+    )
+    parser.add_argument(
+        "-i",
+        "--include",
+        nargs="*",
+        default=[],
+        help="File/folder patterns to include.",
+    )
+    parser.add_argument(
+        "-e",
+        "--exclude",
+        nargs="*",
+        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()
+
+    log_level = logging.DEBUG if args.debug else logging.INFO
+    logging.basicConfig(
+        level=log_level, format="%(asctime)s - %(levelname)s - %(message)s"
+    )
+
+    controller = ProjectController(args)
+    controller.run()
+
+
+if __name__ == "__main__":
+    main()

reposnap/interfaces/gui.py

@@ -0,0 +1,158 @@
+# src/reposnap/interfaces/gui.py
+
+import urwid
+from pathlib import Path
+from reposnap.controllers.project_controller import ProjectController
+
+
+class MyCheckBox(urwid.CheckBox):
+    def __init__(self, label, user_data=None, **kwargs):
+        super().__init__(label, **kwargs)
+        self.user_data = user_data
+
+
+class RepoSnapGUI:
+    def __init__(self):
+        self.controller = ProjectController()
+        self.root_dir = Path(".").resolve()
+        self.file_tree = None
+        self.selected_files = set()
+
+        self.main_loop = None
+        self.build_main_menu()
+
+    def build_main_menu(self):
+        self.root_dir_edit = urwid.Edit(
+            ("bold", "Root Directory: "), str(self.root_dir)
+        )
+        scan_button = urwid.Button("Scan", on_press=self.on_scan)
+
+        main_menu = urwid.Frame(
+            header=urwid.Text(("bold", "RepoSnap - Main Menu")),
+            body=urwid.Padding(
+                urwid.LineBox(
+                    urwid.ListBox(urwid.SimpleFocusListWalker([self.root_dir_edit])),
+                    title="Enter Root Directory",
+                ),
+                left=2,
+                right=2,
+            ),
+            footer=urwid.Padding(scan_button, align="center"),
+        )
+
+        self.main_widget = main_menu
+
+    def on_scan(self, button):
+        self.root_dir = Path(self.root_dir_edit.edit_text).resolve()
+        self.controller.set_root_dir(self.root_dir)
+        self.controller.collect_file_tree()
+        self.file_tree = self.controller.get_file_tree()
+        self.build_file_tree_menu()
+
+    def build_file_tree_menu(self):
+        tree_widgets = self.build_tree_widget(self.file_tree.structure)
+        tree_listbox = urwid.ListBox(urwid.SimpleFocusListWalker(tree_widgets))
+        render_button = urwid.Button("Render", on_press=self.on_render)
+
+        tree_menu = urwid.Frame(
+            header=urwid.Text(("bold", f"File Tree of {self.root_dir}")),
+            body=urwid.LineBox(tree_listbox),
+            footer=urwid.Padding(render_button, align="center"),
+        )
+
+        self.main_widget = tree_menu
+        self.refresh()
+
+    def build_tree_widget(self, tree_structure, parent_path="", level=0):
+        widgets = []
+        for key, value in sorted(tree_structure.items()):
+            node_path = f"{parent_path}/{key}".lstrip("/")
+            checkbox = MyCheckBox(
+                key,
+                user_data={"path": node_path, "level": level},
+                state=False,
+                on_state_change=self.on_checkbox_change,
+            )
+            indented_checkbox = urwid.Padding(checkbox, left=4 * level)
+            widgets.append(indented_checkbox)
+            if isinstance(value, dict):
+                widgets.extend(
+                    self.build_tree_widget(value, node_path, level=level + 1)
+                )
+        return widgets
+
+    def on_checkbox_change(self, checkbox, state):
+        user_data = checkbox.user_data
+        node_path = user_data["path"]
+        level = user_data["level"]
+        if state:
+            self.selected_files.add(node_path)
+        else:
+            self.selected_files.discard(node_path)
+        # Handle toggling all children
+        self.toggle_children(checkbox, state, level)
+
+    def toggle_children(self, checkbox, state, level):
+        listbox = self.main_widget.body.original_widget.body
+        walker = listbox
+        # Find the index of the Padding widget that contains the checkbox
+        idx = None
+        for i, widget in enumerate(walker):
+            if isinstance(widget, urwid.Padding) and widget.original_widget == checkbox:
+                idx = i
+                break
+        if idx is None:
+            return
+        idx += 1
+        while idx < len(walker):
+            widget = walker[idx]
+            if isinstance(widget, urwid.Padding):
+                checkbox_widget = widget.original_widget
+                widget_user_data = checkbox_widget.user_data
+                widget_level = widget_user_data["level"]
+                if widget_level > level:
+                    checkbox_widget.set_state(state, do_callback=False)
+                    node_path = widget_user_data["path"]
+                    if state:
+                        self.selected_files.add(node_path)
+                    else:
+                        self.selected_files.discard(node_path)
+                    idx += 1
+                else:
+                    break
+            else:
+                idx += 1
+
+    def on_render(self, button):
+        self.controller.generate_output_from_selected(self.selected_files)
+        message = urwid.Text(
+            ("bold", f"Markdown generated at {self.controller.output_file}")
+        )
+        exit_button = urwid.Button("Exit", on_press=self.exit_program)
+        result_menu = urwid.Frame(
+            header=urwid.Text(("bold", "Success")),
+            body=urwid.Filler(message, valign="middle"),
+            footer=urwid.Padding(exit_button, align="center"),
+        )
+        self.main_widget = result_menu
+        self.refresh()
+
+    def refresh(self):
+        if self.main_loop:
+            self.main_loop.widget = self.main_widget
+
+    def exit_program(self, button):
+        raise urwid.ExitMainLoop()
+
+    def run(self):
+        self.main_loop = urwid.MainLoop(self.main_widget)
+        self.main_loop.run()
+
+
+def main():
+    app = RepoSnapGUI()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

reposnap/models/file_tree.py

@@ -0,0 +1,91 @@
+# src/reposnap/models/file_tree.py
+
+import logging
+from pathlib import Path
+from typing import Dict, List, Any
+import pathspec
+
+
+class FileTree:
+    def __init__(self, structure: Dict[str, Any]):
+        self.structure: Dict[str, Any] = structure
+        self.logger = logging.getLogger(__name__)
+
+    def get_all_files(self) -> List[Path]:
+        """
+        Recursively retrieve all file paths from the tree.
+        Returns:
+            List[Path]: List of file paths relative to root_dir.
+        """
+        return self._extract_files(self.structure)
+
+    def _extract_files(
+        self, subtree: Dict[str, Any], path_prefix: str = ""
+    ) -> List[Path]:
+        files: List[Path] = []
+        for key, value in subtree.items():
+            current_path: str = f"{path_prefix}/{key}".lstrip("/")
+            if isinstance(value, dict):
+                files.extend(self._extract_files(value, current_path))
+            else:
+                files.append(Path(current_path))
+        return files
+
+    def filter_files(self, spec: pathspec.PathSpec) -> None:
+        """
+        Filters files in the tree structure based on the provided pathspec.
+
+        Args:
+            spec (pathspec.PathSpec): The pathspec for filtering files.
+        """
+        self.logger.debug("Filtering files in the file tree.")
+        self.structure = self._filter_tree(self.structure, spec)
+
+    def _filter_tree(
+        self, subtree: Dict[str, Any], spec: pathspec.PathSpec, path_prefix: str = ""
+    ) -> Dict[str, Any]:
+        filtered_subtree: Dict[str, Any] = {}
+        for key, value in subtree.items():
+            current_path: str = f"{path_prefix}/{key}".lstrip("/")
+            if isinstance(value, dict):
+                filtered_value: Dict[str, Any] = self._filter_tree(
+                    value, spec, current_path
+                )
+                if filtered_value:
+                    filtered_subtree[key] = filtered_value
+            else:
+                # Exclude the file if either the full path OR its basename matches a .gitignore pattern.
+                if not spec.match_file(current_path) and not spec.match_file(
+                    Path(current_path).name
+                ):
+                    filtered_subtree[key] = value
+        return filtered_subtree
+
+    def prune_tree(self, selected_files: set) -> Dict[str, Any]:
+        """
+        Prunes the tree to include only the selected files and their directories.
+
+        Args:
+            selected_files (set): Set of selected file paths.
+
+        Returns:
+            Dict[str, Any]: Pruned tree structure.
+        """
+        return self._prune_tree(self.structure, selected_files)
+
+    def _prune_tree(
+        self, subtree: Dict[str, Any], selected_files: set, path_prefix: str = ""
+    ) -> Dict[str, Any]:
+        pruned_subtree: Dict[str, Any] = {}
+        for key, value in subtree.items():
+            current_path: str = f"{path_prefix}/{key}".lstrip("/")
+            if isinstance(value, dict):
+                pruned_value: Dict[str, Any] = self._prune_tree(
+                    value, selected_files, current_path
+                )
+                if pruned_value:
+                    pruned_subtree[key] = pruned_value
+            else:
+                if current_path in selected_files:
+                    pruned_subtree[key] = value
+        return pruned_subtree

reposnap/utils/path_utils.py

@@ -0,0 +1,15 @@
+# src/reposnap/utils/path_utils.py
+from typing import Dict, Generator, Any
+
+
+def format_tree(
+    tree: Dict[str, Any], indent: str = "", hide_untoggled: bool = False
+) -> Generator[str, None, None]:
+    for key, value in tree.items():
+        if value == "<hidden>":
+            yield f"{indent}<...>\n"
+        elif isinstance(value, dict):
+            yield f"{indent}{key}/\n"
+            yield from format_tree(value, indent + "    ", hide_untoggled)
+        else:
+            yield f"{indent}{key}\n"

{reposnap-0.6.4.dist-info → reposnap-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reposnap
-Version: 0.6.4
+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.7.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+reposnap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/controllers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/controllers/project_controller.py,sha256=RROOcb_FiEhFc9oshptPL8moH-5lkUrio7Lp0MqBqp0,10599
+reposnap/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/core/file_system.py,sha256=82gwvmgrsWf63paMrIz-Z0eqIjbqt9_-vujdXlJJoFE,1074
+reposnap/core/git_repo.py,sha256=YVIbx-Y_MUbnn5Z4E2XBTJbG7Kawx5aUX2tg6vnocd0,4284
+reposnap/core/markdown_generator.py,sha256=V6uEbxVSbCbxKN9ysTDKsIDvEGBxFutpOpyaZRXZUGw,3747
+reposnap/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/interfaces/cli.py,sha256=gL0gauEt_AkuRRr-p5YAeHeUPgvZ59lpZMqsopLjHas,1661
+reposnap/interfaces/gui.py,sha256=sTuQxjD1nPa9FpgfzOwi6VDO5QMMtDX-5CiEhbJJcs4,5429
+reposnap/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/models/file_tree.py,sha256=jGo_SizdFcOiDC1OOMz-tiijRN3iSD7ENh6Xw8S6OL0,3362
+reposnap/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reposnap/utils/path_utils.py,sha256=UrMe5cjspTf-4gjg2lzv6BgLwZ7S_1lLECQvDMDZO9Y,507
+reposnap-0.7.0.dist-info/METADATA,sha256=oJF5qQGPWc6aG2mnupOpiDrbJ1hWbApjDCP0tM-lB2Y,6768
+reposnap-0.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+reposnap-0.7.0.dist-info/entry_points.txt,sha256=o3GyO7bpR0dujPCjsvvZMPv4pXNJlFwD49_pA1r5FOA,102
+reposnap-0.7.0.dist-info/licenses/LICENSE,sha256=Aj7WCYBXi98pvi723HPn4GDRyjxToNWb3PC6j1_lnPk,1069
+reposnap-0.7.0.dist-info/RECORD,,

reposnap-0.6.4.dist-info/RECORD

@@ -1,5 +0,0 @@
-reposnap-0.6.4.dist-info/METADATA,sha256=ZD55J-JVXgwC_ENrX8dmcIT5s3KlJqG26gPAzj74wlU,5348
-reposnap-0.6.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-reposnap-0.6.4.dist-info/entry_points.txt,sha256=o3GyO7bpR0dujPCjsvvZMPv4pXNJlFwD49_pA1r5FOA,102
-reposnap-0.6.4.dist-info/licenses/LICENSE,sha256=Aj7WCYBXi98pvi723HPn4GDRyjxToNWb3PC6j1_lnPk,1069
-reposnap-0.6.4.dist-info/RECORD,,