[Show & Tell] Editor Tooling: Janet LSP and Janet++ for VS Code

[CFiggers]

For the past year or so (and since February in earnest) I've been working on a personal fork of the official VS Code extension for Janet. I'm heavily inspired to do so by (and I have directly adapted significant amounts of the internals of) BetterThanTomorrow/Calva, which is, without competition, the best VS Code extension for Clojure on the VS Code Extension marketplace.

I like Calva a lot, and when switching from Clojure to Janet as my tinkering language of choice I quickly missed a number of things that Calva offers (this list is non-exhaustive and in no particular order):

• ParEdit-style structural editing (the biggest thing for me—see Calva's visual introduction to ParEdit if you don't know what that is)
• Strict paren balancing (ignores backspace over parens by default if that would result in an unbalanced expression)
• Auto-formatting while typing (and on command when triggered manually with Tab)
• Hover-over documentation pop-ups showing function signatures and docstrings without needing to context-switch (either to the REPL or to the API docs on the website)
• Reformatting shortcuts, like moving highlighted S-exps into or out of let bindings
• Inline compiler warnings (to quickly identify undefined symbols, function calls with wrong arity, typos, etc.)

With my fork of vscode-janet, I've been trying to recreate the Calva experience as much as possible, but for Janet instead of Clojure. I've been moderately successful—mostly by just swiping the bits from Calva that I miss and haphazardly adapting them to Janet!

Over the past month, I've finally gotten it to a point where the bugs are occasional annoyances rather than things to be constantly and actively worked around (which is how things started). And also, I've added one of the last remaining "big pieces" that Calva offers that my pale imitation did not—and that is, an LSP-compliant Language Server. I started with the work of John Doneth in JohnDoneth/janet-language-server. I completely reworked and expanded the on-hover documentation feature, fixed some bugs with the RPC responses that were causing errors/crashes in some situations, and got dynamic relative imports working (I think), which removed some of the hard-coding that was in there when John Doneth last touched it. Otherwise, I'm mostly using John's code unchanged. I then compiled the server into binaries (for Linux and Windows only, at the moment) and bundled those with the VS Code extension. So on installing, the LSP just works out of the box in VS Code, hopefully without needing direct configuration or setup from the user. That's just like Calva does it with clojure-lsp.

This expanded version of vscode-janet, which I'm calling Janet++ for the time being, is now published on the VS Code Extension marketplace and if you use VS Code you can go find and install it right now by searching for "janet" in the regular ol' extension panel in the VS Code sidebar!

The other thing about Janet LSP is, I did check to see whether John Doneth is still around and interested in collaborating on his janet-language-server project. But, in absence of a response from him to that inquiry from two weeks ago (yet, I would still be interested in collaborating on his project as the main repo for a Janet LSP server if he resurfaces at some point), in the mean time I have forked janet-language-server into CFiggers/janet-lsp as a place to store my updates and pull from for building Janet++. Ideally, that project could be useful for anyone with an LSP-capable editor, not just VS Code. I am not a vim/neovim user primarily, but in ~20 minutes of tinkering I was able to pretty easily get Janet LSP talking to NeoVim and providing completion and on-hover documentation for Janet! So the proof-of-concept is there at least.

