reposnap 0.5.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

reposnap/controllers/project_controller.py

@@ -2,86 +2,169 @@
 
 import logging
 from pathlib import Path
-from reposnap.core.git_repo import GitRepo
 from reposnap.core.file_system import FileSystem
 from reposnap.core.markdown_generator import MarkdownGenerator
 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__)
-        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
+        if args:
+            # Support both new 'paths' (multiple paths) and legacy 'path'
+            if hasattr(args, 'paths'):
+                input_paths = [Path(p) for p in args.paths]
+            else:
+                input_paths = [Path(args.path)]
+            self.args = args
+            # Determine repository root (using provided paths’ common parent if available)
+            self.root_dir = self._get_repo_root().resolve()
+            # Convert provided paths to be relative to the repository root.
+            self.input_paths = []
+            for p in input_paths:
+                try:
+                    candidate = (self.root_dir / p).resolve()
+                    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.")
+            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 []
+        else:
+            self.root_dir = Path('.').resolve()
+            self.input_paths = []
+            self.output_file = Path('output.md').resolve()
+            self.structure_only = False
+            self.args = None
+            self.include_patterns = []
+            self.exclude_patterns = []
         self.file_tree: Optional[FileTree] = None
         self.gitignore_patterns: List[str] = []
-        self.include_patterns: List[str] = args.include if args and hasattr(args, 'include') else []
-        self.exclude_patterns: List[str] = args.exclude if args and hasattr(args, 'exclude') else []
         if self.root_dir:
             self.gitignore_patterns = self._load_gitignore_patterns()
 
+    def _get_repo_root(self) -> Path:
+        """
+        Determine the repository root. If arguments were provided and those paths exist,
+        use the common parent directory of all provided paths. Otherwise, fall back to the
+        git repository working tree directory (or current directory if not a git repo).
+        """
+        if self.args is not None:
+            candidate_paths = []
+            if hasattr(self.args, 'paths'):
+                for p in self.args.paths:
+                    candidate = Path(p).resolve()
+                    if candidate.exists():
+                        candidate_paths.append(candidate)
+            elif hasattr(self.args, 'path'):
+                candidate = Path(self.args.path).resolve()
+                if candidate.exists():
+                    candidate_paths.append(candidate)
+            if candidate_paths:
+                from os.path import commonpath
+                common = Path(commonpath([str(p) for p in candidate_paths]))
+                return common
+        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
+        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 run(self) -> None:
-        self.collect_file_tree()
-        self.apply_filters()
-        self.generate_output()
-
-    def collect_file_tree(self) -> None:
-        self.logger.info("Collecting git files.")
-        git_repo: GitRepo = GitRepo(self.root_dir)
-        git_files: List[Path] = git_repo.get_git_files()
-        self.logger.debug(f"Git files before filtering: {git_files}")
-
-        # Adjust patterns
+    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 pattern in patterns:
-                if '*' in pattern or '?' in pattern or '[' in pattern:
-                    adjusted.append(pattern)
+            for p in patterns:
+                if any(ch in p for ch in ['*', '?', '[']):
+                    adjusted.append(p)
                 else:
-                    adjusted.append(f'*{pattern}*')
+                    adjusted.append(f'*{p}*')
             return adjusted
-
-        # Apply include patterns
         if self.include_patterns:
-            adjusted_include_patterns = adjust_patterns(self.include_patterns)
-            include_spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, adjusted_include_patterns)
-            git_files = [f for f in git_files if include_spec.match_file(f.as_posix())]
-            self.logger.debug(f"Git files after include patterns: {git_files}")
-
-        # Apply exclude 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:
-            adjusted_exclude_patterns = adjust_patterns(self.exclude_patterns)
-            exclude_spec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, adjusted_exclude_patterns)
-            git_files = [f for f in git_files if not exclude_spec.match_file(f.as_posix())]
-            self.logger.debug(f"Git files after exclude patterns: {git_files}")
+            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
 
