gitrelevance 0.1.2__tar.gz → 0.1.4__tar.gz

{gitrelevance-0.1.2 → gitrelevance-0.1.4}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.5
 Name: gitrelevance
-Version: 0.1.2
+Version: 0.1.4
 Summary: Analyze whether historical GitHub issues are still relevant to a codebase, using Git history as evidence
-Project-URL: Homepage, https://github.com/gitrelevance/gitrelevance
-Project-URL: Repository, https://github.com/gitrelevance/gitrelevance
-Project-URL: Issues, https://github.com/gitrelevance/gitrelevance/issues
-Author: GitRelevance Contributors
+Project-URL: Homepage, https://github.com/Aditya30ag/gitrelevance
+Project-URL: Repository, https://github.com/Aditya30ag/gitrelevance
+Project-URL: Issues, https://github.com/Aditya30ag/gitrelevance/issues
+Author: Aditya30ag
 License-Expression: MIT
 License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
@@ -66,7 +66,7 @@ pip install gitrelevance
 
 For development:
 ```bash
-git clone https://github.com/gitrelevance/gitrelevance.git
+git clone https://github.com/Aditya30ag/gitrelevance.git
 cd gitrelevance
 pip install -e ".[dev]"
 ```

{gitrelevance-0.1.2 → gitrelevance-0.1.4}/README.md

@@ -31,7 +31,7 @@ pip install gitrelevance
 
 For development:
 ```bash
-git clone https://github.com/gitrelevance/gitrelevance.git
+git clone https://github.com/Aditya30ag/gitrelevance.git
 cd gitrelevance
 pip install -e ".[dev]"
 ```

