datahike-browser-tests 1.0.0

package/bb/src/tools/build.clj

@@ -0,0 +1,132 @@
+(ns tools.build
+  (:refer-clojure :exclude [compile])
+  (:require
+    [babashka.fs :as fs]
+    [babashka.process :as p]
+    [cheshire.core :as json]
+    [clojure.string :as str]
+    [clojure.tools.build.api :as b]
+    [selmer.parser :refer [render]]
+    [tools.version :as version :refer [read-edn-file]]))
+
+(defn clean [{:keys [target-dir] :as _project-config}]
+  (print (str "Cleaning up target directory '" target-dir "'..."))
+  (fs/delete-tree target-dir)
+  (println "Done."))
+
+(defn basis [{:keys [deps-file aliases] :as _project-config}]
+  (b/create-basis (cond-> {:project deps-file}
+                    aliases (assoc :aliases aliases))))
+
+(defn write-version-resource
+  "Writes version string to resources/DATAHIKE_VERSION for embedding in builds"
+  [repo-config]
+  (print "Writing version resource file...")
+  (fs/create-dirs "resources")
+  (spit "resources/DATAHIKE_VERSION" (version/string repo-config))
+  (println "Done. Version:" (version/string repo-config)))
+
+(defn compile-java
+  ([] (compile-java (read-edn-file "config.edn")))
+  ([{:keys [class-dir java-src-dirs] :as project-config}]
+   (print (str "Compiling Java classes saving them to '" class-dir "'..."))
+   (b/javac {:src-dirs java-src-dirs
+             :class-dir class-dir
+             :basis (basis project-config)
+             :javac-opts ["--release" "8"
+                          "-Xlint:deprecation"]})
+   (println "Done.")))
+
+(defn compile-clojure [{:keys [class-dir src-dirs] :as project-config}]
+  (print (str "Compiling Clojure namespaces saving them to '" class-dir "'..."))
+  (b/compile-clj {:src-dirs src-dirs
+                  :class-dir class-dir
+                  :basis (basis project-config)})
+  (println "Done."))
+
+(defn pom-path [{:keys [class-dir lib] :as _project-config}]
+  (b/pom-path {:lib lib
+               :class-dir class-dir}))
+
+(defn pom [{:keys [pom-template scm] :as repo-config}
+           {:keys [class-dir lib src-dirs] :as project-config}]
+  (print (str "Creating pom file from template at '" pom-template "'..."))
+  (b/write-pom {:src-pom pom-template
+                :src-dirs src-dirs
+                :class-dir class-dir
+                :lib lib
+                :version (version/string repo-config)
+                :basis (basis project-config)
+                :scm (assoc scm :tag (version/sha))})
+  (println "Done." "Saved to" (pom-path project-config)))
+
+(defn jar-path [repo-config {:keys [target-dir jar-pattern] :as project-config}]
+  (str target-dir "/" (render jar-pattern {:project project-config
+                                           :repo repo-config
+                                           :version-str (version/string repo-config)})))
+
+(defn lib-path [repo-config {:keys [target-dir jar-pattern] :as project-config}]
+  (str target-dir "/" (render jar-pattern {:project project-config
+                                           :repo repo-config
+                                           :version-str (version/string repo-config)})))
+
+(defn jar
+  "Builds jar file"
+  [repo-config {:keys [class-dir target-dir src-dirs resource-dir] :as project-config}]
+  (print (str "Packaging jar at '" target-dir "'..."))
+  (b/copy-dir {:src-dirs (filter identity (conj src-dirs resource-dir))
+               :target-dir class-dir})
+  (b/jar {:class-dir class-dir
+          :jar-file (jar-path repo-config project-config)})
+  (println "Done."))
+
+(defn uber
+  "Builds uber jar file"
+  [repo-config {:keys [class-dir target-dir src-dirs resource-dir main] :as project-config}]
+  (print (str "Packaging uber jar at '" target-dir "'..."))
+  (b/copy-dir {:src-dirs (filter identity (conj src-dirs resource-dir))
+               :target-dir class-dir})
+  (b/uber {:class-dir class-dir
+           :uber-file (jar-path repo-config project-config)
+           :basis (basis project-config)
+           :main main})
+  (println "Done."))
+
+(defn native-compile [repo-config {:keys [project-target-dir class-path project-name java-interface] :as project-config}]
+  (if-let [graalvm-dir (System/getenv "GRAALVM_HOME")]
+    (let [native-jar (jar-path repo-config project-config)
+          svm-jar (str graalvm-dir "/lib/svm/builder/svm.jar")
+          java-base-file (str/replace java-interface #"LibDatahike\.java$" "LibDatahikeBase.java")]
+      (println "Compiling native bindings Java classes.")
+      (p/shell (str graalvm-dir "/bin/javac")
+               "-cp" (str native-jar ":" svm-jar)
+               "-d" class-path
+               java-base-file java-interface)
+      (println "Compiling shared library through native image.")
+      (p/shell (str graalvm-dir "/bin/native-image")
+               "-jar" native-jar
+               "-cp" class-path
+               (str "-o " project-name)
+               "--shared"
+               "-H:+ReportExceptionStackTraces"
+               "-H:+GenerateBuildArtifactsFile"
+               "-J-Dclojure.spec.skip-macros=true"
+               "-J-Dclojure.compiler.direct-linking=true"
+               (str "-H:IncludeResources=" (version/string repo-config))
+               "--initialize-at-build-time"
+               "-H:Log=registerResource:"
+               "--verbose"
+               "--no-fallback"
+               "--no-server"
+               "-J-Xmx5g")
+      (fs/delete-tree project-target-dir)
+      (fs/create-dir project-target-dir)
+      (->> (slurp "build-artifacts.json")
+           (json/parse-string)
+           vals
+           (apply concat)
+           (cons "build-artifacts.json")
+           (run! #(fs/move % project-target-dir))))
+    (do (println "GRAALVM_HOME not set!")
+        (println "Please set GRAALVM_HOME to the root of the graalvm directory on your system.")
+        (System/exit 1))))

package/bb/src/tools/clj_kondo.clj

@@ -0,0 +1,32 @@
+(ns tools.clj-kondo
+  "Generate clj-kondo export configuration for dynamically generated API."
+  (:require [babashka.process :as p]))
+
+(defn generate-clj-kondo-config!
+  "Generate clj-kondo configuration from api-specification.
+
+  This:
+  1. Generates export config at resources/clj-kondo.exports/io.replikativ/datahike/config.edn
+     (packaged in jar, auto-imported by consuming projects)
+  2. Copies to .clj-kondo/datahike/datahike/config.edn
+     (for local development via :config-paths)
+  3. Updates main config at .clj-kondo/config.edn with type-mismatch linter
+     (for Datahike's own project)
+
+  This allows clj-kondo to understand the dynamically expanded API functions
+  from the emit-api macro, providing IDE autocomplete, signature hints, and
+  type checking."
+  [export-path local-path main-path]
+  (println "Generating clj-kondo configuration...")
+  (let [clj-code (str "(require '[datahike.codegen.clj-kondo :as clj-kondo]) "
+                      "(clj-kondo/write-config! \"" export-path "\") "
+                      "(clj-kondo/copy-export-to-local! \"" export-path "\" \"" local-path "\") "
+                      "(clj-kondo/update-main-config! \"" main-path "\")")
+        result (p/shell {:out :string
+                         :err :string}
+                        "clojure" "-M" "-e" clj-code)]
+    (when-not (zero? (:exit result))
+      (println "Error generating clj-kondo config:")
+      (println (:err result))
+      (throw (ex-info "clj-kondo config generation failed" result)))
+    (println (:out result))))

package/bb/src/tools/deploy.clj

@@ -0,0 +1,26 @@
+(ns tools.deploy
+  (:require [babashka.process :refer [shell]]
+            [tools.build :refer [pom-path jar-path]]))
+
+(defn clj [& args] (apply shell "clojure" args))
+(defn quoted [s] (str \" s \"))
+
+(defn remote
+  "Deploy library to clojars"
+  [repo-config project-config]
+  (if-not (System/getenv "CLOJARS_USERNAME")
+    (println "Environment variable CLOJARS_USERNAME not set!")
+    (if-not (System/getenv "CLOJARS_PASSWORD")
+      (println "Environment variable CLOJARS_PASSWORD not set!")
+      (clj "-X:deploy" "deps-deploy.deps-deploy/deploy"
+           :installer :remote
+           :artifact (jar-path repo-config project-config)
+           :pom-file (quoted (pom-path project-config))))))
+
+(defn local
+  "Install library locally"
+  [repo-config project-config]
+  (clj "-X:deploy" "deps-deploy.deps-deploy/deploy"
+       :installer :local
+       :artifact (jar-path repo-config project-config)
+       :pom-file (quoted (pom-path project-config))))

package/bb/src/tools/examples.clj

@@ -0,0 +1,19 @@
+(ns tools.examples
+  "Tools for managing example projects"
+  (:require [clojure.string :as str]
+            [tools.version :as version]))
+
+(defn update-java-examples-version!
+  "Update the datahike.version property in examples/java/pom.xml to match current version"
+  [config]
+  (let [pom-file "examples/java/pom.xml"
+        current-version (version/string config)
+        pom-content (slurp pom-file)
+        updated-content (str/replace
+                         pom-content
+                         #"<datahike\.version>[^<]+</datahike\.version>"
+                         (str "<datahike.version>" current-version "</datahike.version>"))]
+    (when (not= pom-content updated-content)
+      (println (str "Updating examples/java/pom.xml datahike.version to " current-version))
+      (spit pom-file updated-content)
+      true)))

package/bb/src/tools/npm.clj

@@ -0,0 +1,100 @@
+(ns tools.npm
+  "Build and version management for npm package."
+  (:require [babashka.fs :as fs]
+            [babashka.process :as p]
+            [cheshire.core :as json]
+            [clojure.string :as str]
+            [tools.version :as version]))
+
+(defn clean-npm-package!
+  "Remove compiled JS files from npm package directory (both Node and browser builds)"
+  [npm-package-path]
+  (println "Cleaning npm package directory...")
+  (let [js-files (fs/glob npm-package-path "*.js")
+        js-map-files (fs/glob npm-package-path "*.js.map")
+        all-files (concat js-files js-map-files)
+        files-to-keep #{"test.js" "test-final.js" "test-config-keys.js" "test-key-duplication.js"}
+        files-to-delete (remove #(contains? files-to-keep (str (fs/file-name %))) all-files)]
+    (doseq [file files-to-delete]
+      (fs/delete file))
+    (println (str "Removed " (count files-to-delete) " compiled files from " npm-package-path))
+    (when (fs/exists? (str npm-package-path "/browser"))
+      (fs/delete-tree (str npm-package-path "/browser"))
+      (println "Removed browser build directory"))))
+
+(defn update-package-json-version!
+  "Generate npm package.json from template with version from config.edn"
+  [config npm-package-path]
+  (let [version-str (version/string config)
+        package-json-path (str npm-package-path "/package.json")
+        template-path (str npm-package-path "/package.template.json")
+        template-content (slurp template-path)
+        generated-content (str/replace template-content "{{VERSION}}" version-str)]
+    (spit package-json-path generated-content)
+    (println (str "Generated " package-json-path " from template with version: " version-str))))
+
+(defn generate-typescript-definitions!
+  "Generate TypeScript definitions for npm package"
+  [output-path]
+  (println "Generating TypeScript definitions...")
+  (let [clj-code (str "(require '[datahike.codegen.typescript :as ts]) "
+                      "(ts/write-type-definitions! \"" output-path "\")")
+        result (p/shell {:out :string
+                         :err :string}
+                        "clojure" "-M" "-e" clj-code)]
+    (when-not (zero? (:exit result))
+      (println "Error generating TypeScript definitions:")
+      (println (:err result))
+      (throw (ex-info "TypeScript generation failed" result)))
+    (println (str "TypeScript definitions written to: " output-path))))
+
+(defn build-npm-package!
+  "Build npm package: clean, update version, generate types, compile ClojureScript for Node and Browser"
+  [config npm-package-path]
+  (println "Building npm package...")
+  (println "")
+
+  (println "Step 1/6: Cleaning old compiled files")
+  (clean-npm-package! npm-package-path)
+  (println "")
+
+  (println "Step 2/6: Updating package.json version")
+  (update-package-json-version! config npm-package-path)
+  (println "")
+
+  (println "Step 3/6: Generating TypeScript definitions")
+  (generate-typescript-definitions! (str npm-package-path "/index.d.ts"))
+  (println "")
+
+  (println "Step 4/6: Compiling Node.js build with shadow-cljs")
+  (let [result (p/shell {:out :inherit
+                         :err :inherit}
+                        "npx shadow-cljs compile npm-release")]
+    (when-not (zero? (:exit result))
+      (throw (ex-info "Shadow-cljs Node.js compilation failed" result)))
+    (println ""))
+
+  (println "Step 5/6: Compiling Browser build with shadow-cljs")
+  (let [result (p/shell {:out :inherit
+                         :err :inherit}
+                        "npx shadow-cljs compile browser-release")]
+    (when-not (zero? (:exit result))
+      (throw (ex-info "Shadow-cljs browser compilation failed" result)))
+    (println ""))
+
+  (println "Step 6/6: Running npm package tests")
+  (let [test-result (p/shell {:dir npm-package-path
+                              :out :inherit
+                              :err :inherit}
+                             "node test.js")]
+    (when-not (zero? (:exit test-result))
+      (throw (ex-info "npm package tests failed" test-result)))
+    (println "")
+    (println "✓ npm package build complete!")
+    (println (str "  Version: " (version/string config)))
+    (println (str "  Node.js: " npm-package-path "/datahike.js.api.js"))
+    (println (str "  Browser: " npm-package-path "/browser/main.js"))
+    (println "")
+    (println "Next steps:")
+    (println (str "  1. Verify: cd " npm-package-path " && npm pack --dry-run"))
+    (println "  2. Publish: npm publish")))

package/bb/src/tools/python.clj

@@ -0,0 +1,14 @@
+(ns tools.python
+  "Python package utilities."
+  (:require [clojure.string :as str]
+            [tools.version :as version]))
+
+(defn update-python-version!
+  "Generate Python version file from config.edn"
+  [config python-package-path]
+  (let [version-str (version/string config)
+        version-file-path (str python-package-path "/src/datahike/_version.py")
+        content (str "\"\"\"Auto-generated version file from config.edn.\"\"\"\n"
+                     "__version__ = \"" version-str "\"\n")]
+    (spit version-file-path content)
+    (println (str "Generated " version-file-path " with version: " version-str))))

package/bb/src/tools/release.clj

@@ -0,0 +1,94 @@
+(ns tools.release
+  (:require
+   [babashka.fs :as fs]
+   [borkdude.gh-release-artifact :as gh]
+   [selmer.parser :refer [render]]
+   [tools.build :as build]
+   [tools.version :as version])
+  (:import
+   [clojure.lang ExceptionInfo]))
+
+(defn fib [a b]
+  (lazy-seq (cons a (fib b (+ a b)))))
+
+(defn retry-with-fib-backoff [retries exec-fn fail-test-fn]
+  (loop [idle-times (take retries (fib 1 2))]
+    (let [result (exec-fn)]
+      (if (fail-test-fn result)
+        (do (println "Returned: " result)
+            (if-let [sleep-ms (first idle-times)]
+              (do (println "Retrying with remaining back-off times (in s): " idle-times)
+                  (Thread/sleep (* 1000 sleep-ms))
+                  (recur (rest idle-times)))
+              result))
+        result))))
+
+(defn try-release [file repo-config]
+  (try (gh/release-artifact
+        {:org (:org repo-config)
+         :repo (:lib repo-config)
+         :tag (version/string repo-config)
+         :commit (version/current-commit)
+         :file file
+         :content-type "application/java-archive"
+         :draft false})
+       (catch ExceptionInfo e
+         (assoc (ex-data e) :failure? true))))
+
+(defn gh-release
+  "Create a GitHub release and upload the library jar"
+  [repo-config file]
+  (println "Trying to release artifact" file "...")
+  (let [_ (when-not (fs/exists? file)
+            (println "Release file at" file "doesn't exist!")
+            (System/exit 1))
+        ret (retry-with-fib-backoff 10 #(try-release file repo-config) :failure?)]
+    (if (:failure? ret)
+      (do (println "GitHub release failed!")
+          (System/exit 1))
+      (println (:url ret)))))
+
+(defn zip-path [lib version target-dir zip-pattern]
+  (let [platform (System/getenv "DTHK_PLATFORM")
+        arch (System/getenv "DTHK_ARCH")]
+    (if-not (and platform arch)
+      (do (println "ERROR: Environment variables DTHK_PLATFORM and DTHK_ARCH need to be set")
+          (System/exit 1))
+      (str target-dir "/" (render zip-pattern {:platform platform
+                                               :arch arch
+                                               :lib lib
+                                               :version version})))))
+
+(defn zip-lib [config project]
+  (let [{:keys [target-dir zip-pattern]} (-> config :release project) lib "libdatahike"
+        version (version/string config)]
+    (if-not (fs/exists? target-dir)
+      (do (println (str "ERROR: " target-dir " path not found, please compile first."))
+          (System/exit 1))
+      (let [zip-name (zip-path lib version "." zip-pattern)]
+        (fs/zip zip-name [target-dir])
+        zip-name))))
+
+(defn zip-cli [config project]
+  (let [{:keys [target-dir binary-name zip-pattern]} (-> config :release project)
+        lib (:lib config)
+        version (version/string config)
+        binary-path (str target-dir "/" binary-name)]
+    (if-not (fs/exists? binary-path)
+      (do (println (str "ERROR: " binary-path " executable not found, please compile first."))
+          (System/exit 1))
+      (let [zip-name (zip-path lib version target-dir zip-pattern)]
+        (fs/zip zip-name [binary-name])
+        zip-name))))
+
+(defn -main [config args]
+  (let [cmd (first args)]
+    (case cmd
+      "jar" (->> (build/jar-path config (-> config :build :clj))
+                 (gh-release config))
+      "native-image" (->> (zip-cli config :native-cli)
+                          (gh-release config))
+      "libdatahike" (->> (zip-lib config :libdatahike)
+                         (gh-release config))
+      (do (println "ERROR: Command not found: " cmd)
+          (System/exit 1)))))

package/bb/src/tools/test.clj

@@ -0,0 +1,148 @@
+(ns tools.test
+  (:refer-clojure :exclude [test])
+  (:require [babashka.fs :as fs]
+            [babashka.process :as p]
+            [clojure.java.io :as io]
+            [tools.build :as build]))
+
+(defn clj [opts & args] (apply p/shell opts "clojure" args))
+(defn git [opts & args] (apply p/shell opts "git" args))
+
+(defn kaocha [& args]
+  (apply clj {:extra-env {"TIMBRE_LEVEL" ":warn"}}
+         "-M:test" "-m" "kaocha.runner" args))
+
+(defn back-compat [config]
+  (println "Testing backwards compatibility")
+  (let [old-version-dir "datahike-old"
+        ssh-dir (fs/expand-home "~/.ssh")
+        known-hosts-file (fs/expand-home "~/.ssh/known_hosts")]
+    (println "WRITING TEST DATA TO TEST-DB")
+    (when-not (fs/exists? ssh-dir)
+      (fs/create-dirs ssh-dir))
+    (fs/delete-on-exit old-version-dir)
+    (let [output (:out (p/shell {:out :string}
+                                "ssh-keyscan" "github.com"))]
+      (when-not (fs/exists? known-hosts-file)
+        (fs/create-file known-hosts-file))
+      (fs/write-lines known-hosts-file [output] {:append true}))
+    (fs/delete-tree old-version-dir)
+    (git {:dir "."}
+         "clone" "--depth" "1" (:git-url config) old-version-dir)
+
+    ;; Generate Java API bindings before compiling
+    (println "Generating Java API for old version...")
+    (let [old-dir old-version-dir
+          cp (:out (p/shell {:out :string :dir old-dir}
+                           "clojure" "-Spath"))]
+      ;; First compile Java dependencies
+      (println "Compiling Java dependencies...")
+      (p/shell {:dir old-dir}
+               "javac" "-cp" cp "-d" "target/classes"
+               "java/src/datahike/java/IEntity.java"
+               "java/src/datahike/java/Util.java")
+      ;; Generate DatahikeGenerated.java
+      (println "Generating DatahikeGenerated.java...")
+      (p/shell {:dir old-dir}
+               "clojure" "-M" "-m" "datahike.codegen.java" "java/src-generated"))
+
+    (build/compile-java {:class-dir (str old-version-dir "/target/classes")
+                         :java-src-dirs [(str old-version-dir "/java")
+                                         (str old-version-dir "/java/src-generated")]
+                         :deps-file (str old-version-dir "/deps.edn")})
+
+    (clj {:dir old-version-dir}
+         "-Sdeps" (str "{:deps {io.replikativ/datahike {:local/root \".\"}}"
+                       " :paths [\"test/datahike/backward_compatibility_test/src\"]}")
+         "-X" "backward-test/write")
+    (fs/delete-tree old-version-dir)
+
+    (println "READING TEST DATA FROM TEST-DB")
+    (clj {:dir "."}
+         "-Sdeps" (str "{:deps {io.replikativ/datahike {:local/root \".\"}}"
+                       " :paths [\"test/datahike/backward_compatibility_test/src\"]}")
+         "-X" "backward-test/read")))
+
+(defn native-image []
+  (if (fs/exists? "./dthk")
+    (p/shell "./bb/resources/native-image-tests/run-native-image-tests")
+    (println "Native image cli missing. Please run 'bb ni-cli' and try again.")))
+
+(defn libdatahike []
+  (if (fs/exists? "./libdatahike/target")
+    (p/shell "./bb/resources/native-image-tests/run-libdatahike-tests")
+    (println "libdatahike binaries missing. Please run 'bb ni-compile' and try again.")))
+
+(defn bb-pod []
+  (if (fs/exists? "./dthk")
+    (p/shell "./bb/resources/native-image-tests/run-bb-pod-tests.clj")
+    (do (println "Native image cli missing. Please run 'bb ni-cli' and try again.")
+        (System/exit 1))))
+
+(defn python []
+  (if (fs/exists? "./libdatahike/target")
+    (p/shell "./bb/resources/native-image-tests/run-python-tests")
+    (println "libdatahike binaries missing. Please run 'bb ni-compile' and try again.")))
+
+(defn specs []
+  (kaocha "--focus" "specs" "--plugin" "kaocha.plugin/orchestra"))
+
+(defn kabel []
+  (kaocha "--focus" "kabel"))
+
+(defn cljs-node-test []
+  (p/shell "clj -M:cljs -m shadow.cljs.devtools.cli compile :node-test")
+  (p/shell "node target/out/node-test.js"))
+
+(defn cljs-browser-test []
+  (println "Installing npm dependencies...")
+  (p/shell "npm install")
+  (println "Starting Kabel test server...")
+  (let [server-process (p/process "clojure -M:test -e \"(require 'datahike.kabel.browser-test-server) (datahike.kabel.browser-test-server/start-test-server!) (Thread/sleep Long/MAX_VALUE)\"")]
+    (try
+      (println "Waiting for server startup...")
+      (Thread/sleep 5000)
+      (println "Compiling browser tests...")
+      (p/shell "npx shadow-cljs compile :browser-ci")
+      (println "Running tests with Karma...")
+      ;; Set CHROME_BIN to chromium if available
+      (let [chrome-bin (or (System/getenv "CHROME_BIN")
+                           (first (keep #(when (.exists (io/file %)) %)
+                                        ["/snap/bin/chromium"
+                                         "/usr/bin/chromium"
+                                         "/usr/bin/chromium-browser"
+                                         "/usr/bin/google-chrome"])))
+            env (if chrome-bin
+                  (assoc (into {} (System/getenv)) "CHROME_BIN" chrome-bin)
+                  (into {} (System/getenv)))]
+        (p/shell {:env env} "npx karma start --single-run"))
+      (finally
+        (println "Stopping test server...")
+        (p/destroy server-process)))))
+
+(defn all [config]
+  (kaocha "--skip" "specs")
+  (specs)
+  (kabel)
+  (back-compat config)
+  (native-image)
+  (libdatahike)
+  (python)
+  (bb-pod)
+  (cljs-node-test)
+  (cljs-browser-test))
+
+(defn -main [config & args]
+  (if (seq args)
+    (case (first args)
+      "native-image" (native-image)
+      "libdatahike" (libdatahike)
+      "python" (python)
+      "bb-pod" (bb-pod)
+      "back-compat" (back-compat config)
+      "specs" (specs)
+      "kabel" (kabel)
+      "cljs-node" (cljs-node-test)
+      "cljs-browser" (cljs-browser-test)
+      (apply kaocha "--focus" args))
+    (all config)))

package/bb/src/tools/version.clj

@@ -0,0 +1,47 @@
+(ns tools.version
+  "Update the project version."
+  (:refer-clojure :exclude [inc])
+  (:require [clojure.edn :as edn]
+            [clojure.string :as str]
+            [clojure.tools.build.api :as b]))
+
+(defn read-edn-file [filename]
+  (edn/read-string (slurp filename)))
+
+(defn commit-nr []
+  (b/git-count-revs {:dir "."}))
+
+(defn current-commit []
+  (str/trim (b/git-process {:git-args "rev-parse HEAD"})))
+
+(defn sha []
+  (-> (b/git-process {:git-args "log -1"})
+      (str/split #"\s+")
+      second))
+
+(defn string [config]
+  (let [{:keys [major minor]} (:version config)]
+    (str major "." minor "." (commit-nr))))
+
+(defn- update-in-settings [config-file ks fn]
+  (spit config-file (update-in (read-edn-file config-file) ks fn)))
+
+(defn show
+  "Show the version string of a library"
+  [config]
+  (println (string config)))
+
+(defn inc
+  "Increment the library version.
+   The version part can be 'major' or 'minor'."
+  ([config-file]
+   (println "Current library version: ")
+   (show (read-edn-file config-file))
+   (println "Call this function with :major or :minor to increase the respective version part!"))
+  ([config-file part]
+   (case (name part)
+     "major" (update-in-settings config-file [:version :major] inc)
+     "minor" (update-in-settings config-file [:version :minor] inc))))
+
+(defn as-tag [config]
+  (str "v" (string config)))