Organizing computer windows

#!/Users/dev/.dotfiles/bin/bb
;;explicit path above because I can't figure out how to update Karabiner-Elements's PATH to find babashka via `env`.

(require '[clojure.java.shell :refer [sh]]
         '[cheshire.core :as json]
         '[clojure.core.match :refer [match]])

;;Space indexes aren't persistent, seems like MacOS rearranges them somehow.
;;So use labels s1, s2, ..., s10 for all spaces so they can have a consistent identity
;;Moving spaces between monitors tears the background =( https://github.com/koekeishiya/yabai/issues/781


(def yabai
  "/opt/local/bin/yabai")

(def placeholder-space-label "s11")

(defn active-display-idx []
  (-> (sh yabai "-m" "query" "--displays" "--display" "mouse")
      :out
      (json/parse-string true)
      :index
      str))

(defn current-state
  []
  (let [spaces (->
                ;;yabai takes about 20--30ms to run
                (sh yabai "-m" "query" "--spaces")

                :out
                (json/parse-string true)
                (->> (map #(update % :display str))
                     (map #(assoc % :idx (str (:index %))))))]

    {:display->spaces (reduce (fn [m {:keys [idx display] :as space}]
                                (assoc-in m [display idx] space))
                              {} spaces)
     :spaces-by-label (into {} (map (juxt :label identity) spaces))}))


(defn focus-space!
  [idx]
  (sh yabai "-m" "space" "--focus" idx))


(defn focus-display!
  [idx]
  (sh yabai "-m" "display" "--focus" idx))


(defn move-space-to-display!
  [{:keys [display->spaces spaces-by-label]} space-label display-idx]
  (let [space (spaces-by-label space-label)
        old-display-idx (:display space)]
    (when (not= display-idx old-display-idx)
      (let [only-space-on-old-display? (= 1 (count (display->spaces old-display-idx)))]

        (when only-space-on-old-display?
          ;;have to put placeholder on old display first, so that moving the space to the new display always works.
          ;;there's no atomic space swapping in yabai yet: https://github.com/koekeishiya/yabai/pull/555
          (prn "Space" space-label "is only space on" old-display-idx ", moving placeholder to take its place")
          (sh yabai "-m" "space" placeholder-space-label "--display" old-display-idx))

        ;;move space to new display
        (sh yabai "-m" "space" space-label "--display" display-idx)

        ;;if the space we're moving was visible, then swap whatever was on the target display to the old display.
        (when (:is-visible space)
          (let [new-display-visible-space-label (->> (display->spaces display-idx)
                                                     vals
                                                     (filter :is-visible)
                                                     first
                                                     :label)]
            (sh yabai "-m" "space" new-display-visible-space-label "--display" old-display-idx)))))))


(defn switch-to-space-on-active-display!
  "Switches current display to space and focuses it. If space is already visible on another display, swap the current space to that display"
  [state space-label]
  (let [display-idx (active-display-idx)]
    (move-space-to-display! state space-label display-idx)
    (focus-space! space-label)
    (focus-display! display-idx)))


(defn focused-space
  [state]
  (->> (vals (:spaces-by-label state))
       (filter :has-focus)
       first))


(defn toggle-stack!
  [state]
  (let [{:keys [idx type]} (focused-space state)]
    (sh yabai "-m" "config" "--space" idx "layout" (case type
                                                     "bsp" "stack"
                                                     "stack" "bsp"))))

(defn focus-window!
  [state next-or-prev]
  (let [{:keys [label type]} (focused-space state)]
    (case type
      "bsp"
      (or (= 0 (:exit (sh yabai "-m" "window" "--focus" next-or-prev)))
          (= 0 (:exit (sh yabai "-m" "window" "--focus" (case next-or-prev
                                                          "next" "first"
                                                          "prev" "last")))))
      "stack"
      (or (= 0 (:exit (sh yabai "-m" "window" "--focus" (str "stack." next-or-prev))))
          (= 0 (:exit (sh yabai "-m" "window" "--focus" (case next-or-prev
                                                          "next" "stack.first"
                                                          "prev" "stack.last"))))))))


(time ;;hmm, most commands are still on the order of 100ms, probably the query and json parsing...
  (let [state (current-state)]
    (match (vec *command-line-args*)
      ["info"]
      (clojure.pprint/pprint (current-state))

      ["active-display"]
      (prn (active-display-idx))

      ["switch-to-space" space-label]
      (switch-to-space-on-active-display! state space-label)

      ["toggle-stack"]
      (toggle-stack! state)

      ["focus-window" next-or-prev]
      (focus-window! state next-or-prev)

      :else
      (prn "Unknown: " *command-line-args*))))

;; See: https://github.com/yqrashawn/GokuRakuJoudo/blob/master/tutorial.md
;; Keys specified as physical ones (i.e., ignoring alternative keyboard layouts like colmak, dvorak, etc.)
;; update by running:
;;
;;     GOKU_EDN_CONFIG_FILE=~/.dotfiles/scripts/karabiner.edn goku

;; !  | means mandatory
;; #  | means optional
;; C  | left_command
;; T  | left_control
;; O  | left_option
;; S  | left_shift
;; F  | fn
;; Q  | right_command
;; W  | right_control
;; E  | right_option
;; R  | right_shift
;; !! | mandatory command + control + optional + shift (hyper)
;; ## | optional any

{:applications {:chrome ["^com\\.google\\.Chrome$"]
                :emacs ["^org\\.gnu\\.Emacs$"]}

 :templates {:yabai "/opt/local/bin/yabai -m %s"
             :yabaik "/Users/dev/.dotfiles/bin/yabaik %s"}

 :main [{:des "Caps lock to control"
         :rules [[:##caps_lock :left_control]]}

        {:des "Yabai"
         :rules [
                 [:!Oj [:yabaik "focus-window next"]]
                 [:!Ok [:yabaik "focus-window prev"]]

                 [:!Ou [:yabai "display --focus prev || /opt/local/bin/yabai -m display --focus last"]]
                 [:!Oi [:yabai "display --focus next || /opt/local/bin/yabai -m display --focus first"]]

                 [:!OSu [:yabai "window --display prev || /opt/local/bin/yabai -m window --display last"]]
                 [:!OSi [:yabai "window --display next || /opt/local/bin/yabai -m window --display first"]]

                 [:!Ospacebar [:yabai "space --rotate 90"]]
                 [:!Otab [:yabai "display --focus recent"]]

                 [:!Oy [:yabaik "toggle-stack"]]

                 [:!O1 [:yabaik "switch-to-space s1"]]
                 [:!O2 [:yabaik "switch-to-space s2"]]
                 [:!O3 [:yabaik "switch-to-space s3"]]
                 [:!O4 [:yabaik "switch-to-space s4"]]
                 [:!O5 [:yabaik "switch-to-space s5"]]
                 [:!O6 [:yabaik "switch-to-space s6"]]
                 [:!O7 [:yabaik "switch-to-space s7"]]
                 [:!O8 [:yabaik "switch-to-space s8"]]
                 [:!O9 [:yabaik "switch-to-space s9"]]
                 [:!O0 [:yabaik "switch-to-space s10"]]

                 [:!OS1 [:yabai "window --space s1"]]
                 [:!OS2 [:yabai "window --space s2"]]
                 [:!OS3 [:yabai "window --space s3"]]
                 [:!OS4 [:yabai "window --space s4"]]
                 [:!OS5 [:yabai "window --space s5"]]
                 [:!OS6 [:yabai "window --space s6"]]
                 [:!OS7 [:yabai "window --space s7"]]
                 [:!OS8 [:yabai "window --space s8"]]
                 [:!OS9 [:yabai "window --space s9"]]
                 [:!OS0 [:yabai "window --space s10"]]

                 ]}


        {:des "Remap emacs-muscle-memory to similar keys outside of emacs"
         :rules [
                 ;;arrows
                 [:!Tl :down_arrow :!emacs]
                 [:!Tr :up_arrow :!emacs]
                 [:!Ty :right_arrow :!emacs]
                 [:!Tn :left_arrow :!emacs]

                 [:!Tu :escape :!emacs]

                 [:!Cr :page_up :chrome]
                 [:!Cl :page_down :chrome]

                 ]}]
}