diffstory 0.4.0__tar.gz → 0.4.2__tar.gz

{diffstory-0.4.0 → diffstory-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffstory
-Version: 0.4.0
+Version: 0.4.2
 Summary: Transform Git diffs into rich, interactive, self-contained HTML reports
 License: MIT
 Project-URL: Homepage, https://github.com/lakshayjindal/diffstory

{diffstory-0.4.0 → diffstory-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "diffstory"
-version = "0.4.0"
+version = "0.4.2"
 description = "Transform Git diffs into rich, interactive, self-contained HTML reports"
 readme = "README.md"
 license = {text = "MIT"}

{diffstory-0.4.0 → diffstory-0.4.2}/src/diffstory/__init__.py

@@ -1,3 +1,3 @@
 """DiffStory — Transform Git diffs into rich, interactive HTML reports."""
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"

{diffstory-0.4.0 → diffstory-0.4.2}/src/diffstory/cli.py

@@ -13,11 +13,11 @@ from diffstory.diff_parser import parse_diff
 from diffstory.git_utils import (
     GitError,
     check_git_repo,
-    get_diff,
     get_diff_with_renames,
     get_git_root,
 )
 from diffstory.html_generator import generate_report
+from diffstory.loader import Spinner
 
 
 # ---------------------------------------------------------------------------
@@ -389,67 +389,65 @@ def main() -> None:
     # Parse revisions
     commit_a, commit_b, paths = _parse_revisions(args)
 
-    if verbose:
-        rev_desc = "staged" if args.staged else "working tree"
-        if commit_a and commit_b:
-            rev_desc = f"{commit_a}..{commit_b}"
-        elif commit_a:
-            rev_desc = commit_a
-        print(f"  Diff: {rev_desc}")
+    with Spinner() as spinner:
+        spinner.update("Fetching diff...")
+        try:
+            diff_text = get_diff_with_renames(
+                staged=args.staged,
+                commit_a=commit_a,
+                commit_b=commit_b,
+                paths=paths,
+            )
+        except GitError as e:
+            spinner.fail(f"Error fetching diff: {e}")
+            sys.exit(1)
 
-    try:
-        # Get diff
-        diff_text = get_diff_with_renames(
-            staged=args.staged,
-            commit_a=commit_a,
-            commit_b=commit_b,
-            paths=paths,
-        )
-    except GitError as e:
-        print(f"Error fetching diff: {e}", file=sys.stderr)
-        sys.exit(1)
+        if not diff_text.strip():
+            spinner.fail("No changes detected")
+            sys.exit(0)
 
-    if not diff_text.strip():
-        print("No changes detected.")
-        sys.exit(0)
+        spinner.update("Parsing diff...")
+        files = parse_diff(diff_text)
 
-    if verbose:
-        print(f"  Diff size: {len(diff_text)} bytes")
+        if not files:
+            spinner.fail("No parseable diff files found")
+            sys.exit(0)
 
-    # Parse diff
-    files = parse_diff(diff_text)
+        # Generate exports if requested
+        has_exports = args.json or args.md or args.csv
+        if has_exports:
+            generate_exports(files, output_path, args.json, args.md, args.csv)
 
-    if not files:
-        print("No parseable diff files found.")
-        sys.exit(0)
+        # Progress callback for per-file blame tracking
+        total_files = len(files)
 
-    if verbose:
-        print(f"  Files changed: {len(files)}")
+        def on_blame_progress(current, total, filepath):
+            spinner.update(
+                f"Blamed {current}/{total} files",
+                suffix=Path(filepath).name,
+            )
 
-    # Generate exports if requested
-    has_exports = args.json or args.md or args.csv
-    if has_exports:
-        generate_exports(files, output_path, args.json, args.md, args.csv)
+        spinner.update(f"Blaming {total_files} files...")
 
-    # Always generate HTML report
-    try:
-        report_path = generate_report(
-            files,
-            output_path=output_path,
-            staged=args.staged,
-            commit_a=commit_a,
-            commit_b=commit_b,
-            verbose=verbose,
-        )
-    except Exception as e:
-        if debug:
-            import traceback
-            traceback.print_exc()
-        print(f"Error generating report: {e}", file=sys.stderr)
-        sys.exit(1)
+        # Always generate HTML report
+        try:
+            report_path = generate_report(
+                files,
+                output_path=output_path,
+                staged=args.staged,
+                commit_a=commit_a,
+                commit_b=commit_b,
+                verbose=verbose,
+                progress_callback=on_blame_progress if total_files > 1 else None,
+            )
+        except Exception as e:
+            if debug:
+                import traceback
+                traceback.print_exc()
+            spinner.fail(f"Error generating report: {e}")
+            sys.exit(1)
 
-    print(f"\\n  HTML: {report_path}")
-    print("  Report generated successfully!")
+        spinner.succeed(f"Report saved to {Path(report_path).name}")
 
     # Open in browser unless --no-open
     if not args.no_open:

{diffstory-0.4.0 → diffstory-0.4.2}/src/diffstory/diff_parser.py

@@ -199,13 +199,25 @@ def parse_diff(diff_text: str) -> list[DiffFile]:
 
 
 def _parse_diff_header(line: str) -> DiffFile:
-    """Parse 'diff --git a/path b/path' header."""
+    """Parse 'diff --git a/path b/path' header.
+
+    Git uses 'dev/null' (no leading slash) in the diff --git header
+    for added/deleted files. We normalize this to '/dev/null' to
+    match the convention used in ---/+++ lines and throughout the
+    rest of the codebase.
+    """
     # Extract paths after 'diff --git '
     rest = line[11:]
     parts = rest.split(" b/", 1)
     if len(parts) == 2:
         old_path = parts[0][2:] if parts[0].startswith("a/") else parts[0]
         new_path = parts[1]
+        # Git uses 'dev/null' (no leading slash) in the diff --git header.
+        # Normalize to '/dev/null' for consistency with our checks.
+        if old_path == "dev/null":
+            old_path = "/dev/null"
+        if new_path == "dev/null":
+            new_path = "/dev/null"
     else:
         old_path = rest
         new_path = rest

{diffstory-0.4.0 → diffstory-0.4.2}/src/diffstory/git_utils.py

@@ -12,14 +12,54 @@ class GitError(Exception):
     """Raised when a git command fails."""
 
 
+# Cache the git repo root once discovered to avoid repeated rev-parse calls.
+# This is safe because the cwd doesn't change during a single diffstory run.
+_GIT_ROOT_CACHE: Optional[str] = None
+
+
+def _get_repo_root(cwd: Path) -> Optional[str]:
+    """Detect and cache the git repository root directory.
+
+    Returns None if cwd is not inside a git repository.
+    """
+    global _GIT_ROOT_CACHE
+    if _GIT_ROOT_CACHE is not None:
+        return _GIT_ROOT_CACHE
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        _GIT_ROOT_CACHE = result.stdout.strip()
+        return _GIT_ROOT_CACHE
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+
 def _run_git(args: list[str], cwd: Optional[Path] = None) -> str:
     """Run a git command and return stdout.
 
+    Automatically resolves cwd to the git repository root so that all
+    git commands execute from the top-level directory. This is critical
+    because paths from git diff are always repo-relative, but git blame,
+    git log, etc. resolve paths relative to the current working directory.
+    Without this, running diffstory from a subdirectory would cause
+    "fatal: cannot stat path 'src/foo.py'" errors.
+
     Raises GitError on non-zero exit.
     """
     if cwd is None:
         cwd = Path.cwd()
 
+    # Resolve to repo root so that repo-relative paths (from diff output)
+    # work correctly with all git commands (blame, log, diff, etc.)
+    repo_root = _get_repo_root(cwd)
+    if repo_root is not None:
+        cwd = Path(repo_root)
+
     try:
         result = subprocess.run(
             ["git"] + args,

{diffstory-0.4.0 → diffstory-0.4.2}/src/diffstory/html_generator.py

@@ -174,8 +174,8 @@ def _render_sidebyside_hunk(hunk: Hunk, filepath: str, lexer_cache: dict) -> str
 
         rows += (
             '<div class="sbs-row">'
-            '<div class="sbs-left ' + left_class + '">' + left_content + '</div>'
-            '<div class="sbs-right ' + right_class + '">' + right_content + '</div>'
+            '<div class="sbs-left ' + left_class + ' diff-line" data-old="' + (str(left.old_lineno) if left and left.old_lineno else '') + '" data-new="' + (str(left.new_lineno) if left and left.new_lineno else '') + '">' + left_content + '</div>'
+            '<div class="sbs-right ' + right_class + ' diff-line" data-old="' + (str(right.old_lineno) if right and right.old_lineno else '') + '" data-new="' + (str(right.new_lineno) if right and right.new_lineno else '') + '">' + right_content + '</div>'
             '</div>\n'
         )
 
@@ -357,6 +357,7 @@ def _collect_blame_data(
     commit_a: Optional[str] = None,
     commit_b: Optional[str] = None,
     verbose: bool = False,
+    progress_callback: Optional[callable] = None,
 ) -> dict:
     """Collect blame and commit metadata for all changed lines.
 
@@ -391,6 +392,10 @@ def _collect_blame_data(
             old_revision = commit_a
         elif staged:
             old_revision = "HEAD"
+        elif not commit_a and not commit_b:
+            # Working tree diff: blame deletions against HEAD so that
+            # old_lineno lookups correctly reference the committed version
+            old_revision = "HEAD"
 
         # File exists — attempt blame. For working tree (all None), get_blame
         # runs on the working tree. For --diff mode (no git repo), the per-file
@@ -465,6 +470,10 @@ def _collect_blame_data(
         if verbose:
             print(f"      Mapped {mapped_count} lines to blame data")
 
+        # Report progress after each file
+        if progress_callback is not None:
+            progress_callback(fi + 1, len(files), file.display_path)
+
     # Collect commit metadata for all unique commits
     commits: dict = {}
     if blame_attempted and all_commits:
@@ -522,6 +531,7 @@ def generate_report(
     commit_a: Optional[str] = None,
     commit_b: Optional[str] = None,
     verbose: bool = False,
+    progress_callback: Optional[callable] = None,
 ) -> str:
     """Generate a self-contained HTML report.
 
@@ -545,6 +555,7 @@ def generate_report(
     try:
         blame_data_dict = _collect_blame_data(
             files, staged=staged, commit_a=commit_a, commit_b=commit_b, verbose=verbose,
+            progress_callback=progress_callback,
         )
     except Exception as e:
         if verbose:

diffstory-0.4.2/src/diffstory/loader.py

@@ -0,0 +1,98 @@
+"""
+Animated CLI spinner with step tracking and elapsed time.
+
+Shows a spinning animation with a status message and elapsed time,
+then resolves to a ✓ or ✗ on completion.
+
+Usage:
+    spinner = Spinner()
+    spinner.start("Fetching diff...")
+    # ... do work ...
+    spinner.succeed("Diff fetched")      # ✓ Diff fetched (0.5s)
+
+Or as a context manager:
+    with Spinner("Fetching diff...") as s:
+        s.update("Blamed 3/5 files...")
+"""
+
+from __future__ import annotations
+
+import sys
+import threading
+import time
+
+
+class Spinner:
+    """An animated CLI spinner with status updates and elapsed time."""
+
+    # Braille dot-dash spinner frames
+    _FRAMES = ("⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷")
+
+    def __init__(self, message: str = ""):
+        self._message = message
+        self._running = False
+        self._thread: threading.Thread | None = None
+        self._start: float = 0.0
+        self._suffix: str = ""
+
+    # ── public API ──────────────────────────────────────────────
+
+    def start(self, message: str = "") -> None:
+        """Start the spinner with an optional initial message."""
+        if message:
+            self._message = message
+        self._running = True
+        self._start = time.monotonic()
+        self._thread = threading.Thread(target=self._spin, daemon=True)
+        self._thread.start()
+
+    def update(self, message: str, suffix: str = "") -> None:
+        """Change the status message shown next to the spinner."""
+        self._message = message
+        if suffix:
+            self._suffix = suffix
+
+    def succeed(self, message: str | None = None) -> None:
+        """Stop the spinner and show a green-ish checkmark."""
+        self._stop("✓", message or self._message)
+
+    def fail(self, message: str | None = None) -> None:
+        """Stop the spinner and show a red-ish cross."""
+        self._stop("✗", message or self._message)
+
+    # ── context manager ─────────────────────────────────────────
+
+    def __enter__(self) -> "Spinner":
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        if exc_type is None:
+            self.succeed()
+        else:
+            self.fail()
+
+    # ── internals ───────────────────────────────────────────────
+
+    def _spin(self) -> None:
+        idx = 0
+        while self._running:
+            elapsed = time.monotonic() - self._start
+            frame = self._FRAMES[idx % len(self._FRAMES)]
+            extra = f" {self._suffix}" if self._suffix else ""
+            # \033[K clears to end of line so we overwrite cleanly
+            sys.stdout.write(f"\r\033[K{frame} {self._message}{extra}  ")
+            sys.stdout.flush()
+            idx += 1
+            time.sleep(0.08)
+
+    def _stop(self, icon: str, message: str) -> None:
+        # Idempotent — safe to call multiple times (e.g. explicit fail + __exit__)
+        if not self._running:
+            return
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=0.3)
+        elapsed = time.monotonic() - self._start
+        sys.stdout.write(f"\r\033[K{icon} {message}  ({elapsed:.1f}s)\n")
+        sys.stdout.flush()

{diffstory-0.4.0 → diffstory-0.4.2}/src/diffstory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffstory
-Version: 0.4.0
+Version: 0.4.2
 Summary: Transform Git diffs into rich, interactive, self-contained HTML reports
 License: MIT
 Project-URL: Homepage, https://github.com/lakshayjindal/diffstory

{diffstory-0.4.0 → diffstory-0.4.2}/src/diffstory.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/diffstory/cli.py
 src/diffstory/diff_parser.py
 src/diffstory/git_utils.py
 src/diffstory/html_generator.py
+src/diffstory/loader.py
 src/diffstory/syntax.py
 src/diffstory.egg-info/PKG-INFO
 src/diffstory.egg-info/SOURCES.txt