Clojure Q&A - Recent questions and answers in Tools

Answered: does deps.edd support "exclusion" with wild cards ?

Sun, 08 Feb 2026 17:14:18 +0000

There is an existing enhancement jira for this at https://clojure.atlassian.net/browse/TDEPS-141

Answered: Improving curl options for CLI install scripts (brew-install)

Mon, 26 Jan 2026 19:36:29 +0000

Logged as https://clojure.atlassian.net/browse/TDEPS-274

Answered: Prepping - cache invalidation

Tue, 16 Sep 2025 12:53:23 +0000

There's no general way to know if a local project's build directory is stale. In that case, you'll need to force a re-prep, either by deleting the ensure directory or by using the :force flag on prep.

https://clojure.github.io/tools.deps.cli/clojure.tools.deps.cli.api-api.html#clojure.tools.deps.cli.api/prep

Answered: how do you set -Djdk.attach.allowAttachSelf enabled so that I can interrupt a cider repl in emacs

Tue, 02 Sep 2025 16:25:43 +0000

It should be just "-Djdk.attach.allowAttachSelf", without the word "enabled". See https://nrepl.org/nrepl/installation.html#jvmti.

On the CIDER side, it is preferable to customize cider-clojure-cli-global-aliases instead:
(setq cider-clojure-cli-global-aliases ":dev")

Answered: clojure -X:deps find-versions doesn't sort tags correctly?

Mon, 11 Aug 2025 01:54:03 +0000

git tags are sorted via:

git tag --sort=v:refname

which treats the tag name as a version. How suffix versions are sorted is dependent on your git config settings. It's possible to change this setting on your machine to consider suffixes before releases with:

git config --global versionsort.suffix -rc

It would be possible to resolve tags to commits and sort based on ancestor comparison but this would affect the performance (possibly a lot). Hard to say what the effect would be without some testing.

Answered: tools.deps.cli.api/mvn-install docstring typo

Mon, 11 Aug 2025 01:11:53 +0000

Yep, thx - fixed in source for next release.

POSIX-style command line arguments in tools (-T)

Thu, 03 Jul 2025 21:06:46 +0000

I have a couple command line tools written as libraries that I'd like to expose as proper Clojure Tools. They have classic POSIX-style command line interfaces, relying on tools.cli. I could add an -X kv-map interface, but there are a number of boolean flags that would not translate well to :foo true style (such as arbitrary file paths).

Is there a way to pass arbitrary arguments to a clojure Tool without using the kv-map style?

And if not, would there be interest in a flag or option that would allow for such a thing?

Improve clojure cli error msg: "The following libs must be prepared" could include "clojure -X:deps prep"

Sun, 08 Jun 2025 17:57:20 +0000

This happens basically every time I add a dependency that needs prepping. I see the error, but don't have the prep command memorized so I have to look it up. It would be very helpful if the error printed also included the command invocation for prepping, clojure -X:deps prep.

Answered: How to uberjar without bundling source code?

Thu, 03 Apr 2025 14:02:17 +0000

For those using leiningen, :omit-source true will do the same trick [1].

[1] https://github.com/technomancy/leiningen/blob/master/sample.project.clj#L417

Answered: a) how: programmatically set REPL ‘context’ ‘prj-1 aware’? b) how: programmatically switch REPL ‘context’ ‘prj-n aware’?

Sun, 23 Feb 2025 17:34:17 +0000

The implication seems to be to work on a different project one must (System/exit 0) VM and start another VM using clj

You don't have to exit the existing REPL process before starting a new one. You can have however many running clj instances, all inside different or the same projects.

If you want to switch to a different project from within the same window, be it a terminal or some IDE or something else, then it might also be possible but then it depends on what that "something" is. In a terminal, people usually use screen or tmux for something like that, or even Ctrl+Z with fg or bg if you're on Linux and maybe Mac or WSL.

This appears to be idiomatically (colloquially) referred to as ‘restarting the REPL’ I believe?

