nit-cli 0.2.0__py3-none-any.whl

nit/cli.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import argparse
+import importlib.metadata
+from dataclasses import dataclass
+
+
+@dataclass
+class CLIArgs:
+    mode: str | None = None
+    commit_range: str | None = None
+    path_filter: str | None = None
+    verbose: bool = False
+
+
+def build_parser() -> argparse.ArgumentParser:
+    try:
+        version = importlib.metadata.version("nit-cli")
+    except importlib.metadata.PackageNotFoundError:
+        version = "0.0.0-dev"
+
+    parser = argparse.ArgumentParser(
+        prog="nit",
+        description="Terminal diff viewer with inline review comments.",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"nit {version}",
+    )
+    parser.add_argument(
+        "--mode",
+        choices=["branch", "unstaged", "all"],
+        default=None,
+        help="Diff mode (default: branch)",
+    )
+    parser.add_argument(
+        "--path",
+        default=None,
+        help="Filter to specific file or directory path",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        default=False,
+        help="Enable verbose logging to stderr",
+    )
+    parser.add_argument(
+        "commit_range",
+        nargs="?",
+        default=None,
+        help="Git commit range, e.g. HEAD~3..HEAD or main..feature",
+    )
+    return parser
+
+
+def parse_args(argv: list[str] | None = None) -> CLIArgs:
+    parser = build_parser()
+    ns = parser.parse_args(argv)
+    return CLIArgs(
+        mode=ns.mode,
+        commit_range=ns.commit_range,
+        path_filter=ns.path,
+        verbose=ns.verbose,
+    )

nit/comments.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import json
+import logging
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .models import DiffLine, ReviewComment
+
+logger = logging.getLogger(__name__)
+
+COMMENT_FILE = ".nit.json"
+
+
+def _comment_to_dict(c: ReviewComment) -> dict:
+    d: dict = {"file": c.file_path, "line_content": c.line_content, "comment": c.comment}
+    if c.new_line_no is not None:
+        d["line"] = c.new_line_no
+    if c.old_line_no is not None:
+        d["old_line"] = c.old_line_no
+    d["hunk_context"] = c.hunk_context
+    d["timestamp"] = c.timestamp
+    d["diff_mode"] = c.diff_mode
+    return d
+
+
+def _dict_to_comment(d: dict) -> ReviewComment:
+    return ReviewComment(
+        file_path=d["file"],
+        new_line_no=d.get("line"),
+        old_line_no=d.get("old_line"),
+        line_content=d.get("line_content", ""),
+        comment=d["comment"],
+        hunk_context=d.get("hunk_context", []),
+        timestamp=d.get("timestamp", ""),
+        diff_mode=d.get("diff_mode", "branch"),
+    )
+
+
+def load_comments(repo_root: Path) -> list[ReviewComment]:
+    path = repo_root / COMMENT_FILE
+    if not path.exists():
+        return []
+    try:
+        data = json.loads(path.read_text())
+        return [_dict_to_comment(c) for c in data.get("comments", [])]
+    except (json.JSONDecodeError, KeyError, TypeError, AttributeError) as e:
+        logger.warning("Failed to load %s: %s", path, e)
+        return []
+
+
+def save_comments(
+    repo_root: Path,
+    comments: list[ReviewComment],
+    branch: str = "",
+    base: str = "",
+) -> None:
+    data = {
+        "version": 1,
+        "branch": branch,
+        "base": base,
+        "comments": [_comment_to_dict(c) for c in comments],
+    }
+    path = repo_root / COMMENT_FILE
+    # Atomic write
+    fd, tmp = tempfile.mkstemp(dir=repo_root, suffix=".nit.tmp")
+    try:
+        with open(fd, "w") as f:
+            json.dump(data, f, indent=2)
+            f.write("\n")
+        Path(tmp).replace(path)
+    except Exception:
+        Path(tmp).unlink(missing_ok=True)
+        raise
+
+
+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
+    if c.old_line_no is not None and dl.old_line_no == c.old_line_no and dl.new_line_no is None:
+        return True
+    return False
+
+
+def make_comment(
+    file_path: str,
+    line: DiffLine,
+    comment_text: str,
+    hunk_context: list[str],
+    diff_mode: str = "branch",
+) -> ReviewComment:
+    return ReviewComment(
+        file_path=file_path,
+        new_line_no=line.new_line_no,
+        old_line_no=line.old_line_no,
+        line_content=line.content,
+        comment=comment_text,
+        hunk_context=hunk_context,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+        diff_mode=diff_mode,
+    )

