An idea for a hotel theme api:

var bat_theme_rules = [
        {path_opts: [ELEVATOR, BAT, {skip_tile=BAT_BOXES, width=2}]}
        ]

A bit nicer in clojure:

(def bat_theme_rules [
  {:label     "Start to Bat, Box-free Path Rule"
   :path_opts [:elevator :bat {:skip_tile :bat_boxes :width 2}]}
  {:label     "Post-Boss Battle Lost-Bat Elevator Walk"
   :path_opts [:boss-room :elevator {:skip_tile :bat_boxes :width 2}]}])

in clojure via repl

(defn merge-org-roam-files [{:keys [old-id new-id dry-run]}]
  (println "\n\n\tFind-replacing across your org files!!")
  (if dry-run (println "\tDRY RUN!") (println "\tBOMBS AWAY!"))

  (let [files
        (concat
          (fs/list-dir (fs/expand-home "~/todo/garden") "*.org")
          (fs/list-dir (fs/expand-home "~/todo/daily") "*.org")
          (fs/list-dir (fs/expand-home "~/todo/garden/workspaces") "*.org"))]
    (->> files
         #_(take 50)
         (map (fn [file]
                (let [lm           (fs/last-modified-time file)
                      any-changes? (atom false)
                      res
                      (cond->> (slurp (str file))
                        true (string/split-lines)
                        true
                        (map
                          (fn [line]
                            (if (string/includes? line old-id)
                              (do
                                (when dry-run
                                  (println "\n\t" (fs/file-name file)
                                           "\nwould replace" line
                                           "\nwith" (string/replace line old-id new-id)))

                                (when-not @any-changes?
                                  (reset! any-changes? true))

                                (when-not dry-run
                                  (println "\n\t updating" (fs/file-name file) "\n" line))

                                (if dry-run
                                  line (string/replace line old-id new-id)))
                              line)))
                        true                (string/join "\n")
                        (and (not dry-run)
                             @any-changes?) (spit (str file)))]
                  (fs/set-last-modified-time file lm)
                  res)))
         (remove nil?)
         count)))

(comment
  (merge-org-roam-files
    {:old-id  "id:f617ee24-cfad-4c6e-8dff-227ae56c22e5"
     :new-id  "id:f617ee24-cfad-4c6e-8dff-227ae56c22e5"
     :dry-run true}))

;;;###autoload
(defun russ/last-screenshot ()
  (let ((filename (shell-command-to-string "ls ~/Screenshots | sort -V | tail -n 1")))
    (s-trim filename)))

Following the blame, this is only one step removed from the original snippet:

# key: scr
# name: screenshot
# --
`(shell-command-to-string "ls ~/Screenshots | sort -V | tail -n 1")`

with a link to the repo: https://github.com/russmatney/clawe

(defn resource-notes []
  (->>
    (db/query
      '[:find (pull ?note [*])
        :where
        [?note :doctor/type :type/note]
        [?note :org/name-string ?name]
        (or
          [?note :org/tags "resources"]
          [(clojure.string/includes? ?name "resources")])])
    (map first)
    (garden.db/join-children)
    (map (fn [db-note]
           (let [found-note (some-> db-note :org/id blog.db/id->note)]
             (if found-note
               (merge db-note found-note)
               ;; TODO support looking up note in blog.db without :org/id
               ;; probably similarly via :org/fallback-id
               db-note))))))

(defn resource-notes-from-blog-db []
  (->>
    (blog.db/all-notes)
    (filter (fn [note]
              (or
                (-> note :org/name-string (string/includes? "resources"))
                (-> note :org/tags (#(% "resources"))))))))

(comment
  (count (resource-notes))
  (count (resource-notes-from-blog-db))

  (->>
    (resource-notes)
    (filter (comp seq :org/items)))

  (->>
    #_(resource-notes)
    (resource-notes-from-blog-db)
    first
    org-crud/nested-item->flattened-items)

  (->>
    (db/query
      '[:find (pull ?note [*])
        :where
        [?note :doctor/type :type/note]
        [?note :org/parent-name ?pname]
        [(clojure.string/includes? ?pname "mac osx customization")]
        [?note :org/name-string ?name]
        [(clojure.string/includes? ?name "resources")]])
    (map first)
    (garden.db/join-children))

  (db/query '[:find (pull ?c [*])
              :in $ ?db-id
              :where [?c :org/parents ?db-id]]
            19429))

I want to plan a stream to create the recording

and edit the recording into a reasonable youtube video

maybe use-filter should take a datalog query and the connection

ideally it could also ping the backend for stats/missing data

derive filters/presets from the content itself

(or define them via database indexes)

e.g. sort-bys, filter-bys, group-bys

e.g. preset for grouping by top 5 most common tags

e.g. preset for sorting by any dates found

e.g. paging on presets means show-more, i.e. got to 10 most-common-tags

show suggested tags on hover, click to add

Hopefully I can keep this up to date, and that I don't mix it up with the content calendar

Will try to assign some dates via Twitch