reuseify 0.1.0__tar.gz

reuseify-0.1.0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: reuseify
+Version: 0.1.0
+Summary: Automate REUSE license annotation from git history.
+Project-URL: Homepage, https://github.com/sahiljhawar/reuseify
+Project-URL: Tracker, https://github.com/sahiljhawar/reuseify/issues
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13.0
+Requires-Dist: reuse>=6.2.0
+
+<!--
+SPDX-FileCopyrightText: 2026 Sahil Jhawar
+SPDX-FileContributor: Sahil Jhawar
+
+SPDX-License-Identifier: GPL-3.0-or-later
+-->
+
+<!--
+-->
+
+# reuseify
+[![REUSE status](https://api.reuse.software/badge/github.com/sahiljhawar/reuseify)](https://api.reuse.software/info/github.com/sahiljhawar/reuseify)
+
+
+Automate [REUSE](https://reuse.software/) license annotation from git history.
+
+`reuseify` inspects which files are missing license headers (via `reuse lint`),
+looks up their git commit authors, and applies `reuse annotate`, all from a single CLI.
+
+## Installation
+
+```bash
+uv pip install .
+```
+
+## Usage
+
+The workflow is two steps: collect authors → annotate files.
+
+### Step 1: collect authors
+
+```bash
+reuseify get-authors [OPTIONS]
+```
+
+Runs `reuse lint`, finds every file missing a license header, looks up its git
+commit authors, and writes a JSON file:
+
+```json
+{
+  "src/foo.py": ["Alice", "Bob"],
+  "src/bar.c":  ["Alice"],
+  "src/new.py": [] #NOT_IN_GIT
+}
+```
+
+| Option                 | Short | Default                       | Description                                                            |
+| ---------------------- | ----- | ----------------------------- | ---------------------------------------------------------------------- |
+| `--output`             | `-o`  | `reuse_annotate_authors.json` | Output JSON file                                                       |
+| `--include-not-in-git` | `-i`  | off                           | Include files with no git history (empty author list)                  |
+| `--exclude PATTERN`    | `-e`  |                               | Extra glob pattern to exclude (matched per path component, repeatable) |
+
+Files matching built-in patterns are always excluded:
+`__pycache__`, `.venv`, `venv`, `.env`, `env`, `.git`, `.vscode`, `.idea`,
+`*.egg-info`, `*.pyc`, `dist`, `build`, `node_modules`, `.tox`,
+`.mypy_cache`, `.pytest_cache`, `.ruff_cache`.
+
+Files ignored by `.gitignore` are also excluded
+automatically.
+
+**Examples**
+
+```bash
+# defaults
+reuseify get-authors
+
+# custom output path + include untracked files
+reuseify get-authors --output authors.json --include-not-in-git
+
+# add an extra exclusion pattern
+reuseify get-authors --exclude reports --exclude "*.tmp"
+```
+
+---
+
+### Step 2: annotate files
+
+```bash
+reuseify annotate [OPTIONS] [REUSE ANNOTATE FLAGS...]
+```
+
+Reads the JSON file from [Step 1](#step-1-collect-authors) and calls `reuse annotate` for every file.
+`--contributor` flags are injected automatically from the JSON data.
+All unrecognised flags are forwarded verbatim to `reuse annotate`, giving you
+full control over `--copyright`, `--license`, `--year`, `--style`,
+`--fallback-dot-license`, `--force-dot-license`, `--skip-unrecognised`, etc.
+
+| Option                       | Short | Default                       | Description                                              |
+| ---------------------------- | ----- | ----------------------------- | -------------------------------------------------------- |
+| `--input`                    | `-i`  | `reuse_annotate_authors.json` | JSON file from `get-authors`                             |
+| `--default-contributor NAME` | `-d`  | —                             | Fallback contributor for `NOT_IN_GIT` files (repeatable) |
+
+Output is grouped: all successes first, then skips, then failures, then finally a summary.
+
+### Examples
+
+```bash
+# basic
+reuseify annotate \
+    --copyright "2025 X-Men" \
+    --license Apache-2.0 \
+    --fallback-dot-license
+
+# custom input + fallback contributor for untracked files
+reuseify annotate \
+    --input authors.json \
+    --default-contributor "Charles Xavier" \
+    --copyright "2025 X-Men" \
+    --license Apache-2.0
+
+# multiple default contributors
+reuseify annotate \
+    --default-contributor "Professor X" \
+    --default-contributor "Cyclops" \
+    --copyright "2025 X-Men" \
+    --license MIT
+```
+
+## Disclaimer
+
+> [!CAUTION]
+> Use at your own risk. `reuse annotate` modifies files in place.
+
+```bash
+reuse annotate --help
+```
+
+This project is not affiliated with the REUSE project or its maintainers in any way.

reuseify-0.1.0/README.md

@@ -0,0 +1,128 @@
+<!--
+SPDX-FileCopyrightText: 2026 Sahil Jhawar
+SPDX-FileContributor: Sahil Jhawar
+
+SPDX-License-Identifier: GPL-3.0-or-later
+-->
+
+<!--
+-->
+
+# reuseify
+[![REUSE status](https://api.reuse.software/badge/github.com/sahiljhawar/reuseify)](https://api.reuse.software/info/github.com/sahiljhawar/reuseify)
+
+
+Automate [REUSE](https://reuse.software/) license annotation from git history.
+
+`reuseify` inspects which files are missing license headers (via `reuse lint`),
+looks up their git commit authors, and applies `reuse annotate`, all from a single CLI.
+
+## Installation
+
+```bash
+uv pip install .
+```
+
+## Usage
+
+The workflow is two steps: collect authors → annotate files.
+
+### Step 1: collect authors
+
+```bash
+reuseify get-authors [OPTIONS]
+```
+
+Runs `reuse lint`, finds every file missing a license header, looks up its git
+commit authors, and writes a JSON file:
+
+```json
+{
+  "src/foo.py": ["Alice", "Bob"],
+  "src/bar.c":  ["Alice"],
+  "src/new.py": [] #NOT_IN_GIT
+}
+```
+
+| Option                 | Short | Default                       | Description                                                            |
+| ---------------------- | ----- | ----------------------------- | ---------------------------------------------------------------------- |
+| `--output`             | `-o`  | `reuse_annotate_authors.json` | Output JSON file                                                       |
+| `--include-not-in-git` | `-i`  | off                           | Include files with no git history (empty author list)                  |
+| `--exclude PATTERN`    | `-e`  |                               | Extra glob pattern to exclude (matched per path component, repeatable) |
+
+Files matching built-in patterns are always excluded:
+`__pycache__`, `.venv`, `venv`, `.env`, `env`, `.git`, `.vscode`, `.idea`,
+`*.egg-info`, `*.pyc`, `dist`, `build`, `node_modules`, `.tox`,
+`.mypy_cache`, `.pytest_cache`, `.ruff_cache`.
+
+Files ignored by `.gitignore` are also excluded
+automatically.
+
+**Examples**
+
+```bash
+# defaults
+reuseify get-authors
+
+# custom output path + include untracked files
+reuseify get-authors --output authors.json --include-not-in-git
+
+# add an extra exclusion pattern
+reuseify get-authors --exclude reports --exclude "*.tmp"
+```
+
+---
+
+### Step 2: annotate files
+
+```bash
+reuseify annotate [OPTIONS] [REUSE ANNOTATE FLAGS...]
+```
+
+Reads the JSON file from [Step 1](#step-1-collect-authors) and calls `reuse annotate` for every file.
+`--contributor` flags are injected automatically from the JSON data.
+All unrecognised flags are forwarded verbatim to `reuse annotate`, giving you
+full control over `--copyright`, `--license`, `--year`, `--style`,
+`--fallback-dot-license`, `--force-dot-license`, `--skip-unrecognised`, etc.
+
+| Option                       | Short | Default                       | Description                                              |
+| ---------------------------- | ----- | ----------------------------- | -------------------------------------------------------- |
+| `--input`                    | `-i`  | `reuse_annotate_authors.json` | JSON file from `get-authors`                             |
+| `--default-contributor NAME` | `-d`  | —                             | Fallback contributor for `NOT_IN_GIT` files (repeatable) |
+
+Output is grouped: all successes first, then skips, then failures, then finally a summary.
+
+### Examples
+
+```bash
+# basic
+reuseify annotate \
+    --copyright "2025 X-Men" \
+    --license Apache-2.0 \
+    --fallback-dot-license
+
+# custom input + fallback contributor for untracked files
+reuseify annotate \
+    --input authors.json \
+    --default-contributor "Charles Xavier" \
+    --copyright "2025 X-Men" \
+    --license Apache-2.0
+
+# multiple default contributors
+reuseify annotate \
+    --default-contributor "Professor X" \
+    --default-contributor "Cyclops" \
+    --copyright "2025 X-Men" \
+    --license MIT
+```
+
+## Disclaimer
+
+> [!CAUTION]
+> Use at your own risk. `reuse annotate` modifies files in place.
+
+```bash
+reuse annotate --help
+```
+
+This project is not affiliated with the REUSE project or its maintainers in any way.

reuseify-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: 2026 Sahil Jhawar
+# SPDX-FileContributor: Sahil Jhawar
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "reuseify"
+version = "0.1.0"
+description = "Automate REUSE license annotation from git history."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "typer>=0.12",
+    "rich>=13.0",
+    "reuse>=6.2.0",
+]
+
+[project.scripts]
+reuseify = "reuseify.cli:app"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+
+[project.urls]
+Homepage = "https://github.com/sahiljhawar/reuseify"
+Tracker = "https://github.com/sahiljhawar/reuseify/issues"
+
+[tool.bumpver]
+current_version = "0.1.0"
+version_pattern = "MAJOR.MINOR.PATCH[PYTAGNUM]"
+commit_message = "bump version {old_version} -> {new_version}"
+commit = true
+tag = true
+push = true
+
+[tool.bumpver.file_patterns]
+"pyproject.toml" = ['version = "{version}"']
+"src/reuseify/__init__.py" = ['__version__ = "{version}"']

reuseify-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

reuseify-0.1.0/src/reuseify/__init__.py

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: 2026 Sahil Jhawar
+# SPDX-FileContributor: Sahil Jhawar
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+__version__ = "0.1.0"

reuseify-0.1.0/src/reuseify/annotate.py

@@ -0,0 +1,161 @@
+# SPDX-FileCopyrightText: 2026 Sahil Jhawar
+# SPDX-FileContributor: Sahil Jhawar
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""Apply REUSE license headers to files using authors from a JSON file.
+
+All flags not consumed by this script are forwarded verbatim to
+`reuse annotate` (e.g. --copyright, --license, --year, --style,
+--fallback-dot-license, --force-dot-license, --skip-unrecognised, ...).
+The --contributor flags are populated automatically from the JSON file
+produced by get_authors.py.
+"""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+console = Console()
+
+
+def check_reuse() -> None:
+    if not shutil.which("reuse"):
+        console.print(
+            "[bold red]Error:[/] 'reuse' command not found. Please install it:"
+        )
+        console.print("  pip install reuse")
+        sys.exit(1)
+
+
+app = typer.Typer()
+
+
+def main(
+    ctx: typer.Context,
+    input_file: Annotated[
+        str,
+        typer.Option(
+            "--input",
+            "-i",
+            help="JSON file produced by get-authors.",
+            show_default=True,
+        ),
+    ] = "reuse_annotate_authors.json",
+    default_contributor: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--default-contributor",
+            "-d",
+            help=(
+                "Fallback contributor name(s) for files with no git history (NOT_IN_GIT). "
+                "Can be repeated for multiple names. Without this flag those files are skipped."
+            ),
+        ),
+    ] = None,
+) -> None:
+    """
+    Apply REUSE license headers using authors from a JSON file.
+
+    Any additional flags (not part of reuseify) are forwarded directly to `reuse annotate`.
+
+    Example:
+        reuseify annotate -i file.json --copyright-holder "John Doe"
+    """
+    reuse_args: list[str] = ctx.args
+    _default_contributors: list[str] = default_contributor or []
+    check_reuse()
+
+    try:
+        with open(input_file) as f:
+            authors_map: dict[str, list[str]] = json.load(f)
+    except FileNotFoundError:
+        console.print(f"[bold red]Error:[/] Input file '{input_file}' not found.")
+        console.print("Run [bold]reuseify get-authors[/] first to generate it.")
+        sys.exit(1)
+    except json.JSONDecodeError as exc:
+        console.print(f"[bold red]Error:[/] Failed to parse '{input_file}': {exc}")
+        sys.exit(1)
+
+    console.print(f"Reading authors from: [bold]{input_file}[/]")
+
+    to_annotate: list[tuple[str, list[str]]] = []
+    skipped: list[tuple[str, str]] = []
+
+    for filepath, authors in authors_map.items():
+        if not authors:
+            if _default_contributors and os.path.isfile(filepath):
+                to_annotate.append((filepath, _default_contributors))
+            else:
+                reason = "NOT_IN_GIT" + (
+                    "" if not _default_contributors else " (file not found)"
+                )
+                skipped.append((filepath, reason))
+        elif not os.path.isfile(filepath):
+            skipped.append((filepath, "file not found"))
+        else:
+            to_annotate.append((filepath, authors))
+
+    console.print(
+        f"Found [bold]{len(to_annotate)}[/] file(s) to annotate, "
+        f"[bold]{len(skipped)}[/] to skip.\n"
+    )
+
+    passed: list[str] = []
+    failed: list[tuple[str, str]] = []  # (filepath, stderr)
+
+    for filepath, authors in to_annotate:
+        contributor_flags: list[str] = []
+        for author in authors:
+            contributor_flags.extend(["--contributor", author])
+
+        cmd = ["reuse", "annotate"] + list(reuse_args) + contributor_flags + [filepath]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+
+        if result.returncode == 0:
+            passed.append(filepath)
+        else:
+            failed.append((filepath, result.stderr.strip()))
+
+    if passed:
+        console.print("[bold]Annotated:[/]")
+        for filepath in passed:
+            authors = authors_map.get(filepath, _default_contributors)
+            console.print(
+                f"  [bold green]PASS[/]  {filepath}  [dim]({', '.join(authors)})[/]"
+            )
+        console.print()
+
+    if skipped:
+        console.print("[bold]Skipped:[/]")
+        for filepath, reason in skipped:
+            console.print(f"  [yellow]SKIP[/]  {filepath}  [dim]({reason})[/]")
+        console.print()
+
+    if failed:
+        console.print("[bold]Failed:[/]")
+        for filepath, stderr in failed:
+            console.print(f"  [bold red]FAIL[/]  {filepath}")
+            if stderr:
+                console.print(f"         [red]{stderr}[/]")
+        console.print()
+
+    total = len(passed) + len(skipped) + len(failed)
+    console.rule()
+    console.print(f"Total:   {total}")
+    console.print(f"[green]Success: {len(passed)}[/]")
+    console.print(f"[yellow]Skipped: {len(skipped)}[/]")
+    if failed:
+        console.print(f"[red]Failed:  {len(failed)}[/]")
+    else:
+        console.print(f"Failed:  {len(failed)}")
+
+
+if __name__ == "__main__":
+    app()

reuseify-0.1.0/src/reuseify/cli.py

@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: 2026 Sahil Jhawar
+# SPDX-FileContributor: Sahil Jhawar
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""reuseify — top-level CLI entry point."""
+
+import typer
+
+from reuseify.get_authors import main as _get_authors_cmd
+from reuseify.annotate import main as _annotate_cmd
+
+app = typer.Typer(
+    name="reuseify",
+    help="Automate REUSE license annotation from git history.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+app.command("get-authors")(_get_authors_cmd)
+app.command("annotate", context_settings={"allow_extra_args": True, "ignore_unknown_options": True})(_annotate_cmd)
+
+
+if __name__ == "__main__":
+    app()

reuseify-0.1.0/src/reuseify/get_authors.py

@@ -0,0 +1,189 @@
+# SPDX-FileCopyrightText: 2026 Sahil Jhawar
+# SPDX-FileContributor: Sahil Jhawar
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""Get authors for files with missing REUSE licenses and save to a JSON file."""
+
+import fnmatch
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+console = Console()
+
+DEFAULT_EXCLUDE_PATTERNS: tuple[str, ...] = (
+    "__pycache__",
+    ".venv",
+    "venv",
+    ".env",
+    "env",
+    ".git",
+    ".vscode",
+    ".idea",
+    "*.egg-info",
+    "*.pyc",
+    "dist",
+    "build",
+    "node_modules",
+    ".tox",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+)
+
+
+def is_path_excluded(filepath: str, patterns: tuple[str, ...]) -> bool:
+    """Return True if any component of *filepath* matches any glob *pattern*."""
+    return any(
+        fnmatch.fnmatch(part, pattern)
+        for part in Path(filepath).parts
+        for pattern in patterns
+    )
+
+
+def filter_git_ignored(files: list[str]) -> list[str]:
+    """Remove files that are ignored by git (.gitignore et al.)."""
+    if not files:
+        return []
+    result = subprocess.run(
+        ["git", "check-ignore", "--stdin"],
+        input="\n".join(files),
+        capture_output=True,
+        text=True,
+    )
+    ignored = set(result.stdout.splitlines())
+    return [f for f in files if f not in ignored]
+
+
+def check_git_repo() -> None:
+    result = subprocess.run(
+        ["git", "rev-parse", "--git-dir"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        console.print("[bold red]Error:[/] Not in a git repository.")
+        sys.exit(1)
+
+
+def get_missing_license_files() -> list[str]:
+    result = subprocess.run(
+        ["reuse", "lint"],
+        capture_output=True,
+        text=True,
+    )
+    files: list[str] = []
+    for line in (result.stdout + result.stderr).splitlines():
+        if line.strip().startswith("# SUMMARY"):
+            break
+        stripped = line.strip()
+        if stripped.startswith("* "):
+            files.append(stripped[2:])
+    return files
+
+
+def get_git_authors(filepath: str) -> list[str]:
+    result = subprocess.run(
+        ["git", "log", "--format=%an", "--", filepath],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0 or not result.stdout.strip():
+        return []
+    return sorted(set(result.stdout.strip().splitlines()))
+
+
+app = typer.Typer()
+
+
+@app.command()
+def main(
+    output: Annotated[
+        str,
+        typer.Option("--output", "-o", help="Output JSON file.", show_default=True),
+    ] = "reuse_annotate_authors.json",
+    include_not_in_git: Annotated[
+        bool,
+        typer.Option(
+            "--include-not-in-git",
+            "-i",
+            help="Include files with no git history in the JSON output (empty author list).",
+        ),
+    ] = False,
+    exclude: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--exclude",
+            "-e",
+            help=(
+                "Glob pattern to exclude (matched against each path component). "
+                "Can be repeated. Default patterns always apply: "
+                + ", ".join(DEFAULT_EXCLUDE_PATTERNS)
+            ),
+        ),
+    ] = None,
+) -> None:
+    """Get git authors for files missing REUSE license headers."""
+    _exclude: tuple[str, ...] = tuple(exclude or [])
+    check_git_repo()
+
+    console.print("Running [bold]reuse lint[/]...")
+    files = get_missing_license_files()
+
+    if not files:
+        console.print("[green]No files with licensing issues found by reuse lint.[/]")
+        sys.exit(0)
+
+    console.print(f"Found [bold]{len(files)}[/] file(s) with licensing issues.")
+
+    all_patterns = DEFAULT_EXCLUDE_PATTERNS + _exclude
+    before = len(files)
+    files = [f for f in files if not is_path_excluded(f, all_patterns)]
+    files = filter_git_ignored(files)
+    excluded_count = before - len(files)
+    if excluded_count:
+        console.print(
+            f"[dim]Excluded {excluded_count} file(s) via path patterns / .gitignore.[/]"
+        )
+    if not files:
+        console.print("[green]All remaining files were excluded.[/]")
+        sys.exit(0)
+
+    console.print("Fetching git authors...\n")
+
+    authors_map: dict[str, list[str]] = {}
+    not_in_git: list[str] = []
+    for filepath in files:
+        authors = get_git_authors(filepath)
+        if not authors:
+            not_in_git.append(filepath)
+            if include_not_in_git:
+                authors_map[filepath] = []
+                console.print(f"  [yellow]{filepath}[/]: NOT_IN_GIT (included)")
+            else:
+                console.print(f"  [dim]{filepath}[/]: NOT_IN_GIT (omitted)")
+        else:
+            authors_map[filepath] = authors
+            console.print(f"  [cyan]{filepath}[/]: {', '.join(authors)}")
+
+    if not_in_git and not include_not_in_git:
+        console.print(
+            f"\n[yellow]Note:[/] {len(not_in_git)} file(s) with no git history were omitted. "
+            "Use [bold]--include-not-in-git[/] / [bold]-i[/] to include them."
+        )
+
+    with open(output, "w") as f:
+        json.dump(authors_map, f, indent=2)
+
+    console.print(f"\n[green]JSON written to:[/] {output}")
+    console.print(f"Total entries:  {len(authors_map)}")
+
+
+if __name__ == "__main__":
+    app()

reuseify-0.1.0/src/reuseify.egg-info/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: reuseify
+Version: 0.1.0
+Summary: Automate REUSE license annotation from git history.
+Project-URL: Homepage, https://github.com/sahiljhawar/reuseify
+Project-URL: Tracker, https://github.com/sahiljhawar/reuseify/issues
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13.0
+Requires-Dist: reuse>=6.2.0
+
+<!--
+SPDX-FileCopyrightText: 2026 Sahil Jhawar
+SPDX-FileContributor: Sahil Jhawar
+
+SPDX-License-Identifier: GPL-3.0-or-later
+-->
+
+<!--
+-->
+
+# reuseify
+[![REUSE status](https://api.reuse.software/badge/github.com/sahiljhawar/reuseify)](https://api.reuse.software/info/github.com/sahiljhawar/reuseify)
+
+
+Automate [REUSE](https://reuse.software/) license annotation from git history.
+
+`reuseify` inspects which files are missing license headers (via `reuse lint`),
+looks up their git commit authors, and applies `reuse annotate`, all from a single CLI.
+
+## Installation
+
+```bash
+uv pip install .
+```
+
+## Usage
+
+The workflow is two steps: collect authors → annotate files.
+
+### Step 1: collect authors
+
+```bash
+reuseify get-authors [OPTIONS]
+```
+
+Runs `reuse lint`, finds every file missing a license header, looks up its git
+commit authors, and writes a JSON file:
+
+```json
+{
+  "src/foo.py": ["Alice", "Bob"],
+  "src/bar.c":  ["Alice"],
+  "src/new.py": [] #NOT_IN_GIT
+}
+```
+
+| Option                 | Short | Default                       | Description                                                            |
+| ---------------------- | ----- | ----------------------------- | ---------------------------------------------------------------------- |
+| `--output`             | `-o`  | `reuse_annotate_authors.json` | Output JSON file                                                       |
+| `--include-not-in-git` | `-i`  | off                           | Include files with no git history (empty author list)                  |
+| `--exclude PATTERN`    | `-e`  |                               | Extra glob pattern to exclude (matched per path component, repeatable) |
+
+Files matching built-in patterns are always excluded:
+`__pycache__`, `.venv`, `venv`, `.env`, `env`, `.git`, `.vscode`, `.idea`,
+`*.egg-info`, `*.pyc`, `dist`, `build`, `node_modules`, `.tox`,
+`.mypy_cache`, `.pytest_cache`, `.ruff_cache`.
+
+Files ignored by `.gitignore` are also excluded
+automatically.
+
+**Examples**
+
+```bash
+# defaults
+reuseify get-authors
+
+# custom output path + include untracked files
+reuseify get-authors --output authors.json --include-not-in-git
+
+# add an extra exclusion pattern
+reuseify get-authors --exclude reports --exclude "*.tmp"
+```
+
+---
+
+### Step 2: annotate files
+
+```bash
+reuseify annotate [OPTIONS] [REUSE ANNOTATE FLAGS...]
+```
+
+Reads the JSON file from [Step 1](#step-1-collect-authors) and calls `reuse annotate` for every file.
+`--contributor` flags are injected automatically from the JSON data.
+All unrecognised flags are forwarded verbatim to `reuse annotate`, giving you
+full control over `--copyright`, `--license`, `--year`, `--style`,
+`--fallback-dot-license`, `--force-dot-license`, `--skip-unrecognised`, etc.
+
+| Option                       | Short | Default                       | Description                                              |
+| ---------------------------- | ----- | ----------------------------- | -------------------------------------------------------- |
+| `--input`                    | `-i`  | `reuse_annotate_authors.json` | JSON file from `get-authors`                             |
+| `--default-contributor NAME` | `-d`  | —                             | Fallback contributor for `NOT_IN_GIT` files (repeatable) |
+
+Output is grouped: all successes first, then skips, then failures, then finally a summary.
+
+### Examples
+
+```bash
+# basic
+reuseify annotate \
+    --copyright "2025 X-Men" \
+    --license Apache-2.0 \
+    --fallback-dot-license
+
+# custom input + fallback contributor for untracked files
+reuseify annotate \
+    --input authors.json \
+    --default-contributor "Charles Xavier" \
+    --copyright "2025 X-Men" \
+    --license Apache-2.0
+
+# multiple default contributors
+reuseify annotate \
+    --default-contributor "Professor X" \
+    --default-contributor "Cyclops" \
+    --copyright "2025 X-Men" \
+    --license MIT
+```
+
+## Disclaimer
+
+> [!CAUTION]
+> Use at your own risk. `reuse annotate` modifies files in place.
+
+```bash
+reuse annotate --help
+```
+
+This project is not affiliated with the REUSE project or its maintainers in any way.

reuseify-0.1.0/src/reuseify.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+src/reuseify/__init__.py
+src/reuseify/annotate.py
+src/reuseify/cli.py
+src/reuseify/get_authors.py
+src/reuseify.egg-info/PKG-INFO
+src/reuseify.egg-info/SOURCES.txt
+src/reuseify.egg-info/dependency_links.txt
+src/reuseify.egg-info/entry_points.txt
+src/reuseify.egg-info/requires.txt
+src/reuseify.egg-info/top_level.txt

reuseify-0.1.0/src/reuseify.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

reuseify-0.1.0/src/reuseify.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+reuseify = reuseify.cli:app

reuseify-0.1.0/src/reuseify.egg-info/requires.txt

@@ -0,0 +1,3 @@
+typer>=0.12
+rich>=13.0
+reuse>=6.2.0

reuseify-0.1.0/src/reuseify.egg-info/top_level.txt

@@ -0,0 +1 @@
+reuseify