nit/diff_parser.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import re
+
+from .models import DiffHunk, DiffLine, FileDiff
+
+DIFF_HEADER_RE = re.compile(r"^diff --git a/(.*) b/(.*)")
+HUNK_HEADER_RE = re.compile(r"^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@(.*)")
+RENAME_FROM_RE = re.compile(r"^rename from (.*)")
+RENAME_TO_RE = re.compile(r"^rename to (.*)")
+NEW_FILE_RE = re.compile(r"^new file mode")
+DELETED_FILE_RE = re.compile(r"^deleted file mode")
+BINARY_RE = re.compile(r"^Binary files")
+
+
+def parse_diff(text: str) -> list[FileDiff]:
+    if not text.strip():
+        return []
+
+    files: list[FileDiff] = []
+    current_file: FileDiff | None = None
+    current_hunk: DiffHunk | None = None
+    old_no = 0
+    new_no = 0
+
+    for line in text.splitlines():
+        # New file diff
+        m = DIFF_HEADER_RE.match(line)
+        if m:
+            current_file = FileDiff(path=m.group(2), old_path=m.group(1))
+            if m.group(1) != m.group(2):
+                current_file.status = "renamed"
+            files.append(current_file)
+            current_hunk = None
+            continue
+
+        if current_file is None:
+            continue
+
+        # File metadata
+        if NEW_FILE_RE.match(line):
+            current_file.status = "added"
+            continue
+        if DELETED_FILE_RE.match(line):
+            current_file.status = "deleted"
+            continue
+        m = RENAME_FROM_RE.match(line)
+        if m:
+            current_file.old_path = m.group(1)
+            current_file.status = "renamed"
+            continue
+        m = RENAME_TO_RE.match(line)
+        if m:
+            current_file.path = m.group(1)
+            continue
+        if BINARY_RE.match(line):
+            current_file.is_binary = True
+            continue
+
+        # Skip index and ---/+++ lines
+        if line.startswith("index ") or line.startswith("--- ") or line.startswith("+++ "):
+            continue
+
+        # Hunk header
+        m = HUNK_HEADER_RE.match(line)
+        if m:
+            old_no = int(m.group(1))
+            new_no = int(m.group(2))
+            current_hunk = DiffHunk(
+                header=line,
+                old_start=old_no,
+                new_start=new_no,
+            )
+            current_hunk.lines.append(
+                DiffLine(
+                    content=m.group(3).strip(),
+                    line_type="hunk_header",
+                    raw=line,
+                )
+            )
+            current_file.hunks.append(current_hunk)
+            continue
+
+        if current_hunk is None:
+            continue
+
+        # Diff lines
+        if line.startswith("+"):
+            current_hunk.lines.append(
+                DiffLine(
+                    content=line[1:],
+                    line_type="add",
+                    new_line_no=new_no,
+                    raw=line,
+                )
+            )
+            new_no += 1
+        elif line.startswith("-"):
+            current_hunk.lines.append(
+                DiffLine(
+                    content=line[1:],
+                    line_type="remove",
+                    old_line_no=old_no,
+                    raw=line,
+                )
+            )
+            old_no += 1
+        elif line.startswith("\\"):
+            # ""
+            continue
+        else:
+            # Context line (starts with space or is empty)
+            content = line[1:] if line.startswith(" ") else line
+            current_hunk.lines.append(
+                DiffLine(
+                    content=content,
+                    line_type="context",
+                    old_line_no=old_no,
+                    new_line_no=new_no,
+                    raw=line,
+                )
+            )
+            old_no += 1
+            new_no += 1
+
+    return files

