README.md

I've been moving my blog to Astro and needed to add a slug property to each file. My files had a permalink that included the slug but I needed just the slug as a standalone property.

✅ Script did exactly what I needed ✨

The prompt

(With my babashka scripting context window attached)

Please create a script that transforms all markdown files in a provided directory in the following way:

The goal is to add a slug field to the YAML front matter based on an existing frontmatter field permalink

The permalink field can look like this:

permalink: /posts/emacs-and-vim.html 
permalink: /posts/analytics-data.html 

And I want to extract the emacs-and-vim or analytics-data values as slug

add-slug.clj

#!/usr/bin/env bb

(require '[clojure.string :as str]
         '[babashka.fs :as fs]
         '[clj-yaml.core :as yaml]
         '[babashka.cli :as cli])

(defn extract-frontmatter
  "Extracts YAML frontmatter from markdown content.
   Returns [frontmatter remaining-content] or nil if no frontmatter found."
  [content]
  (when (str/starts-with? content "---\n")
    (when-let [end-idx (str/index-of content "\n---\n" 4)]
      (let [frontmatter (subs content 4 end-idx)
            remaining (subs content (+ end-idx 5))]
        [frontmatter remaining]))))

(defn extract-slug-from-permalink
  "Extracts slug from permalink value like '/posts/some-slug.html'"
  [permalink]
  (when permalink
    (let [pattern #"/posts/([^/]+)\.html"
          matches (re-find pattern permalink)]
      (second matches))))

(defn update-frontmatter-data
  "Updates frontmatter data by adding slug based on permalink"
  [data]
  (if-let [permalink (:permalink data)]
    (if-let [slug (extract-slug-from-permalink permalink)]
      (-> data
          (assoc :slug slug)
          (dissoc :permalink))
      data)
    data))

(defn update-file-frontmatter
  "Updates the frontmatter in a markdown file by adding slug based on permalink"
  [file-path {:keys [dry-run verbose]}]
  (let [content (slurp file-path)
        [frontmatter remaining] (extract-frontmatter content)]
    (if frontmatter
      (let [data (yaml/parse-string frontmatter)
            updated-data (update-frontmatter-data data)]
        (when verbose
          (println "📄 Processing:" (str file-path))
          (when-let [slug (:slug updated-data)]
            (println "🔖 Extracted slug:" slug)))
        
        (if (not= data updated-data)
          (let [new-content (str "---\n"
                                (yaml/generate-string updated-data
                                                    :dumper-options {:flow-style :block})
                                "---\n"
                                remaining)]
            (if dry-run
              (println "🔍 Would update:" (str file-path))
              (do
                (spit file-path new-content)
                (println "✅ Updated:" (str file-path)))))
          (when verbose
            (println "⏭️ No changes needed for:" (str file-path)))))
      (println "⚠️ No frontmatter found in:" (str file-path)))))

(def cli-options
  {:coerce {:verbose :boolean
            :dry-run :boolean}
   :spec {:dir {:desc "Directory containing markdown files"
                :require true}
          :verbose {:desc "Enable verbose output"
                   :alias :v}
          :dry-run {:desc "Show what would be done without making changes"
                   :alias :d}}})

(defn process-directory
  [{:keys [dir] :as opts}]
  (let [md-files (->> (fs/glob dir "**/*.md")
                      (map fs/file))]
    (if (seq md-files)
      (do
        (println "🔍 Found" (count md-files) "markdown files")
        (doseq [file md-files]
          (update-file-frontmatter file opts)))
      (println "⚠️ No markdown files found in directory:" dir))))

(defn -main [& args]
  (let [opts (cli/parse-opts args cli-options)]
    (if (:help opts)
      (println (cli/format-opts cli-options))
      (process-directory opts))))

(when (= *file* (System/getProperty "babashka.file"))
  (apply -main *command-line-args*))