feat(file): add blob buffer support

- Add majutsu-file.el for viewing files at revisions
- Support blob buffer navigation (prev/next change)
- Smart diff visit behavior (worktree vs blob)
- Line mapping between revisions via diff hunks
- Add change-at-point detection for edit/new commands
- Add evil keybindings for blob mode

Author: 0WD0

docs/majutsu.org

@@ -134,7 +134,8 @@ Press ~d~ to open the Diff transient.
 
 *** Diff Buffer
 The diff buffer is highly interactive:
-- ~RET~ :: Visit the file in your workspace at the corresponding line.
+- ~RET~ :: Visit the appropriate version of the file at point. For working copy diffs, visits the actual file. For committed changes, visits the blob.
+- ~C-j~ / ~C-<return>~ :: Always visit the workspace file, regardless of diff type.
 - ~+~ / ~-~ :: Increase or decrease the amount of context shown.
 - ~t~ :: Toggle word-level refinement.
 

majutsu-base.el

@@ -263,6 +263,38 @@ of the selected frame."
   (unless (derived-mode-p mode)
     (user-error "Command is only valid in %s buffers" mode)))
 
+;;; Change at Point
+
+(defvar majutsu-buffer-blob-revision)
+
+(defun majutsu-change-at-point ()
+  "Return the change-id at point.
+This checks multiple sources in order:
+1. Section value (jj-commit section)
+2. `jj-revision' thing-at-point
+3. Blob buffer revision
+4. Diff/revision buffer revision"
+  (or (magit-section-value-if 'jj-commit)
+      (magit-thing-at-point 'jj-revision t)
+      (and (bound-and-true-p majutsu-buffer-blob-revision)
+           majutsu-buffer-blob-revision)
+      (and (derived-mode-p 'majutsu-diff-mode)
+           (bound-and-true-p majutsu-buffer-diff-range)
+           (let ((range majutsu-buffer-diff-range))
+             (or (and (equal (car range) "-r") (cadr range))
+                 (cdr (assoc "--revisions=" range)))))))
+
+;; Register jj-revision as a thing-at-point type
+(put 'jj-revision 'bounds-of-thing-at-point
+     (lambda ()
+       (when (looking-at "[a-z]\\{1,12\\}")
+         (cons (match-beginning 0) (match-end 0)))))
+
+(put 'jj-revision 'thing-at-point
+     (lambda ()
+       (when-let* ((bounds (bounds-of-thing-at-point 'jj-revision)))
+         (buffer-substring-no-properties (car bounds) (cdr bounds)))))
+
 ;;; _
 (provide 'majutsu-base)
 ;;; majutsu-base.el ends here

majutsu-diff.el

@@ -21,6 +21,7 @@
 (require 'majutsu-config)
 (require 'majutsu-selection)
 (require 'majutsu-section)
+(require 'majutsu-file)
 (require 'magit-diff)      ; for faces/font-lock keywords
 (require 'diff-mode)
 (require 'smerge-mode)
@@ -747,31 +748,146 @@ works with the simplified jj diff we render here."
   (when-let* ((file (majutsu-diff--file-at-point)))
     (find-file (expand-file-name file default-directory))))
 
+(defun majutsu-diff--range-value (range prefix)
+  "Return the value in RANGE for argument starting with PREFIX."
+  (when range
+    (when-let* ((arg (seq-find (lambda (item) (string-prefix-p prefix item)) range)))
+      (substring arg (length prefix)))))
+
+(defun majutsu-diff--on-removed-line-p ()
+  "Return non-nil if point is on a removed diff line."
+  (eq (char-after (line-beginning-position)) ?-))
+
+(defun majutsu-diff--default-revset ()
+  "Return the revset implied by the current diff buffer."
+  (let* ((range majutsu-buffer-diff-range)
+         (removed (majutsu-diff--on-removed-line-p))
+         (from (majutsu-diff--range-value range "--from="))
+         (to (majutsu-diff--range-value range "--to="))
+         (revisions (majutsu-diff--range-value range "--revisions=")))
+    (cond
+     ((and range (equal (car range) "-r") (cadr range)) (cadr range))
+     (revisions revisions)
+     (from (if (and removed from) from (or to from)))
+     (t "@"))))
+
+(defun majutsu-diff--hunk-line (section goto-from)
+  "Return the line number in SECTION for GOTO-FROM side."
+  (with-slots (content from-range to-range) section
+    (let ((start (car (if goto-from from-range to-range))))
+      (when start
+        (let ((line start)
+              (target (point)))
+          (save-excursion
+            (goto-char content)
+            (while (< (point) target)
+              (let ((ch (char-after (line-beginning-position))))
+                (cond
+                 ((eq ch ?+) (unless goto-from (setq line (1+ line))))
+                 ((eq ch ?-) (when goto-from (setq line (1+ line))))
+                 (t (setq line (1+ line)))))
+              (forward-line 1)))
+          line)))))
+
+(defun majutsu-diff--hunk-column (section goto-from)
+  "Return the column for SECTION based on GOTO-FROM side."
+  (let ((bol (line-beginning-position)))
+    (if (or (< (point) (oref section content))
+            (and (not goto-from) (eq (char-after bol) ?-)))
+        0
+      (let ((col (current-column)))
+        (if (memq (char-after bol) '(?+ ?-))
+            (max 0 (1- col))
+          col)))))
+
+(defun majutsu-diff--goto-line-col (buffer line col)
+  "Move point in BUFFER to LINE and COL."
+  (with-current-buffer buffer
+    (widen)
+    (goto-char (point-min))
+    (forward-line (max 0 (1- line)))
+    (move-to-column col)))
+
+(defun majutsu-diff--visit-workspace-p ()
+  "Return non-nil if the current diff should visit the workspace file.
+This is true when diffing the working copy (@) on the new/right side."
+  (let* ((range majutsu-buffer-diff-range)
+         (to (majutsu-diff--range-value range "--to="))
+         (revisions (majutsu-diff--range-value range "--revisions=")))
+    (cond
+     ;; Explicit --to=@ means we're looking at working copy changes
+     ((equal to "@") t)
+     ;; No range specified defaults to -r @ (working copy)
+     ((null range) t)
+     ;; Single revision diff (-r @) shows working copy
+     ((and revisions (equal revisions "@")) t)
+     ;; Otherwise we're looking at committed changes
+     (t nil))))
+
 ;;;###autoload
-(defun majutsu-diff-visit-file ()
-  "Visit the file at point.
+(defun majutsu-diff-visit-file (&optional force-workspace)
+  "From a diff, visit the appropriate version of the file at point.
 
-When point is on a hunk section, jump to the corresponding line in the
-file."
-  (interactive)
-  (let ((section (magit-current-section)))
-    (cond
-     ((and section (magit-section-match 'jj-hunk section))
-      (majutsu-goto-diff-line))
-     ((majutsu-diff--file-at-point)
-      (majutsu-visit-file))
-     (t
-      (user-error "No file at point")))))
+If point is on an added or context line, visit the new/right side.
+If point is on a removed line, visit the old/left side.
+
+For diffs of the working copy (@), this visits the actual file in
+the workspace.  For diffs of committed changes, this visits the
+blob from the appropriate revision.
+
+With prefix argument FORCE-WORKSPACE, always visit the workspace file
+regardless of what the diff is about."
+  (interactive "P")
+  (let* ((section (magit-current-section))
+         (file (majutsu-diff--file-at-point)))
+    (unless file
+      (user-error "No file at point"))
+    (let* ((goto-from (and section (magit-section-match 'jj-hunk section)
+                           (majutsu-diff--on-removed-line-p)))
+           (goto-workspace (or force-workspace
+                              (and (majutsu-diff--visit-workspace-p)
+                                   (not goto-from))))
+           (line (and section (magit-section-match 'jj-hunk section)
+                      (majutsu-diff--hunk-line section goto-from)))
+           (col (and section (magit-section-match 'jj-hunk section)
+                     (majutsu-diff--hunk-column section goto-from))))
+      (if goto-workspace
+          ;; Visit workspace file
+          (let ((full-path (expand-file-name file default-directory)))
+            (if (file-exists-p full-path)
+                (progn
+                  (find-file full-path)
+                  (when (and line col)
+                    (goto-char (point-min))
+                    (forward-line (1- line))
+                    (move-to-column col)))
+              (user-error "File does not exist in workspace: %s" file)))
+        ;; Visit blob
+        (let* ((revset (majutsu-diff--default-revset))
+               (buf (majutsu-find-file revset file)))
+          (when (and buf line col)
+            (majutsu-diff--goto-line-col buf line col)))))))
 
 ;;; Section Keymaps
 
 (defvar-keymap majutsu-diff-section-map
   :doc "Keymap for diff sections."
-  "<remap> <majutsu-visit-thing>" #'majutsu-diff-visit-file)
+  "<remap> <majutsu-visit-thing>" #'majutsu-diff-visit-file
+  "C-j" #'majutsu-diff-visit-workspace-file
+  "C-<return>" #'majutsu-diff-visit-workspace-file)
+
+;;;###autoload
+(defun majutsu-diff-visit-workspace-file ()
+  "From a diff, visit the workspace version of the file at point.
+Always visits the actual file in the working tree, regardless of
+what the diff is about."
+  (interactive)
+  (majutsu-diff-visit-file t))
 
 (defvar-keymap majutsu-file-section-map
   :doc "Keymap for `jj-file' sections."
-  :parent majutsu-diff-section-map)
+  :parent majutsu-diff-section-map
+  "v" #'majutsu-find-file-at-point)
 
 (defvar-keymap majutsu-hunk-section-map
   :doc "Keymap for `jj-hunk' sections."

majutsu-edit.el

@@ -38,11 +38,12 @@
 
 With prefix ARG, pass --ignore-immutable."
   (interactive "P")
-  (when-let* ((revset (magit-section-value-if 'jj-commit))
-              (args (append (list "edit" revset)
-                            (when arg (list "--ignore-immutable")))))
-    (when (zerop (apply #'majutsu-run-jj args))
-      (message "Now editing commit %s" revset))))
+  (if-let* ((revset (majutsu-change-at-point))
+            (args (append (list "edit" revset)
+                          (when arg (list "--ignore-immutable")))))
+      (when (zerop (apply #'majutsu-run-jj args))
+        (message "Now editing commit %s" revset))
+    (user-error "No revision at point")))
 
 ;;; _
 (provide 'majutsu-edit)

majutsu-evil.el

@@ -82,10 +82,28 @@ If KEYMAP is not yet bound, defer binding until it becomes available."
                     majutsu-diff-mode))
       (evil-set-initial-state mode majutsu-evil-initial-state))))
 
+(defun majutsu-evil--adjust-section-bindings ()
+  "Unbind C-j from section maps so Evil navigation takes precedence.
+This mirrors `evil-collection-magit-adjust-section-bindings'."
+  (when (boundp 'majutsu-diff-section-map)
+    (define-key majutsu-diff-section-map "\C-j" nil))
+  (when (boundp 'majutsu-file-section-map)
+    (define-key majutsu-file-section-map "\C-j" nil))
+  (when (boundp 'majutsu-hunk-section-map)
+    (define-key majutsu-hunk-section-map "\C-j" nil)))
+
 (defun majutsu-evil--define-mode-keys ()
   "Install Evil keybindings for Majutsu maps."
+  ;; Unbind C-j from section maps first.
+  (majutsu-evil--adjust-section-bindings)
   ;; Normal/visual/motion share the same bindings for navigation commands.
   (majutsu-evil--define-keys '(normal visual motion) 'majutsu-mode-map
+    (kbd "C-j") #'magit-section-forward
+    (kbd "C-k") #'magit-section-backward
+    (kbd "g j") #'magit-section-forward-sibling
+    (kbd "g k") #'magit-section-backward-sibling
+    (kbd "]") #'magit-section-forward-sibling
+    (kbd "[") #'magit-section-backward-sibling
     (kbd "R") #'majutsu-restore
     (kbd "g r") #'majutsu-refresh
     (kbd "`") #'majutsu-process-buffer
@@ -114,7 +132,17 @@ If KEYMAP is not yet bound, defer binding until it becomes available."
     (kbd "Y") #'majutsu-duplicate-dwim)
 
   (majutsu-evil--define-keys '(normal visual) 'majutsu-diff-mode-map
-    (kbd "g d") #'majutsu-jump-to-diffstat-or-diff)
+    (kbd "g d") #'majutsu-jump-to-diffstat-or-diff
+    (kbd "C-<return>") #'majutsu-diff-visit-workspace-file)
+
+  ;; majutsu-blob-mode is a minor mode, need hook + define-keys
+  (add-hook 'majutsu-blob-mode-hook #'evil-normalize-keymaps)
+  (majutsu-evil--define-keys '(normal visual motion) 'majutsu-blob-mode-map
+    (kbd "p") #'majutsu-blob-previous
+    (kbd "n") #'majutsu-blob-next
+    (kbd "q") #'majutsu-blob-quit
+    ;; RET visits the revision (edit)
+    (kbd "RET") #'majutsu-edit-changeset)
 
   (majutsu-evil--define-keys '(normal visual motion) 'majutsu-log-mode-map
     (kbd ".") #'majutsu-log-goto-@