reposnap 0.6.2__tar.gz → 0.6.4__tar.gz

reposnap-0.6.4/.github/workflows/python-package.yml

@@ -0,0 +1,32 @@
+name: CI (Rye)
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Install Rye
+      uses: eifinger/setup-rye@v4
+      with:
+        enable-cache: true
+
+    - name: Sync dependencies & install package
+      run: |
+        rye sync
+
+    - name: Lint
+      run: |
+        rye lint
+
+    - name: Test
+      run: |
+        rye test

reposnap-0.6.4/.github/workflows/release.yml

@@ -0,0 +1,52 @@
+name: Release to PyPI
+
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+*'     # any SemVer tag, eg v1.2.3 or v1.2.3-rc.1
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+
+    # Block publication unless the normal CI passed on this commit
+    needs: build                     # <— refers to the existing job id in python-package.yml
+
+    permissions:
+      contents: read                 # principle of least privilege
+      id-token: write                # enable OIDC if you switch to trusted publishing later :contentReference[oaicite:1]{index=1}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Rye
+        uses: eifinger/setup-rye@v4
+        with:
+          enable-cache: true
+
+      - name: Build wheel & sdist
+        run: |
+          rye sync
+          rye build --clean           # Hatchling is the backend; Rye shells out to it :contentReference[oaicite:2]{index=2}
+
+      - name: Verify metadata (optional)
+        run: |
+          rye run -e 'twine>=5' twine check dist/* :contentReference[oaicite:3]{index=3}
+
+      # Select real PyPI vs TestPyPI
+      - name: Set target repository
+        id: repository
+        run: |
+          if [[ "${GITHUB_REF_NAME}" == *"-"* ]]; then
+            echo "index_url=https://test.pypi.org/legacy/" >> "$GITHUB_OUTPUT"
+          else
+            echo "index_url=https://upload.pypi.org/legacy/" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}
+          repository-url: ${{ steps.repository.outputs.index_url }}
+          skip-existing: true          # idempotent re-runs :contentReference[oaicite:4]{index=4}

{reposnap-0.6.2 → reposnap-0.6.4}/.gitignore

@@ -12,3 +12,6 @@ wheels/
 output.md
 pytest.ini
 .envrc
+
+# pytest
+.pytest_cache/

reposnap-0.6.4/.pre-commit-config.yaml

@@ -0,0 +1,47 @@
+# Pre‑commit configuration for **RepoSnap**
+# Install hooks with:
+#   rye add --dev pre-commit
+#   pre-commit install
+#
+# Hooks are kept minimal and fast; they rely on Rye’s built‑in commands.
+
+repos:
+  # Generic housekeeping hooks
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+      - id: check-yaml
+      - id: check-added-large-files
+      - id: check-merge-conflict
+
+  # Project‑specific commands driven by Rye
+  - repo: local
+    hooks:
+      - id: rye-fmt
+        name: rye fmt --check
+        entry: rye
+        language: system
+        args: ["fmt", "--check"]
+        pass_filenames: false
+
+      - id: rye-lint
+        name: rye lint
+        entry: rye
+        language: system
+        args: ["lint"]
+        pass_filenames: false
+
+      - id: rye-test
+        name: rye test (quick)
+        entry: rye
+        language: system
+        args: ["test", "-q"]
+        pass_filenames: false
+        always_run: true
+        # Skip if only docs/markdown changed
+        files: "^(src/|tests/)"
+
+# Run hooks only on commit; skip CI or manual stages unless invoked.
+default_stages: [commit]

reposnap-0.6.4/.vscode/launch.json

@@ -0,0 +1,13 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python Debugger: Run reposnap",
+            "type": "debugpy",
+            "request": "launch",
+            "module": "reposnap.interfaces.cli",
+            "console": "integratedTerminal",
+            "args": ["src/reposnap/controllers", "src/reposnap/interfaces", "README.md", "tests/reposnap"]
+        }
+    ]
+}

reposnap-0.6.4/CONTRIBUTING.md

@@ -0,0 +1,155 @@
+# Contributing to **RepoSnap**
+
+---
+
+## Table of Contents
+
+1. [Getting Started](#getting-started)
+2. [Development Workflow](#development-workflow)
+3. [Coding Standards](#coding-standards)
+4. [Testing Guidelines](#testing-guidelines)
+5. [Pull‑Request Checklist](#pull-request-checklist)
+6. [Release Process](#release-process)
+7. [Security & Responsible Disclosure](#security--responsible-disclosure)
+8. [Code of Conduct](#code-of-conduct)
+
+---
+
+## Getting Started
+
+### 1. Fork & Clone
+
+```bash
+git clone https://github.com/<your-handle>/reposnap.git
+cd reposnap
+```
+
+### 2. Python 3.12 Environment
+
+We pin to **Python 3.12.6** (see `.python-version`). If you are not using Rye’s built‑in virtual‑env management, create one manually:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+```
+
+### 3. Install Dependencies
+
+**Using Rye (recommended)**
+
+```bash
+rye sync   # installs runtime + dev deps and refreshes lockfiles
+```
+
+*Fallback — vanilla tooling only*
+
+```bash
+pip install -e .[dev]   # editable install with dev extras (pytest, etc.)
+```
+
+### 4. Optional Pre‑Commit Hooks
+
+Automate formatting and linting on every commit with [pre‑commit](https://pre-commit.com/):
+
+```bash
+pre-commit install         # install hooks into .git
+```
+
+The default hook runs `rye fmt --check` and `rye lint` before each commit. Skip this step if you prefer manual control.
+
+---
+
+## Development Workflow
+
+1. **Create a branch**
+
+   * Feature → `feat/<short-slug>`
+   * Bugfix → `fix/<issue-number>`
+2. **Make focused changes** inside `src/` (and matching tests under `tests/`).
+3. **Run the full test suite**: `rye test -q`.
+4. **Format & lint**: `rye fmt` then `rye lint --fix` (to auto‑apply safe fixes).
+5. **Commit, push, and open a Pull Request**.
+
+> CI mirrors these steps. A failing check blocks merging.
+
+### Architectural Boundaries
+
+```
+interfaces  ─┐               (CLI, GUI)
+controllers ─┼─> orchestrate use cases
+core        ─┼─> pure, reusable logic (no side‑effects)
+models      ─┘   data structures (dumb, typed)
+```
+
+* **Never import from a higher layer.**
+* Keep `utils/` minimal — prefer domain‑specific modules in `core/`.
+
+---
+
+## Coding Standards
+
+RepoSnap relies on **Rye’s built‑in helpers** for code quality:
+
+| Command    | Description                                   |
+| ---------- | --------------------------------------------- |
+| `rye fmt`  | Formats code (powered under‑the‑hood by Ruff) |
+| `rye lint` | Lints and can auto‑fix issues with `--fix`    |
+
+Guidelines:
+
+* Follow **PEP 8**; `rye lint` will flag deviations.
+* All public functions **must** be type‑hinted.
+* Use **Google‑style** docstrings (`Args:`, `Returns:`).
+* Log via `logging`; avoid `print()` in library code.
+* Prefer `pathlib.Path` over `os.path`.
+
+---
+
+## Testing Guidelines
+
+* Framework: **pytest**.
+* Mirror `src/` structure under `tests/`.
+* **Minimum coverage:** 90 %. New code should raise the bar.
+* Write *unit tests* for pure functions and *integration tests* for I/O flows (e.g., CLI interaction).
+* Measure coverage locally: `pytest --cov=reposnap`.
+
+---
+
+## Pull‑Request Checklist
+
+Before requesting review, confirm:
+
+* [ ] Tests pass (`rye test -q`) and coverage ≥ 90 %.
+* [ ] `rye fmt --check` and `rye lint` report no issues.
+* [ ] Docstrings & docs updated where relevant.
+* [ ] No new circular dependencies (`pipdeptree --warn`).
+* [ ] CI is green.
+* [ ] PR description explains **why** the change is needed.
+* [ ] Commits follow Conventional Commits.
+
+At least one core maintainer must approve before merging. We use **Squash & Merge** to keep history linear.
+
+---
+
+## Release Process
+
+1. Merge PRs into `main`.
+2. Bump version manually in [pyproject.toml](pyproject.toml).
+3. Tag release: `git tag vX.Y.Z && git push --tags`.
+4. CI publishes to PyPI.
+
+We adhere to **Semantic Versioning 2.0.0**.
+
+---
+
+## Security & Responsible Disclosure
+
+If you discover a vulnerability, email [maintainer@example.com](mailto:maintainer@example.com) **privately**. We will coordinate a fix and issue a CVE if appropriate.
+
+---
+
+## Code of Conduct
+
+Participation in this project is covered by the [Contributor Covenant v2.1](https://www.contributor-covenant.org/version/2/1/code_of_conduct/).
+
+---

{reposnap-0.6.2 → reposnap-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reposnap
-Version: 0.6.2
+Version: 0.6.4
 Summary: Generate a Markdown file with all contents of your project
 Author: agoloborodko
 License-File: LICENSE

{reposnap-0.6.2 → reposnap-0.6.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reposnap"
-version = "0.6.2"
+version = "0.6.4"
 description = "Generate a Markdown file with all contents of your project"
 authors = [
     { name = "agoloborodko" }
@@ -22,13 +22,20 @@ build-backend = "hatchling.build"
 managed = true
 dev-dependencies = [
     "pytest>=8.3.2",
+    "pre-commit>=4.2.0",
+    "pytest-cov>=6.2.1",
 ]
 
 [tool.hatch.metadata]
 allow-direct-references = true
 
+[tool.hatch.build]
+sources = ["src"]
+dev-mode-dirs = ["src"]
+
 [tool.hatch.build.targets.wheel]
-packages = ["src/reposnap"]
+packages = ["reposnap"]
+include = ["reposnap"]
 
 [project.scripts]
 reposnap = "reposnap.interfaces.cli:main"

{reposnap-0.6.2/src → reposnap-0.6.4}/reposnap/controllers/project_controller.py

@@ -1,45 +1,57 @@
-# src/reposnap/controllers/project_controller.py
-
 import logging
 from pathlib import Path
 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__)
+        # Always determine repository root using Git (or cwd)
+        self.root_dir = self._get_repo_root().resolve()
         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.
+            # Treat positional arguments as literal file/directory names.
+            input_paths = [
+                Path(p) for p in (args.paths if hasattr(args, "paths") else [args.path])
+            ]
             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 []
+                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 []
+            )
         else:
-            self.root_dir = Path('.').resolve()
+            self.args = None
             self.input_paths = []
-            self.output_file = Path('output.md').resolve()
+            self.output_file = self.root_dir / "output.md"
             self.structure_only = False
-            self.args = None
             self.include_patterns = []
             self.exclude_patterns = []
         self.file_tree: Optional[FileTree] = None
@@ -49,31 +61,18 @@ class ProjectController:
 
     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).
+        Determine the repository root using Git if available,
+        otherwise use the current directory.
         """
-        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.")
+            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:
@@ -85,43 +84,65 @@ class ProjectController:
 
     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 ['*', '?', '[']):
+                if any(ch in p for ch in ["*", "?", "["]):
                     adjusted.append(p)
                 else:
-                    adjusted.append(f'*{p}*')
+                    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)
+            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)
+            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:
-        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.
+        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}")
+        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 include/exclude filtering: {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 f.parts[:len(input_path.parts)] == input_path.parts
+                    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:
@@ -158,30 +179,40 @@ class ProjectController:
 
     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)
+        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
+            structure_only=self.structure_only,
+        )
+        markdown_generator.generate_markdown(
+            self.file_tree.structure, self.file_tree.get_all_files()
         )
-        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
+            hide_untoggled=True,
+        )
+        markdown_generator.generate_markdown(
+            pruned_tree, [Path(f) for f in selected_files]
         )
-        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:
@@ -191,18 +222,25 @@ class ProjectController:
         self.generate_output()
 
     def _load_gitignore_patterns(self) -> List[str]:
-        gitignore_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'
-                if gitignore_path.exists():
+                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 = gitignore.readlines()
-            self.logger.debug(f"Loaded .gitignore patterns from {gitignore_path.parent}: {patterns}")
+            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}.")

{reposnap-0.6.2/src → reposnap-0.6.4}/reposnap/core/git_repo.py

@@ -30,4 +30,3 @@ class GitRepo:
         except InvalidGitRepositoryError:
             self.logger.error(f"Invalid Git repository at: {self.repo_path}")
             return []
-