reposnap 0.3.2__tar.gz → 0.4.0__tar.gz

reposnap-0.4.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.3
+Name: reposnap
+Version: 0.4.0
+Summary: Generate a Markdown file with all contents of your project
+Author: agoloborodko
+License-File: LICENSE
+Requires-Python: >=3.8
+Requires-Dist: gitpython>=3.1.43
+Requires-Dist: pathlib>=1.0.1
+Requires-Dist: pathspec>=0.12.1
+Requires-Dist: urwid>=2.6.15
+Description-Content-Type: text/markdown
+
+# RepoSnap
+
+## Overview
+
+`reposnap` is a Python tool designed to generate a Markdown file that documents the structure and contents of a Git project. It provides both a command-line interface (CLI) and a graphical user interface (GUI) for ease of use. This tool is particularly useful for creating a quick overview of a project's file hierarchy, including optional syntax-highlighted code snippets.
+
+## Features
+
+- **Command-Line Interface (CLI)**: Quickly generate documentation from the terminal.
+- **Graphical User Interface (GUI)**: A user-friendly GUI if you want to select files and directories interactively.
+- **Syntax Highlighting**: Includes syntax highlighting for known file types in the generated Markdown file.
+- **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.
+
+## Installation
+
+You can install `reposnap` using pip:
+
+```bash
+pip install reposnap
+```
+
+Alternatively, you can clone the repository and install the required dependencies:
+
+```bash
+git clone https://github.com/username/reposnap.git
+cd reposnap
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Command-Line Interface
+
+To use `reposnap` from the command line, run it with the following options:
+
+```bash
+reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] path
+```
+
+- `path`: Path to the Git repository or subdirectory.
+- `-h, --help`: Show help message and exit.
+- `-o, --output`: The name of the output Markdown file. Defaults to `output.md`.
+- `--structure-only`: Generate a Markdown file that includes only the project structure, without file contents.
+- `--debug`: Enable debug-level logging.
+
+#### Examples
+
+1. **Generate a full project structure with file contents**:
+
+    ```bash
+    reposnap .
+    ```
+
+2. **Generate a project structure only**:
+
+    ```bash
+    reposnap my_project/ --structure-only
+    ```
+
+3. **Generate a Markdown file excluding certain files and directories**:
+
+    ```bash
+    reposnap my_project/ -o output.md
+    ```
+
+### Graphical User Interface
+
+`reposnap` also provides a GUI for users who prefer an interactive interface.
+
+To launch the GUI, simply run:
+
+```bash
+reposnap-gui
+```
+
+#### Using the GUI
+
+1. **Select Root Directory**: When the GUI opens, you can specify the root directory of your Git project. By default, it uses the current directory.
+
+2. **Scan the Project**: Click the "Scan" button to analyze the project. The GUI will display the file tree of your project.
+
+3. **Select Files and Directories**: Use the checkboxes to select which files and directories you want to include in the Markdown documentation. Toggling a directory checkbox will toggle all its child files and directories.
+
+4. **Generate Markdown**: After selecting the desired files, click the "Render" button. The Markdown file will be generated and saved as `output.md` in the current directory.
+
+5. **Exit**: Click the "Exit" button to close the GUI.
+
+## Testing
+
+To run the tests, use the following command:
+
+```bash
+pytest tests/
+```
+
+Ensure that you have the `pytest` library installed:
+
+```bash
+pip install pytest
+```
+
+## License
+
+This project is licensed under the MIT License.
+
+## Acknowledgments
+
+- [GitPython](https://gitpython.readthedocs.io/) - Used for interacting with Git repositories.
+- [pathspec](https://pathspec.readthedocs.io/) - Used for pattern matching file paths.
+- [Urwid](https://urwid.org/) - Used for creating the GUI interface.

reposnap-0.4.0/README.md

@@ -0,0 +1,111 @@
+# RepoSnap
+
+## Overview
+
+`reposnap` is a Python tool designed to generate a Markdown file that documents the structure and contents of a Git project. It provides both a command-line interface (CLI) and a graphical user interface (GUI) for ease of use. This tool is particularly useful for creating a quick overview of a project's file hierarchy, including optional syntax-highlighted code snippets.
+
+## Features
+
+- **Command-Line Interface (CLI)**: Quickly generate documentation from the terminal.
+- **Graphical User Interface (GUI)**: A user-friendly GUI if you want to select files and directories interactively.
+- **Syntax Highlighting**: Includes syntax highlighting for known file types in the generated Markdown file.
+- **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.
+
+## Installation
+
+You can install `reposnap` using pip:
+
+```bash
+pip install reposnap
+```
+
+Alternatively, you can clone the repository and install the required dependencies:
+
+```bash
+git clone https://github.com/username/reposnap.git
+cd reposnap
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Command-Line Interface
+
+To use `reposnap` from the command line, run it with the following options:
+
+```bash
+reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] path
+```
+
+- `path`: Path to the Git repository or subdirectory.
+- `-h, --help`: Show help message and exit.
+- `-o, --output`: The name of the output Markdown file. Defaults to `output.md`.
+- `--structure-only`: Generate a Markdown file that includes only the project structure, without file contents.
+- `--debug`: Enable debug-level logging.
+
+#### Examples
+
+1. **Generate a full project structure with file contents**:
+
+    ```bash
+    reposnap .
+    ```
+
+2. **Generate a project structure only**:
+
+    ```bash
+    reposnap my_project/ --structure-only
+    ```
+
+3. **Generate a Markdown file excluding certain files and directories**:
+
+    ```bash
+    reposnap my_project/ -o output.md
+    ```
+
+### Graphical User Interface
+
+`reposnap` also provides a GUI for users who prefer an interactive interface.
+
+To launch the GUI, simply run:
+
+```bash
+reposnap-gui
+```
+
+#### Using the GUI
+
+1. **Select Root Directory**: When the GUI opens, you can specify the root directory of your Git project. By default, it uses the current directory.
+
+2. **Scan the Project**: Click the "Scan" button to analyze the project. The GUI will display the file tree of your project.
+
+3. **Select Files and Directories**: Use the checkboxes to select which files and directories you want to include in the Markdown documentation. Toggling a directory checkbox will toggle all its child files and directories.
+
+4. **Generate Markdown**: After selecting the desired files, click the "Render" button. The Markdown file will be generated and saved as `output.md` in the current directory.
+
+5. **Exit**: Click the "Exit" button to close the GUI.
+
+## Testing
+
+To run the tests, use the following command:
+
+```bash
+pytest tests/
+```
+
+Ensure that you have the `pytest` library installed:
+
+```bash
+pip install pytest
+```
+
+## License
+
+This project is licensed under the MIT License.
+
+## Acknowledgments
+
+- [GitPython](https://gitpython.readthedocs.io/) - Used for interacting with Git repositories.
+- [pathspec](https://pathspec.readthedocs.io/) - Used for pattern matching file paths.
+- [Urwid](https://urwid.org/) - Used for creating the GUI interface.

{reposnap-0.3.2 → reposnap-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reposnap"
-version = "0.3.2"
+version = "0.4.0"
 description = "Generate a Markdown file with all contents of your project"
 authors = [
     { name = "agoloborodko" }
@@ -9,6 +9,7 @@ dependencies = [
     "pathlib>=1.0.1",
     "pathspec>=0.12.1",
     "gitpython>=3.1.43",
+    "urwid>=2.6.15",
 ]
 readme = "README.md"
 requires-python = ">= 3.8"
@@ -30,4 +31,5 @@ allow-direct-references = true
 packages = ["src/reposnap"]
 
 [project.scripts]
-reposnap = "reposnap:main"
+reposnap = "reposnap.interfaces.cli:main"
+reposnap-gui = "reposnap.interfaces.gui:main"

{reposnap-0.3.2 → reposnap-0.4.0}/requirements-dev.lock

@@ -27,3 +27,9 @@ pluggy==1.5.0
 pytest==8.3.2
 smmap==5.0.1
     # via gitdb
+typing-extensions==4.12.2
+    # via urwid
+urwid==2.6.15
+    # via reposnap
+wcwidth==0.2.13
+    # via urwid

{reposnap-0.3.2 → reposnap-0.4.0}/requirements.lock

@@ -20,3 +20,9 @@ pathspec==0.12.1
     # via reposnap
 smmap==5.0.1
     # via gitdb
+typing-extensions==4.12.2
+    # via urwid
+urwid==2.6.15
+    # via reposnap
+wcwidth==0.2.13
+    # via urwid

{reposnap-0.3.2 → reposnap-0.4.0}/src/reposnap/controllers/project_controller.py

@@ -11,14 +11,23 @@ from typing import List, Optional
 
 
 class ProjectController:
-    def __init__(self, args: object):
+    def __init__(self, args: Optional[object] = None):
         self.logger = logging.getLogger(__name__)
-        self.root_dir: Path = Path(args.path).resolve()
-        self.output_file: Path = Path(args.output).resolve()
-        self.structure_only: bool = args.structure_only
+        self.root_dir: Path = Path(args.path).resolve() if args else Path('.').resolve()
+        self.output_file: Path = Path(args.output).resolve() if args else Path('output.md').resolve()
+        self.structure_only: bool = args.structure_only if args else False
         self.args: object = args
         self.file_tree: Optional[FileTree] = None
-        self.gitignore_patterns: List[str] = self._load_gitignore_patterns()
+        self.gitignore_patterns: List[str] = []
+        if self.root_dir:
+            self.gitignore_patterns = self._load_gitignore_patterns()
+
+    def set_root_dir(self, root_dir: Path) -> None:
+        self.root_dir = root_dir
+        self.gitignore_patterns = self._load_gitignore_patterns()
+
+    def get_file_tree(self) -> Optional[FileTree]:
+        return self.file_tree
 
     def run(self) -> None:
         self.collect_file_tree()
@@ -52,7 +61,20 @@ class ProjectController:
             structure_only=self.structure_only
         )
         markdown_generator.generate_markdown(self.file_tree.structure, self.file_tree.get_all_files())
-        self.logger.info("Markdown generation completed.")
+        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.")
+        # Build a pruned tree structure based on selected files
+        pruned_tree = self.file_tree.prune_tree(selected_files)
+        markdown_generator: MarkdownGenerator = 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 _load_gitignore_patterns(self) -> List[str]:
         gitignore_path: Path = self.root_dir / '.gitignore'

{reposnap-0.3.2 → reposnap-0.4.0}/src/reposnap/core/markdown_generator.py

@@ -7,10 +7,11 @@ from typing import List, Dict, Any
 
 
 class MarkdownGenerator:
-    def __init__(self, root_dir: Path, output_file: Path, structure_only: bool = False):
+    def __init__(self, root_dir: Path, output_file: Path, structure_only: bool = False, hide_untoggled: bool = False):
         self.root_dir: Path = root_dir.resolve()
         self.output_file: Path = output_file.resolve()
         self.structure_only: bool = structure_only
+        self.hide_untoggled: bool = hide_untoggled
         self.logger = logging.getLogger(__name__)
 
     def generate_markdown(self, tree_structure: Dict[str, Any], files: List[Path]) -> None:
@@ -34,7 +35,7 @@ class MarkdownGenerator:
             with self.output_file.open('w', encoding='utf-8') as f:
                 f.write("# Project Structure\n\n")
                 f.write("```\n")
-                for line in format_tree(tree_structure):
+                for line in format_tree(tree_structure, hide_untoggled=self.hide_untoggled):
                     f.write(line)
                 f.write("```\n\n")
             self.logger.debug("Header and project structure written successfully.")
@@ -72,4 +73,3 @@ class MarkdownGenerator:
                 f.write(f"{content}\n```\n\n")
         except IOError as e:
             self.logger.error(f"Error reading or writing file {file_path}: {e}")
-

{reposnap-0.3.2 → reposnap-0.4.0}/src/reposnap/interfaces/cli.py

@@ -7,7 +7,7 @@ from reposnap.controllers.project_controller import ProjectController
 
 def main():
     parser = argparse.ArgumentParser(description='Generate a Markdown representation of a Git repository.')
-    parser.add_argument('path', help='Path to the Git repository or subdirectory.')
+    parser.add_argument('path', nargs='?', default='.', help='Path to the Git repository or subdirectory.')
     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.')

reposnap-0.4.0/src/reposnap/interfaces/gui.py

@@ -0,0 +1,155 @@
+# 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-0.3.2 → reposnap-0.4.0}/src/reposnap/models/file_tree.py

@@ -52,3 +52,27 @@ class FileTree:
                     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-0.4.0/src/reposnap/utils/path_utils.py

@@ -0,0 +1,13 @@
+# 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.4.0/tests/reposnap/test_gui.py

@@ -0,0 +1,103 @@
+# tests/reposnap/test_gui.py
+
+import pytest
+import urwid
+from unittest.mock import patch, MagicMock
+from urwid import ExitMainLoop
+from reposnap.interfaces.gui import RepoSnapGUI
+from pathlib import Path
+
+
+@pytest.fixture
+def gui_app():
+    app = RepoSnapGUI()
+    app.main_loop = MagicMock()
+    app.main_loop.widget = None  # Initialize the widget attribute
+    return app
+
+
+def test_initial_state(gui_app):
+    assert isinstance(gui_app.main_widget, gui_app.main_widget.__class__)
+    assert gui_app.root_dir == Path('.').resolve()
+
+
+def test_scan_button(gui_app):
+    with patch.object(gui_app.controller, 'set_root_dir') as mock_set_root_dir, \
+         patch.object(gui_app.controller, 'collect_file_tree') as mock_collect_file_tree, \
+         patch.object(gui_app.controller, 'get_file_tree') as mock_get_file_tree:
+
+        mock_get_file_tree.return_value = MagicMock(structure={
+            'dir1': {
+                'file1.py': None,
+                'dir2': {
+                    'file2.py': None
+                }
+            },
+            'file3.py': None
+        })
+
+        # Simulate pressing the "Scan" button
+        gui_app.on_scan(None)
+
+        mock_set_root_dir.assert_called_once_with(gui_app.root_dir)
+        mock_collect_file_tree.assert_called_once()
+        mock_get_file_tree.assert_called_once()
+        assert gui_app.file_tree is not None
+
+        # Ensure that main_widget is updated without errors
+        assert isinstance(gui_app.main_widget, urwid.Frame)
+
+
+def test_render_button(gui_app):
+    with patch.object(gui_app.controller, 'generate_output_from_selected') as mock_generate_output:
+        # Simulate setting up the file tree
+        gui_app.file_tree = MagicMock()
+        gui_app.file_tree.structure = {}
+        gui_app.selected_files = {'file1.py', 'dir/file2.py'}
+
+        # Build the file tree menu to initialize widgets
+        gui_app.build_file_tree_menu()
+
+        # Simulate pressing the "Render" button
+        gui_app.on_render(None)
+
+        mock_generate_output.assert_called_once_with(gui_app.selected_files)
+        # Check that the main_widget has been updated to the result menu
+        assert 'Markdown generated at' in gui_app.main_widget.body.base_widget.text
+
+
+def test_exit_program(gui_app):
+    with pytest.raises(ExitMainLoop):
+        gui_app.exit_program(None)
+
+
+def test_toggle_children(gui_app):
+    # Setup the file tree structure
+    gui_app.file_tree = MagicMock()
+    gui_app.file_tree.structure = {
+        'dir1': {
+            'file1.py': None,
+            'dir2': {
+                'file2.py': None
+            }
+        },
+        'file3.py': None
+    }
+
+    # Build the file tree menu to initialize widgets
+    gui_app.build_file_tree_menu()
+
+    # Simulate toggling a parent checkbox
+    listbox = gui_app.main_widget.body.original_widget.body
+    parent_padding = listbox[0]  # The first item is Padding wrapping the checkbox
+    parent_checkbox = parent_padding.original_widget
+    gui_app.on_checkbox_change(parent_checkbox, True)
+
+    # Check that child checkboxes are also toggled
+    child_padding = listbox[1]
+    child_checkbox = child_padding.original_widget
+    assert child_checkbox.get_state() is True
+
+    # Check that selected_files contains both parent and child paths
+    expected_selected_files = {'dir1', 'dir1/file1.py', 'dir1/dir2', 'dir1/dir2/file2.py'}
+    assert gui_app.selected_files == expected_selected_files

reposnap-0.3.2/PKG-INFO

@@ -1,88 +0,0 @@
-Metadata-Version: 2.3
-Name: reposnap
-Version: 0.3.2
-Summary: Generate a Markdown file with all contents of your project
-Author: agoloborodko
-License-File: LICENSE
-Requires-Python: >=3.8
-Requires-Dist: gitpython>=3.1.43
-Requires-Dist: pathlib>=1.0.1
-Requires-Dist: pathspec>=0.12.1
-Description-Content-Type: text/markdown
-
-# RepoSnap
-
-## Overview
-
-`reposnap` is a Python script designed to generate a Markdown file that documents the structure and contents of a git project. This tool is particularly useful for creating a quick overview of a project's file hierarchy, including optional syntax-highlighted code snippets.
-
-## Features
-
-- **Syntax Highlighting**: Includes syntax highlighting for known file types in the generated Markdown file.
-- **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.
-
-## Installation
-```bash
-pip install reposnap
-```
-
-Alternatively, you can clone the repository and install the required dependencies:
-
-```bash
-git clone https://github.com/username/reposnap.git
-cd reposnap
-pip install -r requirements.lock
-```
-
-## Usage
-
-### Command-Line Interface
-
-To use `reposnap`, run it with the following options:
-
-```bash
-reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] path
-```
-
-- `path`: Path to the Git repository or subdirectory
-- `-h, --help`: show help message and exit
-- `-o, --output`: The name of the output Markdown file. Defaults to `output.md`.
-- `--structure-only`: Generate a Markdown file that includes only the project structure, without file contents.
-- `--debug`: Enable debug-level logging.
-
-### Examples
-
-1. **Generate a full project structure with file contents**:
-
-    ```bash
-    reposnap .
-    ```
-
-2. **Generate a project structure only**:
-
-    ```bash
-    reposnap my_project/ --structure-only
-    ```
-
-3. **Generate a Markdown file excluding certain files and directories**:
-
-    ```bash
-    reposnap my_project/ -o output.md
-    ```
-
-## Testing
-
-To run the tests, use `rye`:
-
-```bash
-rye test
-```
-
-## License
-
-This project is licensed under the MIT License.
-
-## Acknowledgments
-
-- [GitPython](https://gitpython.readthedocs.io/) - Used for interacting with Git repositories.
-- [pathspec](https://pathspec.readthedocs.io/) - Used for pattern matching file paths.

reposnap-0.3.2/README.md

@@ -1,76 +0,0 @@
-# RepoSnap
-
-## Overview
-
-`reposnap` is a Python script designed to generate a Markdown file that documents the structure and contents of a git project. This tool is particularly useful for creating a quick overview of a project's file hierarchy, including optional syntax-highlighted code snippets.
-
-## Features
-
-- **Syntax Highlighting**: Includes syntax highlighting for known file types in the generated Markdown file.
-- **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.
-
-## Installation
-```bash
-pip install reposnap
-```
-
-Alternatively, you can clone the repository and install the required dependencies:
-
-```bash
-git clone https://github.com/username/reposnap.git
-cd reposnap
-pip install -r requirements.lock
-```
-
-## Usage
-
-### Command-Line Interface
-
-To use `reposnap`, run it with the following options:
-
-```bash
-reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] path
-```
-
-- `path`: Path to the Git repository or subdirectory
-- `-h, --help`: show help message and exit
-- `-o, --output`: The name of the output Markdown file. Defaults to `output.md`.
-- `--structure-only`: Generate a Markdown file that includes only the project structure, without file contents.
-- `--debug`: Enable debug-level logging.
-
-### Examples
-
-1. **Generate a full project structure with file contents**:
-
-    ```bash
-    reposnap .
-    ```
-
-2. **Generate a project structure only**:
-
-    ```bash
-    reposnap my_project/ --structure-only
-    ```
-
-3. **Generate a Markdown file excluding certain files and directories**:
-
-    ```bash
-    reposnap my_project/ -o output.md
-    ```
-
-## Testing
-
-To run the tests, use `rye`:
-
-```bash
-rye test
-```
-
-## License
-
-This project is licensed under the MIT License.
-
-## Acknowledgments
-
-- [GitPython](https://gitpython.readthedocs.io/) - Used for interacting with Git repositories.
-- [pathspec](https://pathspec.readthedocs.io/) - Used for pattern matching file paths.

reposnap-0.3.2/src/reposnap/__init__.py

@@ -1,4 +0,0 @@
-from reposnap.interfaces.cli import main
-
-if __name__ == "__main__":
-    main()

reposnap-0.3.2/src/reposnap/utils/path_utils.py

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