If it's all in the same process - yes. Although usually it means restarting a REPL within the same project, since nothing between projects conflicts with each other.
If there's a server process for the REPL and a client process, it might mean restarting both or restarting only the server if the client can reconnect without restarting.
But usually all the fine points are not important at all.

a required lisp feature, for me anyway: multiple simultaneous-concurrent (multi-threaded) REPLs, I refer to as ‘Clojure Listeners’ (‘in-process’ or ‘against the same runtime’)

I have never experienced or even heard of a need for that, so I'm curious what the actual use case is that isn't satisfied with multiple separate REPLs.

In any case, even that is possible if you start multiple socket REPLs.

non-socket non-nREPL non-LSP non-network non-middleware non-multi-VM based REPL approaches

But why all the limitations? Do they have any purpose?

SEE Multiple Clojure Listeners

I have no idea what I'm looking at, there's very little context on that image.

Could easily have multi-threaded socket-based listeners . . .

But you said "non-socket" above?..

Clojure Listeners: multi-threaded, full history, type ahead, line editing, completion, pop-up menus, colorized output, colorized-balanced-brackets-([{, etc. Also working on other listener features: multi-line editing, enhanced source lookup, doc lookup, repo-artifact search, embeddable .e.g. in morse, etc.

You're just describing an IDE, just with that small addition of "multi-threaded REPL" with a yet-unclear-to-me value add.

I want a fully dynamic long running VM under full clojure programmatic control.

That's a very, very vague statement, specifically the "fully dynamic" part.

I'm still not entirely sure what's going on here, but I feel that it might be useful to add that at least on JVM you'll have issues in your attempts to be "fully dynamic" in case it also means "changing dependencies within the same process". There are tools to add dependencies at run time, but you cannot remove them. You cannot have two of the same things as well. And you cannot update a dependency to a version that made a breaking change and expect things to continue working exactly as they did before.

With that being said an given the sheer length of your opening message and the length of the previous message, I'm absolutely certain that such a discussion is much better to be had via some more interactive medium, like Slack or Zulip. There's much less risk of getting stuck in the weeds only because you took a wrong turn, and it's much easier for both the writer and all the readers to unfold the idea piece by piece instead of having to deal with a truck load of vague info.

Answered: deps.edn support for :git/branch + :git/sha

Thu, 20 Feb 2025 17:55:42 +0000

As we discussed in Slack, the intent here is to pinpoint a specific commit which is done via :git/sha with long sha. The current support for :git/tag allows you to provide a short sha and use the :git/tag as an extra check on the commit (so long sha not necessary) while also providing a human readable "version".

Because branches are virtual refs, change over time, and are easier to delete and recreate, they are not a suitable for verification of single short sha, and that's why we don't support them now.

If you are providing long shas, you don't need :git/tag or a branch verifier at all - you could provide one now and it would just be ignored. If you wanted to use an external process to trigger an external sha update process, you could, all of that is compatible with existing deps.edn.

I'm not sure about the nuances of what you are proposing re auto update. I guess there are distinct aspects encoded currently:

what "versions" are considered (current answer: tagged)
how to order those versions (current answer: most descendant sha = "newer")

It sounds like you are proposing a new strategy for #1 that would involve "commits on a branch but not on some kinds of sub branches". I'm not sure how to make that generically viable but happy to hear ideas. #2 seems same as currently used.

Answered: a) how to start REPL with ‘context’ for ‘project-1 aware’? b) How to switch REPL ‘context’ to ‘project-n aware’?

Wed, 19 Feb 2025 21:15:06 +0000

If you are using the Clojure CLI, then running clj in a directory will start a repl that has "project context" to the project deps.edn in that directory, and that is the way that most Clojure developers (regardless of editor) create a connected repl. (Alternately, they may be using Leiningen with a project.clj, but same idea.)

Typically you do not need tools.build / build.clj at all to create and work in a project until the point that you want to build and release an artifact. (Note that because the Clojure CLI / deps.edn support projects in public git repos like github, you don't necessarily ever need an artifact at all.) So I would ignore this aspect at the beginning, unless it affects your end goals.

It's unclear to me what you need at this point that you don't have. Do you need help with getting a project REPL connected in Emacs?

Answered: Confusing error message on deps.edn wrong git/url dependency

Thu, 05 Dec 2024 17:05:52 +0000

There's really a stack of things here...

Cloning: https://github.com/MISSPELLED-ORG-OR-REPO-PATH

Is an informational message from tools.gitlibs, I think that's ok.

Error building classpath. Unable to clone /home/user/.gitlibs/_repos/https/github.com/MISSPELLED-ORG-OR-REPO-PATH
fatal: could not read Username for 'https://github.com': terminal prompts disabled

This is actually an error turducken combining info from three places:
1. "Error building classpath" is from the Clojure CLI catching an unexpected error floating out of classpath construction - it doesn't know what happened, just something bad, so very generic.
2. The "Unable to clone " part is from tools.gitlibs when it gets an error from shelling out to git,and I agree that it would make more sense to list at least the git url or maybe both url and path there (can be errors with read/write perms on the path too). I will update that for next release.
3. The "fatal: ..." is from git itself basically saying that it tried to authenticate a repository url (https so http auth) but terminal prompts are disabled so it could not do that. I think you will get better errors if you are authenticated about invalid repo at that point.

I am curious what you see for echo $GIT_TERMINAL_PROMPT before the CLI call - is this set to 0 in your environment for some reason?

Similarly, if you can authenticate to github before running the CLI command, you should be seeing either success or a better error.

You can replicate this scenario at the terminal by:

Logging out of github: gh auth logout (presumably you are already logged out here).
Turning off terminal prompts: export GIT_TERMINAL_PROMPT=0
Issuing the command: git clone --quiet --mirror https://github.com/ANY-ORG/ANY-REPO foo:

fatal: could not read Username for 'https://github.com': terminal prompts disabled

Answered: why does clj -X pass in options as a clojure.lang.Symbol?

Mon, 25 Nov 2024 21:16:56 +0000

-X will edn/read-string each argument

Answered: Is there a plan to have completion for "clojure" command?

Mon, 18 Nov 2024 16:20:30 +0000

Would love to have completion support but it may require some planning wrt performance as it will likely require edn parsing, which implies Clojure, which implies a JVM.

Answered: How can I make Calva use a relative path when loading a file in cljs?

Tue, 24 Sep 2024 19:04:20 +0000

Hello. I don't think there is a way to configure that currently. You are welcome to file an issue about it. We can probably make this work.

Meanwhile.

Is shadow-cljs or Figwheel managing the loading of the project? If so, saving the file should load it .

Also, I think you most often get away with selecting the whole file and evaluate selection. You can configure a keyboard shortcut like this to give yourself something quite similar to the command that doesn't work:

  {
    "command": "runCommands",
    "key": "ctrl+alt+c ctrl+alt+enter",
    "args": {
      "commands": [
        "editor.action.selectAll",
        "calva.evaluateSelection",
        "cursorUndo"
      ]
    }
  },

You can add a when clause to it to only operate on cljs files. I think it would be resourceExtName == .cljs. See https://code.visualstudio.com/api/references/when-clause-contexts

That said, it's probably fine to let it load Clojure files this way as well. You can copy the existing when clause from the command in the in Keyboard Shortcuts UI.

Answered: clojure is not starting on databricks file system (DBFS)

Thu, 19 Sep 2024 20:15:26 +0000

Sounds like a DataBricks issue?

No way to specify Clojure version across all deps.edn files in a monorepo

Sun, 15 Sep 2024 19:46:47 +0000

Suppose you have deps.edn at the root and then a bunch of sub-directories with their own deps.edn files.

If you want to have a set of common dependencies for all of the projects, you can simply have e.g. a common directory where common/deps.edn specifies all of the common dependencies and all the rest of deps.edn files list common as one of their deps.

However, that doesn't work with org.clojure/clojure, making it implicitly special.

As I mentioned on Slack, it seems that clojure.tools.deps/root-deps brings the default top-level version of org.clojure/clojure and nothing else can override it but another top-level version.

Refresh/Reload deps.edn changes in Calva + VS Code in WSL Ubuntu

Mon, 19 Aug 2024 15:16:49 +0000

Hi, I am new to Clojure and am following this tutorial to make a Clojure API. This uses Cursive plugin in IntelliJ, but I am using Calva in VS Code.

This is my project structure:

 .
├── deps.edn
├── resources
│   └── config.edn
└── src
    └── clojure_api
        ├── config.clj
        └── core.clj

My config.clj file contents:

(ns clojure-api.config
    (:require [aero.core :as aero]
            [clojure.java.io :as io]))

(defn read-config []
  (-> "config.edn"
      (io/resource)
      (aero/read-config)))

I changed my deps.edn file to add the paths src & resources like this:

{:deps {aero/aero {:mvn/version "1.1.6"}} :path ["resources" "src"]}

while keeping the config.edn file an empty map: {}. However, I could not read the config file from read-config function in config.clj. It gave this error in Calva repl:

; Execution error (IllegalArgumentException) at aero.core/read-config-into-tagged-literal (core.cljc:194).
; Cannot open <nil> as a Reader.

The tutorial solved this error in Cursive by refreshing the project structure. I cannot seem to find any such commands in Calva. How can I update/refresh my project structure in Calva so that the deps.edn changes are reflected in the repl?

I have tried to restart the repl, reopening the folder in VS code, shuffling the resources directory around to no avail.

I could not find related answers to this problem after googling, so any help will be appreciated.

Answered: Using log4j-layout-template-json with Leiningen

Thu, 13 Jun 2024 17:10:43 +0000

If you depend on multiple libraries that each have their own plugins cache (the .dat file), you need to merge those as part of your build process -- which is what the log4j2-plugins-cache plugin is for, with Leiningen.

In log4j 3.x, they plan to do away with this cache file and use something more amenable to build tooling that doesn't require custom merging like this.

I had to write something similar for tools.build / build.clj for use with the Clojure CLI: https://github.com/seancorfield/build-uber-log4j2-handler

Answered: tools.tools install-latest throws sha error with :coord and never upgrades with :tool

Wed, 05 Jun 2024 19:36:01 +0000

Logged as https://clojure.atlassian.net/browse/TDEPS-265

Thanks!

Answered: Does tools.deps treat a version (e.g. 1.2.3) as a range (i.e. [1.2.3,))?

Wed, 05 Jun 2024 17:51:22 +0000

No, tools.deps versions specify an exact version only, no ranges, no soft versions:

$ clj -Sdeps '{:deps {org.clojure/data.json {:mvn/version "2"}}}' -Stree
Error building classpath. Could not find artifact org.clojure:data.json:jar:2 in central (https://repo1.maven.org/maven2/)
$ clj -Sdeps '{:deps {org.clojure/data.json {:mvn/version "2.5"}}}' -Stree
Error building classpath. Could not find artifact org.clojure:data.json:jar:2.5 in central (https://repo1.maven.org/maven2/)
$ clj -Sdeps '{:deps {org.clojure/data.json {:mvn/version "2.5.0"}}}' -Stree
org.clojure/clojure 1.11.3
  . org.clojure/spec.alpha 0.3.218
  . org.clojure/core.specs.alpha 0.2.62
org.clojure/data.json 2.5.0

But note of course that you only control the versions if you are the top project - transitive versions can always be overridden from above.

Answered: Option in `clojure` CLI command to print the basis

Wed, 22 May 2024 19:46:51 +0000

Logged as https://clojure.atlassian.net/browse/TDEPS-264

Answered: Combining :exec-args from multiple aliases with user-defined semantics

Wed, 22 May 2024 19:39:53 +0000

Logged here: https://clojure.atlassian.net/browse/TDEPS-263

clojure -X:deps aliases fails for alias-as-data

Wed, 01 May 2024 05:35:46 +0000

(~/clojure/t)-(!2011)-> cat > deps.edn
{:aliases {:foo ["some" "data"]}}

Tue Apr 30 22:33:28
(~/clojure/t)-(!2012)-> clj
Clojure 1.12.0-alpha11
user=>

Tue Apr 30 22:33:37
(~/clojure/t)-(!2013)-> clojure -X:deps aliases
Execution error (ClassCastException) at clojure.tools.deps.cli.api/aliases$fn$fn (api.clj:170).
class java.lang.String cannot be cast to class java.util.Map$Entry (java.lang.String and java.util.Map$Entry are in module java.base of loader 'bootstrap')

Full report at:
/tmp/clojure-4544942395618193305.edn

Answered: Add workspace level config

Wed, 14 Feb 2024 23:46:16 +0000

I'm going to redirect this to a dup - please vote/comment there

Answered: Race condition in .cpcache directory creation

Wed, 14 Feb 2024 18:07:45 +0000

We have a ticket for this in https://clojure.atlassian.net/browse/TDEPS-250

Answered: Typo in :clojure.tools.deps.specs/claspath-args

Thu, 04 Jan 2024 19:53:20 +0000

Fixed and released in tools.deps 0.18.1398.

Answered: Does the clojure cli have an option to include new extensions for dependency resolution?

Mon, 18 Dec 2023 23:09:14 +0000

Added clj-2820 to track this issue.

Answered: clojure cli bug on windows

Wed, 29 Nov 2023 06:14:49 +0000

The Clojure CLI reference talks about the quoting issues on Windows:

https://clojure.org/reference/deps_and_cli#quoting

Answered: In tools.deps, get the source of dependencies without downloading

Tue, 14 Nov 2023 14:09:42 +0000

I added https://clojure.atlassian.net/browse/TDEPS-257 for resolving without artifact downloads (poms etc of course will need to be downloaded).

Once resolved to a list of lib/coords, the existing https://clojure.github.io/tools.deps/#clojure.tools.deps/lib-location api can tell you location without procuring.

Answered: Is tools.build considering adding a :license argument?

Fri, 06 Oct 2023 21:00:44 +0000

tools.build v0.9.6 now includes an additional :pom-data attribute that can be used to provide license (and any other pom data) in hiccup style to put in the generated pom.

Docs: https://clojure.github.io/tools.build/clojure.tools.build.api.html#var-write-pom

Example:

(b/write-pom
  ...
  :pom-data 
    [[:licenses
      [:license
        [:name "Eclipse Public License 1.0"]
        [:url "https://opensource.org/license/epl-1-0/";]
        [:distribution "repo"]]]])

Test suit doesn't find function implemented in my solution

Sun, 01 Oct 2023 14:05:15 +0000

I have submitted a solution to the bird watcher problem, and the test suit complains that it doesn't find the function day-without-birds. Visual Studio Code is able to import it and run it from another file.

The full implementation of the solution is as follows:

Solution

(ns bird-watcher)

 (def last-week [0 2 5 3 7 8 4])

 (defn last_position [v]
   (- (clojure.core/count v) 1))

 (defn today [birds]
   (get birds (last_position birds)))

(defn inc-bird [birds]
  (assoc birds (last_position birds)  (+ (today birds) 1)))

(defn day-without-birds
  [birds]
  (loop [y birds]
    (let [[x & rest] y]
      (if (= x 0)
        true
        (if (empty? rest)
          false
          (recur rest))))))
 
 

(defn n-days-count [birds n]
  (reduce + (take n birds)))

(defn busy [day]
  (if (> day 5)
    1
    0))

(defn busy-days [birds]
  (reduce + (map busy birds)))

(defn odd-week-internal
  [birds x]
  (loop [y birds
         target x]
    (let [[x & rest] y
          target (- 1 target)]
      (if (= x target)
        (if (empty? rest)
          true
          (recur rest target))
        false))))

(defn odd-week [birds]
  (odd-week-internal birds 0))

Thank you in advance!

Tagged literals in Clojure CLI arguments and deps.edn

Tue, 12 Sep 2023 21:02:35 +0000

As it stands there is no way for the Clojure CLI to extend the reader with tagged literals for use within arguments or deps.edn.

I propose that some mechanism for this should be added, which can enable additional tooling to use the intended use case of putting data within aliases in deps.edn where they otherwise would be restricted by data readers.

An example of a current project which would benefit from this is Codox, which has support for regular expression based filters on namespaces to be documented, however as the default EDN reader does not include support for regular expressions, this feature is unusable.

If tagged literals support was added to the Clojure CLI, this problem could be resolved by a #jvm/regex tag or similar being added for that usecase.

If this feature is added it should also be considered what happens when a deps.edn file or argument to the CLI includes a tagged literal which is not bound in the current invocation.

There are multiple ways that support could be added to the CLI, and below I present a few of my own thoughts on the matter, but this is not a request for this to be the way that the feature is implemented, just some ideas.

Tagged literals could be added via aliases in the user deps.edn which are then used by default in all projects
Tagged literals could be specified by an environment variable, which users can then set with direnv or other tooling

Answered: clj/clojure scripts throws a stacktrace with unknown command-line argument

Thu, 07 Sep 2023 14:33:19 +0000

Logged as https://clojure.atlassian.net/browse/TDEPS-254

Answered: Accepting "-" as argument to read non edn data fails with `-X` cli invocation

Tue, 29 Aug 2023 13:44:21 +0000

Sorry, this usage is not going to work now as the clj tool itself uses - to accept args from stdin now as part of -X handling.

You could still use cat data.json | clojure -X:viscous '{:json-file -}' with the trailing map support.

Answered: clojure.tools.deps/calc-basis can fail with "Unable to resolve" due to a version range

Sat, 26 Aug 2023 13:54:58 +0000

This was caused because of the lack of :mvn/repos in my call.

Support for binary resources and large resources via deps cli.

Fri, 25 Aug 2023 00:58:32 +0000

I've written a few libraries that depend on binary resources (eg. native shared libraries) and other libraries that have very large resources (eg. the llm weights for llama).

In principle, both of these types of dependencies can be satisfied by the deps tools without any changes since the deps cli can fetch resources and add them to classpath.

However, there are few additional challenges which makes using the deps cli for large and/or binary resources awkward.

Large resources are Large

I've avoided using the deps machinery for large resources because there are several affordances missing:

a) no yes/no prompt before downloading dependencies.

It seems reasonable to download maybe 100's of megabytes of dependencies when invoking the cli, but it doesn't feel right for the cli to download gigabytes of data dependencies without asking first

b) no progress indicator when downloading dependencies

Downloading dependencies is usually pretty quick, but it's nice to have a progress indicator if several gigabytes of dependencies are being downloaded.

Native dependencies are often large

Native dependencies can range from a few megabytes all the way to a gigabyte (eg. Chromium embedded framework).

Native dependencies are platform/OS dependent

I think there's some maven magic that helps with this which I haven't had a chance to look into. Anyway, the artifacts required for running depend on the platform that the program is running on. Usually, it's ok to include the artifacts for all possible platforms, but that may be unnecessarily using resources and might not work in particular cases.

Shared libraries must be extracted from jars before loading

Many ffi libraries (like JNA) will do this for you. It's implemented in an adhoc way depending on the ffi library. It may or may not work depending on whether the shared library is standalone or depends on other shared libraries.

Potentially, the deps tools could help extract shared libraries using an acceptable, uniform method.

Precompiled linux shared libraries barely work

It's possible to precompile shared libraries for mac osx and windows with a wide range of compatibility that "just work". With linux, there are lots of caveats. Generally, it seems like you can get something that mostly works if you have a standalone shared library and compile it with zig (eg. llmdb), but compatibility goes way down if there are multiple dependent shared libraries that don't use zig (eg. graphviz).

Native dependencies should be compiled from source?

Some package managers ship precompiled binaries (eg. conda), but it seems like many package managers tend to compile from source (eg. pip, macports, homebrew, etc).

Compiling from source may help with some of the following:

compiling from source sidesteps many of the challenges of providing native dependencies on linux
native deps could be git deps!
Some devs really dislike precompiled binaries and strongly prefer compiling from source.

Obviously, supporting compiling from source has its own challenges.

The above covers many of the problems with large and/or binary resources. Here are some concrete use cases:

clj-cef: wraps the chromium embedded framework. The framework itself is about 0.5-1.5gb depending on the platform and includes both shared libraries and large resource files. There's also an additional small, shared library required.
clj-graphviz: wraps the graphviz c libraries. Extra tricky because there are multiple shared libraries and each shared libraries have additional dependencies (eg. libpng).
llama.clj: wraps the llama.cpp library for running llms locally. It would also be nice to add specific llm weights as dependencies, but they can be very large (eg. a few gigabytes up to hundreds of gigabytes). Further, llama.cpp can be compiled with gpu support, but I haven't figured out how to do in a portable way without a compile from source option.

I know there's a lot of overlap with existing tools, so maybe there's some way for the deps cli to integrate with those existing tools:

fetching native deps: pip, conda, homebrew, macports, apt, scoop, etc.
fetching data dependencies: hugging face, https://dvc.org/

Anyway, I've made multiple attempts at finding a good approach for including native and/or large dependencies and all of the options still feel pretty awkward.

Answered: install-latest does not use coords to find versions in self-hosted git

Tue, 22 Aug 2023 02:17:34 +0000

Logged as https://clojure.atlassian.net/browse/TDEPS-253

Answered: Problem with leiningen and a local library

Wed, 16 Aug 2023 08:52:08 +0000

Your setup is uncommon, therefore it is kinda hard to figure out what you expect to happen or why you'd want typically development only files in the .jar.

In common Clojure(Script) setups libraries only contain their source code, and no compiled artifacts. Actual projects then use those libraries to build what they need.

There can still be CLJS builds in the library as well, but those would only be relevant for the development of that library, and not part of the actual published outputs.

If for some reason you don't want this and prefer to keep the build in the library, then the only relevant file the project should include in the .jar is the .js file produced by the prod build. Which is likely defined in a prod.edn in the project. It likely only produces one output file. The files you complained about missing are development files, and should no longer be relevant.

Your project also seems to be a little stitched together since there are still remnants of what probably used to be lein-cljsbuild config, yet also some newer figwheel.main references. You probably want to clean that up so it is easier to figure out what is actually going on.

I'm also not sure about the use of lein-localrepo. A simpler lein install should achieve the same, if the goal is using the local installed library from the project. Not sure what else localrepo does exactly.

Unable to locate a Java Runtime

Sat, 29 Jul 2023 18:13:11 +0000

I try to learn Clojure and follow Clojure for the Brave and True book.

In core.clj file, I typed M-x cider-jack-in command. I see following error:

error in process sentinel: Could not start nREPL server: The operation couldn’t be completed. Unable to locate a Java Runtime.

I tried both 8 and 17 versions of Java, I verified them via which java and echo $JAVA_HOME

Lein commands works by themselves.

Can you help me?

Answered: Path to installed man pages by Clojure POSIX installer script

Tue, 25 Jul 2023 13:23:57 +0000

Added issue on the site repo here: https://github.com/clojure/clojure-site/issues/658

Answered: make-classpath2 in tools.deps cannot be run from a directory other than the project one

Sun, 16 Jul 2023 17:59:41 +0000

This should not be considered a public api - it changes regularly in breaking ways, and using it for any directory other than the current directory is not supported (this is only called from the CLI, which assumes current directory).

To programmatically make a classpath from deps.edn, you should use clojure.tools.deps/create-basis (which can specify a project deps.edn in any directory).

Answered: Feature request for Clojure CLI: Some way to specify OS-conditional values for :local/root in deps.edn

Wed, 12 Jul 2023 07:49:22 +0000

FWIW I would recommend just using relative paths for :local/root. Absolute paths are not necessary and just makes things complicated.

In my own setup I have all my projects in ~/code. So ~/code/project and ~/code/some-lib, in deps.edn I just use :local/root "../some-lib" from the project and everything works. Regardless of whether thats executing in WSL/Windows or whatever else.

I also have setups where everything is in the same ~/code/project and ~/code/project/packages/some-lib where I again just use :local/root "packages/some-lib" instead of the absolute path.

(Most of the projects actually still use project.clj, but the same method applies)

If you avoid absolute paths your entire problem goes away. ;)

Answered: Could the CLI check for the latest stable version?

Wed, 21 Jun 2023 16:14:02 +0000

Created ticket at https://clojure.atlassian.net/browse/TCLI-103

Answered: proper XDG support

Tue, 30 May 2023 16:59:05 +0000

The question continues to be: how could the Clojure CLI definitively know that you wish to use XDG configuration options. If there is a definitive answer to that question, I'd be happy to use that to select this behavior. We're not going to change that to be the default.

Another option would be to have a Clojure CLI specific environment variable that you could set to do that (but you're going to have to take that action).

Answered: Shutdown Morse Gracefully?

Tue, 30 May 2023 15:45:12 +0000

As long as you don't hold any references to the UI yourself, then when you close the Morse window it should be released by the FX toolkit and eligible for garbage collection.

Answered: clojure.tools.deps.cli.api/find-versions yields empty result for git-lib when offline

Tue, 30 May 2023 14:27:47 +0000

Logged as https://clojure.atlassian.net/browse/TDEPS-248

Answered: incorrect test? clojure.tools.deps.test-deps/test-dep-choice

Thu, 18 May 2023 12:43:48 +0000

Thanks, fixed

Answered: Clojure CLI has a way to specify namespace to REPL like Leiningen :init-ns?

Fri, 28 Apr 2023 13:35:16 +0000

There is no need to introduce code into any tooling to switch namespaces when starting a REPL.

Defining a custom user namespace has been a long standing approach to managing component lifecycle (start, stop, restart) during development that is not editor, tool or component library dependant, i.e. it works with everything.

Create a dev/user.clj file in the project that defines a user namespace. Code in this namespace is loaded during REPL startup, unless it is in comment forms.

The repl starts in the user namespace, so functions defined in dev/user.clj are immediately available without having to switch to a different namespace or use fully qualified names.

Defining functions that manage components in the custom dev/user.clj user namespace makes them immediately available in the default namespace used by the REPL.

The added benefit of this approach is cleaner code and a clear separation between development support code and production code.

Libraries such as component repl and integrant repl can be included via a Clojure CLI alias, so they are not adding weight to CI workflow and the resulting deployed uberjar.

The custom user namespace contains the require statements for component repl (or other develop-time component libraries like Integrant REPL)

Personally I use this approach for launching a range of supporting development tools, regardless of it being Leiningen or Clojure CLI project.

Practicalli Custom REPL Startup details the general approach

Practicalli REPL Reloaded details the specific development tooling I use (portal, hotload, namespace reload, event logging, etc)

Practicalli Project Templates provides production level templates for seancorfiled/deps-new which include a dev/user.clj custom user namespace, the practicalli/service template included Integrant REPL example with aero