diffstory 0.3.0__tar.gz → 0.4.0__tar.gz

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

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

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

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

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

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

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

@@ -243,6 +243,9 @@ def get_commit_info(commit_hash: str, cwd: Optional[Path] = None) -> dict:
     Returns dict with: hash, author, author_email, author_date,
     committer, committer_email, committer_date, subject, body,
     parents, files_changed, insertions, deletions.
+
+    Handles root commits (no parent), merge commits, and
+    the all-zero hash (uncommitted/staged changes).
     """
     # Handle all-zero hash (uncommitted/staged changes)
     if all(c == "0" for c in commit_hash):
@@ -278,16 +281,49 @@ def get_commit_info(commit_hash: str, cwd: Optional[Path] = None) -> dict:
     if len(parts) < 9:
         return {"hash": commit_hash, "subject": "unknown"}
 
+    parents_list = parts[7].split() if parts[7] else []
+
     # Count files changed, insertions, deletions (skip for all-zero/uncommitted)
     files_changed = 0
     insertions = 0
     deletions = 0
     if not all(c == "0" for c in commit_hash):
         try:
-            stat_output = _run_git(
-                ["diff", "--stat", f"{commit_hash}~1..{commit_hash}", "--"],
-                cwd=cwd,
-            )
+            if parents_list:
+                # Has parents — use diff with first parent
+                parent_ref = parents_list[0]
+                stat_output = _run_git(
+                    ["diff", "--stat", f"{parent_ref}..{commit_hash}", "--"],
+                    cwd=cwd,
+                )
+            else:
+                # Root commit — count files via log --name-status
+                stat_output = _run_git(
+                    ["log", "-1", "--format=", "--name-status", commit_hash],
+                    cwd=cwd,
+                )
+                # Parse added files from root commit
+                for line in stat_output.strip().splitlines():
+                    if line.strip():
+                        files_changed += 1
+                        if line.startswith("A"):
+                            insertions += 1  # approximate
+                return {
+                    "hash": parts[0],
+                    "author": parts[1],
+                    "author_email": parts[2],
+                    "author_date": parts[3],
+                    "committer": parts[4],
+                    "committer_email": parts[5],
+                    "committer_date": parts[6],
+                    "parents": parents_list,
+                    "subject": parts[8],
+                    "body": body.strip(),
+                    "files_changed": files_changed,
+                    "insertions": insertions,
+                    "deletions": deletions,
+                }
+
             stat_lines = stat_output.strip().split("\n") if stat_output.strip() else []
             for line in stat_lines:
                 m = re.search(r"(\d+) file[s]? changed", line)
@@ -310,7 +346,7 @@ def get_commit_info(commit_hash: str, cwd: Optional[Path] = None) -> dict:
         "committer": parts[4],
         "committer_email": parts[5],
         "committer_date": parts[6],
-        "parents": parts[7].split() if parts[7] else [],
+        "parents": parents_list,
         "subject": parts[8],
         "body": body.strip(),
         "files_changed": files_changed,

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

@@ -356,6 +356,7 @@ def _collect_blame_data(
     staged: bool = False,
     commit_a: Optional[str] = None,
     commit_b: Optional[str] = None,
+    verbose: bool = False,
 ) -> dict:
     """Collect blame and commit metadata for all changed lines.
 