-        self.logger.info("Building tree structure.")
-        file_system: FileSystem = FileSystem(self.root_dir)
-        tree_structure: dict = file_system.build_tree_structure(git_files)
-
-        self.file_tree = FileTree(tree_structure)
-        self.logger.debug(f"Tree structure: {self.file_tree.structure}")
+    def collect_file_tree(self) -> None:
+        self.logger.info("Collecting files by walking the repository root.")
+        all_files = []
+        for path in self.root_dir.rglob("*"):
+            if path.is_file():
+                try:
+                    rel = path.relative_to(self.root_dir)
+                    all_files.append(rel)
+                except ValueError:
+                    continue
+        # Apply include/exclude filtering.
+        all_files = self._apply_include_exclude(all_files)
+        self.logger.debug(f"All files after include/exclude filtering: {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 f.parts[:len(input_path.parts)] == 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 filters to the file tree.")
-        spec: pathspec.PathSpec = pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, self.gitignore_patterns)
-        self.logger.debug(f"Filter patterns: {self.gitignore_patterns}")
+        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.")
-        markdown_generator: MarkdownGenerator = MarkdownGenerator(
+        self.logger.info("Starting Markdown generation.")
+        markdown_generator = MarkdownGenerator(
             root_dir=self.root_dir,
             output_file=self.output_file,
             structure_only=self.structure_only
@@ -90,10 +173,9 @@ class ProjectController:
         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
+        self.logger.info("Generating Markdown from selected files.")
         pruned_tree = self.file_tree.prune_tree(selected_files)
-        markdown_generator: MarkdownGenerator = MarkdownGenerator(
+        markdown_generator = MarkdownGenerator(
             root_dir=self.root_dir,
             output_file=self.output_file,
             structure_only=False,
@@ -102,8 +184,14 @@ class ProjectController:
         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: Path = self.root_dir / '.gitignore'
+        gitignore_path = self.root_dir / '.gitignore'
         if not gitignore_path.exists():
             for parent in self.root_dir.parents:
                 gitignore_path = parent / '.gitignore'
@@ -111,12 +199,11 @@ class ProjectController:
                     break
             else:
                 gitignore_path = None
-
         if gitignore_path and gitignore_path.exists():
             with gitignore_path.open('r') as gitignore:
-                patterns: List[str] = gitignore.readlines()
-            self.logger.debug(f"Patterns from .gitignore in {gitignore_path.parent}: {patterns}")
+                patterns = gitignore.readlines()
+            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}. Proceeding without patterns.")
+            self.logger.debug(f"No .gitignore found starting from {self.root_dir}.")
             return []

reposnap/interfaces/cli.py

@@ -6,14 +6,19 @@ 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', nargs='?', default='.', help='Path to the Git repository or subdirectory.')
+    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.')
-
-    # New arguments for include and exclude patterns
     parser.add_argument('-i', '--include', nargs='*', default=[],
                         help='File/folder patterns to include.')
     parser.add_argument('-e', '--exclude', nargs='*', default=[],

{reposnap-0.5.1.dist-info → reposnap-0.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: reposnap
-Version: 0.5.1
+Version: 0.6.2
 Summary: Generate a Markdown file with all contents of your project
 Author: agoloborodko
 License-File: LICENSE
@@ -49,10 +49,10 @@ 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 ...]] path
+reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]] [-e EXCLUDE [EXCLUDE ...]] paths [paths ...]
 ```
 
-- `path`: Path to the Git repository or subdirectory.
+- `paths`: One or more paths (files or directories) within the repository whose content and structure should be rendered.
 - `-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.
@@ -94,7 +94,7 @@ reposnap [-h] [-o OUTPUT] [--structure-only] [--debug] [-i INCLUDE [INCLUDE ...]
 4. **Generate a Markdown file excluding certain files and directories**:
 
     ```bash
-    reposnap my_project/ -e "tests" -e "*.md"
+    reposnap my_project_folder my_project_folder_2 -e "tests" -e "*.md"
     ```
 
 5. **Exclude files and directories containing a substring**:

{reposnap-0.5.1.dist-info → reposnap-0.6.2.dist-info}/RECORD

@@ -1,19 +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=hDYNLE_OtusAZOb6sKyvSFtbc7j-DUuYcmFST7U5Dao,5638
+reposnap/controllers/project_controller.py,sha256=qYsZL-8ZX6sqTdmJtVRMFnv0yHIUGk_fROMZnitwiTo,9513
 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=2u_ILkV-Ur7qr1WHmHM2yg44Ggft61RsdbZLsZaQ5NU,1256
 reposnap/core/markdown_generator.py,sha256=Ld6ix4gzkLJJyeUoWHwhpbAf3DvEC5E0S1DykYnLGnQ,3297
 reposnap/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reposnap/interfaces/cli.py,sha256=tq9OfVE1NvUYrsdr2ewx6nBhG76k8E-yucwVgTo-LM8,1302
+reposnap/interfaces/cli.py,sha256=JzTNDibzuRRmnWg-gBfKJ2tSlh-NYSL_3q6J-Erjrr8,1374
 reposnap/interfaces/gui.py,sha256=pzWQbW55gBNZu4tXRdBFic39upGtYxew91FSiEvalj0,5421
 reposnap/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 reposnap/models/file_tree.py,sha256=SQ1cKW066uh1F1BcF8AXuw4Q-l6rkybxjdJEcLFjewg,3052
 reposnap/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 reposnap/utils/path_utils.py,sha256=7072816LCP8Q8XBydn0iknmfrObPO_-2rFqpbAvPrjY,501
-reposnap-0.5.1.dist-info/METADATA,sha256=D6PPKKJAUGFYWK02v1_2WhvGVXUIFv_OoZBOlv9-AUw,5241
-reposnap-0.5.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-reposnap-0.5.1.dist-info/entry_points.txt,sha256=o3GyO7bpR0dujPCjsvvZMPv4pXNJlFwD49_pA1r5FOA,102
-reposnap-0.5.1.dist-info/licenses/LICENSE,sha256=Aj7WCYBXi98pvi723HPn4GDRyjxToNWb3PC6j1_lnPk,1069
-reposnap-0.5.1.dist-info/RECORD,,
+reposnap-0.6.2.dist-info/METADATA,sha256=nZ4w5dZc3i0dk2GmcLPWdoF5pj7CO2ttce6s6-JoIFo,5348
+reposnap-0.6.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+reposnap-0.6.2.dist-info/entry_points.txt,sha256=o3GyO7bpR0dujPCjsvvZMPv4pXNJlFwD49_pA1r5FOA,102
+reposnap-0.6.2.dist-info/licenses/LICENSE,sha256=Aj7WCYBXi98pvi723HPn4GDRyjxToNWb3PC6j1_lnPk,1069
+reposnap-0.6.2.dist-info/RECORD,,

{reposnap-0.5.1.dist-info → reposnap-0.6.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.25.0
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any