nit/git.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import logging
+import subprocess
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+GIT_TIMEOUT = 30
+
+
+def _run(args: list[str], cwd: Path | None = None) -> str:
+    logger.debug("Running: %s", " ".join(args))
+    try:
+        result = subprocess.run(
+            args,
+            capture_output=True,
+            text=True,
+            cwd=cwd,
+            timeout=GIT_TIMEOUT,
+        )
+    except subprocess.TimeoutExpired:
+        logger.warning("Git command timed out: %s", " ".join(args))
+        raise subprocess.CalledProcessError(1, args, "", "Command timed out")
+    if result.returncode != 0:
+        raise subprocess.CalledProcessError(
+            result.returncode,
+            args,
+            result.stdout,
+            result.stderr,
+        )
+    return result.stdout
+
+
+def get_repo_root(cwd: Path | None = None) -> Path:
+    out = _run(["git", "rev-parse", "--show-toplevel"], cwd=cwd)
+    return Path(out.strip())
+
+
+def get_current_branch(cwd: Path | None = None) -> str:
+    return _run(["git", "branch", "--show-current"], cwd=cwd).strip()
+
+
+def get_main_branch(cwd: Path | None = None) -> str:
+    for name in ("main", "master"):
+        result = subprocess.run(
+            ["git", "rev-parse", "--verify", f"refs/heads/{name}"],
+            capture_output=True,
+            text=True,
+            cwd=cwd,
+            timeout=GIT_TIMEOUT,
+        )
+        if result.returncode == 0:
+            return name
+    return "main"
+
+
+def get_merge_base(base: str, cwd: Path | None = None) -> str:
+    return _run(["git", "merge-base", base, "HEAD"], cwd=cwd).strip()
+
+
+def _append_path_filter(cmd: list[str], path_filter: str | None) -> list[str]:
+    if path_filter:
+        return cmd + ["--", path_filter]
+    return cmd
+
+
+def get_branch_diff(cwd: Path | None = None, path_filter: str | None = None) -> str:
+    base = get_main_branch(cwd)
+    cmd = ["git", "diff", f"{base}...HEAD"]
+    return _run(_append_path_filter(cmd, path_filter), 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_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_commit_range_diff(
+    commit_range: str, cwd: Path | None = None, path_filter: str | None = None
+) -> str:
+    cmd = ["git", "diff", commit_range]
+    return _run(_append_path_filter(cmd, path_filter), cwd=cwd)

nit/models.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class DiffLine:
+    content: str
+    line_type: str  # "context", "add", "remove", "hunk_header"
+    old_line_no: int | None = None
+    new_line_no: int | None = None
+    raw: str = ""
+
+
+@dataclass
+class DiffHunk:
+    header: str
+    lines: list[DiffLine] = field(default_factory=list)
+    old_start: int = 0
+    new_start: int = 0
+
+
+@dataclass
+class FileDiff:
+    path: str
+    old_path: str | None = None
+    status: str = "modified"  # "modified", "added", "deleted", "renamed"
+    hunks: list[DiffHunk] = field(default_factory=list)
+    is_binary: bool = False
+
+
+@dataclass
+class ReviewComment:
+    file_path: str
+    new_line_no: int | None
+    old_line_no: int | None
+    line_content: str
+    comment: str
+    hunk_context: list[str] = field(default_factory=list)
+    timestamp: str = ""
+    diff_mode: str = "branch"

nit_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: nit-cli
+Version: 0.2.0
+Summary: Terminal diff viewer with inline review comments
+Author: Joshua Zink-Duda
+License-Expression: GPL-3.0-only
+Project-URL: Homepage, https://github.com/joshuazd/nit
+Project-URL: Repository, https://github.com/joshuazd/nit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual<1.0,>=0.47.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Dynamic: license-file
+
+# nit
+
+Terminal diff viewer with inline review comments.
+
+Navigate diffs with vim-style keybindings, leave comments on specific lines, and persist them as structured JSON. Useful for code review workflows, self-review before committing, and giving feedback to AI coding tools.
+
+## Install
+
+```bash
+pip install nit-cli
+```
+
+## Usage
+
+```bash
+# Review current branch changes (vs main/master)
+nit
+
+# Review unstaged changes
+nit --mode unstaged
+
+# Review all uncommitted changes
+nit --mode all
+
+# Review a specific commit range
+nit HEAD~3..HEAD
+nit main..feature
+
+# Filter to specific files or directories
+nit --path src/
+nit --path src/nit/app.py main..feature
+```
+
+## Keybindings
+
+| Key | Action |
+|-----|--------|
+| `j` / `k` | Move cursor down / up |
+| `J` / `K` | Jump to next / previous hunk |
+| `n` / `p` | Next / previous file |
+| `]` / `[` | Jump to next / previous comment |
+| `c` | Add comment on current line |
+| `d` | Delete comment on current line |
+| `m` | Cycle diff mode (branch / unstaged / all) |
+| `r` | Refresh diff |
+| `q` | Quit |
+
+## Comment Storage
+
+Comments are saved to `.nit.json` at the root of your git repository. The format is structured JSON:
+
+```json
+{
+  "version": 1,
+  "branch": "my-feature",
+  "base": "main",
+  "comments": [
+    {
+      "file": "src/app.py",
+      "line": 42,
+      "line_content": "    return result",
+      "comment": "Should handle the empty case here",
+      "hunk_context": ["...", "..."],
+      "timestamp": "2025-01-15T10:30:00+00:00",
+      "diff_mode": "branch"
+    }
+  ]
+}
+```
+
+Add `.nit.json` to your global gitignore to keep comments local:
+
+```bash
+echo '.nit.json' >> ~/.config/git/ignore
+```
+
+## Claude Code Integration
+
+nit works as a review tool for [Claude Code](https://docs.anthropic.com/en/docs/claude-code). Leave comments on Claude's changes using nit, then have Claude read them with the `/review-feedback` skill. This creates a feedback loop where you can guide Claude's work through inline code review.
+
+## Development
+
+```bash
+git clone https://github.com/joshuazd/nit.git
+cd nit
+pip install -e ".[dev]"
+pytest
+```
+
+The `./nit` bootstrap script auto-creates a virtualenv for quick local use without manual setup.
+
+## License
+
+GPL-3.0 - see [LICENSE](LICENSE) for details.

nit_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+nit/__init__.py,sha256=ItrZPRnS5iTpsbefdIGOsHfcTPSyNahRYu3hmaD0j5s,163
+nit/app.py,sha256=yYF4Y1QT7EE4sfUyyDF6h-8LAjkYV3EEreOerD9H53Q,21879
+nit/cli.py,sha256=xuwyqoDScZ17oJ6OuFTNkOuPMQXuFRZ6ZXAP16C3Npw,1616
+nit/comments.py,sha256=FyP60vtHBCVZFXsY7Mcz7hA_RJ4Kuy2pN4AI3ga1InI,2869
+nit/diff_parser.py,sha256=uwOeRbGRNLlXWk7Uvn2SIDTIvZDIPQaeDUbvnmlOZ44,3741
+nit/git.py,sha256=KZ7MljE0N-74eaiArhKvGbObj_EQJ1TRJsT2tA5MK5A,2616
+nit/models.py,sha256=bI8EYXN3ac4qm8GMqZuyhZkb24UwSJs4ab3lBCjghgc,915
+nit_cli-0.2.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+nit_cli-0.2.0.dist-info/METADATA,sha256=V5A0e2f1cdxB4eDPW6Z2qGVT7dCW8s9t_l4TQYL8byg,3273
+nit_cli-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+nit_cli-0.2.0.dist-info/entry_points.txt,sha256=t2GZfgXHdiO58CuJAcrHDz8pcWAbHRsTcQ5F504xNWw,37
+nit_cli-0.2.0.dist-info/top_level.txt,sha256=HPE4deTgjYUBT7wH6DHtIVjNnO6KsJnbLn2z8Bx2aCc,4
+nit_cli-0.2.0.dist-info/RECORD,,

nit_cli-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nit_cli-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nit = nit.app:main