@@ -364,15 +365,12 @@ def _collect_blame_data(
       - commits: dict mapping commit_hash to commit metadata
 
     Handles renamed files by using the old path for deletion blame
-    and the new path for addition/context blame. Skips blame when
-    no revision info is available (e.g. --diff mode).
+    and the new path for addition/context blame. Falls back to
+    blaming the working tree when no revision info is available.
     """
-    # If no commit info at all, skip blame entirely (e.g. --diff mode)
-    if not staged and commit_a is None and commit_b is None:
-        return {"line_blame": {}, "commits": {}}
-
     line_blame: dict = {}
     all_commits: set = set()
+    blame_attempted = False
 
     for fi, file in enumerate(files):
         new_filepath = file.display_path
@@ -394,55 +392,100 @@ def _collect_blame_data(
         elif staged:
             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
+        # try/except catches the GitError gracefully.
+        blame_attempted = True
+
+        if verbose:
+            new_rev_str = str(new_revision) if new_revision else "working tree"
+            old_rev_str = str(old_revision) if old_revision else "working tree"
+            print(f"    Blaming {file.display_path} (new: {new_rev_str}, old: {old_rev_str})...")
+
         # Get blame for current (new) version — skip if file doesn't exist at revision
         blame_new: dict = {}
+        new_blame_ok = False
         if new_filepath != "/dev/null":
             try:
                 blame_new = get_blame_for_revision(new_filepath, revision=new_revision)
-            except Exception:
-                pass
-
-        # Get blame for old version if different from new (e.g. renames)
+                new_blame_ok = True
+                if verbose:
+                    print(f"      Got {len(blame_new)} blame entries for new version")
+            except Exception as e:
+                if verbose:
+                    print(f"      Warning: could not get blame for {new_filepath} at {new_revision}: {e}")
+
+        # Get blame for old version if different from new (e.g. renames, different revision)
         blame_old: dict = blame_new
+        old_blame_ok = new_blame_ok
         if old_revision and old_filepath != new_filepath:
             try:
                 blame_old = get_blame_for_revision(old_filepath, revision=old_revision)
-            except Exception:
+                old_blame_ok = True
+                if verbose:
+                    print(f"      Got {len(blame_old)} blame entries for old version (renamed path)")
+            except Exception as e:
                 blame_old = {}
+                old_blame_ok = False
+                if verbose:
+                    print(f"      Warning: could not get blame for {old_filepath} at {old_revision}: {e}")
         elif old_revision and old_filepath == new_filepath and old_revision != new_revision:
             # Same path but different revision — re-blame
             try:
                 blame_old = get_blame_for_revision(old_filepath, revision=old_revision)
-            except Exception:
-                pass
+                old_blame_ok = True
+                if verbose:
+                    print(f"      Got {len(blame_old)} blame entries for old version (different revision)")
+            except Exception as e:
+                old_blame_ok = new_blame_ok
+                if verbose:
+                    print(f"      Warning: could not get blame for {old_filepath} at {old_revision}: {e}")
 
         # Map blame by line number for additions and context
+        mapped_count = 0
         for hunk in file.hunks:
             for line in hunk.lines:
                 if line.line_type in ("addition", "context") and line.new_lineno:
-                    entry = blame_new.get(line.new_lineno)
+                    entry = blame_new.get(line.new_lineno) if new_blame_ok else None
                     if entry:
                         key = str(fi) + ":" + str(line.new_lineno)
                         line_blame[key] = entry
                         all_commits.add(entry["commit"])
+                        mapped_count += 1
 
                 elif line.line_type == "deletion" and line.old_lineno:
-                    if blame_old:
+                    if old_blame_ok:
                         entry = blame_old.get(line.old_lineno)
                         if entry:
                             key = str(fi) + ":" + str(line.old_lineno)
                             line_blame[key] = entry
                             all_commits.add(entry["commit"])
+                            mapped_count += 1
+
+        if verbose:
+            print(f"      Mapped {mapped_count} lines to blame data")
 
     # Collect commit metadata for all unique commits
     commits: dict = {}
-    for chash in all_commits:
-        if chash and len(chash) == 40:
-            try:
-                info = get_commit_info(chash)
-                commits[chash] = info
-            except Exception:
-                pass
+    if blame_attempted and all_commits:
+        if verbose:
+            print(f"  Collecting metadata for {len(all_commits)} unique commits...")
+        for chash in all_commits:
+            if chash and len(chash) == 40:
+                try:
+                    info = get_commit_info(chash)
+                    commits[chash] = info
+                except Exception as e:
+                    if verbose:
+                        print(f"    Warning: could not get commit info for {chash[:8]}: {e}")
+
+    # Warn if blame was attempted but produced no data at all
+    if blame_attempted and not line_blame:
+        import sys as _sys
+        _sys.stderr.write(
+            "Warning: git blame could not collect data for any files. "
+            "Try --verbose for details.\n"
+        )
 
     return {
         "line_blame": line_blame,
@@ -500,10 +543,19 @@ def generate_report(
 
     # Collect blame data
     try:
-        blame_data_dict = _collect_blame_data(files, staged=staged, commit_a=commit_a, commit_b=commit_b)
-    except Exception:
+        blame_data_dict = _collect_blame_data(
+            files, staged=staged, commit_a=commit_a, commit_b=commit_b, verbose=verbose,
+        )
+    except Exception as e:
+        if verbose:
+            print(f"  Warning: blame collection failed: {e}")
         blame_data_dict = {"line_blame": {}, "commits": {}}
 
+    blame_line_count = len(blame_data_dict["line_blame"])
+    blame_commit_count = len(blame_data_dict["commits"])
+    if verbose:
+        print(f"  Blame data: {blame_line_count} lines mapped, {blame_commit_count} commits")
+
     stats = _compute_stats(files, blame_data=blame_data_dict["line_blame"], commits_data=blame_data_dict["commits"])
 
     # Collect search data

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

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