I think having a well-supported LSP could be a big jump up in tooling support for Janet, particularly because it works across a wide variety of different editor setups (as long as the editor has or can get an LSP client). So, even if you don't use VS Code, I'd be really eager for collaborators on Janet LSP because I think that could move the general state of Janet tooling forward in a big way. The best part is, unlike the VS Code extension, which is written in both TypeScript and ClojureScript (because that's how Calva is written, and I just shamelessly stole 99% of this thing from them... woof), Janet LSP is written entirely in Janet, so it should be readily hack-on-able for any of us who know Janet and would be interested in tinkering!

Take-aways/Calls to action

The take-aways are, Janet++ and Janet LSP exist, such as they are. Yay!

As for calls to action, I'd really love it if anyone here who's interested would like to:

1. Share any thoughts/comments/feedback on anything I've written here
2. Take Janet++ for a test drive in VS Code (just search for "janet" in the extension sidebar panel and you'll find it immediately)
3. See if Janet LSP works with your preferred editor on your preferred OS (especially interested in hearing from Emacsen and anyone running MacOS, which is the one of the Big Three that I don't have easy access to be able to build binaries for)
4. Collaborate with issues/discussions/pull requests on either Janet++ or Janet LSP (especially Janet LSP, especially getting module imports working on Windows and adding other stuff from the LSP feature set)

Thanks for reading!

[pepe]

I have limited time to evaluate the Janet++, but from what I have seen, it is very high quality! Thank you very much. I see this as a big step forward! I will report back when I have more time to spend with it. <3

[pepe]

I adore the contour logo for your extension. <3

Next week, I plan to test the Janet LSP server with kakoune.

[subsetpark]

I’m not a VSCode user, but heavy LSP user via neovim. Super excited that someone’s picked up the torch and would be really happy to pitch in where useful.

[sogaiu]

For the record, CFiggers' janet-lsp fork is useful already in Emacs 29.1 using eglot.

This bit of code may be helpful if using janet-ts-mode:

(with-eval-after-load 'eglot
  (add-to-list 'eglot-server-programs
               '(janet-ts-mode . ("janet-lsp"))))

or if using one of the janet-modes:

(with-eval-after-load 'eglot
  (add-to-list 'eglot-server-programs
               '(janet-mode . ("janet-lsp"))))

cfiggers-janet-lsp-emacs-eglot.mp4

[sogaiu]

There are some rough edges still, but had some success hooking up CFiggers' janet-lsp fork and tree-sitter-janet-simple to helix.

For the adventurous (note: CFiggers' janet-lsp fork is a prerequisite):

# assuming rust tooling exists...
git clone https://github.com/sogaiu/helix -b janet
cd helix

# building may take a while...
cargo install --path helix-term --locked --timings --verbose

# more info: https://docs.helix-editor.com/install.html#building-from-source
export HELIX_RUNTIME=$(pwd)/runtime
hx --health

# try viewing a .janet file -- assuming janet source in sibling dir
hx ../janet/src/janet/boot/boot.janet

[bakpakin]

Janet++ is pretty cool, gave it a shot with vscode and it worked out of the box!

[CubicMelon]

I'm a definite Janet beginner and have been using Janet++ in VSCode during my tinkering and I think it's pretty great! Especially as a beginner, the details when you mouseover functions/macros are a HUGE help.

My only complaint as a Windows user so far is that for some reason, the language server does not seem to be able to find jpm installed modules. For example:

I have the jaylib module installed and it functions perfectly fine when run through Janet. I'm not missing something am I?

[CFiggers]

Nope! You're not missing anything—Windows support needs more work. 😅 There's an issue open for it over in the Janet LSP repo, if you'd like to be updated when that gets worked on: CFiggers/janet-lsp#2

[CubicMelon]

Thanks for the confirmation! I'll keep an eye out; in the meantime it's still extremely useful though and works quite well on Windows. Thanks for your efforts!

[CFiggers]

@CubicMelon I just published a pre-release version of Janet++ that bundles Janet LSP as a .jimage file rather than as a compiled executable. This should mean that, assuming you have janet on your path (which you should have if you installed Janet by any of the recommended methods) the LSP will run in your local copy of Janet and not the embedded copy of Janet that would come along with an executable binary. I think this solves the module import issue you were seeing in the screenshot above.

Would you like to test the pre-release version and let me know if you run into issues? If so you can switch to the pre-release copy from within VS Code:

Thanks!

[CubicMelon]

With the pre-release version active, this issue seems to be fixed!

Thanks a bunch for the heads up and working on it :)