nit-cli 0.3.0__tar.gz → 0.4.1__tar.gz

{nit_cli-0.3.0/src/nit_cli.egg-info → nit_cli-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nit-cli
-Version: 0.3.0
+Version: 0.4.1
 Summary: Terminal diff viewer with inline review comments
 Author: Joshua Zink-Duda
 License-Expression: GPL-3.0-only
@@ -33,6 +33,12 @@ Navigate diffs with vim-style keybindings, leave comments on specific lines, and
 
 ## Install
 
+```bash
+brew install joshuazd/tap/nit
+```
+
+Or via pip/pipx:
+
 ```bash
 pipx install nit-cli
 ```
@@ -60,11 +66,20 @@ nit --mode all
 nit HEAD~3..HEAD
 nit main..feature
 
+# Review any file (read-only, no git required)
+nit path/to/file.py
+
 # Filter to specific files or directories
 nit --path src/
 nit --path src/nit/app.py main..feature
+
+# Export comments on quit
+nit --export-comments comments.md
+nit --export-comments - --export-format json  # stdout as JSON
 ```
 
+On main/master, nit defaults to unstaged mode. On feature branches, it defaults to branch diff. The diff auto-refreshes every 5 seconds.
+
 ## Keybindings
 
 | Key | Action |
@@ -73,12 +88,27 @@ nit --path src/nit/app.py main..feature
 | `J` / `K` | Jump to next / previous hunk |
 | `n` / `p` | Next / previous file |
 | `]` / `[` | Jump to next / previous comment |
+| `gg` / `G` | Jump to top / bottom |
 | `c` | Add comment on current line |
 | `d` | Delete comment on current line |
-| `m` | Cycle diff mode (branch / unstaged / all) |
+| `e` | Export comments to clipboard |
+| `m` | Cycle diff mode (branch / unstaged / staged / all) |
+| `s` | Toggle side-by-side diff view |
+| `w` | Toggle word-level diff highlighting |
+| `W` | Toggle hide whitespace-only changes |
+| `h` | Toggle syntax highlighting |
 | `r` | Refresh diff |
 | `q` | Quit |
 
+### Git operations (g-prefixed)
+
+| Key | Action |
+|-----|--------|
+| `ga` | Stage hunk under cursor |
+| `gu` | Unstage hunk (staged mode) |
+| `gx` | Discard hunk |
+| `gc` | Commit with message prompt |
+
 ## Comment Storage
 
 Comments are saved to `.nit.json` at the root of your git repository. The format is structured JSON:

{nit_cli-0.3.0 → nit_cli-0.4.1}/README.md

@@ -6,6 +6,12 @@ Navigate diffs with vim-style keybindings, leave comments on specific lines, and
 
 ## Install
 
+```bash
+brew install joshuazd/tap/nit
+```
+
+Or via pip/pipx:
+
 ```bash
 pipx install nit-cli
 ```
@@ -33,11 +39,20 @@ nit --mode all
 nit HEAD~3..HEAD
 nit main..feature
 
+# Review any file (read-only, no git required)
+nit path/to/file.py
+
 # Filter to specific files or directories
 nit --path src/
 nit --path src/nit/app.py main..feature
+
+# Export comments on quit
+nit --export-comments comments.md
+nit --export-comments - --export-format json  # stdout as JSON
 ```
 
+On main/master, nit defaults to unstaged mode. On feature branches, it defaults to branch diff. The diff auto-refreshes every 5 seconds.
+
 ## Keybindings
 
 | Key | Action |
@@ -46,12 +61,27 @@ nit --path src/nit/app.py main..feature
 | `J` / `K` | Jump to next / previous hunk |
 | `n` / `p` | Next / previous file |
 | `]` / `[` | Jump to next / previous comment |
+| `gg` / `G` | Jump to top / bottom |
 | `c` | Add comment on current line |
 | `d` | Delete comment on current line |
-| `m` | Cycle diff mode (branch / unstaged / all) |
+| `e` | Export comments to clipboard |
+| `m` | Cycle diff mode (branch / unstaged / staged / all) |
+| `s` | Toggle side-by-side diff view |
+| `w` | Toggle word-level diff highlighting |
+| `W` | Toggle hide whitespace-only changes |
+| `h` | Toggle syntax highlighting |
 | `r` | Refresh diff |
 | `q` | Quit |
 
+### Git operations (g-prefixed)
+
+| Key | Action |
+|-----|--------|
+| `ga` | Stage hunk under cursor |
+| `gu` | Unstage hunk (staged mode) |
+| `gx` | Discard hunk |
+| `gc` | Commit with message prompt |
+
 ## Comment Storage
 
 Comments are saved to `.nit.json` at the root of your git repository. The format is structured JSON:

{nit_cli-0.3.0 → nit_cli-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nit-cli"
-version = "0.3.0"
+version = "0.4.1"
 description = "Terminal diff viewer with inline review comments"
 readme = "README.md"
 license = "GPL-3.0-only"

{nit_cli-0.3.0 → nit_cli-0.4.1}/src/nit/app.py

@@ -2,8 +2,10 @@ from __future__ import annotations
 
 import logging
 import os
+import shutil
 import subprocess
 from collections import Counter
+from pathlib import Path
 
 from rich.style import Style
 from rich.text import Text
@@ -18,9 +20,10 @@ from textual.widgets._tree import TreeNode
 from . import comments as comments_mod
 from . import git
 from .cli import CLIArgs
-from .diff_parser import align_hunk_lines, build_patch, parse_diff, word_diff_segments
+from .diff_parser import align_hunk_lines, build_patch, file_to_diff, parse_diff, word_diff_segments
 from .models import DiffHunk, FileDiff, ReviewComment, SideBySideRow
 from .models import DiffLine as DiffLineModel
+from .syntax import detect_language, highlight_line
 
 logger = logging.getLogger(__name__)
 
@@ -214,6 +217,7 @@ class DiffView(VerticalScroll):
     cursor_index: reactive[int] = reactive(0)
     side_by_side: reactive[bool] = reactive(False)
     word_diff: reactive[bool] = reactive(False)
+    syntax_highlight: reactive[bool] = reactive(False)
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
@@ -295,6 +299,8 @@ class DiffView(VerticalScroll):
                 else:
                     i += 1
 
+        lang = detect_language(file_diff.path) if self.syntax_highlight else None
+
         flat_idx = 0
         for hunk in file_diff.hunks:
             for dl in hunk.lines:
@@ -307,11 +313,22 @@ class DiffView(VerticalScroll):
                     text = self._format_word_diff_line(
                         dl, word_pairs[flat_idx], line_no_str, prefix
                     )
+                elif lang and dl.line_type == "context":
+                    text = self._format_syntax_line(dl, line_no_str, prefix, lang)
+                elif lang and dl.line_type in ("add", "remove"):
+                    style = "reverse green" if dl.line_type == "add" else "reverse red"
+                    text = Text(f"{line_no_str}{prefix}{dl.content}", style=style)
                 else:
-                    text = f"{line_no_str}{prefix}{dl.content}"
+                    text = Text()
+                    if dl.line_type == "context":
+                        text.append(line_no_str, style="dim")
+                    else:
+                        text.append(line_no_str)
+                    text.append(f"{prefix}{dl.content}")
 
                 w = DiffLineWidget(text)
-                w.add_class(dl.line_type.replace("_", "-"))
+                if not (lang and dl.line_type in ("add", "remove", "context")):
+                    w.add_class(dl.line_type.replace("_", "-"))
                 self._line_widgets.append(w)
                 self.mount(w)
 
@@ -330,6 +347,7 @@ class DiffView(VerticalScroll):
         comment_map: dict[int | None, list[ReviewComment]],
     ) -> None:
         half = max(40, (self.size.width - 15) // 2)  # each side's content width
+        lang = detect_language(file_diff.path) if self.syntax_highlight else None
 
         for hunk in file_diff.hunks:
             rows = align_hunk_lines(hunk.lines)
@@ -343,7 +361,7 @@ class DiffView(VerticalScroll):
                 self.diff_lines.append(primary)
 
                 # Build Rich Text for the row
-                text = self._format_sbs_row(row, half)
+                text = self._format_sbs_row(row, half, lang if row.row_type == "context" else None)
                 w = DiffLineWidget(text)
 
                 w.add_class("sbs")
@@ -351,7 +369,6 @@ class DiffView(VerticalScroll):
                     w.add_class("hunk-header")
                 elif row.row_type == "context":
                     w.add_class("context")
-                # For change rows, coloring is in the Rich Text itself
 
                 self._line_widgets.append(w)
                 self.mount(w)
@@ -365,7 +382,7 @@ class DiffView(VerticalScroll):
                         block = CommentBlock(f"-- {c.comment}")
                         self.mount(block)
 
-    def _format_sbs_row(self, row: SideBySideRow, half: int) -> Text:
+    def _format_sbs_row(self, row: SideBySideRow, half: int, language: str | None = None) -> Text:
         """Format a side-by-side row as Rich Text with per-side coloring."""
         if row.row_type == "hunk_header":
             left = row.left
@@ -400,6 +417,10 @@ class DiffView(VerticalScroll):
                     if left_len >= half:
                         break
                 text.append(" " * max(0, half - left_len))
+            elif language:
+                highlighted = highlight_line(row.left.content[:half], language)
+                text.append_text(highlighted)
+                text.append(" " * max(0, half - highlighted.cell_len))
             else:
                 left_content = row.left.content[:half]
                 style = "red" if row.left.line_type == "remove" else ""
@@ -418,6 +439,9 @@ class DiffView(VerticalScroll):
             if do_word_diff:
                 for seg_text, changed in new_segs:
                     text.append(seg_text[:half], style="bold reverse green" if changed else "green")
+            elif language:
+                highlighted = highlight_line(row.right.content[:half], language)
+                text.append_text(highlighted)
             else:
                 right_content = row.right.content[:half]
                 style = "green" if row.right.line_type == "add" else ""
@@ -443,6 +467,20 @@ class DiffView(VerticalScroll):
             return ""
         return " "
 
+    def _format_syntax_line(
+        self,
+        dl: DiffLineModel,
+        line_no_str: str,
+        prefix: str,
+        language: str,
+    ) -> Text:
+        """Render a context line with syntax highlighting."""
+        text = Text()
+        text.append(f"{line_no_str}{prefix}", style="dim")
+        highlighted = highlight_line(dl.content, language)
+        text.append_text(highlighted)
+        return text
+
     def _format_word_diff_line(
         self,
         dl: DiffLineModel,
@@ -621,7 +659,7 @@ class NitApp(App):
     """
 
     BINDINGS = [
-        Binding("q", "quit", "Quit"),
+        Binding("q", "quit", "Quit", show=False),
         Binding("j", "cursor_down", "Down", show=False),
         Binding("k", "cursor_up", "Up", show=False),
         Binding("J", "next_hunk", "Next hunk", show=False),
@@ -629,17 +667,21 @@ class NitApp(App):
         Binding("n", "next_file", "Next file"),
         Binding("p", "prev_file", "Prev file"),
         Binding("c", "comment", "Comment"),
-        Binding("d", "delete_comment", "Delete comment"),
+        Binding("d", "delete_comment", "Delete"),
         Binding("m", "cycle_mode", "Mode"),
-        Binding("r", "refresh", "Refresh"),
+        Binding("r", "refresh", "Refresh", show=False),
         Binding("right_square_bracket", "next_comment", "]", show=False),
         Binding("left_square_bracket", "prev_comment", "[", show=False),
         Binding("G", "cursor_end", "End", show=False),
         Binding("s", "toggle_side_by_side", "Split"),
-        Binding("w", "toggle_word_diff", "Word diff"),
+        Binding("w", "toggle_word_diff", "Word"),
+        Binding("W", "toggle_whitespace", "Whitespace"),
+        Binding("e", "export_comments", "Export", show=False),
+        Binding("h", "toggle_syntax", "Highlight", show=False),
     ]
 
     diff_mode: reactive[str] = reactive("branch")
+    ignore_whitespace: reactive[bool] = reactive(False)
 
     def __init__(self, cli_args: CLIArgs | None = None, *args, **kwargs) -> None:
         kwargs.setdefault("ansi_color", True)
@@ -654,6 +696,8 @@ class NitApp(App):
         self.branch = ""
         self.base = ""
         self._file_index: int = 0
+        self._last_raw_diff: str = ""
+        self._file_review_mode: bool = False
 
     def compose(self) -> ComposeResult:
         with Vertical(id="frame"):
@@ -670,6 +714,9 @@ class NitApp(App):
         yield Footer()
 
     def on_mount(self) -> None:
+        if self._cli_args.file_path:
+            self._mount_file_review()
+            return
         try:
             self.repo_root = git.get_repo_root()
         except Exception:
@@ -679,10 +726,12 @@ class NitApp(App):
         try:
             self.branch = git.get_current_branch(self.repo_root)
         except Exception:
-            self.branch = ""
+            self.branch = "(detached HEAD)"
         self.base = git.get_main_branch(self.repo_root)
         if self._cli_args.mode:
             self.diff_mode = self._cli_args.mode
+        elif self.branch and self.branch == self.base:
+            self.diff_mode = "unstaged"
         try:
             self.comments = comments_mod.load_comments(self.repo_root)
         except Exception:
@@ -690,30 +739,79 @@ class NitApp(App):
             self.notify("Could not load .nit.json — starting with no comments", severity="warning")
             self.comments = []
         self._load_diff()
+        self.set_interval(5.0, self._auto_refresh_poll)
 
-    def _load_diff(self) -> None:
-        if self.repo_root is None:
+    def _mount_file_review(self) -> None:
+        from pathlib import Path
+
+        file_path = self._cli_args.file_path
+        p = Path(file_path)
+        if not p.exists():
+            self.notify(f"File not found: {file_path}", severity="error")
+            self.exit()
+            return
+        self._file_review_mode = True
+        self.branch = str(p.name)
+        self.diff_mode = "file"
+        try:
+            self.repo_root = git.get_repo_root()
+        except Exception:
+            self.repo_root = p.parent
+        try:
+            self.comments = comments_mod.load_comments(self.repo_root)
+        except Exception:
+            self.comments = []
+        content = p.read_text()
+        self.file_diffs = file_to_diff(str(p), content)
+        self._update_file_list()
+        self._update_status()
+
+    def _auto_refresh_poll(self) -> None:
+        if self._file_review_mode:
+            return
+        if self._commit_input is not None:
+            return
+        dv = self.query_one("#diff-view", DiffView)
+        if dv._active_input is not None:
+            return
+        try:
+            raw = self._get_raw_diff()
+        except Exception:
             return
+        if raw != self._last_raw_diff:
+            self._last_raw_diff = raw
+            self.file_diffs = parse_diff(raw)
+            self._update_file_list()
+            self._update_status()
+
+    def _get_raw_diff(self) -> str:
+        if self.repo_root is None:
+            return ""
         cwd = self.repo_root
         path_filter = self._cli_args.path_filter
-
         try:
+            ws = self.ignore_whitespace
             if self._cli_args.commit_range:
-                raw = git.get_commit_range_diff(self._cli_args.commit_range, cwd, path_filter)
+                return git.get_commit_range_diff(
+                    self._cli_args.commit_range, cwd, path_filter, ignore_whitespace=ws
+                )
             elif self.diff_mode == "branch":
-                raw = git.get_branch_diff(cwd, path_filter)
+                return git.get_branch_diff(cwd, path_filter, ignore_whitespace=ws)
             elif self.diff_mode == "unstaged":
-                raw = git.get_unstaged_diff(cwd, path_filter)
+                return git.get_unstaged_diff(cwd, path_filter, ignore_whitespace=ws)
             elif self.diff_mode == "staged":
-                raw = git.get_staged_diff(cwd, path_filter)
+                return git.get_staged_diff(cwd, path_filter, ignore_whitespace=ws)
             else:
-                raw = git.get_all_uncommitted_diff(cwd, path_filter)
+                return git.get_all_uncommitted_diff(cwd, path_filter, ignore_whitespace=ws)
         except subprocess.CalledProcessError as e:
             msg = (e.stderr or "").strip() or "Failed to load diff"
             logger.warning("Git diff failed: %s", msg)
             self.notify(msg, severity="error")
-            raw = ""
+            return ""
 
+    def _load_diff(self) -> None:
+        raw = self._get_raw_diff()
+        self._last_raw_diff = raw
         self.file_diffs = parse_diff(raw)
         self._update_file_list()
         self._update_status()
@@ -777,7 +875,8 @@ class NitApp(App):
         n_comments = len(self.comments)
         n_files = len(self.file_diffs)
         self.query_one("#seg-branch", Label).update(f"⎇ {self.branch}")
-        self.query_one("#seg-mode", Label).update(f"⇄  {mode_label}")
+        ws_indicator = " [no-ws]" if self.ignore_whitespace else ""
+        self.query_one("#seg-mode", Label).update(f"⇄  {mode_label}{ws_indicator}")
         self.query_one("#seg-files", Label).update(f"▤ {n_files} files")
         self.query_one("#seg-comments", Label).update(f"✎ {n_comments} comments")
 
@@ -832,7 +931,7 @@ class NitApp(App):
                 action()
                 event.prevent_default()
                 event.stop()
-            return
+                return
         if event.key == "g":
             self._pending_g = True
             event.prevent_default()
@@ -866,7 +965,7 @@ class NitApp(App):
         self.query_one("#diff-view", DiffView).jump_to_next_comment(forward=False)
 
     def action_cycle_mode(self) -> None:
-        if self._cli_args.commit_range:
+        if self._file_review_mode or self._cli_args.commit_range:
             return
         idx = DIFF_MODES.index(self.diff_mode)
         self.diff_mode = DIFF_MODES[(idx + 1) % len(DIFF_MODES)]
@@ -914,7 +1013,12 @@ class NitApp(App):
                     diff_mode=self.diff_mode,
                 )
                 self.comments.append(comment)
-                comments_mod.save_comments(self.repo_root, self.comments, self.branch, self.base)
+                try:
+                    comments_mod.save_comments(
+                        self.repo_root, self.comments, self.branch, self.base
+                    )
+                except Exception as e:
+                    self.notify(f"Failed to save comment: {e}", severity="error")
         saved_cursor = diff_view.cursor_index
         diff_view.hide_comment_input()
         if self.current_file:
@@ -923,6 +1027,10 @@ class NitApp(App):
             self._update_status()
             self._refresh_file_labels()
 
+    def action_toggle_whitespace(self) -> None:
+        self.ignore_whitespace = not self.ignore_whitespace
+        self._load_diff()
+
     def action_toggle_word_diff(self) -> None:
         dv = self.query_one("#diff-view", DiffView)
         dv.word_diff = not dv.word_diff
@@ -931,6 +1039,14 @@ class NitApp(App):
             file_comments = [c for c in self.comments if c.file_path == self.current_file.path]
             dv.load_file_diff(self.current_file, file_comments, restore_cursor=saved_cursor)
 
+    def action_toggle_syntax(self) -> None:
+        dv = self.query_one("#diff-view", DiffView)
+        dv.syntax_highlight = not dv.syntax_highlight
+        if self.current_file:
+            saved_cursor = dv.cursor_index
+            file_comments = [c for c in self.comments if c.file_path == self.current_file.path]
+            dv.load_file_diff(self.current_file, file_comments, restore_cursor=saved_cursor)
+
     def action_toggle_side_by_side(self) -> None:
         dv = self.query_one("#diff-view", DiffView)
         dv.side_by_side = not dv.side_by_side
@@ -942,6 +1058,8 @@ class NitApp(App):
     # --- Git operations (g-prefixed chords) ---
 
     def _action_stage_hunk(self) -> None:
+        if self._file_review_mode:
+            return
         if self.diff_mode not in ("unstaged", "all"):
             self.notify("Stage: switch to unstaged/all mode", severity="warning")
             return
@@ -960,6 +1078,8 @@ class NitApp(App):
         self._load_diff()
 
     def _action_unstage_hunk(self) -> None:
+        if self._file_review_mode:
+            return
         if self.diff_mode != "staged":
             self.notify("Unstage: switch to staged mode", severity="warning")
             return
@@ -978,6 +1098,8 @@ class NitApp(App):
         self._load_diff()
 
     def _action_discard_hunk(self) -> None:
+        if self._file_review_mode:
+            return
         if self.diff_mode not in ("unstaged", "all"):
             self.notify("Discard: switch to unstaged/all mode", severity="warning")
             return
@@ -996,6 +1118,8 @@ class NitApp(App):
         self._load_diff()
 
     def _action_commit_prompt(self) -> None:
+        if self._file_review_mode:
+            return
         if self._commit_input is not None:
             return
         self._commit_input = CommitInput(
@@ -1032,6 +1156,38 @@ class NitApp(App):
             self._update_status()
             self._refresh_file_labels()
 
+    def action_export_comments(self) -> None:
+        if not self.comments:
+            self.notify("No comments to export", severity="warning")
+            return
+        text = comments_mod.export_comments_markdown(self.comments)
+        clip_cmd = None
+        for cmd in ("pbcopy", "xclip", "xsel"):
+            if shutil.which(cmd):
+                clip_cmd = [cmd] if cmd == "pbcopy" else [cmd, "-selection", "clipboard"]
+                break
+        if clip_cmd is None:
+            self.notify("No clipboard command found (pbcopy/xclip/xsel)", severity="error")
+            return
+        try:
+            subprocess.run(clip_cmd, input=text, text=True, check=True, timeout=5)
+            self.notify(f"Copied {len(self.comments)} comments to clipboard")
+        except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired):
+            self.notify("Clipboard copy failed", severity="error")
+
+
+def _export_on_quit(args: CLIArgs, comments: list[ReviewComment]) -> None:
+    if not args.export_comments or not comments:
+        return
+    if args.export_format == "json":
+        text = comments_mod.export_comments_json(comments)
+    else:
+        text = comments_mod.export_comments_markdown(comments)
+    if args.export_comments == "-":
+        print(text)
+    else:
+        Path(args.export_comments).write_text(text)
+
 
 def main() -> None:
     from .cli import parse_args
@@ -1044,6 +1200,7 @@ def main() -> None:
     )
     app = NitApp(cli_args=args)
     app.run()
+    _export_on_quit(args, app.comments)
 
 
 if __name__ == "__main__":

{nit_cli-0.3.0 → nit_cli-0.4.1}/src/nit/cli.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import argparse
 import importlib.metadata
 from dataclasses import dataclass
+from pathlib import Path
 
 
 @dataclass
@@ -11,6 +12,9 @@ class CLIArgs:
     commit_range: str | None = None
     path_filter: str | None = None
     verbose: bool = False
+    file_path: str | None = None
+    export_comments: str | None = None
+    export_format: str = "markdown"
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -47,10 +51,24 @@ def build_parser() -> argparse.ArgumentParser:
         help="Enable verbose logging to stderr",
     )
     parser.add_argument(
-        "commit_range",
+        "--export-comments",
         nargs="?",
+        const="-",
         default=None,
-        help="Git commit range, e.g. HEAD~3..HEAD or main..feature",
+        metavar="FILE",
+        help="Export comments on quit (- for stdout, or file path)",
+    )
+    parser.add_argument(
+        "--export-format",
+        choices=["markdown", "json"],
+        default="markdown",
+        help="Comment export format (default: markdown)",
+    )
+    parser.add_argument(
+        "target",
+        nargs="?",
+        default=None,
+        help="File path (review mode) or git commit range (e.g. HEAD~3..HEAD)",
     )
     return parser
 
@@ -58,9 +76,20 @@ def build_parser() -> argparse.ArgumentParser:
 def parse_args(argv: list[str] | None = None) -> CLIArgs:
     parser = build_parser()
     ns = parser.parse_args(argv)
+    target = ns.target
+    file_path = None
+    commit_range = None
+    if target:
+        if Path(target).exists():
+            file_path = target
+        else:
+            commit_range = target
     return CLIArgs(
         mode=ns.mode,
-        commit_range=ns.commit_range,
+        commit_range=commit_range,
         path_filter=ns.path,
         verbose=ns.verbose,
+        file_path=file_path,
+        export_comments=ns.export_comments,
+        export_format=ns.export_format,
     )

{nit_cli-0.3.0 → nit_cli-0.4.1}/src/nit/comments.py

@@ -75,6 +75,31 @@ def save_comments(
         raise
 
 
+def export_comments_markdown(comments: list[ReviewComment]) -> str:
+    if not comments:
+        return ""
+    by_file: dict[str, list[ReviewComment]] = {}
+    for c in comments:
+        by_file.setdefault(c.file_path, []).append(c)
+    lines = ["# Code Review Comments", ""]
+    for path in sorted(by_file):
+        lines.append(f"## {path}")
+        lines.append("")
+        for c in sorted(by_file[path], key=lambda x: x.new_line_no or x.old_line_no or 0):
+            line_ref = f"L{c.new_line_no}" if c.new_line_no else f"old L{c.old_line_no}"
+            lines.append(f"- **{line_ref}**: {c.comment}")
+            if c.line_content:
+                lines.append("  ```")
+                lines.append(f"  {c.line_content}")
+                lines.append("  ```")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def export_comments_json(comments: list[ReviewComment]) -> str:
+    return json.dumps([_comment_to_dict(c) for c in comments], indent=2)
+
+
 def comment_matches_line(c: ReviewComment, dl: DiffLine) -> bool:
     if c.new_line_no is not None and dl.new_line_no == c.new_line_no:
         return True

{nit_cli-0.3.0 → nit_cli-0.4.1}/src/nit/diff_parser.py

@@ -127,6 +127,31 @@ def parse_diff(text: str) -> list[FileDiff]:
     return files
 
 
+def file_to_diff(path: str, content: str) -> list[FileDiff]:
+    """Create a synthetic FileDiff showing all lines as context for file review."""
+    lines_text = content.splitlines()
+    n = len(lines_text)
+    diff_lines = [
+        DiffLine(
+            content=f"@@ -1,{n} +1,{n} @@",
+            line_type="hunk_header",
+            raw=f"@@ -1,{n} +1,{n} @@",
+        )
+    ]
+    for i, line in enumerate(lines_text, 1):
+        diff_lines.append(
+            DiffLine(
+                content=line,
+                line_type="context",
+                old_line_no=i,
+                new_line_no=i,
+                raw=f" {line}",
+            )
+        )
+    hunk = DiffHunk(header=diff_lines[0].content, lines=diff_lines, old_start=1, new_start=1)
+    return [FileDiff(path=path, status="modified", hunks=[hunk])]
+
+
 def align_hunk_lines(lines: list[DiffLine]) -> list[SideBySideRow]:
     """Pair remove/add lines for side-by-side display."""
     rows: list[SideBySideRow] = []

{nit_cli-0.3.0 → nit_cli-0.4.1}/src/nit/git.py

@@ -65,25 +65,54 @@ def _append_path_filter(cmd: list[str], path_filter: str | None) -> list[str]:
     return cmd
 
 
-def get_branch_diff(cwd: Path | None = None, path_filter: str | None = None) -> str:
+def _append_whitespace_flag(cmd: list[str], ignore_whitespace: bool) -> list[str]:
+    if ignore_whitespace:
+        cmd = cmd + ["-w"]
+    return cmd
+
+
+def _build_diff_cmd(
+    base_cmd: list[str], ignore_whitespace: bool, path_filter: str | None
+) -> list[str]:
+    cmd = _append_whitespace_flag(base_cmd, ignore_whitespace)
+    return _append_path_filter(cmd, path_filter)
+
+
+def get_branch_diff(
+    cwd: Path | None = None,
+    path_filter: str | None = None,
+    ignore_whitespace: bool = False,
+) -> str:
     base = get_main_branch(cwd)
-    cmd = ["git", "diff", f"{base}...HEAD"]
-    return _run(_append_path_filter(cmd, path_filter), cwd=cwd)
+    cmd = _build_diff_cmd(["git", "diff", f"{base}...HEAD"], ignore_whitespace, path_filter)
+    return _run(cmd, cwd=cwd)
 
 
-def get_unstaged_diff(cwd: Path | None = None, path_filter: str | None = None) -> str:
-    cmd = ["git", "diff"]
-    return _run(_append_path_filter(cmd, path_filter), cwd=cwd)
+def get_unstaged_diff(
+    cwd: Path | None = None,
+    path_filter: str | None = None,
+    ignore_whitespace: bool = False,
+) -> str:
+    cmd = _build_diff_cmd(["git", "diff"], ignore_whitespace, path_filter)
+    return _run(cmd, cwd=cwd)
 
 
-def get_all_uncommitted_diff(cwd: Path | None = None, path_filter: str | None = None) -> str:
-    cmd = ["git", "diff", "HEAD"]
-    return _run(_append_path_filter(cmd, path_filter), cwd=cwd)
+def get_all_uncommitted_diff(
+    cwd: Path | None = None,
+    path_filter: str | None = None,
+    ignore_whitespace: bool = False,
+) -> str:
+    cmd = _build_diff_cmd(["git", "diff", "HEAD"], ignore_whitespace, path_filter)
+    return _run(cmd, cwd=cwd)
 
 
-def get_staged_diff(cwd: Path | None = None, path_filter: str | None = None) -> str:
-    cmd = ["git", "diff", "--cached"]
-    return _run(_append_path_filter(cmd, path_filter), cwd=cwd)
+def get_staged_diff(
+    cwd: Path | None = None,
+    path_filter: str | None = None,
+    ignore_whitespace: bool = False,
+) -> str:
+    cmd = _build_diff_cmd(["git", "diff", "--cached"], ignore_whitespace, path_filter)
+    return _run(cmd, cwd=cwd)
 
 
 def apply_patch(
@@ -116,7 +145,10 @@ def commit(message: str, cwd: Path | None = None) -> str:
 
 
 def get_commit_range_diff(
-    commit_range: str, cwd: Path | None = None, path_filter: str | None = None
+    commit_range: str,
+    cwd: Path | None = None,
+    path_filter: str | None = None,
+    ignore_whitespace: bool = False,
 ) -> str:
-    cmd = ["git", "diff", commit_range]
-    return _run(_append_path_filter(cmd, path_filter), cwd=cwd)
+    cmd = _build_diff_cmd(["git", "diff", commit_range], ignore_whitespace, path_filter)
+    return _run(cmd, cwd=cwd)

nit_cli-0.4.1/src/nit/syntax.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import os
+from functools import lru_cache
+
+from rich.syntax import Syntax
+from rich.text import Text
+
+
+@lru_cache(maxsize=32)
+def _get_syntax(language: str) -> Syntax:
+    """Get a cached Syntax object for a language."""
+    theme = "ansi_dark"
+    if os.environ.get("NO_COLOR"):
+        theme = "default"
+    return Syntax("", language, theme=theme, line_numbers=False)
+
+
+def detect_language(file_path: str) -> str | None:
+    """Detect language from file extension. Returns None if unknown."""
+    try:
+        lexer = Syntax.guess_lexer(file_path)
+        return lexer if lexer not in ("text", "default") else None
+    except Exception:
+        return None
+
+
+def highlight_line(code: str, language: str) -> Text:
+    """Return a Rich Text with syntax highlighting for a single line."""
+    syntax = _get_syntax(language)
+    text = syntax.highlight(code)
+    text.rstrip()
+    return text

{nit_cli-0.3.0 → nit_cli-0.4.1/src/nit_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nit-cli
-Version: 0.3.0
+Version: 0.4.1
 Summary: Terminal diff viewer with inline review comments
 Author: Joshua Zink-Duda
 License-Expression: GPL-3.0-only
@@ -33,6 +33,12 @@ Navigate diffs with vim-style keybindings, leave comments on specific lines, and
 
 ## Install
 
+```bash
+brew install joshuazd/tap/nit
+```
+
+Or via pip/pipx:
+
 ```bash
 pipx install nit-cli
 ```
@@ -60,11 +66,20 @@ nit --mode all
 nit HEAD~3..HEAD
 nit main..feature
 
+# Review any file (read-only, no git required)
+nit path/to/file.py
+
 # Filter to specific files or directories
 nit --path src/
 nit --path src/nit/app.py main..feature
+
+# Export comments on quit
+nit --export-comments comments.md
+nit --export-comments - --export-format json  # stdout as JSON
 ```
 
+On main/master, nit defaults to unstaged mode. On feature branches, it defaults to branch diff. The diff auto-refreshes every 5 seconds.
+
 ## Keybindings
 
 | Key | Action |
@@ -73,12 +88,27 @@ nit --path src/nit/app.py main..feature
 | `J` / `K` | Jump to next / previous hunk |
 | `n` / `p` | Next / previous file |
 | `]` / `[` | Jump to next / previous comment |
+| `gg` / `G` | Jump to top / bottom |
 | `c` | Add comment on current line |
 | `d` | Delete comment on current line |
-| `m` | Cycle diff mode (branch / unstaged / all) |
+| `e` | Export comments to clipboard |
+| `m` | Cycle diff mode (branch / unstaged / staged / all) |
+| `s` | Toggle side-by-side diff view |
+| `w` | Toggle word-level diff highlighting |
+| `W` | Toggle hide whitespace-only changes |
+| `h` | Toggle syntax highlighting |
 | `r` | Refresh diff |
 | `q` | Quit |
 
+### Git operations (g-prefixed)
+
+| Key | Action |
+|-----|--------|
+| `ga` | Stage hunk under cursor |
+| `gu` | Unstage hunk (staged mode) |
+| `gx` | Discard hunk |
+| `gc` | Commit with message prompt |
+
 ## Comment Storage
 
 Comments are saved to `.nit.json` at the root of your git repository. The format is structured JSON:

{nit_cli-0.3.0 → nit_cli-0.4.1}/src/nit_cli.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ src/nit/comments.py
 src/nit/diff_parser.py
 src/nit/git.py
 src/nit/models.py
+src/nit/syntax.py
 src/nit_cli.egg-info/PKG-INFO
 src/nit_cli.egg-info/SOURCES.txt
 src/nit_cli.egg-info/dependency_links.txt
@@ -18,4 +19,5 @@ tests/test_app.py
 tests/test_cli.py
 tests/test_comments.py
 tests/test_diff_parser.py
-tests/test_git.py
+tests/test_git.py
+tests/test_syntax.py

{nit_cli-0.3.0 → nit_cli-0.4.1}/tests/test_app.py

@@ -92,4 +92,19 @@ async def test_app_detached_head(mock_git, mock_comments):
     mock_git.get_current_branch.side_effect = Exception("not on branch")
     app = NitApp()
     async with app.run_test():
-        assert app.branch == ""
+        assert app.branch == "(detached HEAD)"
+
+
+async def test_g_chord_unrecognized_key_not_swallowed(mock_git, mock_comments):
+    app = NitApp()
+    async with app.run_test() as pilot:
+        # Press g — sets pending flag
+        await pilot.press("g")
+        assert app._pending_g is True
+        # Press unrecognized key — flag resets, key not swallowed
+        await pilot.press("z")
+        assert app._pending_g is False
+        # Valid chord still works after: gg = cursor to start
+        await pilot.press("g", "g")
+        dv = app.query_one("#diff-view")
+        assert dv.cursor_index == 0

{nit_cli-0.3.0 → nit_cli-0.4.1}/tests/test_comments.py

@@ -2,6 +2,8 @@ import json
 
 from nit.comments import (
     comment_matches_line,
+    export_comments_json,
+    export_comments_markdown,
     load_comments,
     make_comment,
     save_comments,
@@ -114,3 +116,53 @@ def test_load_missing_comment_fields(tmp_path):
     loaded = load_comments(tmp_path)
     assert len(loaded) == 1
     assert loaded[0].file_path == "x.py"
+
+
+def _make_review_comment(**overrides):
+    defaults = dict(
+        file_path="src/app.py",
+        new_line_no=10,
+        old_line_no=None,
+        line_content="return result",
+        comment="Fix this",
+        hunk_context=["line1", "return result"],
+        timestamp="2025-01-15T10:00:00+00:00",
+        diff_mode="branch",
+    )
+    defaults.update(overrides)
+    return ReviewComment(**defaults)
+
+
+def test_export_comments_markdown_empty():
+    assert export_comments_markdown([]) == ""
+
+
+def test_export_comments_markdown():
+    comments = [
+        _make_review_comment(file_path="b.py", new_line_no=5, comment="second file"),
+        _make_review_comment(file_path="a.py", new_line_no=10, comment="note here"),
+        _make_review_comment(
+            file_path="a.py", new_line_no=None, old_line_no=3, comment="old line comment"
+        ),
+    ]
+    md = export_comments_markdown(comments)
+    assert md.startswith("# Code Review Comments")
+    # Files sorted alphabetically
+    assert md.index("## a.py") < md.index("## b.py")
+    assert "**L10**: note here" in md
+    assert "**old L3**: old line comment" in md
+    assert "**L5**: second file" in md
+    assert "```" in md  # code fence for line_content
+
+
+def test_export_comments_json():
+    comments = [
+        _make_review_comment(comment="test comment"),
+    ]
+    result = export_comments_json(comments)
+    parsed = json.loads(result)
+    assert isinstance(parsed, list)
+    assert len(parsed) == 1
+    assert parsed[0]["comment"] == "test comment"
+    assert parsed[0]["file"] == "src/app.py"
+    assert parsed[0]["line"] == 10

{nit_cli-0.3.0 → nit_cli-0.4.1}/tests/test_git.py

@@ -10,21 +10,11 @@ def git_repo(tmp_path):
     """Create a temporary git repo with one commit."""
     subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True)
     subprocess.run(["git", "checkout", "-b", "main"], cwd=tmp_path, capture_output=True)
+    subprocess.run(["git", "config", "user.name", "test"], cwd=tmp_path, capture_output=True)
+    subprocess.run(["git", "config", "user.email", "t@t"], cwd=tmp_path, capture_output=True)
     (tmp_path / "file.txt").write_text("hello\n")
     subprocess.run(["git", "add", "."], cwd=tmp_path, capture_output=True)
-    subprocess.run(
-        ["git", "commit", "-m", "init"],
-        cwd=tmp_path,
-        capture_output=True,
-        env={
-            "GIT_AUTHOR_NAME": "test",
-            "GIT_AUTHOR_EMAIL": "t@t",
-            "GIT_COMMITTER_NAME": "test",
-            "GIT_COMMITTER_EMAIL": "t@t",
-            "HOME": str(tmp_path),
-            "PATH": subprocess.check_output(["bash", "-c", "echo $PATH"], text=True).strip(),
-        },
-    )
+    subprocess.run(["git", "commit", "-m", "init"], cwd=tmp_path, capture_output=True)
     return tmp_path
 
 
@@ -70,22 +60,6 @@ def test_detached_head(git_repo):
     assert branch == ""
 
 
-GIT_ENV_KEYS = {
-    "GIT_AUTHOR_NAME": "test",
-    "GIT_AUTHOR_EMAIL": "t@t",
-    "GIT_COMMITTER_NAME": "test",
-    "GIT_COMMITTER_EMAIL": "t@t",
-}
-
-
-def _git_env(tmp_path):
-    return {
-        **GIT_ENV_KEYS,
-        "HOME": str(tmp_path),
-        "PATH": subprocess.check_output(["bash", "-c", "echo $PATH"], text=True).strip(),
-    }
-
-
 def test_get_staged_diff_empty(git_repo):
     diff = git.get_staged_diff(cwd=git_repo)
     assert diff == ""
@@ -132,12 +106,7 @@ def test_commit(git_repo):
     (git_repo / "file.txt").write_text("committed\n")
     subprocess.run(["git", "add", "file.txt"], cwd=git_repo, capture_output=True)
     git.commit("test commit", cwd=git_repo)
-    log = subprocess.check_output(
-        ["git", "log", "--oneline", "-1"],
-        cwd=git_repo,
-        text=True,
-        env=_git_env(git_repo),
-    )
+    log = subprocess.check_output(["git", "log", "--oneline", "-1"], cwd=git_repo, text=True)
     assert "test commit" in log
 
 

nit_cli-0.4.1/tests/test_syntax.py

@@ -0,0 +1,26 @@
+from rich.text import Text
+
+from nit.syntax import detect_language, highlight_line
+
+
+def test_detect_language_python():
+    assert detect_language("app.py") == "python"
+
+
+def test_detect_language_javascript():
+    assert detect_language("index.js") == "javascript"
+
+
+def test_detect_language_unknown():
+    assert detect_language("file.xyzunknown") is None
+
+
+def test_highlight_line_returns_text():
+    result = highlight_line("x = 1", "python")
+    assert isinstance(result, Text)
+    assert str(result).strip() == "x = 1"
+
+
+def test_highlight_line_empty():
+    result = highlight_line("", "python")
+    assert isinstance(result, Text)