reposnap 0.6.3__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.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/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.3 → reposnap-0.6.4}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "reposnap"
-version = "0.6.3"
+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.3/src → reposnap-0.6.4}/reposnap/controllers/project_controller.py

@@ -5,6 +5,7 @@ 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__)
@@ -13,27 +14,43 @@ class ProjectController:
         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 [args.path])]
+            input_paths = [
+                Path(p) for p in (args.paths if hasattr(args, "paths") else [args.path])
+            ]
             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('.'):
+                        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.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.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.args = None
             self.input_paths = []
-            self.output_file = self.root_dir / 'output.md'
+            self.output_file = self.root_dir / "output.md"
             self.structure_only = False
             self.include_patterns = []
             self.exclude_patterns = []
@@ -48,11 +65,14 @@ class ProjectController:
         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.")
+            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:
@@ -64,21 +84,27 @@ 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
 
@@ -86,6 +112,7 @@ class ProjectController:
         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}")
@@ -96,7 +123,9 @@ class ProjectController:
         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.")
+                self.logger.info(
+                    "Git tracked files empty, using filesystem scan fallback."
+                )
                 all_files = []
                 for path in file_list:
                     try:
@@ -109,7 +138,12 @@ class ProjectController:
         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)]
+                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)
@@ -145,32 +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:
@@ -180,19 +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:
-                candidate = parent / '.gitignore'
+                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}")
+            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.3/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 []
-

reposnap-0.6.4/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)