[SUGGESTION] id links with search

[Ypot]

Hi

Long time user of org-super-links here!

I would like to make a suggestion to add search to id links.

As I see you have little time, I will just share an example. If you are interested, and it is not enough to explain myself, let me know:

* Test 1
:PROPERTIES:
:ID:       2024-09-15T004054791309
:END:
:LINKS:
- [[id:2024-09-15T004054782261][Test 2]]
:END:
[[id:2024-09-15T004054782261][N20240915T004053.190543]]
* Test 2
:PROPERTIES:
:ID:       2024-09-15T004054782261
:END:
:LINKS:
- [[id:2024-09-15T004054791309::N20240915T004053.190543][Test 1]]
:END:

[alexispurslane]

If you have org super links use org-super-links-get-location, which uses org refile get location under the hood, then this vanilla org mode code to get completion for IDs for org refile targets should work, if I understand how org works correctly (I'm new to this and not at my computer to test):

(org-link-set-parameters "id" :complete #'org-id-complete-link)

(defun org-id-complete-link ()
  "Create an id: link using completion."
  (concat "id:" (org-id-get-with-outline-path-completion org-refile-targets)))

[Ypot]

I am trying this:

;;; Commentary:

;; A standalone system for creating bidirectional links in Org-mode using
;; timestamp-based custom IDs.
;;
;; Main functions:
;; - `org-super-links-custom-store-link': Generate a custom-id and store link
;; - `org-super-links-custom-insert-link': Insert bidirectional links
;; - `org-super-links-custom-cleanup-buffer': Remove duplicate drawers
;;
;; Installation:
;; 1. Save this file somewhere in your load-path
;; 2. Add to your init file:
;;    (require 'org-super-links-custom)
;;    (global-set-key (kbd "C-c l") 'org-super-links-custom-store-link)
;;    (define-key org-mode-map (kbd "C-c C-l") 'org-super-links-custom-insert-link)
;;
;; Workflow:
;; 1. In heading 1, press C-c l to insert [[N20240915T004053.190543]]
;; 2. Move to heading 2, press C-c C-l to create bidirectional links
;;
;; Result:
;; - Heading 1: [[N...]] becomes [[id:heading2-id][N...]]
;; - Both headings get LINKS drawers with cross-references
;; - The link from heading 2 uses id:XXX::search format to jump to the exact location
;;
;; Available commands:
;; - M-x org-super-links-custom-store-link: Store link with custom ID
;; - M-x org-super-links-custom-insert-link: Create bidirectional links
;; - M-x org-super-links-custom-cleanup-buffer: Clean duplicate drawers

;;; Code:

(require 'org)
(require 'org-id)

;;; CUSTOMIZATION GROUP

(defgroup org-super-links-custom nil
  "Settings for bidirectional links with custom-ids."
  :group 'org
  :prefix "org-super-links-custom-")

(defcustom org-super-links-custom-backlink-prefix "- "
  "Prefix for backlinks in drawers."
  :type 'string
  :group 'org-super-links-custom)

(defcustom org-super-links-custom-drawer-name "LINKS"
  "Name of the drawer for storing links."
  :type 'string
  :group 'org-super-links-custom)

(defcustom org-super-links-custom-id-format 'timestamp
  "Format for generating custom-ids."
  :type '(choice (const :tag "Timestamp (N20240915T004053.190543)" timestamp)
                 (const :tag "Short UUID" short-uuid)
                 (const :tag "Simple date (N2024-09-15)" date))
  :group 'org-super-links-custom)

(defcustom org-super-links-custom-debug nil
  "Enable debug messages."
  :type 'boolean
  :group 'org-super-links-custom)

;;; INTERNAL VARIABLES

(defvar org-super-links-custom--stored-link nil
  "Stores the current link as (buffer . position . custom-id).")

;;; UTILITY FUNCTIONS

(defun org-super-links-custom--debug (format-string &rest args)
  "Print debug message if debug mode is enabled."
  (when org-super-links-custom-debug
    (apply #'message (concat "ORG-SUPER-LINKS: " format-string) args)))

(defun org-super-links-custom--remove-duplicate-drawers ()
  "Remove duplicate LINKS drawers in current heading. Return number removed."
  (let ((drawer-name org-super-links-custom-drawer-name)
        (drawers-found 0)
        (drawers-removed 0))
    (save-excursion
      (org-back-to-heading t)
      (let ((heading-start (point))
            (heading-end (save-excursion (org-end-of-subtree t t))))
        ;; Count and remove extra drawers
        (goto-char heading-start)
        (while (re-search-forward 
                (format "^[ \t]*:%s:[ \t]*$" (regexp-quote drawer-name))
                heading-end t)
          (setq drawers-found (1+ drawers-found))
          (when (> drawers-found 1)
            ;; Delete this drawer
            (beginning-of-line)
            (let ((drawer-start (point)))
              (when (re-search-forward "^[ \t]*:END:[ \t]*$" heading-end t)
                (forward-line 1)
                (delete-region drawer-start (point))
                (setq drawers-removed (1+ drawers-removed))))))
        drawers-removed))))

(defun org-super-links-custom--generate-id ()
  "Generate an ID according to the configured format."
  (pcase org-super-links-custom-id-format
    ('timestamp (format "N%s" (format-time-string "%Y%m%dT%H%M%S.%6N")))
    ('short-uuid (format "N%s" (substring (org-id-uuid) 0 8)))
    ('date (format "N%s" (format-time-string "%Y-%m-%d")))
    (_ (format "N%s" (format-time-string "%Y%m%dT%H%M%S.%6N")))))

(defun org-super-links-custom--detect-id-at-point ()
  "Detect custom-id [[N{id}]] on current line."
  (save-excursion
    (beginning-of-line)
    (when (re-search-forward "\\[\\[\\(N[^]]+\\)\\]\\]" (line-end-position) t)
      (match-string 1))))

(defun org-super-links-custom--get-heading-context ()
  "Get current heading context: (buffer position title id)."
  (save-excursion
    (org-back-to-heading t)
    (list (current-buffer)
          (point)
          (org-get-heading t t t t)
          (org-id-get-create))))

(defun org-super-links-custom--goto-heading (buffer position)
  "Go to heading at POSITION in BUFFER."
  (switch-to-buffer buffer)
  (goto-char position)
  (org-back-to-heading t))

(defun org-super-links-custom--find-or-create-drawer ()
  "Find existing LINKS drawer or create it. Return drawer bounds (start . end)."
  (let ((drawer-name org-super-links-custom-drawer-name))
    (org-back-to-heading t)
    (let ((heading-beg (point)))
      ;; First, try to find existing drawer using org's built-in function
      (let ((drawer-re (concat "^[ \t]*:" (regexp-quote drawer-name) ":[ \t]*$")))
        (save-excursion
          (goto-char heading-beg)
          ;; Move past the heading line
          (forward-line 1)
          ;; Look for the drawer in the entry
          (let ((entry-end (save-excursion
                            (goto-char heading-beg)
                            (org-end-of-subtree t t))))
            (if (re-search-forward drawer-re entry-end t)
                ;; Found existing drawer
                (let ((drawer-start (match-beginning 0)))
                  (if (re-search-forward "^[ \t]*:END:[ \t]*$" entry-end t)
                      (cons drawer-start (match-end 0))
                    (error "Malformed drawer at %s" drawer-start)))
              ;; No drawer found, create one
              (progn
                ;; Position after all metadata
                (goto-char heading-beg)
                (org-end-of-meta-data t)
                ;; Remove any blank lines before inserting drawer
                (while (and (not (eobp))
                           (looking-at "^[ \t]*$"))
                  (delete-char 1))
                (let ((start (point)))
                  (insert ":" drawer-name ":\n:END:\n")
                  (cons start (point)))))))))))

(defun org-super-links-custom--add-link-to-drawer (buffer position target-id description)
  "Add link to LINKS drawer of heading at POSITION in BUFFER."
  (save-excursion
    (org-super-links-custom--goto-heading buffer position)
    (org-super-links-custom--debug "Adding link in heading: %s" 
                                   (org-get-heading t t t t))
    
    ;; Find or create drawer only once
    (let ((drawer-bounds (org-super-links-custom--find-or-create-drawer)))
      (when drawer-bounds
        ;; Extract base ID for duplicate detection
        (let* ((base-id (if (string-match "\\([^:]+\\)::" target-id)
                           (match-string 1 target-id)
                         target-id))
               (link-pattern (format "\\[\\[id:%s" (regexp-quote base-id))))
          
          ;; Check if a link to this ID already exists
          (goto-char (car drawer-bounds))
          (unless (re-search-forward link-pattern (cdr drawer-bounds) t)
            ;; Link doesn't exist, add it before :END:
            (goto-char (cdr drawer-bounds))
            (forward-line -1)
            (end-of-line)
            (insert "\n" org-super-links-custom-backlink-prefix 
                    (format "[[id:%s][%s]]" target-id description))))))))

(defun org-super-links-custom--replace-custom-id (custom-id target-id target-title)
  "Replace all [[custom-id]] with [[id:target-id][custom-id]] in current buffer."
  (save-excursion
    (goto-char (point-min))
    (let ((search-pattern (concat "\\[\\[" (regexp-quote custom-id) "\\]\\]"))
          (replacement (format "[[id:%s][%s]]" target-id custom-id))
          (count 0))
      
      (while (re-search-forward search-pattern nil t)
        (replace-match replacement t t)
        (setq count (1+ count)))
      
      (when (> count 0)
        (org-super-links-custom--debug "Replaced %d occurrence(s) of %s" count custom-id))
      count)))

;;; MAIN FUNCTIONS

;;;###autoload
(defun org-super-links-custom-store-link ()
  "Generate a timestamp custom-id and store the link location.
Inserts [[N{timestamp}]] at point and stores the location for later linking."
  (interactive)
  (let* ((id (org-super-links-custom--generate-id))
         (id-with-brackets (concat "[[" id "]]"))
         (context (org-super-links-custom--get-heading-context)))
    
    ;; Insert the custom-id
    (insert id-with-brackets)
    
    ;; Store: (buffer position custom-id heading-title)
    (setq org-super-links-custom--stored-link 
          (list (nth 0 context)  ; buffer
                (nth 1 context)  ; position
                id               ; custom-id
                (nth 2 context))) ; heading title
    
    ;; Copy ID to kill ring
    (kill-new id)
    
    (org-super-links-custom--debug "Stored link in '%s': %s" 
                                   (nth 2 context) id)
    (message "Custom-id created and stored: %s" id)))

;;;###autoload
(defun org-super-links-custom-insert-link ()
  "Insert bidirectional links between current heading and stored link.
Creates LINKS drawers in both headings with cross-references."
  (interactive)
  (unless org-super-links-custom--stored-link
    (user-error "No link stored. Use org-super-links-custom-store-link first"))
  
  (let* ((stored org-super-links-custom--stored-link)
         (target-buffer (nth 0 stored))
         (target-position (nth 1 stored))
         (custom-id (nth 2 stored))
         (target-title (nth 3 stored))
         ;; Get source (current) heading info
         (source-context (org-super-links-custom--get-heading-context))
         (source-buffer (nth 0 source-context))
         (source-position (nth 1 source-context))
         (source-title (nth 2 source-context))
         (source-id (nth 3 source-context)))
    
    ;; Get target ID
    (let ((target-id (save-excursion
                      (org-super-links-custom--goto-heading target-buffer target-position)
                      (org-id-get-create))))
      
      (org-super-links-custom--debug "Creating links: '%s' <-> '%s'" 
                                     target-title source-title)
      
      ;; Clean up any duplicate drawers first
      (with-current-buffer target-buffer
        (save-excursion
          (goto-char target-position)
          (org-super-links-custom--remove-duplicate-drawers)))
      
      (with-current-buffer source-buffer
        (save-excursion
          (goto-char source-position)
          (org-super-links-custom--remove-duplicate-drawers)))
      
      ;; 1. Replace [[N...]] with [[id:source][N...]] in target buffer
      (with-current-buffer target-buffer
        (org-super-links-custom--replace-custom-id custom-id source-id source-title))
      
      ;; 2. Add link in target's drawer pointing to source
      (org-super-links-custom--add-link-to-drawer 
       target-buffer target-position source-id source-title)
      
      ;; 3. Add link in source's drawer pointing to target with custom-id search
      (org-super-links-custom--add-link-to-drawer 
       source-buffer source-position 
       (format "%s::%s" target-id custom-id)
       target-title)
      
      ;; Clear stored link
      (setq org-super-links-custom--stored-link nil)
      
      (message "Bidirectional links created: '%s' <-> '%s'" 
               target-title source-title))))

;;; ADDITIONAL INTERACTIVE COMMANDS

;;;###autoload
(defun org-super-links-custom-cleanup-buffer ()
  "Clean up duplicate LINKS drawers in the entire buffer."
  (interactive)
  (when (derived-mode-p 'org-mode)
    (save-excursion
      (goto-char (point-min))
      (let ((count 0))
        (while (outline-next-heading)
          (let ((removed (org-super-links-custom--remove-duplicate-drawers)))
            (when (> removed 0)
              (setq count (+ count removed)))))
        (if (> count 0)
            (message "Removed %d duplicate LINKS drawers" count)
          (message "No duplicate LINKS drawers found"))))))

(provide 'org-super-links-custom)

;;; org-super-links-custom.el ends here