{gitrelevance-0.1.2 → gitrelevance-0.1.4}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gitrelevance"
-version = "0.1.2"
+version = "0.1.4"
 description = "Analyze whether historical GitHub issues are still relevant to a codebase, using Git history as evidence"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.10"
 authors = [
-    { name = "GitRelevance Contributors" },
+    { name = "Aditya30ag" },
 ]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -46,9 +46,9 @@ dev = [
 gitrelevance = "gitrelevance.cli.commands:app"
 
 [project.urls]
-Homepage = "https://github.com/gitrelevance/gitrelevance"
-Repository = "https://github.com/gitrelevance/gitrelevance"
-Issues = "https://github.com/gitrelevance/gitrelevance/issues"
+Homepage = "https://github.com/Aditya30ag/gitrelevance"
+Repository = "https://github.com/Aditya30ag/gitrelevance"
+Issues = "https://github.com/Aditya30ag/gitrelevance/issues"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/gitrelevance"]

{gitrelevance-0.1.2 → gitrelevance-0.1.4}/src/gitrelevance/analysis/matcher.py

@@ -188,6 +188,9 @@ def build_all_match_sets(
 ) -> dict[int, MatchSet]:
     """Build match sets for all given issues, fetching pull requests only once.
 
+    Pre-indexes pull requests by closing issue numbers and PR numbers to correlate
+    issues in O(I + P) time rather than O(I * P).
+
     Args:
         issues: List of issues to correlate.
         repo: The local Git repository wrapper.
@@ -197,4 +200,31 @@ def build_all_match_sets(
         Dictionary mapping issue number to its corresponding MatchSet.
     """
     prs = provider.get_pull_requests(state="all")
-    return {issue.number: build_match_set(issue, repo, prs) for issue in issues}
+
+    # Invert PR index for O(1) issue-to-PR lookups
+    issue_to_closing_prs: dict[int, list[PullRequest]] = {}
+    pr_by_number: dict[int, PullRequest] = {}
+    for pr in prs:
+        pr_by_number[pr.number] = pr
+        for issue_num in pr.closes_issue_numbers:
+            issue_to_closing_prs.setdefault(issue_num, []).append(pr)
+
+    match_sets: dict[int, MatchSet] = {}
+    for issue in issues:
+        # Collect candidate PRs for this issue
+        candidate_prs: list[PullRequest] = []
+        seen_cand_nums: set[int] = set()
+
+        for pr in issue_to_closing_prs.get(issue.number, []):
+            if pr.number not in seen_cand_nums:
+                seen_cand_nums.add(pr.number)
+                candidate_prs.append(pr)
+
+        for pr_num in issue.linked_pr_numbers:
+            if pr_num in pr_by_number and pr_num not in seen_cand_nums:
+                seen_cand_nums.add(pr_num)
+                candidate_prs.append(pr_by_number[pr_num])
+
+        match_sets[issue.number] = build_match_set(issue, repo, candidate_prs)
+
+    return match_sets

{gitrelevance-0.1.2 → gitrelevance-0.1.4}/src/gitrelevance/cli/commands.py

@@ -75,6 +75,13 @@ def analyze(
         "--since",
         help="Filter issues created on or after date (YYYY-MM-DD).",
     ),
+    token: Optional[str] = typer.Option(
+        None,
+        "--token",
+        "-t",
+        "--api-key",
+        help="GitHub Personal Access Token or API key for authenticated requests.",
+    ),
     json_output: bool = typer.Option(
         False,
         "--json",
@@ -122,18 +129,18 @@ def analyze(
     owner, repo_name = parsed
 
     # 3. Construct provider
-    token = config.load_github_token()
+    resolved_token = token or config.load_github_token()
     if _provider_override is not None:
         provider = _provider_override
     elif _provider_factory is not None:
-        provider = _provider_factory(owner, repo_name, token)
+        provider = _provider_factory(owner, repo_name, resolved_token)
     else:
-        if not token and not json_output:
+        if not resolved_token and not json_output:
             err_console.print(
-                "[yellow]Note:[/yellow] Running in unauthenticated mode (GITHUB_TOKEN not set). "
+                "[yellow]Note:[/yellow] Running in unauthenticated mode (GITHUB_TOKEN / --token not set). "
                 "GitHub API rate limit is 60 requests/hour."
             )
-        provider = GitHubProvider(owner=owner, repo=repo_name, token=token)
+        provider = GitHubProvider(owner=owner, repo=repo_name, token=resolved_token)
 
     # Validate state option
     state_normalized = state.lower()
@@ -253,6 +260,29 @@ def analyze(
         raise typer.Exit(code=1)
 
 
+@app.command(name="auth")
+def auth(
+    token: Optional[str] = typer.Option(
+        None,
+        "--token",
+        "-t",
+        "--api-key",
+        help="GitHub Personal Access Token or API key to store.",
+    ),
+) -> None:
+    """Configure and store GitHub Personal Access Token / API key."""
+    console = Console()
+    if not token:
+        token = typer.prompt("Enter your GitHub Personal Access Token", hide_input=True)
+
+    if token and token.strip():
+        saved_path = config.save_github_token(token.strip())
+        console.print(f"[green]✓ Token saved successfully to {saved_path}[/green]")
+    else:
+        console.print("[red]Error: Token cannot be empty.[/red]")
+        raise typer.Exit(code=1)
+
+
 def main() -> None:
     """CLI entry point function."""
     app()

gitrelevance-0.1.4/src/gitrelevance/config.py

@@ -0,0 +1,56 @@
+"""Configuration and environment loading."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".gitrelevance"
+TOKEN_FILE = CONFIG_DIR / "token"
+
+try:
+    from dotenv import load_dotenv  # type: ignore[import-not-found]
+
+    # Try loading .env if python-dotenv is installed
+    load_dotenv()
+except ImportError:
+    pass
+
+
+def load_github_token() -> str | None:
+    """Load GitHub Personal Access Token or API key.
+
+    Checks environment variables (GITHUB_TOKEN, GH_TOKEN, GITHUB_API_KEY)
+    and falls back to persistent token file (~/.gitrelevance/token).
+
+    Returns:
+        The token string if found, None otherwise.
+    """
+    for var in ("GITHUB_TOKEN", "GH_TOKEN", "GITHUB_API_KEY"):
+        token = os.getenv(var)
+        if token and token.strip():
+            return token.strip()
+
+    if TOKEN_FILE.is_file():
+        try:
+            content = TOKEN_FILE.read_text(encoding="utf-8").strip()
+            if content:
+                return content
+        except OSError:
+            pass
+
+    return None
+
+
+def save_github_token(token: str) -> Path:
+    """Save GitHub Personal Access Token or API key to user config directory.
+
+    Args:
+        token: The token/API key string to save.
+
+    Returns:
+        Path to the saved token file.
+    """
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    TOKEN_FILE.write_text(token.strip(), encoding="utf-8")
+    return TOKEN_FILE

{gitrelevance-0.1.2 → gitrelevance-0.1.4}/src/gitrelevance/git/files.py

@@ -46,6 +46,54 @@ class FileOperations:
         """Access the underlying GitPython repo object."""
         return self._repo._repo  # type: ignore[return-value]
 
+    def _get_head_files(self) -> set[str]:
+        """Get or compute cached set of all file paths present at HEAD."""
+        if not hasattr(self._repo, "_head_files_cache"):
+            head_files: set[str] = set()
+            try:
+                head_commit = self._git_repo.head.commit
+                for item in head_commit.tree.traverse():
+                    if item.type == "blob":
+                        head_files.add(item.path)
+            except Exception:
+                pass
+            setattr(self._repo, "_head_files_cache", head_files)
+        return getattr(self._repo, "_head_files_cache")
+
+    def _get_rename_index(self) -> dict[str, list[tuple[str, str]]]:
+        """Get or compute cached repository-wide rename index."""
+        if not hasattr(self._repo, "_rename_index_cache"):
+            rename_index: dict[str, list[tuple[str, str]]] = {}
+            all_renames: list[tuple[str, str]] = []
+            try:
+                output: str = self._git_repo.git.log(
+                    "-M",
+                    "--diff-filter=R",
+                    "--name-status",
+                    "--format=",
+                )
+                for line in output.splitlines():
+                    line = line.strip()
+                    if not line or not line.startswith("R"):
+                        continue
+                    parts = line.split("\t")
+                    if len(parts) >= 3:
+                        old, new = parts[1].strip(), parts[2].strip()
+                        all_renames.append((old, new))
+            except gitmodule.GitCommandError:
+                pass
+
+            # git log returns newest-first; reverse to get chronological order
+            all_renames.reverse()
+
+            for old, new in all_renames:
+                rename_index.setdefault(old, []).append((old, new))
+                if new != old:
+                    rename_index.setdefault(new, []).append((old, new))
+
+            setattr(self._repo, "_rename_index_cache", rename_index)
+        return getattr(self._repo, "_rename_index_cache")
+
     def file_exists_at_head(self, path: str) -> bool:
         """Check if a file exists at HEAD.
 
@@ -55,6 +103,9 @@ class FileOperations:
         Returns:
             True if the file exists at HEAD
         """
+        head_files = self._get_head_files()
+        if head_files:
+            return path in head_files
         try:
             self._git_repo.head.commit.tree[path]
             return True
@@ -111,6 +162,14 @@ class FileOperations:
         if self.file_exists_at_head(path):
             return False
 
+        deleted_cache = getattr(self._repo, "_was_deleted_cache", None)
+        if deleted_cache is None:
+            deleted_cache = {}
+            setattr(self._repo, "_was_deleted_cache", deleted_cache)
+
+        if path in deleted_cache:
+            return deleted_cache[path]
+
         # Check whether the path ever appeared in commit history
         try:
             output: str = self._git_repo.git.log(
@@ -122,6 +181,7 @@ class FileOperations:
             )
             # If git log --diff-filter=D finds anything, the file was deleted
             if output.strip():
+                deleted_cache[path] = True
                 return True
             # Also check if it was ever added at all (it might be renamed out)
             output2: str = self._git_repo.git.log(
@@ -131,8 +191,11 @@ class FileOperations:
                 "--",
                 path,
             )
-            return bool(output2.strip())
+            res = bool(output2.strip())
+            deleted_cache[path] = res
+            return res
         except Exception:
+            deleted_cache[path] = False
             return False
 
     def find_renames(self, path: str) -> list[tuple[str, str]]:
@@ -145,31 +208,8 @@ class FileOperations:
             List of (old_path, new_path) tuples showing the rename chain,
             in chronological order (oldest rename first).
         """
-        try:
-            # -M enables rename detection across repository commits
-            output: str = self._git_repo.git.log(
-                "-M",
-                "--diff-filter=R",
-                "--name-status",
-                "--format=",
-            )
-        except gitmodule.GitCommandError:
-            return []
-
-        renames: list[tuple[str, str]] = []
-        for line in output.splitlines():
-            line = line.strip()
-            if not line or not line.startswith("R"):
-                continue
-            parts = line.split("\t")
-            if len(parts) >= 3:
-                old, new = parts[1].strip(), parts[2].strip()
-                if path == old or path == new:
-                    renames.append((old, new))
-
-        # git log returns newest-first; reverse to get chronological order
-        renames.reverse()
-        return renames
+        index = self._get_rename_index()
+        return list(index.get(path, []))
 
 
 # Convenience function to get file operations for a repository

{gitrelevance-0.1.2 → gitrelevance-0.1.4}/src/gitrelevance/git/history.py

@@ -11,6 +11,7 @@ from gitrelevance.git.repository import GitRepository
 
 # Cache key for the commit reference index on GitRepository instances
 _INDEX_CACHE_KEY = "_gitrelevance_commit_reference_index"
+_REVERT_INDEX_CACHE_KEY = "_gitrelevance_revert_index"
 
 # ---------------------------------------------------------------------------
 # Issue-number extraction helpers (private)
@@ -22,6 +23,9 @@ _HASH_ISSUE_RE = re.compile(r"#(\d+)")
 # Matches GH-123-style references (unambiguous, never a PR number)
 _GH_ISSUE_RE = re.compile(r"GH-(\d+)", re.IGNORECASE)
 
+# Matches standard git revert trailer: "This reverts commit <sha>."
+_REVERT_TRAILER_RE = re.compile(r"This reverts commit ([0-9a-fA-F]{40})\.")
+
 # Detects PR-number contexts like "pull request #42" or "PR #42".
 # We check whether the 30 characters *before* the # match this pattern.
 _PR_CONTEXT_RE = re.compile(r"(?:pull\s+request|PR)\s+$", re.IGNORECASE)
@@ -89,6 +93,8 @@ def build_commit_reference_index(repo: GitRepository) -> dict[int, list[Commit]]
     ``pull request #42``, ``PR #42``) are explicitly excluded to prevent
     evidence cross-contamination.
 
+    Also populates the revert index mapping reverted SHAs to revert commits.
+
     Args:
         repo: The GitRepository to build the index for
 
@@ -99,8 +105,9 @@ def build_commit_reference_index(repo: GitRepository) -> dict[int, list[Commit]]
     if hasattr(repo, _INDEX_CACHE_KEY):
         return getattr(repo, _INDEX_CACHE_KEY)
 
-    # Build the index by walking commits once
+    # Build the indices by walking commits once
     index: dict[int, list[Commit]] = {}
+    revert_index: dict[str, list[Commit]] = {}
 
     for commit in repo.commits_since(None):
         issue_nums = _extract_issue_numbers(commit.message)
@@ -109,8 +116,15 @@ def build_commit_reference_index(repo: GitRepository) -> dict[int, list[Commit]]
                 index[num] = []
             index[num].append(commit)
 
-    # Cache the index on the repo instance
+        for match in _REVERT_TRAILER_RE.finditer(commit.message):
+            reverted_sha = match.group(1)
+            if reverted_sha not in revert_index:
+                revert_index[reverted_sha] = []
+            revert_index[reverted_sha].append(commit)
+
+    # Cache the indices on the repo instance
     setattr(repo, _INDEX_CACHE_KEY, index)
+    setattr(repo, _REVERT_INDEX_CACHE_KEY, revert_index)
 
     return index
 
@@ -186,15 +200,12 @@ class GitNativeRevertDetector:
             return []
         full_sha = target_commit.sha
 
-        reverts: list[Commit] = []
-        for commit in repo.commits_since(None):
-            # Look for the exact Git-generated trailer line.
-            # git revert writes: "This reverts commit <sha>."
-            # where <sha> is the full 40-character hex SHA.
-            if f"This reverts commit {full_sha}." in commit.message:
-                reverts.append(commit)
+        revert_index = getattr(repo, _REVERT_INDEX_CACHE_KEY, None)
+        if revert_index is None:
+            build_commit_reference_index(repo)
+            revert_index = getattr(repo, _REVERT_INDEX_CACHE_KEY, {})
 
-        return reverts
+        return list(revert_index.get(full_sha, []))
 
 
 # Default detector instance (module-level singleton)

{gitrelevance-0.1.2 → gitrelevance-0.1.4}/src/gitrelevance/git/repository.py

@@ -47,6 +47,7 @@ class GitRepository:
         try:
             self._repo = git.Repo(path, search_parent_directories=True)
             self.path = str(self._repo.working_dir)
+            self._ancestor_cache: dict[tuple[str, str], bool] = {}
         except (InvalidGitRepositoryError, NoSuchPathError, git.exc.GitError) as e:
             raise NotAGitRepositoryError(path) from e
 
@@ -133,12 +134,22 @@ class GitRepository:
         Raises:
             git.GitCommandError: If either commit doesn't exist
         """
+        cache = getattr(self, "_ancestor_cache", None)
+        if cache is not None:
+            cached = cache.get((ancestor_sha, descendant_sha))
+            if cached is not None:
+                return cached
+
         # Use git merge-base --is-ancestor which returns 0 if true, 1 if false
         try:
             self._repo.git.merge_base("--is-ancestor", ancestor_sha, descendant_sha)
-            return True  # git command succeeded, so it is an ancestor
+            res = True  # git command succeeded, so it is an ancestor
         except git.GitCommandError:
-            return False  # exit code 1 means not an ancestor
+            res = False  # exit code 1 means not an ancestor
+
+        if cache is not None:
+            cache[(ancestor_sha, descendant_sha)] = res
+        return res
 
     def commits_since(self, since: datetime | None = None) -> Iterator[Commit]:
         """Get commits since a given datetime.

{gitrelevance-0.1.2 → gitrelevance-0.1.4}/tests/cli/test_commands.py

@@ -160,5 +160,35 @@ def test_cli_since_filter() -> None:
         data = json.loads(result.output)
         assert data["total_issues"] == 1
         assert data["results"][0]["issue"]["number"] == 2
+    finally:
+        builder.cleanup()
+
+
+def test_cli_token_option_and_auth_command(tmp_path, monkeypatch) -> None:
+    """--token flag and auth command work properly."""
+    # Test auth command
+    custom_token_file = tmp_path / "token"
+    monkeypatch.setattr("gitrelevance.config.TOKEN_FILE", custom_token_file)
+    monkeypatch.setattr("gitrelevance.config.CONFIG_DIR", tmp_path)
+
+    result = runner.invoke(app, ["auth", "--token", "ghp_mock_token_12345"])
+    assert result.exit_code == 0
+    assert "Token saved successfully" in result.output
+    assert custom_token_file.read_text(encoding="utf-8").strip() == "ghp_mock_token_12345"
+
+    # Test analyze with --token
+    builder = (
+        RepoBuilder()
+        .commit("Initial commit", files={"README.md": "readme"})
+        .add_remote("origin", "https://github.com/testowner/testrepo.git")
+    )
+    path = builder.build()
+    try:
+        issue = make_issue(number=1, title="Test", state="closed")
+        fake_provider = FakeCLIProvider(issues=[issue])
+        set_provider_override(fake_provider)
+
+        res = runner.invoke(app, ["analyze", "--path", path, "--token", "ghp_custom_token", "--json"])
+        assert res.exit_code == 0
     finally:
         builder.cleanup()

gitrelevance-0.1.2/src/gitrelevance/config.py

@@ -1,27 +0,0 @@
-"""Configuration and environment loading."""
-
-from __future__ import annotations
-
-import os
-
-try:
-    from dotenv import load_dotenv  # type: ignore[import-not-found]
-
-    # Try loading .env if python-dotenv is installed
-    load_dotenv()
-except ImportError:
-    pass
-
-
-def load_github_token() -> str | None:
-    """Load GitHub Personal Access Token from environment.
-
-    Reads GITHUB_TOKEN environment variable. Returns None if not set.
-
-    Returns:
-        The token string if set in environment, None otherwise.
-    """
-    token = os.getenv("GITHUB_TOKEN")
-    if not token or not token.strip():
-        return None
-    return token.strip()